API 개발

class UserModelClass extends BaseModelClass {
  @api({ httpMethod: "GET" })
  async findById(id: number): Promise<User> {
    return this.findById(id);
  }

  @api({ httpMethod: "POST" })
  async createUser(params: UserSaveParams): Promise<User> {
    return this.save(params);
  }

  @api({ httpMethod: "PUT" })
  async updateUser(id: number, params: UserSaveParams): Promise<User> {
    return this.save({ id, ...params });
  }

  @api({ httpMethod: "DELETE" })
  async deleteUser(id: number): Promise<void> {
    await this.del(id);
  }
}

GET    /user/findById?id=1
POST   /user/createUser
PUT    /user/updateUser
DELETE /user/deleteUser?id=1

@api({ httpMethod: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" })

@api({ 
  httpMethod: "POST",
  guards: ["user", "admin"]  // user 로그인 필요, admin 권한 필요
})
async adminOnly() { }

@api({ 
  httpMethod: "GET",
  noAuth: true  // 로그인 없이 접근 가능
})
async publicApi() { }

@api({ 
  httpMethod: "GET",
  path: "/custom/path"  // /user/method 대신 /custom/path 사용
})
async customPath() { }

@api({ httpMethod: "GET" })
async getUser(id: number, includeProfile?: boolean): Promise<User> {
  // GET /user/getUser?id=1&includeProfile=true
}

@api({ httpMethod: "GET" })
async listUsers(listParams: UserListParams): Promise<ListResult<User>> {
  // GET /user/listUsers?num=20&page=1&orderBy=id-desc
  return this.list("A", listParams);
}

@api({ httpMethod: "POST" })
async createUser(params: UserSaveParams): Promise<User> {
  // POST /user/createUser
  // Body: { name: "John", email: "[email protected]" }
  return this.save(params);
}

@api({ httpMethod: "POST" })
async updateProfile(
  userId: number, 
  profile: ProfileSaveParams
): Promise<Profile> {
  // POST /user/updateProfile
  // Body: { userId: 1, profile: { bio: "..." } }
  return ProfileModel.save({ user_id: userId, ...profile });
}

import { api, upload, Sonamu } from "sonamu";

@api({ httpMethod: "POST" })
@upload({ mode: "single" })
async uploadAvatar(): Promise<{ url: string; filename: string }> {
  // POST /user/uploadAvatar
  // Content-Type: multipart/form-data
  
  const { file } = Sonamu.getUploadContext();
  
  const key = `avatars/${Date.now()}_${file.filename}`;
  const url = await file.saveToDisk(key);
  
  return { url, filename: file.filename };
}

import { api, upload, Sonamu } from "sonamu";

@api({ httpMethod: "POST" })
@upload({ mode: "multiple" })
async uploadFiles(): Promise<{ files: Array<{ url: string; filename: string }> }> {
  // POST /user/uploadFiles
  // Content-Type: multipart/form-data
  
  const { files } = Sonamu.getUploadContext();
  
  const results = [];
  for (const file of files) {
    const key = `files/${Date.now()}_${file.filename}`;
    const url = await file.saveToDisk(key);
    results.push({ url, filename: file.filename });
  }
  
  return { files: results };
}

import { BadRequestException } from "sonamu";

@api({ httpMethod: "POST" })
async createUser(params: UserSaveParams): Promise<User> {
  if (!params.email) {
    throw new BadRequestException("이메일은 필수입니다");
  }
  return this.save(params);
}

import { UnauthorizedException } from "sonamu";

@api({ httpMethod: "GET" })
async getMyProfile(): Promise<User> {
  const userId = Sonamu.getContext().user?.id;
  if (!userId) {
    throw new UnauthorizedException("로그인이 필요합니다");
  }
  return this.findById(userId);
}

import { UnauthorizedException } from "sonamu";

@api({ httpMethod: "DELETE" })
async deleteUser(id: number): Promise<void> {
  const currentUser = Sonamu.getContext().user;
  if (currentUser?.role !== "admin") {
    throw new UnauthorizedException("관리자 권한이 필요합니다");
  }
  await this.del(id);
}

import { NotFoundException } from "sonamu";

@api({ httpMethod: "GET" })
async getUserById(id: number): Promise<User> {
  const user = await this.findById(id);
  if (!user) {
    throw new NotFoundException("사용자를 찾을 수 없습니다");
  }
  return user;
}

import { Sonamu } from "sonamu";

@api({ httpMethod: "GET" })
async getMyProfile(): Promise<User> {
  const context = Sonamu.getContext();
  const userId = context.user?.id;
  
  if (!userId) {
    throw new UnauthorizedException("로그인이 필요합니다");
  }
  
  return this.findById(userId);
}

const context = Sonamu.getContext();

// 사용자 정보
context.user           // 로그인한 사용자 객체
context.userId         // 사용자 ID

// 요청 정보
context.ip             // 클라이언트 IP
context.userAgent      // User-Agent 헤더

// Fastify 객체
context.request        // Fastify Request
context.reply          // Fastify Reply

// 세션
context.session        // 세션 객체

// sonamu.config.ts
export default {
  server: {
    session: {
      secret: process.env.SESSION_SECRET || "my-secret",
      cookie: {
        maxAge: 24 * 60 * 60 * 1000,  // 24시간
        secure: process.env.NODE_ENV === "production"
      }
    }
  }
} satisfies SonamuConfig;

@api({ httpMethod: "POST", noAuth: true })
async login(email: string, password: string): Promise<User> {
  const user = await this.findOne("A", { email });
  
  if (!user || !await bcrypt.compare(password, user.password)) {
    throw new UnauthorizedException("이메일 또는 비밀번호가 잘못되었습니다");
  }
  
  const context = Sonamu.getContext();
  context.session.userId = user.id;
  context.session.role = user.role;
  
  return user;
}

@api({ httpMethod: "GET" })
async getMyInfo(): Promise<User> {
  const context = Sonamu.getContext();
  const userId = context.session.userId;
  
  if (!userId) {
    throw new UnauthorizedException("로그인이 필요합니다");
  }
  
  return this.findById(userId);
}

@api({ httpMethod: "POST" })
async logout(): Promise<{ success: boolean }> {
  const context = Sonamu.getContext();
  context.session.destroy();
  return { success: true };
}

// sonamu.config.ts
export default {
  server: {
    auth: {
      guards: {
        user: async (request) => {
          const userId = request.session.userId;
          if (!userId) return null;
          return UserModel.findById(userId);
        },
        admin: async (request) => {
          const user = request.session.user;
          if (!user || user.role !== "admin") return null;
          return user;
        }
      }
    }
  }
} satisfies SonamuConfig;

// user 로그인 필요
@api({ httpMethod: "GET", guards: ["user"] })
async getMyProfile(): Promise<User> {
  const userId = Sonamu.getContext().user?.id;
  return this.findById(userId!);
}

// admin 권한 필요
@api({ httpMethod: "DELETE", guards: ["admin"] })
async deleteUser(id: number): Promise<void> {
  await this.del(id);
}

// user 또는 admin
@api({ httpMethod: "GET", guards: ["user", "admin"] })
async viewStats(): Promise<Stats> {
  // ...
}

@api({ httpMethod: "GET" })
async getUser(id: number): Promise<User> {
  return this.findById(id);
}

// 응답:
// {
//   "id": 1,
//   "name": "John",
//   "email": "[email protected]"
// }

@api({ httpMethod: "GET" })
async getUserWithStats(id: number): Promise<{
  user: User;
  stats: { postCount: number; commentCount: number };
}> {
  const user = await this.findById(id);
  const postCount = await PostModel.count({ user_id: id });
  const commentCount = await CommentModel.count({ user_id: id });
  
  return {
    user,
    stats: { postCount, commentCount }
  };
}

@api({ httpMethod: "GET" })
async downloadFile(id: number): Promise<Buffer> {
  const file = await FileModel.findById(id);
  
  const context = Sonamu.getContext();
  context.reply.header("Content-Type", "application/pdf");
  context.reply.header("Content-Disposition", `attachment; filename="${file.name}"`);
  
  return file.buffer;
}

@api({ httpMethod: "GET" })
async listUsers(listParams: UserListParams): Promise<ListResult<UserA>> {
  // ListResult = { rows: T[], total: number }
  return this.list("A", listParams);
}

// 응답:
// {
//   "rows": [
//     { "id": 1, "name": "John" },
//     { "id": 2, "name": "Jane" }
//   ],
//   "total": 100
// }

// web/src/services/user/user.service.ts (자동 생성)
export const UserService = {
  async findById(id: number): Promise<User> {
    const response = await axios.get("/user/findById", { params: { id } });
    return response.data;
  },
  
  async createUser(params: UserSaveParams): Promise<User> {
    const response = await axios.post("/user/createUser", params);
    return response.data;
  }
};

import { UserService } from "@/services/user/user.service";

function UserProfile({ userId }: { userId: number }) {
  const [user, setUser] = useState<User | null>(null);
  
  useEffect(() => {
    UserService.findById(userId).then(setUser);
  }, [userId]);
  
  return <div>{user?.name}</div>;
}

import { useUserFindById } from "@/services/user/user.service";

function UserProfile({ userId }: { userId: number }) {
  const { data: user, error, isLoading } = useUserFindById({ id: userId });
  
  if (isLoading) return <div>Loading...</div>;
  if (error) return <div>Error: {error.message}</div>;
  
  return <div>{user?.name}</div>;
}