sonamu 0.5.7 → 0.7.0

package/src/template/entity-converter.ts

@@ -0,0 +1,114 @@
+import assert from "assert";
+import z from "zod";
+import { EntityManager } from "../entity/entity-manager";
+import { ServiceUnavailableException } from "../exceptions/so-exceptions";
+import type { EntityPropNode, RenderingNode } from "../types/types";
+import { propToZodType, zodTypeToRenderingNode } from "./zod-converter";
+
+/**
+ * 엔티티의 특정 subset을 RenderingNode로 변환합니다.
+ * subset의 필드들을 Zod 타입으로 변환한 후 UI 렌더링용 노드로 만듭니다.
+ * object와 array의 경우 적절한 pick 필드를 자동으로 선택합니다.
+ */
+export async function getColumnsNode(entityId: string, subsetKey: string): Promise<RenderingNode> {
+  const entity = EntityManager.get(entityId);
+  const subset = entity.subsets[subsetKey];
+  if (subset === undefined) {
+    throw new ServiceUnavailableException(`Subset ${subsetKey} 가 없습니다.`);
+  }
+  const propNodes = entity.fieldExprsToPropNodes(subset);
+  const rootPropNode: EntityPropNode = {
+    nodeType: "object",
+    children: propNodes,
+  };
+
+  // biome-ignore lint/suspicious/noExplicitAny: zod 스키마를 로드할 때 사용하는 타입
+  const columnsZodType = (await propNodeToZodType(rootPropNode)) as z.ZodObject<any>;
+
+  const columnsNode = zodTypeToRenderingNode(columnsZodType);
+  assert(columnsNode.children !== undefined, "columnsNode.children is undefined");
+  columnsNode.children = columnsNode.children.map((child) => {
+    if (child.renderType === "object") {
+      assert(child.children !== undefined, "child.children is undefined");
+      const pickedCol = child.children.find((cc) => ["title", "name"].includes(cc.name));
+      if (pickedCol) {
+        return {
+          ...child,
+          renderType: "object-pick",
+          config: {
+            picked: pickedCol.name,
+          },
+        };
+      } else {
+        return child;
+      }
+    } else if (
+      child.renderType === "array" &&
+      child.element &&
+      child.element.renderType === "object"
+    ) {
+      const pickedCol = child.element?.children?.find((cc) => ["title", "name"].includes(cc.name));
+      if (pickedCol) {
+        return {
+          ...child,
+          element: {
+            ...child.element,
+            renderType: "object-pick",
+            config: {
+              picked: pickedCol.name,
+            },
+          },
+        };
+      } else {
+        return child;
+      }
+    }
+    return child;
+  });
+
+  return columnsNode;
+}
+
+/**
+ * EntityPropNode를 Zod 타입으로 변환합니다.
+ * plain, array, object 세 가지 nodeType을 재귀적으로 처리합니다.
+ */
+export async function propNodeToZodType(propNode: EntityPropNode): Promise<z.ZodTypeAny> {
+  if (propNode.nodeType === "plain") {
+    return propToZodType(propNode.prop);
+  } else if (propNode.nodeType === "array") {
+    if (propNode.prop === undefined) {
+      throw new Error();
+    } else if (propNode.children.length > 0) {
+      return (
+        await propNodeToZodType({
+          ...propNode,
+          nodeType: "object",
+        })
+      ).array();
+    } else {
+      const innerType = await propToZodType(propNode.prop);
+      if (propNode.prop.nullable === true) {
+        return z.array(innerType).nullable();
+      } else {
+        return z.array(innerType);
+      }
+    }
+  } else if (propNode.nodeType === "object") {
+    const entries = await Promise.all(
+      propNode.children.map(async (childPropNode) => {
+        assert(childPropNode.prop?.name !== undefined, "childPropNode.prop.name is undefined");
+        return [childPropNode.prop.name, await propNodeToZodType(childPropNode)] as const;
+      }),
+    );
+    const obj = Object.fromEntries(entries);
+
+    if (propNode.prop?.nullable === true) {
+      return z.object(obj).nullable();
+    } else {
+      return z.object(obj);
+    }
+  } else {
+    throw Error;
+  }
+}

package/src/template/helpers.ts

@@ -0,0 +1,81 @@
+import inflection from "inflection";
+import { EntityManager, type EntityNamesRecord } from "../entity/entity-manager";
+import { isEnumProp, isRelationProp, type RelationProp } from "../types/types";
+
+/**
+ * Enum의 표시용 라벨을 가져옵니다.
+ * OrderBy, SearchField 등 특수한 경우와 일반 Enum을 구분하여 처리합니다.
+ */
+export function getLabel(entityId: string, enumId: string): string {
+  if (enumId.endsWith("OrderBy")) {
+    return "정렬";
+  } else if (enumId.endsWith("SearchField")) {
+    return "검색";
+  } else {
+    const enumProp = EntityManager.get(entityId).props.find(
+      (prop) => `${entityId}${inflection.camelize(prop.name)}` === enumId,
+    );
+    if (enumProp?.desc) {
+      return enumProp.desc;
+    }
+    return enumId;
+  }
+}
+
+/**
+ * 컬럼 이름으로부터 Enum 정보를 추출합니다.
+ * Entity의 prop 중 enum 타입인 것을 찾아 관련 정보를 반환합니다.
+ */
+export function getEnumInfoFromColName(
+  entityId: string,
+  colName: string,
+): {
+  id: string;
+  targetEntityNames: EntityNamesRecord;
+  targetEntityId: string;
+  title: string;
+} {
+  const baseEntity = EntityManager.get(entityId);
+  const prop = baseEntity.props.find((p) => p.name === colName);
+  if (prop && isEnumProp(prop)) {
+    return {
+      id: prop.id,
+      targetEntityId: entityId,
+      targetEntityNames: EntityManager.getNamesFromId(entityId),
+      title: prop.desc ?? prop.id,
+    };
+  } else {
+    const idCandidate = inflection.camelize(
+      `${inflection.underscore(entityId)}_${inflection.underscore(colName)}`,
+      false,
+    );
+    try {
+      const targetEntityNames = EntityManager.getNamesFromId(entityId);
+      return {
+        id: idCandidate,
+        targetEntityId: entityId,
+        targetEntityNames: targetEntityNames,
+        title: idCandidate,
+      };
+    } catch {}
+    throw new Error(`찾을 수 없는 EnumProp ${colName}`);
+  }
+}
+
+/**
+ * 컬럼 이름으로부터 Relation prop 정보를 가져옵니다.
+ * 관계형 prop이 아닌 경우 에러를 발생시킵니다.
+ */
+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)) {
+    const relEntity = EntityManager.get(relProp.with);
+    if (relEntity.parentId !== undefined) {
+      throw new Error("Only parent entities can be used as relation props");
+    }
+    return relProp;
+  } else {
+    throw new Error(`찾을 수 없는 Relation ${colName}`);
+  }
+}

package/src/{templates → template/implementations}/entity.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__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/{templates → template/implementations}/generated.template.ts

@@ -1,12 +1,13 @@
-import _ from "lodash";
-import { TemplateOptions } from "../types/types";
-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 "./base-template";
-import { nonNullable } from "../utils/utils";
-import { Sonamu } from "../api";
+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 { Naite } from "../../naite/naite";
+import { type EntityPropNode, isVirtualProp } from "../../types/types";
+import { nonNullable } from "../../utils/utils";
+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),
     };
   }
 }