첫 엔티티 만들기

import {
  api,
  BaseModelClass,
  type ListResult,
  NotFoundException,
} from "sonamu";
import type { PostSubsetKey, PostSubsetMapping } from "../sonamu.generated";
import { postLoaderQueries, postSubsetQueries } from "../sonamu.generated.sso";
import type { Post, PostListParams, PostSaveParams } from "./post.types";

class PostModelClass extends BaseModelClass<
  PostSubsetKey,
  PostSubsetMapping,
  typeof postSubsetQueries,
  typeof postLoaderQueries
> {
  constructor() {
    super("Post", postSubsetQueries, postLoaderQueries);
  }

  @api({
    httpMethod: "GET",
    clients: ["axios", "tanstack-query"],
    resourceName: "Post",
  })
  async findById<T extends PostSubsetKey>(
    subset: T,
    id: number,
  ): Promise<PostSubsetMapping[T]> {
    const { rows } = await this.findMany(subset, {
      id,
      num: 1,
      page: 1,
    });
    
    if (!rows[0]) {
      throw new NotFoundException(`Post ID ${id} not found`);
    }

    return rows[0];
  }

  @api({
    httpMethod: "GET",
    clients: ["axios", "tanstack-query"],
    resourceName: "Posts",
  })
  async findMany<T extends PostSubsetKey>(
    subset: T,
    params?: PostListParams,
  ): Promise<ListResult<PostListParams, PostSubsetMapping[T]>> {
    const listParams = {
      num: 10,
      page: 1,
      orderBy: "id-desc" as const,
      ...params,
    };

    return await this.list(subset, listParams, (qb) => {
      // 검색 조건 추가
      if (listParams.search && listParams.searchField) {
        if (listParams.searchField === "id") {
          qb.where("id", Number(listParams.search));
        } else {
          qb.where(listParams.searchField, "like", `%${listParams.search}%`);
        }
      }

      // 정렬
      const [field, direction] = listParams.orderBy.split("-");
      qb.orderBy(field, direction as "asc" | "desc");
    });
  }

  @api({
    httpMethod: "POST",
    clients: ["axios", "tanstack-query"],
    resourceName: "Post",
  })
  async save(params: PostSaveParams): Promise<Post> {
    const id = await this.upsert(params);
    return await this.findById("A", id);
  }

  @api({
    httpMethod: "DELETE",
    clients: ["axios", "tanstack-query"],
    resourceName: "Post",
  })
  async del(id: number): Promise<void> {
    await this.deleteById(id);
  }
}

export const PostModel = new PostModelClass();

export class PostService {
  static async findById(subset: PostSubsetKey, id: number) {
    const res = await axios.get(`/api/posts/${id}`, {
      params: { subset }
    });
    return res.data;
  }

  static async findMany(subset: PostSubsetKey, params?: PostListParams) {
    const res = await axios.get("/api/posts", {
      params: { subset, ...params }
    });
    return res.data;
  }

  static async save(params: PostSaveParams) {
    const res = await axios.post("/api/posts", params);
    return res.data;
  }

  static async del(id: number) {
    await axios.delete(`/api/posts/${id}`);
  }
}