sonamu 0.5.6 → 0.6.0

package/dist/template/entity-converter.js

@@ -0,0 +1,101 @@
+import z from "zod";
+import { EntityManager } from "../entity/entity-manager.js";
+import { ServiceUnavailableException } from "../exceptions/so-exceptions.js";
+import { zodTypeToRenderingNode, propToZodType } from "./zod-converter.js";
+/**
+ * 엔티티의 특정 subset을 RenderingNode로 변환합니다.
+ * subset의 필드들을 Zod 타입으로 변환한 후 UI 렌더링용 노드로 만듭니다.
+ * object와 array의 경우 적절한 pick 필드를 자동으로 선택합니다.
+ */ export async function getColumnsNode(entityId, subsetKey) {
+    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 = {
+        nodeType: "object",
+        children: propNodes
+    };
+    const columnsZodType = await propNodeToZodType(rootPropNode);
+    const columnsNode = zodTypeToRenderingNode(columnsZodType);
+    columnsNode.children = columnsNode.children.map((child)=>{
+        if (child.renderType === "object") {
+            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) {
+    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 obj = await propNode.children.reduce(async (promise, childPropNode)=>{
+            const result = await promise;
+            result[childPropNode.prop.name] = await propNodeToZodType(childPropNode);
+            return result;
+        }, {});
+        if (propNode.prop?.nullable === true) {
+            return z.object(obj).nullable();
+        } else {
+            return z.object(obj);
+        }
+    } else {
+        throw Error;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/template/entity-converter.ts"],"sourcesContent":["import z from \"zod\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { ServiceUnavailableException } from \"../exceptions/so-exceptions\";\nimport { EntityPropNode, RenderingNode } from \"../types/types\";\nimport { zodTypeToRenderingNode, propToZodType } from \"./zod-converter\";\n\n/**\n * 엔티티의 특정 subset을 RenderingNode로 변환합니다.\n * subset의 필드들을 Zod 타입으로 변환한 후 UI 렌더링용 노드로 만듭니다.\n * object와 array의 경우 적절한 pick 필드를 자동으로 선택합니다.\n */\nexport async function getColumnsNode(\n  entityId: string,\n  subsetKey: string\n): Promise<RenderingNode> {\n  const entity = EntityManager.get(entityId);\n  const subset = entity.subsets[subsetKey];\n  if (subset === undefined) {\n    throw new ServiceUnavailableException(`Subset ${subsetKey} 가 없습니다.`);\n  }\n  const propNodes = entity.fieldExprsToPropNodes(subset);\n  const rootPropNode: EntityPropNode = {\n    nodeType: \"object\",\n    children: propNodes,\n  };\n\n  const columnsZodType = (await propNodeToZodType(\n    rootPropNode\n  )) as z.ZodObject<any>;\n\n  const columnsNode = zodTypeToRenderingNode(columnsZodType);\n  columnsNode.children = columnsNode.children!.map((child) => {\n    if (child.renderType === \"object\") {\n      const pickedCol = child.children!.find((cc) =>\n        [\"title\", \"name\"].includes(cc.name)\n      );\n      if (pickedCol) {\n        return {\n          ...child,\n          renderType: \"object-pick\",\n          config: {\n            picked: pickedCol.name,\n          },\n        };\n      } else {\n        return child;\n      }\n    } else if (\n      child.renderType === \"array\" &&\n      child.element &&\n      child.element.renderType === \"object\"\n    ) {\n      const pickedCol = child.element!.children!.find((cc) =>\n        [\"title\", \"name\"].includes(cc.name)\n      );\n      if (pickedCol) {\n        return {\n          ...child,\n          element: {\n            ...child.element,\n            renderType: \"object-pick\",\n            config: {\n              picked: pickedCol.name,\n            },\n          },\n        };\n      } else {\n        return child;\n      }\n    }\n    return child;\n  });\n\n  return columnsNode;\n}\n\n/**\n * EntityPropNode를 Zod 타입으로 변환합니다.\n * plain, array, object 세 가지 nodeType을 재귀적으로 처리합니다.\n */\nexport async function propNodeToZodType(\n  propNode: EntityPropNode\n): Promise<z.ZodTypeAny> {\n  if (propNode.nodeType === \"plain\") {\n    return propToZodType(propNode.prop);\n  } else if (propNode.nodeType === \"array\") {\n    if (propNode.prop === undefined) {\n      throw new Error();\n    } else if (propNode.children.length > 0) {\n      return (\n        await propNodeToZodType({\n          ...propNode,\n          nodeType: \"object\",\n        })\n      ).array();\n    } else {\n      const innerType = await propToZodType(propNode.prop);\n      if (propNode.prop.nullable === true) {\n        return z.array(innerType).nullable();\n      } else {\n        return z.array(innerType);\n      }\n    }\n  } else if (propNode.nodeType === \"object\") {\n    const obj = await propNode.children.reduce(\n      async (promise, childPropNode) => {\n        const result = await promise;\n        result[childPropNode.prop!.name] =\n          await propNodeToZodType(childPropNode);\n        return result;\n      },\n      {} as any\n    );\n\n    if (propNode.prop?.nullable === true) {\n      return z.object(obj).nullable();\n    } else {\n      return z.object(obj);\n    }\n  } else {\n    throw Error;\n  }\n}\n"],"names":["z","EntityManager","ServiceUnavailableException","zodTypeToRenderingNode","propToZodType","getColumnsNode","entityId","subsetKey","entity","get","subset","subsets","undefined","propNodes","fieldExprsToPropNodes","rootPropNode","nodeType","children","columnsZodType","propNodeToZodType","columnsNode","map","child","renderType","pickedCol","find","cc","includes","name","config","picked","element","propNode","prop","Error","length","array","innerType","nullable","obj","reduce","promise","childPropNode","result","object"],"mappings":"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"}

package/dist/template/helpers.d.ts

@@ -0,0 +1,23 @@
+import { EntityNamesRecord } from "../entity/entity-manager";
+import { RelationProp } from "../types/types";
+/**
+ * Enum의 표시용 라벨을 가져옵니다.
+ * OrderBy, SearchField 등 특수한 경우와 일반 Enum을 구분하여 처리합니다.
+ */
+export declare function getLabel(entityId: string, enumId: string): string;
+/**
+ * 컬럼 이름으로부터 Enum 정보를 추출합니다.
+ * Entity의 prop 중 enum 타입인 것을 찾아 관련 정보를 반환합니다.
+ */
+export declare function getEnumInfoFromColName(entityId: string, colName: string): {
+    id: string;
+    targetEntityNames: EntityNamesRecord;
+    targetEntityId: string;
+    title: string;
+};
+/**
+ * 컬럼 이름으로부터 Relation prop 정보를 가져옵니다.
+ * 관계형 prop이 아닌 경우 에러를 발생시킵니다.
+ */
+export declare function getRelationPropFromColName(entityId: string, colName: string): RelationProp;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/template/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/template/helpers.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC5E,OAAO,EAA8B,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE1E;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAcjE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd;IACD,EAAE,EAAE,MAAM,CAAC;IACX,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf,CA0BA;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd,YAAY,CAYd"}

package/dist/template/helpers.js

@@ -0,0 +1,64 @@
+import inflection from "inflection";
+import { EntityManager } from "../entity/entity-manager.js";
+import { isEnumProp, isRelationProp } from "../types/types.js";
+/**
+ * Enum의 표시용 라벨을 가져옵니다.
+ * OrderBy, SearchField 등 특수한 경우와 일반 Enum을 구분하여 처리합니다.
+ */ export function getLabel(entityId, enumId) {
+    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 && enumProp.desc) {
+            return enumProp.desc;
+        }
+        return enumId;
+    }
+}
+/**
+ * 컬럼 이름으로부터 Enum 정보를 추출합니다.
+ * Entity의 prop 중 enum 타입인 것을 찾아 관련 정보를 반환합니다.
+ */ export function getEnumInfoFromColName(entityId, colName) {
+    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, colName) {
+    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}`);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZW1wbGF0ZS9oZWxwZXJzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBpbmZsZWN0aW9uIGZyb20gXCJpbmZsZWN0aW9uXCI7XG5pbXBvcnQgeyBFbnRpdHlNYW5hZ2VyLCBFbnRpdHlOYW1lc1JlY29yZCB9IGZyb20gXCIuLi9lbnRpdHkvZW50aXR5LW1hbmFnZXJcIjtcbmltcG9ydCB7IGlzRW51bVByb3AsIGlzUmVsYXRpb25Qcm9wLCBSZWxhdGlvblByb3AgfSBmcm9tIFwiLi4vdHlwZXMvdHlwZXNcIjtcblxuLyoqXG4gKiBFbnVt7J2YIO2RnOyLnOyaqSDrnbzrsqjsnYQg6rCA7KC47Ji164uI64ukLlxuICogT3JkZXJCeSwgU2VhcmNoRmllbGQg65OxIO2KueyImO2VnCDqsr3smrDsmYAg7J2867CYIEVudW3snYQg6rWs67aE7ZWY7JesIOyymOumrO2VqeuLiOuLpC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldExhYmVsKGVudGl0eUlkOiBzdHJpbmcsIGVudW1JZDogc3RyaW5nKTogc3RyaW5nIHtcbiAgaWYgKGVudW1JZC5lbmRzV2l0aChcIk9yZGVyQnlcIikpIHtcbiAgICByZXR1cm4gXCLsoJXroKxcIjtcbiAgfSBlbHNlIGlmIChlbnVtSWQuZW5kc1dpdGgoXCJTZWFyY2hGaWVsZFwiKSkge1xuICAgIHJldHVybiBcIuqygOyDiVwiO1xuICB9IGVsc2Uge1xuICAgIGNvbnN0IGVudW1Qcm9wID0gRW50aXR5TWFuYWdlci5nZXQoZW50aXR5SWQpLnByb3BzLmZpbmQoXG4gICAgICAocHJvcCkgPT4gYCR7ZW50aXR5SWR9JHtpbmZsZWN0aW9uLmNhbWVsaXplKHByb3AubmFtZSl9YCA9PT0gZW51bUlkXG4gICAgKTtcbiAgICBpZiAoZW51bVByb3AgJiYgZW51bVByb3AuZGVzYykge1xuICAgICAgcmV0dXJuIGVudW1Qcm9wLmRlc2M7XG4gICAgfVxuICAgIHJldHVybiBlbnVtSWQ7XG4gIH1cbn1cblxuLyoqXG4gKiDsu6zrn7wg7J2066aE7Jy866Gc67aA7YSwIEVudW0g7KCV67O066W8IOy2lOy2nO2VqeuLiOuLpC5cbiAqIEVudGl0eeydmCBwcm9wIOykkSBlbnVtIO2DgOyeheyduCDqsoPsnYQg7LC+7JWEIOq0gOugqCDsoJXrs7Trpbwg67CY7ZmY7ZWp64uI64ukLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0RW51bUluZm9Gcm9tQ29sTmFtZShcbiAgZW50aXR5SWQ6IHN0cmluZyxcbiAgY29sTmFtZTogc3RyaW5nXG4pOiB7XG4gIGlkOiBzdHJpbmc7XG4gIHRhcmdldEVudGl0eU5hbWVzOiBFbnRpdHlOYW1lc1JlY29yZDtcbiAgdGFyZ2V0RW50aXR5SWQ6IHN0cmluZztcbiAgdGl0bGU6IHN0cmluZztcbn0ge1xuICBjb25zdCBiYXNlRW50aXR5ID0gRW50aXR5TWFuYWdlci5nZXQoZW50aXR5SWQpO1xuICBjb25zdCBwcm9wID0gYmFzZUVudGl0eS5wcm9wcy5maW5kKChwKSA9PiBwLm5hbWUgPT09IGNvbE5hbWUpO1xuICBpZiAocHJvcCAmJiBpc0VudW1Qcm9wKHByb3ApKSB7XG4gICAgcmV0dXJuIHtcbiAgICAgIGlkOiBwcm9wLmlkLFxuICAgICAgdGFyZ2V0RW50aXR5SWQ6IGVudGl0eUlkLFxuICAgICAgdGFyZ2V0RW50aXR5TmFtZXM6IEVudGl0eU1hbmFnZXIuZ2V0TmFtZXNGcm9tSWQoZW50aXR5SWQpLFxuICAgICAgdGl0bGU6IHByb3AuZGVzYyA/PyBwcm9wLmlkLFxuICAgIH07XG4gIH0gZWxzZSB7XG4gICAgY29uc3QgaWRDYW5kaWRhdGUgPSBpbmZsZWN0aW9uLmNhbWVsaXplKFxuICAgICAgaW5mbGVjdGlvbi51bmRlcnNjb3JlKGVudGl0eUlkKSArIFwiX1wiICsgaW5mbGVjdGlvbi51bmRlcnNjb3JlKGNvbE5hbWUpLFxuICAgICAgZmFsc2VcbiAgICApO1xuICAgIHRyeSB7XG4gICAgICBjb25zdCB0YXJnZXRFbnRpdHlOYW1lcyA9IEVudGl0eU1hbmFnZXIuZ2V0TmFtZXNGcm9tSWQoZW50aXR5SWQpO1xuICAgICAgcmV0dXJuIHtcbiAgICAgICAgaWQ6IGlkQ2FuZGlkYXRlLFxuICAgICAgICB0YXJnZXRFbnRpdHlJZDogZW50aXR5SWQsXG4gICAgICAgIHRhcmdldEVudGl0eU5hbWVzOiB0YXJnZXRFbnRpdHlOYW1lcyxcbiAgICAgICAgdGl0bGU6IGlkQ2FuZGlkYXRlLFxuICAgICAgfTtcbiAgICB9IGNhdGNoIHt9XG4gICAgdGhyb3cgbmV3IEVycm9yKGDssL7snYQg7IiYIOyXhuuKlCBFbnVtUHJvcCAke2NvbE5hbWV9YCk7XG4gIH1cbn1cblxuLyoqXG4gKiDsu6zrn7wg7J2066aE7Jy866Gc67aA7YSwIFJlbGF0aW9uIHByb3Ag7KCV67O066W8IOqwgOyguOyYteuLiOuLpC5cbiAqIOq0gOqzhO2YlSBwcm9w7J20IOyVhOuLjCDqsr3smrAg7JeQ65+s66W8IOuwnOyDneyLnO2CteuLiOuLpC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldFJlbGF0aW9uUHJvcEZyb21Db2xOYW1lKFxuICBlbnRpdHlJZDogc3RyaW5nLFxuICBjb2xOYW1lOiBzdHJpbmdcbik6IFJlbGF0aW9uUHJvcCB7XG4gIGNvbnN0IGJhc2VFbnRpdHkgPSBFbnRpdHlNYW5hZ2VyLmdldChlbnRpdHlJZCk7XG4gIGNvbnN0IHJlbFByb3AgPSBiYXNlRW50aXR5LnByb3BzLmZpbmQoKHByb3ApID0+IHByb3AubmFtZSA9PT0gY29sTmFtZSk7XG4gIGlmIChpc1JlbGF0aW9uUHJvcChyZWxQcm9wKSkge1xuICAgIGNvbnN0IHJlbEVudGl0eSA9IEVudGl0eU1hbmFnZXIuZ2V0KHJlbFByb3Aud2l0aCk7XG4gICAgaWYgKHJlbEVudGl0eS5wYXJlbnRJZCAhPT0gdW5kZWZpbmVkKSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoXCJPbmx5IHBhcmVudCBlbnRpdGllcyBjYW4gYmUgdXNlZCBhcyByZWxhdGlvbiBwcm9wc1wiKTtcbiAgICB9XG4gICAgcmV0dXJuIHJlbFByb3A7XG4gIH0gZWxzZSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKGDssL7snYQg7IiYIOyXhuuKlCBSZWxhdGlvbiAke2NvbE5hbWV9YCk7XG4gIH1cbn1cbiJdLCJuYW1lcyI6WyJpbmZsZWN0aW9uIiwiRW50aXR5TWFuYWdlciIsImlzRW51bVByb3AiLCJpc1JlbGF0aW9uUHJvcCIsImdldExhYmVsIiwiZW50aXR5SWQiLCJlbnVtSWQiLCJlbmRzV2l0aCIsImVudW1Qcm9wIiwiZ2V0IiwicHJvcHMiLCJmaW5kIiwicHJvcCIsImNhbWVsaXplIiwibmFtZSIsImRlc2MiLCJnZXRFbnVtSW5mb0Zyb21Db2xOYW1lIiwiY29sTmFtZSIsImJhc2VFbnRpdHkiLCJwIiwiaWQiLCJ0YXJnZXRFbnRpdHlJZCIsInRhcmdldEVudGl0eU5hbWVzIiwiZ2V0TmFtZXNGcm9tSWQiLCJ0aXRsZSIsImlkQ2FuZGlkYXRlIiwidW5kZXJzY29yZSIsIkVycm9yIiwiZ2V0UmVsYXRpb25Qcm9wRnJvbUNvbE5hbWUiLCJyZWxQcm9wIiwicmVsRW50aXR5Iiwid2l0aCIsInBhcmVudElkIiwidW5kZWZpbmVkIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPQSxnQkFBZ0IsYUFBYTtBQUNwQyxTQUFTQyxhQUFhLFFBQTJCLDhCQUEyQjtBQUM1RSxTQUFTQyxVQUFVLEVBQUVDLGNBQWMsUUFBc0Isb0JBQWlCO0FBRTFFOzs7Q0FHQyxHQUNELE9BQU8sU0FBU0MsU0FBU0MsUUFBZ0IsRUFBRUMsTUFBYztJQUN2RCxJQUFJQSxPQUFPQyxRQUFRLENBQUMsWUFBWTtRQUM5QixPQUFPO0lBQ1QsT0FBTyxJQUFJRCxPQUFPQyxRQUFRLENBQUMsZ0JBQWdCO1FBQ3pDLE9BQU87SUFDVCxPQUFPO1FBQ0wsTUFBTUMsV0FBV1AsY0FBY1EsR0FBRyxDQUFDSixVQUFVSyxLQUFLLENBQUNDLElBQUksQ0FDckQsQ0FBQ0MsT0FBUyxHQUFHUCxXQUFXTCxXQUFXYSxRQUFRLENBQUNELEtBQUtFLElBQUksR0FBRyxLQUFLUjtRQUUvRCxJQUFJRSxZQUFZQSxTQUFTTyxJQUFJLEVBQUU7WUFDN0IsT0FBT1AsU0FBU08sSUFBSTtRQUN0QjtRQUNBLE9BQU9UO0lBQ1Q7QUFDRjtBQUVBOzs7Q0FHQyxHQUNELE9BQU8sU0FBU1UsdUJBQ2RYLFFBQWdCLEVBQ2hCWSxPQUFlO0lBT2YsTUFBTUMsYUFBYWpCLGNBQWNRLEdBQUcsQ0FBQ0o7SUFDckMsTUFBTU8sT0FBT00sV0FBV1IsS0FBSyxDQUFDQyxJQUFJLENBQUMsQ0FBQ1EsSUFBTUEsRUFBRUwsSUFBSSxLQUFLRztJQUNyRCxJQUFJTCxRQUFRVixXQUFXVSxPQUFPO1FBQzVCLE9BQU87WUFDTFEsSUFBSVIsS0FBS1EsRUFBRTtZQUNYQyxnQkFBZ0JoQjtZQUNoQmlCLG1CQUFtQnJCLGNBQWNzQixjQUFjLENBQUNsQjtZQUNoRG1CLE9BQU9aLEtBQUtHLElBQUksSUFBSUgsS0FBS1EsRUFBRTtRQUM3QjtJQUNGLE9BQU87UUFDTCxNQUFNSyxjQUFjekIsV0FBV2EsUUFBUSxDQUNyQ2IsV0FBVzBCLFVBQVUsQ0FBQ3JCLFlBQVksTUFBTUwsV0FBVzBCLFVBQVUsQ0FBQ1QsVUFDOUQ7UUFFRixJQUFJO1lBQ0YsTUFBTUssb0JBQW9CckIsY0FBY3NCLGNBQWMsQ0FBQ2xCO1lBQ3ZELE9BQU87Z0JBQ0xlLElBQUlLO2dCQUNKSixnQkFBZ0JoQjtnQkFDaEJpQixtQkFBbUJBO2dCQUNuQkUsT0FBT0M7WUFDVDtRQUNGLEVBQUUsT0FBTSxDQUFDO1FBQ1QsTUFBTSxJQUFJRSxNQUFNLENBQUMsaUJBQWlCLEVBQUVWLFNBQVM7SUFDL0M7QUFDRjtBQUVBOzs7Q0FHQyxHQUNELE9BQU8sU0FBU1csMkJBQ2R2QixRQUFnQixFQUNoQlksT0FBZTtJQUVmLE1BQU1DLGFBQWFqQixjQUFjUSxHQUFHLENBQUNKO0lBQ3JDLE1BQU13QixVQUFVWCxXQUFXUixLQUFLLENBQUNDLElBQUksQ0FBQyxDQUFDQyxPQUFTQSxLQUFLRSxJQUFJLEtBQUtHO0lBQzlELElBQUlkLGVBQWUwQixVQUFVO1FBQzNCLE1BQU1DLFlBQVk3QixjQUFjUSxHQUFHLENBQUNvQixRQUFRRSxJQUFJO1FBQ2hELElBQUlELFVBQVVFLFFBQVEsS0FBS0MsV0FBVztZQUNwQyxNQUFNLElBQUlOLE1BQU07UUFDbEI7UUFDQSxPQUFPRTtJQUNULE9BQU87UUFDTCxNQUFNLElBQUlGLE1BQU0sQ0FBQyxpQkFBaUIsRUFBRVYsU0FBUztJQUMvQztBQUNGIn0=

package/dist/{templates → template/implementations}/entity.template.d.ts

@@ -1,6 +1,6 @@
-import { TemplateOptions } from "../types/types";
-import { EntityNamesRecord } from "../entity/entity-manager";
-import { Template } from "./base-template";
+import { TemplateOptions } from "../../types/types";
+import { EntityNamesRecord } from "../../entity/entity-manager";
+import { Template } from "../template";
 export declare class Template__entity extends Template {
     constructor();
     getTargetAndPath(names: EntityNamesRecord, parentNames?: EntityNamesRecord): {

package/dist/template/implementations/entity.template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/entity.template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAiB,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAC/E,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC,qBAAa,gBAAiB,SAAQ,QAAQ;;IAK5C,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,EAAE,WAAW,CAAC,EAAE,iBAAiB;;;;IAS1E,MAAM,CAAC,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAC;;;;;;CAoE1C"}

package/dist/template/implementations/entity.template.js

@@ -0,0 +1,87 @@
+import { EntityManager } from "../../entity/entity-manager.js";
+import { Template } from "../template.js";
+import { Sonamu } from "../../api/index.js";
+export class Template__entity extends Template {
+    constructor(){
+        super("entity");
+    }
+    getTargetAndPath(names, parentNames) {
+        const { dir } = Sonamu.config.api;
+        return {
+            target: `${dir}/src/application`,
+            path: `${(parentNames ?? names).fs}/${names.fs}.entity.json`
+        };
+    }
+    render(options) {
+        const { entityId, title, parentId, table } = options;
+        const names = EntityManager.getNamesFromId(entityId);
+        const parent = (()=>{
+            if (parentId) {
+                return {
+                    names: EntityManager.getNamesFromId(parentId),
+                    entity: EntityManager.get(parentId)
+                };
+            } else {
+                return null;
+            }
+        })();
+        return {
+            ...this.getTargetAndPath(names, parent?.names ?? names),
+            body: JSON.stringify({
+                id: entityId,
+                title: title ?? entityId,
+                parentId,
+                table: table ?? names.fsPlural.replace(/\-/g, "_"),
+                props: options.props?.length ? options.props : [
+                    {
+                        name: "id",
+                        type: "integer",
+                        unsigned: true,
+                        desc: "ID"
+                    },
+                    ...parent ? [
+                        {
+                            type: "relation",
+                            name: parent.names.camel,
+                            relationType: "BelongsToOne",
+                            with: parentId,
+                            onUpdate: "CASCADE",
+                            onDelete: "CASCADE",
+                            desc: parent.entity.title
+                        }
+                    ] : [],
+                    {
+                        name: "created_at",
+                        type: "timestamp",
+                        desc: "등록일시",
+                        dbDefault: "CURRENT_TIMESTAMP"
+                    }
+                ],
+                indexes: [
+                    ...options.indexes ?? []
+                ],
+                subsets: options.subsets ?? {
+                    ...parentId ? {} : {
+                        A: [
+                            "id",
+                            "created_at"
+                        ]
+                    }
+                },
+                enums: options.enums ?? {
+                    ...parentId ? {} : {
+                        [`${names.capital}OrderBy`]: {
+                            "id-desc": "ID최신순"
+                        },
+                        [`${names.capital}SearchField`]: {
+                            id: "ID"
+                        }
+                    }
+                }
+            }).trim(),
+            importKeys: []
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/{templates → template/implementations}/generated.template.d.ts

@@ -1,6 +1,6 @@
-import { TemplateOptions } from "../types/types";
-import { Entity } from "../entity/entity";
-import { Template } from "./base-template";
+import { TemplateOptions } from "../../types/types";
+import { Entity } from "../../entity/entity";
+import { Template } from "../template";
 export type SourceCode = {
     label: string;
     lines: string[];

package/dist/template/implementations/generated.template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generated.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/generated.template.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAG7C,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAIvC,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AACF,qBAAa,mBAAoB,SAAQ,QAAQ;;IAK/C,gBAAgB;;;;IAShB,MAAM,CAAC,EAAE,EAAE,eAAe,CAAC,WAAW,CAAC;;;;;;;IAyGvC,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAsBrD,uBAAuB,CACrB,MAAM,EAAE,MAAM,EACd,UAAU,GAAE,MAAM,EAAO,GACxB,UAAU;IAsCb,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAiD9D,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;CAmDvD"}

package/dist/template/implementations/generated.template.js

@@ -0,0 +1,232 @@
+import * as _ from "lodash-es";
+import { EntityManager } from "../../entity/entity-manager.js";
+import { propNodeToZodTypeDef, zodTypeToZodCode } from "../../api/code-converters.js";
+import { Template } from "../template.js";
+import { nonNullable } from "../../utils/utils.js";
+import { Sonamu } from "../../api/index.js";
+export class Template__generated extends Template {
+    constructor(){
+        super("generated");
+    }
+    getTargetAndPath() {
+        const { dir } = Sonamu.config.api;
+        return {
+            target: `${dir}/src/application`,
+            path: `sonamu.generated.ts`
+        };
+    }
+    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();
+        // Sort
+        const LABEL_KEY_ORDER = [
+            "Enums",
+            "BaseSchema",
+            "BaseListParams",
+            "Subsets",
+            "SubsetQueries"
+        ];
+        sourceCodes.sort((a, b)=>{
+            const [aKey] = a.label.split(":");
+            const [bKey] = b.label.split(":");
+            const aIndex = LABEL_KEY_ORDER.indexOf(aKey);
+            const bIndex = LABEL_KEY_ORDER.indexOf(bKey);
+            if (aIndex > bIndex) {
+                return 1;
+            } else if (aIndex < bIndex) {
+                return -1;
+            } else {
+                return 0;
+            }
+        });
+        const sourceCode = sourceCodes.reduce((result, ts)=>{
+            if (ts === null) {
+                return result;
+            }
+            return {
+                lines: [
+                    ...result.lines,
+                    `// ${ts.label}`,
+                    ...ts.lines,
+                    ""
+                ],
+                importKeys: _.uniq([
+                    ...result.importKeys,
+                    ...ts.importKeys
+                ].sort())
+            };
+        }, {
+            lines: [],
+            importKeys: []
+        });
+        // .types.ts의 타입을 참조하는 경우 순환참조(상호참조)가 발생하므로 타입을 가져와 인라인 처리
+        const allTypeKeys = entities.map((entity)=>Object.keys(entity.types)).flat();
+        const cdImportKeys = sourceCode.importKeys.filter((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();
+            sourceCode.lines = [
+                ...customScalarLines,
+                ...sourceCode.lines
+            ];
+            sourceCode.importKeys = sourceCode.importKeys.filter((importKey)=>!cdImportKeys.includes(importKey));
+        }
+        const body = sourceCode.lines.join("\n");
+        // import
+        const sonamuImports = [
+            "zArrayable",
+            "SQLDateTimeString",
+            "SubsetQuery",
+            "SonamuQueryMode"
+        ].filter((mod)=>body.includes(mod));
+        return {
+            ...this.getTargetAndPath(),
+            body,
+            importKeys: sourceCode.importKeys,
+            customHeaders: [
+                `import { z } from 'zod';`,
+                `import { ${sonamuImports.join(",")} } from "sonamu";`
+            ]
+        };
+    }
+    getEnumsSourceCode(entity) {
+        if (Object.keys(entity.enumLabels).length === 0) {
+            return null;
+        }
+        return {
+            label: `Enums: ${entity.id}`,
+            lines: [
+                ...Object.entries(entity.enumLabels).filter(([_, enumLabel])=>Object.keys(enumLabel).length > 0).map(([enumId, enumLabel])=>[
+                        `export const ${enumId} = z.enum([${Object.keys(enumLabel).map((el)=>`"${el}"`)}]).describe("${enumId}");`,
+                        `export type ${enumId} = z.infer<typeof ${enumId}>`,
+                        `export const ${enumId}Label = ${JSON.stringify(enumLabel)}`
+                    ]).flat()
+            ],
+            importKeys: []
+        };
+    }
+    getBaseSchemaSourceCode(entity, importKeys = []) {
+        const schemaName = `${entity.names.module}BaseSchema`;
+        const propNode = {
+            nodeType: "object",
+            children: entity.props.map((prop)=>{
+                return {
+                    nodeType: "plain",
+                    prop
+                };
+            })
+        };
+        const schemaBody = propNodeToZodTypeDef(propNode, importKeys);
+        // fulltext index에 포함된 컬럼들 추출
+        const fulltextColumns = _.uniq(entity.indexes.filter((index)=>index.type === "fulltext").flatMap((index)=>index.columns));
+        const lines = [
+            `export const ${schemaName} = ${schemaBody}`,
+            `export type ${schemaName} = z.infer<typeof ${schemaName}>` + (fulltextColumns.length > 0 ? ` & { readonly __fulltext__: readonly [${fulltextColumns.map((col)=>`"${col}"`).join(", ")}] }` : "")
+        ];
+        return {
+            label: `BaseSchema: ${entity.id}`,
+            importKeys,
+            lines
+        };
+    }
+    getBaseListParamsSourceCode(entity) {
+        // Prop 없는 MD인 경우 생성 제외
+        if (entity.props.length === 0) {
+            return null;
+        } else if (entity.parentId !== undefined) {
+            return null;
+        }
+        const schemaName = `${entity.names.module}BaseListParams`;
+        const filterProps = entity.props.filter((prop)=>prop.toFilter === true);
+        const propNodes = filterProps.map((prop)=>{
+            return {
+                nodeType: "plain",
+                prop,
+                children: []
+            };
+        });
+        const importKeys = [];
+        const filterBody = propNodes.map((propNode)=>propNodeToZodTypeDef(propNode, importKeys)).join("\n");
+        const schemaBody = `
+z.object({
+  num: z.number().int().nonnegative(),
+  page: z.number().int().min(1),
+  search: ${entity.id}SearchField,
+  keyword: z.string(),
+  orderBy: ${entity.id}OrderBy,
+  queryMode: SonamuQueryMode,
+  id: zArrayable(z.number().int().positive()),${filterBody}
+}).partial();
+`.trim();
+        const lines = [
+            `export const ${schemaName} = ${schemaBody}`,
+            `export type ${schemaName} = z.infer<typeof ${schemaName}>`
+        ];
+        return {
+            label: `BaseListParams: ${entity.id}`,
+            importKeys,
+            lines
+        };
+    }
+    getSubsetSourceCode(entity) {
+        if (Object.keys(entity.subsets).length == 0) {
+            return null;
+        } else if (entity.parentId !== undefined) {
+            return null;
+        }
+        const subsetKeys = Object.keys(entity.subsets);
+        const importKeys = [];
+        const lines = [
+            ...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 = {
+                    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(),
+            `export type ${entity.names.module}SubsetMapping = {`,
+            ...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>`,
+            ""
+        ];
+        return {
+            label: `Subsets: ${entity.id}`,
+            lines,
+            importKeys: _.uniq(importKeys)
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/generated.template.ts"],"sourcesContent":["import * as _ from \"lodash-es\";\nimport { TemplateOptions } from \"../../types/types\";\nimport { EntityManager } from \"../../entity/entity-manager\";\nimport { Entity } from \"../../entity/entity\";\nimport { EntityPropNode } from \"../../types/types\";\nimport { propNodeToZodTypeDef, zodTypeToZodCode } from \"../../api/code-converters\";\nimport { Template } from \"../template\";\nimport { nonNullable } from \"../../utils/utils\";\nimport { Sonamu } from \"../../api\";\n\nexport type SourceCode = {\n  label: string;\n  lines: string[];\n  importKeys: string[];\n};\nexport class Template__generated extends Template {\n  constructor() {\n    super(\"generated\");\n  }\n\n  getTargetAndPath() {\n    const { dir } = Sonamu.config.api;\n\n    return {\n      target: `${dir}/src/application`,\n      path: `sonamu.generated.ts`,\n    };\n  }\n\n  render({}: TemplateOptions[\"generated\"]) {\n    const entityIds = EntityManager.getAllIds();\n    const entities = entityIds.map((id) => EntityManager.get(id));\n\n    // 전체 SourceCode 생성\n    const sourceCodes = entities\n      .map((entity) => {\n        return [\n          this.getEnumsSourceCode(entity),\n          this.getBaseSchemaSourceCode(entity),\n          this.getBaseListParamsSourceCode(entity),\n          this.getSubsetSourceCode(entity),\n        ].filter(nonNullable);\n      })\n      .flat();\n\n    // Sort\n    const LABEL_KEY_ORDER = [\n      \"Enums\",\n      \"BaseSchema\",\n      \"BaseListParams\",\n      \"Subsets\",\n      \"SubsetQueries\",\n    ];\n    sourceCodes.sort((a, b) => {\n      const [aKey] = a.label.split(\":\");\n      const [bKey] = b.label.split(\":\");\n      const aIndex = LABEL_KEY_ORDER.indexOf(aKey);\n      const bIndex = LABEL_KEY_ORDER.indexOf(bKey);\n      if (aIndex > bIndex) {\n        return 1;\n      } else if (aIndex < bIndex) {\n        return -1;\n      } else {\n        return 0;\n      }\n    });\n\n    const sourceCode = sourceCodes.reduce(\n      (result, ts) => {\n        if (ts === null) {\n          return result;\n        }\n        return {\n          lines: [...result!.lines, `// ${ts.label}`, ...ts.lines, \"\"],\n          importKeys: _.uniq([...result!.importKeys, ...ts.importKeys].sort()),\n        };\n      },\n      {\n        lines: [],\n        importKeys: [],\n      } as Omit<SourceCode, \"label\">\n    );\n\n    // .types.ts의 타입을 참조하는 경우 순환참조(상호참조)가 발생하므로 타입을 가져와 인라인 처리\n    const allTypeKeys = entities\n      .map((entity) => Object.keys(entity.types))\n      .flat();\n    const cdImportKeys = sourceCode.importKeys.filter((importKey) =>\n      allTypeKeys.includes(importKey)\n    );\n    if (cdImportKeys.length > 0) {\n      const customScalarLines = cdImportKeys\n        .map((importKey) => {\n          const entity = entities.find((entity) => entity.types[importKey]);\n          if (!entity) {\n            throw new Error(`ZodType not found ${importKey}`);\n          }\n          const zodType = entity.types[importKey]!;\n\n          return [\n            `// CustomScalar: ${importKey}`,\n            `const ${importKey} = ${zodTypeToZodCode(zodType)};`,\n            `type ${importKey} = z.infer<typeof ${importKey}>`,\n            \"\",\n          ];\n        })\n        .flat();\n      sourceCode.lines = [...customScalarLines, ...sourceCode.lines];\n      sourceCode.importKeys = sourceCode.importKeys.filter(\n        (importKey) => !cdImportKeys.includes(importKey)\n      );\n    }\n\n    const body = sourceCode.lines.join(\"\\n\");\n\n    // import\n    const sonamuImports = [\n      \"zArrayable\",\n      \"SQLDateTimeString\",\n      \"SubsetQuery\",\n      \"SonamuQueryMode\",\n    ].filter((mod) => body.includes(mod));\n\n    return {\n      ...this.getTargetAndPath(),\n      body,\n      importKeys: sourceCode.importKeys,\n      customHeaders: [\n        `import { z } from 'zod';`,\n        `import { ${sonamuImports.join(\",\")} } from \"sonamu\";`,\n      ],\n    };\n  }\n\n  getEnumsSourceCode(entity: Entity): SourceCode | null {\n    if (Object.keys(entity.enumLabels).length === 0) {\n      return null;\n    }\n    return {\n      label: `Enums: ${entity.id}`,\n      lines: [\n        ...Object.entries(entity.enumLabels)\n          .filter(([_, enumLabel]) => Object.keys(enumLabel).length > 0)\n          .map(([enumId, enumLabel]) => [\n            `export const ${enumId} = z.enum([${Object.keys(enumLabel).map(\n              (el) => `\"${el}\"`\n            )}]).describe(\"${enumId}\");`,\n            `export type ${enumId} = z.infer<typeof ${enumId}>`,\n            `export const ${enumId}Label = ${JSON.stringify(enumLabel)}`,\n          ])\n          .flat(),\n      ],\n      importKeys: [],\n    };\n  }\n\n  getBaseSchemaSourceCode(\n    entity: Entity,\n    importKeys: string[] = []\n  ): SourceCode {\n    const schemaName = `${entity.names.module}BaseSchema`;\n    const propNode: EntityPropNode = {\n      nodeType: \"object\",\n      children: entity.props.map((prop) => {\n        return {\n          nodeType: \"plain\",\n          prop,\n        };\n      }),\n    };\n\n    const schemaBody = propNodeToZodTypeDef(propNode, importKeys);\n\n    // fulltext index에 포함된 컬럼들 추출\n    const fulltextColumns = _.uniq(\n      entity.indexes\n        .filter((index) => index.type === \"fulltext\")\n        .flatMap((index) => index.columns)\n    );\n\n    const lines = [\n      `export const ${schemaName} = ${schemaBody}`,\n      `export type ${schemaName} = z.infer<typeof ${schemaName}>` +\n        (fulltextColumns.length > 0\n          ? ` & { readonly __fulltext__: readonly [${fulltextColumns\n              .map((col) => `\"${col}\"`)\n              .join(\", \")}] }`\n          : \"\"),\n    ];\n\n    return {\n      label: `BaseSchema: ${entity.id}`,\n      importKeys,\n      lines,\n    };\n  }\n\n  getBaseListParamsSourceCode(entity: Entity): SourceCode | null {\n    // Prop 없는 MD인 경우 생성 제외\n    if (entity.props.length === 0) {\n      return null;\n    } else if (entity.parentId !== undefined) {\n      return null;\n    }\n\n    const schemaName = `${entity.names.module}BaseListParams`;\n\n    const filterProps = entity.props.filter((prop) => prop.toFilter === true);\n\n    const propNodes: EntityPropNode[] = filterProps.map((prop) => {\n      return {\n        nodeType: \"plain\" as const,\n        prop,\n        children: [],\n      };\n    });\n\n    const importKeys: string[] = [];\n    const filterBody = propNodes\n      .map((propNode) => propNodeToZodTypeDef(propNode, importKeys))\n      .join(\"\\n\");\n\n    const schemaBody = `\nz.object({\n  num: z.number().int().nonnegative(),\n  page: z.number().int().min(1),\n  search: ${entity.id}SearchField,\n  keyword: z.string(),\n  orderBy: ${entity.id}OrderBy,\n  queryMode: SonamuQueryMode,\n  id: zArrayable(z.number().int().positive()),${filterBody}\n}).partial();\n`.trim();\n\n    const lines = [\n      `export const ${schemaName} = ${schemaBody}`,\n      `export type ${schemaName} = z.infer<typeof ${schemaName}>`,\n    ];\n\n    return {\n      label: `BaseListParams: ${entity.id}`,\n      importKeys,\n      lines,\n    };\n  }\n\n  getSubsetSourceCode(entity: Entity): SourceCode | null {\n    if (Object.keys(entity.subsets).length == 0) {\n      return null;\n    } else if (entity.parentId !== undefined) {\n      return null;\n    }\n\n    const subsetKeys = Object.keys(entity.subsets);\n    const importKeys: string[] = [];\n    const lines: string[] = [\n      ...subsetKeys\n        .map((subsetKey) => {\n          // 서브셋에서 FieldExpr[] 가져옴\n          const fieldExprs = entity.subsets[subsetKey];\n\n          // FieldExpr[]로 EntityPropNode[] 가져옴\n          const propNodes = entity.fieldExprsToPropNodes(fieldExprs);\n          const schemaName = `${entity.names.module}Subset${subsetKey}`;\n          const propNode: EntityPropNode = {\n            nodeType: \"object\",\n            children: propNodes,\n          };\n\n          // EntityPropNode[]로 ZodTypeDef(string)을 가져옴\n          const body = propNodeToZodTypeDef(propNode, importKeys);\n\n          return [\n            `export const ${schemaName} = ${body}`,\n            `export type ${schemaName} = z.infer<typeof ${schemaName}>`,\n          ];\n        })\n        .flat(),\n      `export type ${entity.names.module}SubsetMapping = {`,\n      ...subsetKeys.map(\n        (subsetKey) =>\n          `  ${subsetKey}: ${entity.names.module}Subset${subsetKey};`\n      ),\n      \"}\",\n      `export const ${entity.names.module}SubsetKey = z.enum([${subsetKeys\n        .map((k) => `\"${k}\"`)\n        .join(\",\")}]);`,\n      `export type ${entity.names.module}SubsetKey = z.infer<typeof ${entity.names.module}SubsetKey>`,\n      \"\",\n    ];\n\n    return {\n      label: `Subsets: ${entity.id}`,\n      lines,\n      importKeys: _.uniq(importKeys),\n    };\n  }\n}\n"],"names":["_","EntityManager","propNodeToZodTypeDef","zodTypeToZodCode","Template","nonNullable","Sonamu","Template__generated","getTargetAndPath","dir","config","api","target","path","render","entityIds","getAllIds","entities","map","id","get","sourceCodes","entity","getEnumsSourceCode","getBaseSchemaSourceCode","getBaseListParamsSourceCode","getSubsetSourceCode","filter","flat","LABEL_KEY_ORDER","sort","a","b","aKey","label","split","bKey","aIndex","indexOf","bIndex","sourceCode","reduce","result","ts","lines","importKeys","uniq","allTypeKeys","Object","keys","types","cdImportKeys","importKey","includes","length","customScalarLines","find","Error","zodType","body","join","sonamuImports","mod","customHeaders","enumLabels","entries","enumLabel","enumId","el","JSON","stringify","schemaName","names","module","propNode","nodeType","children","props","prop","schemaBody","fulltextColumns","indexes","index","type","flatMap","columns","col","parentId","undefined","filterProps","toFilter","propNodes","filterBody","trim","subsets","subsetKeys","subsetKey","fieldExprs","fieldExprsToPropNodes","k"],"mappings":"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"}

package/dist/{templates → template/implementations}/generated_http.template.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { TemplateOptions } from "../types/types";
-import { ExtendedApi } from "../api/decorators";
-import { Template } from "./base-template";
+import { TemplateOptions } from "../../types/types";
+import { ExtendedApi } from "../../api/decorators";
+import { Template } from "../template";
 export declare class Template__generated_http extends Template {
     constructor();
     getTargetAndPath(): {

package/dist/template/implementations/generated_http.template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generated_http.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/generated_http.template.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAIvC,qBAAa,wBAAyB,SAAQ,QAAQ;;IAKpD,gBAAgB;;;;IASV,MAAM,CAAC,EAAE,EAAE,eAAe,CAAC,gBAAgB,CAAC;;;;;;IAwDlD,mBAAmB,CAAC,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO;IAoFvE,gBAAgB,CACd,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;KAAE,GACnD;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE;CAc9B"}