sonamu 0.5.7 → 0.7.0

package/src/{templates → template/implementations}/generated_http.template.ts

@@ -1,11 +1,9 @@
 import qs from "qs";
 import { z } from "zod";
-import { TemplateOptions } from "../types/types";
-import { getZodObjectFromApi } from "../api/code-converters";
-import { ExtendedApi } from "../api/decorators";
-import { Template } from "./base-template";
-import prettier from "prettier";
-import { Sonamu } from "../api/sonamu";
+import { getZodObjectFromApi } from "../../api/code-converters";
+import type { ExtendedApi } from "../../api/decorators";
+import { Sonamu } from "../../api/sonamu";
+import { Template } from "../template";
 
 export class Template__generated_http extends Template {
   constructor() {
@@ -21,11 +19,13 @@ export class Template__generated_http extends Template {
     };
   }
 
-  async render({}: TemplateOptions["generated_http"]) {
+  async render() {
     const {
       syncer: { types, apis },
       config: {
-        route: { prefix },
+        api: {
+          route: { prefix },
+        },
       },
     } = Sonamu;
 
@@ -36,23 +36,13 @@ export class Template__generated_http extends Template {
         const dataLines = await (async () => {
           if ((api.options.httpMethod ?? "GET") === "GET") {
             return {
-              querystring: [
-                qs
-                  .stringify(reqObject, { encode: false })
-                  .split("&")
-                  .join("\n\t&"),
-              ],
+              querystring: [qs.stringify(reqObject, { encode: false }).split("&").join("\n\t&")],
               body: [],
             };
           } else {
             return {
               querystring: [],
-              body: [
-                "",
-                await prettier.format(JSON.stringify(reqObject), {
-                  parser: "json",
-                }),
-              ],
+              body: ["", JSON.stringify(reqObject, null, 2)],
             };
           }
         })();
@@ -65,7 +55,7 @@ export class Template__generated_http extends Template {
           `Content-Type: ${api.options.contentType ?? "application/json"}`,
           ...dataLines.body,
         ].join("\n");
-      })
+      }),
     );
 
     return {
@@ -81,15 +71,10 @@ export class Template__generated_http extends Template {
         Object.keys(zodType.shape).map((key) => [
           key,
           this.zodTypeToReqDefault(zodType.shape[key], key),
-        ])
+        ]),
       );
     } else if (zodType instanceof z.ZodArray) {
-      return [
-        this.zodTypeToReqDefault(
-          (zodType as z.ZodArray<z.ZodType>).element,
-          name
-        ),
-      ];
+      return [this.zodTypeToReqDefault((zodType as z.ZodArray<z.ZodType>).element, name)];
     } else if (zodType instanceof z.ZodString) {
       if (name.endsWith("_at") || name.endsWith("_date") || name === "range") {
         return "2000-01-01";
@@ -108,51 +93,36 @@ export class Template__generated_http extends Template {
     } else if (zodType instanceof z.ZodEnum) {
       return zodType.options[0];
     } else if (zodType instanceof z.ZodOptional) {
-      return this.zodTypeToReqDefault(
-        (zodType as z.ZodOptional<z.ZodType>).def.innerType,
-        name
-      );
+      return this.zodTypeToReqDefault((zodType as z.ZodOptional<z.ZodType>).def.innerType, name);
     } else if (zodType instanceof z.ZodNullable) {
       return null;
     } else if (zodType instanceof z.ZodUnion) {
-      return this.zodTypeToReqDefault(
-        (zodType as z.ZodUnion<z.ZodType[]>).def.options[0],
-        name
-      );
+      return this.zodTypeToReqDefault((zodType as z.ZodUnion<z.ZodType[]>).def.options[0], name);
     } else if (zodType instanceof z.ZodUnknown) {
       return "unknown";
     } else if (zodType instanceof z.ZodTuple) {
-      return zodType.def.items.map((item: any) =>
-        this.zodTypeToReqDefault(item, name)
-      );
+      /** biome-ignore lint/suspicious/noExplicitAny: ZodTuple 타입 사용 */
+      return zodType.def.items.map((item: any) => this.zodTypeToReqDefault(item, name));
     } else if (zodType instanceof z.ZodDate) {
       return "2000-01-01";
     } else if (zodType instanceof z.ZodLiteral) {
       return zodType.value;
     } else if (zodType instanceof z.ZodRecord || zodType instanceof z.ZodMap) {
-      const kvDef = (
-        zodType as z.ZodRecord<any, z.ZodType> | z.ZodMap<z.ZodType, z.ZodType>
-      ).def;
+      // biome-ignore lint/suspicious/noExplicitAny: ZodRecord 타입 사용
+      const kvDef = (zodType as z.ZodRecord<any, z.ZodType> | z.ZodMap<z.ZodType, z.ZodType>).def;
+      // biome-ignore lint/suspicious/noExplicitAny: ZodIntersection 타입 사용
       const key = this.zodTypeToReqDefault(kvDef.keyType, name) as any;
       const value = this.zodTypeToReqDefault(kvDef.valueType, name);
       return { [key]: value };
     } else if (zodType instanceof z.ZodSet) {
-      return [
-        this.zodTypeToReqDefault(
-          (zodType as z.ZodSet<z.ZodType>).def.valueType,
-          name
-        ),
-      ];
+      return [this.zodTypeToReqDefault((zodType as z.ZodSet<z.ZodType>).def.valueType, name)];
     } else if (zodType instanceof z.ZodIntersection) {
       return this.zodTypeToReqDefault(
         (zodType as z.ZodIntersection<z.ZodType, z.ZodType>).def.right,
-        name
+        name,
       );
     } else if (zodType instanceof z.ZodDefault) {
-      return this.zodTypeToReqDefault(
-        (zodType as z.ZodDefault<z.ZodType>).def.innerType,
-        name
-      );
+      return this.zodTypeToReqDefault((zodType as z.ZodDefault<z.ZodType>).def.innerType, name);
     } else {
       // console.log(zodType);
       return `unknown-${zodType.type}`;
@@ -161,7 +131,8 @@ export class Template__generated_http extends Template {
 
   resolveApiParams(
     api: ExtendedApi,
-    references: { [typeName: string]: z.ZodObject<any> }
+    // biome-ignore lint/suspicious/noExplicitAny: ZodObject 타입 사용
+    references: { [typeName: string]: z.ZodObject<any> },
   ): { [key: string]: unknown } {
     const reqType = getZodObjectFromApi(api, references);
     try {
@@ -170,9 +141,8 @@ export class Template__generated_http extends Template {
       };
       return def;
     } catch (error) {
-      throw new Error(
-        `Invalid zod type detected on ${api.modelName}:${api.methodName}`
-      );
+      console.error(error);
+      throw new Error(`Invalid zod type detected on ${api.modelName}:${api.methodName}`);
     }
   }
 }

package/src/template/implementations/generated_sso.template.ts

@@ -0,0 +1,151 @@
+import assert from "assert";
+import inflection from "inflection";
+import { unique } from "radashi";
+import { Sonamu } from "../../api";
+import type { Entity } from "../../entity/entity";
+import { EntityManager } from "../../entity/entity-manager";
+import { isManyToManyRelationProp } from "../../types/types";
+import { Template } from "../template";
+import type { SourceCode } from "./generated.template";
+
+export class Template__generated_sso extends Template {
+  constructor() {
+    super("generated_sso");
+  }
+
+  getTargetAndPath() {
+    const { dir } = Sonamu.config.api;
+
+    return {
+      target: `${dir}/src/application`,
+      path: `sonamu.generated.sso.ts`,
+    };
+  }
+
+  render() {
+    const entityIds = EntityManager.getAllIds();
+    const entities = entityIds.map((id) => EntityManager.get(id));
+
+    // SubsetQueries 생성 대상: 부모 엔티티가 없고 서브셋이 존재
+    const targetEntities = entities.filter(
+      (entity) => entity.parentId === undefined && Object.keys(entity.subsets).length > 0,
+    );
+
+    // SubsetQueries 생성
+    const sourceCodes: SourceCode[] = targetEntities.flatMap((entity) => {
+      const subsetKeys = Object.keys(entity.subsets);
+
+      const subsetKeyTypeName = `${entity.names.module}SubsetKey`;
+      const entityCamelName = inflection.camelize(entity.id, true);
+
+      // Puri 기반 SubsetQuery
+      const puriSubsetQuery: SourceCode = {
+        label: `SubsetQuery: ${entity.id}`,
+        lines: [
+          `export const ${entityCamelName}SubsetQueries = {`,
+          ...subsetKeys.map(
+            (subsetKey) => `${subsetKey}: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {
+            ${entity.getPuriSubsetQuery(subsetKey)};
+          },`,
+          ),
+          `};`,
+          "",
+        ],
+        importKeys: [],
+      };
+
+      // Puri 기반 SubsetLoadersQuery
+      const puriLoaderQuery: SourceCode = {
+        label: `LoaderQuery: ${entity.id}`,
+        lines: [
+          `export const ${entityCamelName}LoaderQueries = {`,
+          ...subsetKeys.map((subsetKey) => {
+            return `${subsetKey}: ${entity.getPuriLoaderQuery(subsetKey)},`;
+          }),
+          `} as const satisfies PuriLoaderQueries<${subsetKeyTypeName}>;`,
+          "",
+        ],
+        importKeys: [subsetKeyTypeName],
+      };
+
+      return [puriSubsetQuery, puriLoaderQuery];
+    });
+
+    // DatabaseSchema 생성
+    const dbSchemaSourceCode = this.getDatabaseSchemaSourceCode(entities);
+    if (dbSchemaSourceCode) {
+      sourceCodes.push(dbSchemaSourceCode);
+    }
+
+    const sourceCode = sourceCodes.reduce(
+      (result, ts) => {
+        if (ts === null) {
+          return result;
+        }
+        assert(result);
+        return {
+          lines: [...result.lines, `// ${ts.label}`, ...ts.lines, ""],
+          importKeys: unique([...result.importKeys, ...ts.importKeys]),
+        };
+      },
+      {
+        lines: [],
+        importKeys: [],
+      } as Omit<SourceCode, "label">,
+    );
+
+    const body = sourceCode.lines.join("\n");
+    const isUsingManyToManyBaseSchema = body.includes("ManyToManyBaseSchema");
+
+    const sonamuImports = [
+      "PuriWrapper",
+      "DatabaseSchemaExtend",
+      "PuriLoaderQueries",
+      isUsingManyToManyBaseSchema ? "ManyToManyBaseSchema" : "",
+    ]
+      .filter(Boolean)
+      .join(", ");
+
+    return {
+      ...this.getTargetAndPath(),
+      body: sourceCode.lines.join("\n"),
+      importKeys: sourceCode.importKeys,
+      customHeaders: [`import { ${sonamuImports} } from "sonamu";`],
+    };
+  }
+
+  getDatabaseSchemaSourceCode(entities: Entity[]): SourceCode | null {
+    if (entities.length === 0) {
+      return null;
+    }
+
+    const entitySchemaLines = entities.map((entity) => `${entity.table}: ${entity.id}BaseSchema;`);
+
+    const joinTables = unique(
+      entities.flatMap((entity) =>
+        entity.props.filter(isManyToManyRelationProp).map((prop) => {
+          const fromTableKey = inflection.singularize(entity.table);
+          const toTableKey = inflection.singularize(EntityManager.get(prop.with).table);
+          return { table: prop.joinTable, fromTableKey, toTableKey };
+        }),
+      ),
+      (joinTable) => joinTable.table,
+    );
+
+    return {
+      label: `DatabaseSchema`,
+      lines: [
+        `declare module "sonamu" {`,
+        `  export interface DatabaseSchemaExtend {`,
+        ...entitySchemaLines,
+        ...joinTables.map(
+          (joinTable) =>
+            `${joinTable.table}: ManyToManyBaseSchema<"${joinTable.fromTableKey}", "${joinTable.toTableKey}">;`,
+        ),
+        `  }`,
+        `}`,
+      ],
+      importKeys: entities.map((entity) => `${entity.id}BaseSchema`),
+    };
+  }
+}

package/src/{templates → template/implementations}/init_types.template.ts

@@ -1,7 +1,7 @@
-import { TemplateOptions } from "../types/types";
-import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
-import { Template } from "./base-template";
-import { Sonamu } from "../api";
+import { Sonamu } from "../../api";
+import { EntityManager, type EntityNamesRecord } from "../../entity/entity-manager";
+import type { TemplateOptions } from "../../types/types";
+import { Template } from "../template";
 
 export class Template__init_types extends Template {
   constructor() {
@@ -21,9 +21,7 @@ export class Template__init_types extends Template {
     const names = EntityManager.getNamesFromId(entityId);
 
     const hasCreatedAt =
-      EntityManager.get(entityId).props.find(
-        (prop) => prop.name === "created_at"
-      ) !== undefined;
+      EntityManager.get(entityId).props.find((prop) => prop.name === "created_at") !== undefined;
 
     return {
       ...this.getTargetAndPath(names),

package/src/{templates → template/implementations}/model.template.ts

@@ -1,8 +1,10 @@
-import { RenderingNode, TemplateOptions } from "../types/types";
-import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
-import { Template } from "./base-template";
+import { Sonamu } from "../../api";
+import { EntityManager, type EntityNamesRecord } from "../../entity/entity-manager";
+import { Naite } from "../../naite/naite";
+import type { TemplateOptions } from "../../types/types";
+import { Template } from "../template";
+import { getZodTypeById, zodTypeToRenderingNode } from "../zod-converter";
 import { Template__view_list } from "./view_list.template";
-import { Sonamu } from "../api";
 
 export class Template__model extends Template {
   constructor() {
@@ -18,11 +20,12 @@ export class Template__model extends Template {
     };
   }
 
-  render(
-    { entityId }: TemplateOptions["model"],
-    _columnsNode: RenderingNode,
-    listParamsNode: RenderingNode
-  ) {
+  async render({ entityId }: TemplateOptions["model"]) {
+    Naite.t("render", { entityId });
+
+    const listParamsZodType = await getZodTypeById(`${entityId}ListParams`);
+    const listParamsNode = zodTypeToRenderingNode(listParamsZodType);
+
     const names = EntityManager.getNamesFromId(entityId);
     const entity = EntityManager.get(entityId);
 
@@ -35,20 +38,26 @@ export class Template__model extends Template {
     return {
       ...this.getTargetAndPath(names),
       body: `
-import { BaseModelClass, ListResult, asArray, NotFoundException, BadRequestException, api } from 'sonamu';
+import { BaseModelClass, type ListResult, asArray, NotFoundException, BadRequestException, api, exhaustive } from 'sonamu';
 import {
   ${entityId}SubsetKey,
   ${entityId}SubsetMapping,
 } from "../sonamu.generated";
 import {
   ${names.camel}SubsetQueries,
+  ${names.camel}LoaderQueries,
 } from "../sonamu.generated.sso";
 import { ${entityId}ListParams, ${entityId}SaveParams } from "./${names.fs}.types";
 
 /*
   ${entityId} Model
 */
-class ${entityId}ModelClass extends BaseModelClass {
+class ${entityId}ModelClass extends BaseModelClass<
+  ${entityId}SubsetKey,
+  ${entityId}SubsetMapping,
+  typeof ${names.camel}SubsetQueries,
+  typeof ${names.camel}LoaderQueries
+> {
   modelName = "${entityId}";
 
   @api({ httpMethod: "GET", clients: ["axios", "swr"], resourceName: "${entityId}" })
@@ -96,38 +105,38 @@ class ${entityId}ModelClass extends BaseModelClass {
     };
 
     // build queries
-    let { rows, total } = await this.runSubsetQuery({
+    const { qb, onSubset: _ } = this.getSubsetQueries(subset);
+    
+    // id
+    if (params.id) {
+      qb.whereIn("${entity.table}.id", asArray(params.id));
+    }
+
+    // search-keyword
+    if (params.search && params.keyword && params.keyword.length > 0) {
+      if (params.search === "id") {
+        qb.where("${entity.table}.id", Number(params.keyword));
+        // } else if (params.search === "field") {
+        //   qb.where("${entity.table}.field", "like", \`%\${params.keyword}%\`);
+      } else {
+        throw new BadRequestException(\`구현되지 않은 검색 필드 \${params.search}\`);
+      }
+    }
+      
+    // orderBy
+    if (params.orderBy) {
+      // default orderBy
+      if (params.orderBy === "id-desc") {
+        qb.orderBy("${entity.table}.id", "desc");
+      } else {
+        exhaustive(params.orderBy);
+      }
+    }
+    
+    const { rows, total } = await this.executeSubsetQuery({
       subset,
+      qb,
       params,
-      subsetQuery: ${names.camel}SubsetQueries[subset],
-      build: ({ qb }) => {
-        // id
-        if (params.id) {
-          qb.whereIn("${entity.table}.id", asArray(params.id));
-        }
-
-        // search-keyword
-        if (params.search && params.keyword && params.keyword.length > 0) {
-          if (params.search === "id") {
-            qb.where("${entity.table}.id", params.keyword);
-          // } else if (params.search === "field") {
-          //   qb.where("${entity.table}.field", "like", \`%\${params.keyword}%\`);
-          } else {
-            throw new BadRequestException(
-              \`구현되지 않은 검색 필드 \${params.search}\`
-            );
-          }
-        }
-
-        // orderBy
-        if (params.orderBy) {
-          // default orderBy
-          const [orderByField, orderByDirec] = params.orderBy.split("-");
-          qb.orderBy("${entity.table}." + orderByField, orderByDirec);
-        }
-
-        return qb;
-      },
       debug: false,
     });
 
@@ -144,7 +153,7 @@ class ${entityId}ModelClass extends BaseModelClass {
     const wdb = this.getPuri("w");
 
     // register
-    spa.map((sp) => {
+    spa.forEach((sp) => {
       wdb.ubRegister("${entity.table}", sp);
     });
 
@@ -169,7 +178,7 @@ class ${entityId}ModelClass extends BaseModelClass {
   }
 }
 
-export const ${entityId}Model = new ${entityId}ModelClass();
+export const ${entityId}Model = new ${entityId}ModelClass(${names.camel}SubsetQueries, ${names.camel}LoaderQueries);
       `.trim(),
       importKeys: [],
     };

package/src/{templates → template/implementations}/model_test.template.ts

@@ -1,7 +1,7 @@
-import { TemplateOptions } from "../types/types";
-import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
-import { Template } from "./base-template";
-import { Sonamu } from "../api";
+import { Sonamu } from "../../api";
+import { EntityManager, type EntityNamesRecord } from "../../entity/entity-manager";
+import type { TemplateOptions } from "../../types/types";
+import { Template } from "../template";
 
 export class Template__model_test extends Template {
   constructor() {
@@ -26,7 +26,7 @@ export class Template__model_test extends Template {
 import { describe, test, expect } from "vitest";
 import { bootstrap } from '../../testing/bootstrap';
 
-bootstrap([]);
+bootstrap();
 describe.skip("${entityId}ModelTest", () => {
   test("Query", async () => {
     expect(true).toBe(true);