AuthContext

type AuthContext = {
  user: PassportUser | null;
  passport: {
    login: (user: PassportUser) => Promise<void>;
    logout: () => void;
  };
};

user: PassportUser | null

class UserModelClass extends BaseModel {
  @api()
  async getMyProfile(ctx: Context) {
    if (!ctx.user) {
      throw new UnauthorizedException("로그인이 필요합니다");
    }

    return {
      id: ctx.user.id,
      email: ctx.user.email,
      name: ctx.user.name
    };
  }
}

login: (user: PassportUser) => Promise<void>

class AuthModelClass extends BaseModel {
  @api()
  async login(
    ctx: Context,
    email: string,
    password: string
  ) {
    // 사용자 인증 로직
    const user = await this.validateCredentials(email, password);
    
    if (!user) {
      throw new UnauthorizedException("이메일 또는 비밀번호가 올바르지 않습니다");
    }

    // 세션에 사용자 정보 저장
    await ctx.passport.login(user);

    return { success: true, user };
  }

  private async validateCredentials(email: string, password: string) {
    // 실제 인증 로직 구현
    const user = await this.findByEmail(email);
    if (!user) return null;
    
    const isValid = await bcrypt.compare(password, user.passwordHash);
    return isValid ? user : null;
  }
}

logout: () => void

class AuthModelClass extends BaseModel {
  @api()
  async logout(ctx: Context) {
    ctx.passport.logout();
    return { success: true, message: "로그아웃되었습니다" };
  }
}

// sonamu.config.ts
export default {
  server: {
    plugins: {
      // 세션 플러그인 필수
      session: {
        secret: process.env.SESSION_SECRET || "your-secret-key-here",
        cookie: {
          maxAge: 1000 * 60 * 60 * 24 * 7, // 7일
        }
      }
    },
    auth: true // 기본 직렬화/역직렬화 사용
  }
} satisfies SonamuConfig;

// sonamu.config.ts
export default {
  server: {
    plugins: {
      session: {
        secret: process.env.SESSION_SECRET || "your-secret-key-here",
      }
    },
    auth: {
      userSerializer: async (user, request) => {
        // 세션에 저장할 최소한의 정보만 반환
        return { id: user.id };
      },
      userDeserializer: async (serialized, request) => {
        // 세션에서 복원된 정보로 전체 사용자 객체 재구성
        const user = await UserModel.findById(serialized.id);
        return user;
      }
    }
  }
} satisfies SonamuConfig;

class UserModelClass extends BaseModel {
  @api({ guards: ["user"] })
  async getMyData(ctx: Context) {
    // guards: ["user"]로 인해 ctx.user가 보장됨
    return this.findById(ctx.user!.id);
  }

  @api({ guards: ["admin"] })
  async getAllUsers(ctx: Context) {
    // guards: ["admin"]으로 관리자만 접근 가능
    return this.findAll();
  }
}

// sonamu.config.ts
export default {
  server: {
    apiConfig: {
      guardHandler: (guard, request, api) => {
        if (guard === "user" && !request.user) {
          throw new UnauthorizedException("로그인이 필요합니다");
        }
        
        if (guard === "admin" && (!request.user || !request.user.isAdmin)) {
          throw new UnauthorizedException("관리자 권한이 필요합니다");
        }
        
        return true;
      }
    }
  }
} satisfies SonamuConfig;

// src/types.ts
declare module "fastify" {
  interface PassportUser {
    id: number;
    email: string;
    name: string;
    isAdmin: boolean;
    createdAt: Date;
  }
}