sonamu 0.6.0 → 0.7.1

package/src/template/helpers.ts

@@ -1,6 +1,6 @@
 import inflection from "inflection";
-import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
-import { isEnumProp, isRelationProp, RelationProp } from "../types/types";
+import { EntityManager, type EntityNamesRecord } from "../entity/entity-manager";
+import { isEnumProp, isRelationProp, type RelationProp } from "../types/types";
 
 /**
  * Enum의 표시용 라벨을 가져옵니다.
@@ -13,9 +13,9 @@ export function getLabel(entityId: string, enumId: string): string {
     return "검색";
   } else {
     const enumProp = EntityManager.get(entityId).props.find(
-      (prop) => `${entityId}${inflection.camelize(prop.name)}` === enumId
+      (prop) => `${entityId}${inflection.camelize(prop.name)}` === enumId,
     );
-    if (enumProp && enumProp.desc) {
+    if (enumProp?.desc) {
       return enumProp.desc;
     }
     return enumId;
@@ -28,7 +28,7 @@ export function getLabel(entityId: string, enumId: string): string {
  */
 export function getEnumInfoFromColName(
   entityId: string,
-  colName: string
+  colName: string,
 ): {
   id: string;
   targetEntityNames: EntityNamesRecord;
@@ -46,8 +46,8 @@ export function getEnumInfoFromColName(
     };
   } else {
     const idCandidate = inflection.camelize(
-      inflection.underscore(entityId) + "_" + inflection.underscore(colName),
-      false
+      `${inflection.underscore(entityId)}_${inflection.underscore(colName)}`,
+      false,
     );
     try {
       const targetEntityNames = EntityManager.getNamesFromId(entityId);
@@ -66,10 +66,7 @@ export function getEnumInfoFromColName(
  * 컬럼 이름으로부터 Relation prop 정보를 가져옵니다.
  * 관계형 prop이 아닌 경우 에러를 발생시킵니다.
  */
-export function getRelationPropFromColName(
-  entityId: string,
-  colName: string
-): RelationProp {
+export function getRelationPropFromColName(entityId: string, colName: string): RelationProp {
   const baseEntity = EntityManager.get(entityId);
   const relProp = baseEntity.props.find((prop) => prop.name === colName);
   if (isRelationProp(relProp)) {

package/src/template/implementations/entity.template.ts

@@ -1,7 +1,7 @@
-import { TemplateOptions } from "../../types/types";
-import { EntityManager, EntityNamesRecord } from "../../entity/entity-manager";
-import { Template } from "../template";
 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__entity extends Template {
   constructor() {
@@ -38,11 +38,11 @@ export class Template__entity extends Template {
         id: entityId,
         title: title ?? entityId,
         parentId,
-        table: table ?? names.fsPlural.replace(/\-/g, "_"),
+        table: table ?? names.fsPlural.replace(/-/g, "_"),
         props: options.props?.length
           ? options.props
           : [
-              { name: "id", type: "integer", unsigned: true, desc: "ID" },
+              { name: "id", type: "integer", desc: "ID" },
               ...(parent
                 ? [
                     {
@@ -58,7 +58,7 @@ export class Template__entity extends Template {
                 : []),
               {
                 name: "created_at",
-                type: "timestamp",
+                type: "date",
                 desc: "등록일시",
                 dbDefault: "CURRENT_TIMESTAMP",
               },

package/src/template/implementations/generated.template.ts

@@ -1,12 +1,13 @@
-import * as _ from "lodash-es";
-import { TemplateOptions } from "../../types/types";
+import assert from "assert";
+import { unique } from "radashi";
+import { Sonamu } from "../../api";
+import type { Entity } from "../../entity/entity";
 import { EntityManager } from "../../entity/entity-manager";
-import { Entity } from "../../entity/entity";
-import { EntityPropNode } from "../../types/types";
-import { propNodeToZodTypeDef, zodTypeToZodCode } from "../../api/code-converters";
-import { Template } from "../template";
+import { Naite } from "../../naite/naite";
+import { type EntityPropNode, isVirtualProp } from "../../types/types";
 import { nonNullable } from "../../utils/utils";
-import { Sonamu } from "../../api";
+import { Template } from "../template";
+import { propNodeToZodTypeDef, zodTypeToZodCode } from "../zod-converter";
 
 export type SourceCode = {
   label: string;
@@ -20,37 +21,28 @@ export class Template__generated extends Template {
 
   getTargetAndPath() {
     const { dir } = Sonamu.config.api;
-
     return {
       target: `${dir}/src/application`,
       path: `sonamu.generated.ts`,
     };
   }
-
-  render({}: TemplateOptions["generated"]) {
+  render() {
     const entityIds = EntityManager.getAllIds();
     const entities = entityIds.map((id) => EntityManager.get(id));
 
     // 전체 SourceCode 생성
-    const sourceCodes = entities
-      .map((entity) => {
-        return [
-          this.getEnumsSourceCode(entity),
-          this.getBaseSchemaSourceCode(entity),
-          this.getBaseListParamsSourceCode(entity),
-          this.getSubsetSourceCode(entity),
-        ].filter(nonNullable);
-      })
-      .flat();
+    const sourceCodes = entities.flatMap((entity) => {
+      return [
+        this.getEnumsSourceCode(entity),
+        this.getBaseSchemaSourceCode(entity),
+        this.getBaseListParamsSourceCode(entity),
+        this.getSubsetSourceCode(entity),
+      ].filter(nonNullable);
+    });
+    Naite.t("Template__generated:sourceCodes", sourceCodes);
 
     // Sort
-    const LABEL_KEY_ORDER = [
-      "Enums",
-      "BaseSchema",
-      "BaseListParams",
-      "Subsets",
-      "SubsetQueries",
-    ];
+    const LABEL_KEY_ORDER = ["Enums", "BaseSchema", "BaseListParams", "Subsets", "SubsetQueries"];
     sourceCodes.sort((a, b) => {
       const [aKey] = a.label.split(":");
       const [bKey] = b.label.split(":");
@@ -71,47 +63,45 @@ export class Template__generated extends Template {
           return result;
         }
         return {
-          lines: [...result!.lines, `// ${ts.label}`, ...ts.lines, ""],
-          importKeys: _.uniq([...result!.importKeys, ...ts.importKeys].sort()),
+          lines: [...result.lines, `// ${ts.label}`, ...ts.lines, ""],
+          importKeys: unique([...result.importKeys, ...ts.importKeys].sort()),
         };
       },
       {
         lines: [],
         importKeys: [],
-      } as Omit<SourceCode, "label">
+      } as Omit<SourceCode, "label">,
     );
 
     // .types.ts의 타입을 참조하는 경우 순환참조(상호참조)가 발생하므로 타입을 가져와 인라인 처리
-    const allTypeKeys = entities
-      .map((entity) => Object.keys(entity.types))
-      .flat();
+    const allTypeKeys = entities.flatMap((entity) => Object.keys(entity.types));
     const cdImportKeys = sourceCode.importKeys.filter((importKey) =>
-      allTypeKeys.includes(importKey)
+      allTypeKeys.includes(importKey),
     );
     if (cdImportKeys.length > 0) {
-      const customScalarLines = cdImportKeys
-        .map((importKey) => {
-          const entity = entities.find((entity) => entity.types[importKey]);
-          if (!entity) {
-            throw new Error(`ZodType not found ${importKey}`);
-          }
-          const zodType = entity.types[importKey]!;
-
-          return [
-            `// CustomScalar: ${importKey}`,
-            `const ${importKey} = ${zodTypeToZodCode(zodType)};`,
-            `type ${importKey} = z.infer<typeof ${importKey}>`,
-            "",
-          ];
-        })
-        .flat();
+      const customScalarLines = cdImportKeys.flatMap((importKey) => {
+        const entity = entities.find((entity) => entity.types[importKey]);
+        if (!entity) {
+          throw new Error(`ZodType not found ${importKey}`);
+        }
+        const zodType = entity.types[importKey];
+        assert(zodType);
+
+        return [
+          `// CustomScalar: ${importKey}`,
+          `const ${importKey} = ${zodTypeToZodCode(zodType)};`,
+          `type ${importKey} = z.infer<typeof ${importKey}>`,
+          "",
+        ];
+      });
       sourceCode.lines = [...customScalarLines, ...sourceCode.lines];
       sourceCode.importKeys = sourceCode.importKeys.filter(
-        (importKey) => !cdImportKeys.includes(importKey)
+        (importKey) => !cdImportKeys.includes(importKey),
       );
     }
 
     const body = sourceCode.lines.join("\n");
+    Naite.t("Template__generated:body", body);
 
     // import
     const sonamuImports = [
@@ -126,6 +116,9 @@ export class Template__generated extends Template {
       body,
       importKeys: sourceCode.importKeys,
       customHeaders: [
+        "/** biome-ignore-all lint: generated는 무시 */",
+        "/** biome-ignore-all assist: generated는 무시 */",
+        "",
         `import { z } from 'zod';`,
         `import { ${sonamuImports.join(",")} } from "sonamu";`,
       ],
@@ -141,23 +134,19 @@ export class Template__generated extends Template {
       lines: [
         ...Object.entries(entity.enumLabels)
           .filter(([_, enumLabel]) => Object.keys(enumLabel).length > 0)
-          .map(([enumId, enumLabel]) => [
+          .flatMap(([enumId, enumLabel]) => [
             `export const ${enumId} = z.enum([${Object.keys(enumLabel).map(
-              (el) => `"${el}"`
+              (el) => `"${el}"`,
             )}]).describe("${enumId}");`,
-            `export type ${enumId} = z.infer<typeof ${enumId}>`,
-            `export const ${enumId}Label = ${JSON.stringify(enumLabel)}`,
-          ])
-          .flat(),
+            `export type ${enumId} = z.infer<typeof ${enumId}>;`,
+            `export const ${enumId}Label = ${JSON.stringify(enumLabel)};`,
+          ]),
       ],
       importKeys: [],
     };
   }
 
-  getBaseSchemaSourceCode(
-    entity: Entity,
-    importKeys: string[] = []
-  ): SourceCode {
+  getBaseSchemaSourceCode(entity: Entity, importKeys: string[] = []): SourceCode {
     const schemaName = `${entity.names.module}BaseSchema`;
     const propNode: EntityPropNode = {
       nodeType: "object",
@@ -169,23 +158,39 @@ export class Template__generated extends Template {
       }),
     };
 
-    const schemaBody = propNodeToZodTypeDef(propNode, importKeys);
+    const schemaBody = (() => {
+      const result = propNodeToZodTypeDef(propNode, importKeys);
+      if (result.endsWith(",")) {
+        return result.slice(0, -1);
+      }
+
+      return result;
+    })();
 
     // fulltext index에 포함된 컬럼들 추출
-    const fulltextColumns = _.uniq(
-      entity.indexes
-        .filter((index) => index.type === "fulltext")
-        .flatMap((index) => index.columns)
+    const fulltextColumns = unique(
+      entity.indexes.filter((index) => index.type === "fulltext").flatMap((index) => index.columns),
     );
 
+    // virtual props
+    const virtualProps = entity.props
+      .filter((prop) => isVirtualProp(prop))
+      .map((prop) => prop.name);
+
     const lines = [
-      `export const ${schemaName} = ${schemaBody}`,
+      `export const ${schemaName} = ${schemaBody};`,
       `export type ${schemaName} = z.infer<typeof ${schemaName}>` +
         (fulltextColumns.length > 0
           ? ` & { readonly __fulltext__: readonly [${fulltextColumns
               .map((col) => `"${col}"`)
               .join(", ")}] }`
-          : ""),
+          : "") +
+        (virtualProps.length > 0
+          ? ` & { readonly __virtual__: readonly [${virtualProps
+              .map((prop) => `"${prop}"`)
+              .join(", ")}] }`
+          : "") +
+        ";",
     ];
 
     return {
@@ -234,7 +239,7 @@ z.object({
 
     const lines = [
       `export const ${schemaName} = ${schemaBody}`,
-      `export type ${schemaName} = z.infer<typeof ${schemaName}>`,
+      `export type ${schemaName} = z.infer<typeof ${schemaName}>;`,
     ];
 
     return {
@@ -245,7 +250,7 @@ z.object({
   }
 
   getSubsetSourceCode(entity: Entity): SourceCode | null {
-    if (Object.keys(entity.subsets).length == 0) {
+    if (Object.keys(entity.subsets).length === 0) {
       return null;
     } else if (entity.parentId !== undefined) {
       return null;
@@ -254,45 +259,40 @@ z.object({
     const subsetKeys = Object.keys(entity.subsets);
     const importKeys: string[] = [];
     const lines: string[] = [
-      ...subsetKeys
-        .map((subsetKey) => {
-          // 서브셋에서 FieldExpr[] 가져옴
-          const fieldExprs = entity.subsets[subsetKey];
-
-          // FieldExpr[]로 EntityPropNode[] 가져옴
-          const propNodes = entity.fieldExprsToPropNodes(fieldExprs);
-          const schemaName = `${entity.names.module}Subset${subsetKey}`;
-          const propNode: EntityPropNode = {
-            nodeType: "object",
-            children: propNodes,
-          };
-
-          // EntityPropNode[]로 ZodTypeDef(string)을 가져옴
-          const body = propNodeToZodTypeDef(propNode, importKeys);
-
-          return [
-            `export const ${schemaName} = ${body}`,
-            `export type ${schemaName} = z.infer<typeof ${schemaName}>`,
-          ];
-        })
-        .flat(),
+      ...subsetKeys.flatMap((subsetKey) => {
+        // 서브셋에서 FieldExpr[] 가져옴
+        const fieldExprs = entity.subsets[subsetKey];
+
+        // FieldExpr[]로 EntityPropNode[] 가져옴
+        const propNodes = entity.fieldExprsToPropNodes(fieldExprs);
+        const schemaName = `${entity.names.module}Subset${subsetKey}`;
+        const propNode: EntityPropNode = {
+          nodeType: "object",
+          children: propNodes,
+        };
+
+        // EntityPropNode[]로 ZodTypeDef(string)을 가져옴
+        const body = propNodeToZodTypeDef(propNode, importKeys);
+
+        return [
+          `export const ${schemaName} = ${body.replace(/,$/, "")};`,
+          `export type ${schemaName} = z.infer<typeof ${schemaName}>;`,
+        ];
+      }),
       `export type ${entity.names.module}SubsetMapping = {`,
-      ...subsetKeys.map(
-        (subsetKey) =>
-          `  ${subsetKey}: ${entity.names.module}Subset${subsetKey};`
-      ),
-      "}",
+      ...subsetKeys.map((subsetKey) => `  ${subsetKey}: ${entity.names.module}Subset${subsetKey};`),
+      "};",
       `export const ${entity.names.module}SubsetKey = z.enum([${subsetKeys
         .map((k) => `"${k}"`)
         .join(",")}]);`,
-      `export type ${entity.names.module}SubsetKey = z.infer<typeof ${entity.names.module}SubsetKey>`,
+      `export type ${entity.names.module}SubsetKey = z.infer<typeof ${entity.names.module}SubsetKey>;`,
       "",
     ];
 
     return {
       label: `Subsets: ${entity.id}`,
       lines,
-      importKeys: _.uniq(importKeys),
+      importKeys: unique(importKeys),
     };
   }
 }

package/src/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 "../template";
-import prettier from "prettier";
+import type { ExtendedApi } from "../../api/decorators";
 import { Sonamu } from "../../api/sonamu";
+import { Template } from "../template";
 
 export class Template__generated_http extends Template {
   constructor() {
@@ -21,7 +19,7 @@ export class Template__generated_http extends Template {
     };
   }
 
-  async render({}: TemplateOptions["generated_http"]) {
+  async render() {
     const {
       syncer: { types, apis },
       config: {
@@ -38,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)],
             };
           }
         })();
@@ -67,7 +55,7 @@ export class Template__generated_http extends Template {
           `Content-Type: ${api.options.contentType ?? "application/json"}`,
           ...dataLines.body,
         ].join("\n");
-      })
+      }),
     );
 
     return {
@@ -83,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";
@@ -110,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}`;
@@ -163,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 {
@@ -173,9 +142,7 @@ export class Template__generated_http extends Template {
       return def;
     } catch (error) {
       console.error(error);
-      throw new Error(
-        `Invalid zod type detected on ${api.modelName}:${api.methodName}`
-      );
+      throw new Error(`Invalid zod type detected on ${api.modelName}:${api.methodName}`);
     }
   }
 }