sonamu 0.5.6 → 0.6.0

package/dist/template/implementations/generated_http.template.js

@@ -0,0 +1,131 @@
+import qs from "qs";
+import { z } from "zod";
+import { getZodObjectFromApi } from "../../api/code-converters.js";
+import { Template } from "../template.js";
+import prettier from "prettier";
+import { Sonamu } from "../../api/sonamu.js";
+export class Template__generated_http extends Template {
+    constructor(){
+        super("generated_http");
+    }
+    getTargetAndPath() {
+        const { dir } = Sonamu.config.api;
+        return {
+            target: `${dir}/src/application`,
+            path: `sonamu.generated.http`
+        };
+    }
+    async render({}) {
+        const { syncer: { types, apis }, config: { api: { route: { prefix } } } } = Sonamu;
+        const lines = await Promise.all(apis.map(async (api)=>{
+            const reqObject = this.resolveApiParams(api, types);
+            const dataLines = await (async ()=>{
+                if ((api.options.httpMethod ?? "GET") === "GET") {
+                    return {
+                        querystring: [
+                            qs.stringify(reqObject, {
+                                encode: false
+                            }).split("&").join("\n\t&")
+                        ],
+                        body: []
+                    };
+                } else {
+                    return {
+                        querystring: [],
+                        body: [
+                            "",
+                            await prettier.format(JSON.stringify(reqObject), {
+                                parser: "json"
+                            })
+                        ]
+                    };
+                }
+            })();
+            return [
+                [
+                    `${api.options.httpMethod ?? "GET"} {{baseUrl}}${prefix}${api.path}`,
+                    ...dataLines.querystring
+                ].join("\n\t?"),
+                `Content-Type: ${api.options.contentType ?? "application/json"}`,
+                ...dataLines.body
+            ].join("\n");
+        }));
+        return {
+            ...this.getTargetAndPath(),
+            body: lines.join("\n\n###\n\n"),
+            importKeys: []
+        };
+    }
+    zodTypeToReqDefault(zodType, name) {
+        if (zodType instanceof z.ZodObject) {
+            return Object.fromEntries(Object.keys(zodType.shape).map((key)=>[
+                    key,
+                    this.zodTypeToReqDefault(zodType.shape[key], key)
+                ]));
+        } else if (zodType instanceof z.ZodArray) {
+            return [
+                this.zodTypeToReqDefault(zodType.element, name)
+            ];
+        } else if (zodType instanceof z.ZodString) {
+            if (name.endsWith("_at") || name.endsWith("_date") || name === "range") {
+                return "2000-01-01";
+            } else {
+                return name.toUpperCase();
+            }
+        } else if (zodType instanceof z.ZodNumber) {
+            if (name === "num") {
+                return 24;
+            }
+            const minValue = zodType.minValue ?? 0;
+            return minValue > Number.MIN_SAFE_INTEGER ? minValue : 0;
+        } else if (zodType instanceof z.ZodBoolean) {
+            return false;
+        } else if (zodType instanceof z.ZodEnum) {
+            return zodType.options[0];
+        } else if (zodType instanceof z.ZodOptional) {
+            return this.zodTypeToReqDefault(zodType.def.innerType, name);
+        } else if (zodType instanceof z.ZodNullable) {
+            return null;
+        } else if (zodType instanceof z.ZodUnion) {
+            return this.zodTypeToReqDefault(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)=>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.def;
+            const key = this.zodTypeToReqDefault(kvDef.keyType, name);
+            const value = this.zodTypeToReqDefault(kvDef.valueType, name);
+            return {
+                [key]: value
+            };
+        } else if (zodType instanceof z.ZodSet) {
+            return [
+                this.zodTypeToReqDefault(zodType.def.valueType, name)
+            ];
+        } else if (zodType instanceof z.ZodIntersection) {
+            return this.zodTypeToReqDefault(zodType.def.right, name);
+        } else if (zodType instanceof z.ZodDefault) {
+            return this.zodTypeToReqDefault(zodType.def.innerType, name);
+        } else {
+            // console.log(zodType);
+            return `unknown-${zodType.type}`;
+        }
+    }
+    resolveApiParams(api, references) {
+        const reqType = getZodObjectFromApi(api, references);
+        try {
+            const def = this.zodTypeToReqDefault(reqType, "unknownName");
+            return def;
+        } catch (error) {
+            console.error(error);
+            throw new Error(`Invalid zod type detected on ${api.modelName}:${api.methodName}`);
+        }
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/generated_http.template.ts"],"sourcesContent":["import qs from \"qs\";\nimport { z } from \"zod\";\nimport { TemplateOptions } from \"../../types/types\";\nimport { getZodObjectFromApi } from \"../../api/code-converters\";\nimport { ExtendedApi } from \"../../api/decorators\";\nimport { Template } from \"../template\";\nimport prettier from \"prettier\";\nimport { Sonamu } from \"../../api/sonamu\";\n\nexport class Template__generated_http extends Template {\n  constructor() {\n    super(\"generated_http\");\n  }\n\n  getTargetAndPath() {\n    const { dir } = Sonamu.config.api;\n\n    return {\n      target: `${dir}/src/application`,\n      path: `sonamu.generated.http`,\n    };\n  }\n\n  async render({}: TemplateOptions[\"generated_http\"]) {\n    const {\n      syncer: { types, apis },\n      config: {\n        api: {\n          route: { prefix },\n        },\n      },\n    } = Sonamu;\n\n    const lines = await Promise.all(\n      apis.map(async (api) => {\n        const reqObject = this.resolveApiParams(api, types);\n\n        const dataLines = await (async () => {\n          if ((api.options.httpMethod ?? \"GET\") === \"GET\") {\n            return {\n              querystring: [\n                qs\n                  .stringify(reqObject, { encode: false })\n                  .split(\"&\")\n                  .join(\"\\n\\t&\"),\n              ],\n              body: [],\n            };\n          } else {\n            return {\n              querystring: [],\n              body: [\n                \"\",\n                await prettier.format(JSON.stringify(reqObject), {\n                  parser: \"json\",\n                }),\n              ],\n            };\n          }\n        })();\n\n        return [\n          [\n            `${api.options.httpMethod ?? \"GET\"} {{baseUrl}}${prefix}${api.path}`,\n            ...dataLines.querystring,\n          ].join(\"\\n\\t?\"),\n          `Content-Type: ${api.options.contentType ?? \"application/json\"}`,\n          ...dataLines.body,\n        ].join(\"\\n\");\n      })\n    );\n\n    return {\n      ...this.getTargetAndPath(),\n      body: lines.join(\"\\n\\n###\\n\\n\"),\n      importKeys: [],\n    };\n  }\n\n  zodTypeToReqDefault(zodType: z.ZodType<unknown>, name: string): unknown {\n    if (zodType instanceof z.ZodObject) {\n      return Object.fromEntries(\n        Object.keys(zodType.shape).map((key) => [\n          key,\n          this.zodTypeToReqDefault(zodType.shape[key], key),\n        ])\n      );\n    } else if (zodType instanceof z.ZodArray) {\n      return [\n        this.zodTypeToReqDefault(\n          (zodType as z.ZodArray<z.ZodType>).element,\n          name\n        ),\n      ];\n    } else if (zodType instanceof z.ZodString) {\n      if (name.endsWith(\"_at\") || name.endsWith(\"_date\") || name === \"range\") {\n        return \"2000-01-01\";\n      } else {\n        return name.toUpperCase();\n      }\n    } else if (zodType instanceof z.ZodNumber) {\n      if (name === \"num\") {\n        return 24;\n      }\n\n      const minValue = zodType.minValue ?? 0;\n      return minValue > Number.MIN_SAFE_INTEGER ? minValue : 0;\n    } else if (zodType instanceof z.ZodBoolean) {\n      return false;\n    } else if (zodType instanceof z.ZodEnum) {\n      return zodType.options[0];\n    } else if (zodType instanceof z.ZodOptional) {\n      return this.zodTypeToReqDefault(\n        (zodType as z.ZodOptional<z.ZodType>).def.innerType,\n        name\n      );\n    } else if (zodType instanceof z.ZodNullable) {\n      return null;\n    } else if (zodType instanceof z.ZodUnion) {\n      return this.zodTypeToReqDefault(\n        (zodType as z.ZodUnion<z.ZodType[]>).def.options[0],\n        name\n      );\n    } else if (zodType instanceof z.ZodUnknown) {\n      return \"unknown\";\n    } else if (zodType instanceof z.ZodTuple) {\n      return zodType.def.items.map((item: any) =>\n        this.zodTypeToReqDefault(item, name)\n      );\n    } else if (zodType instanceof z.ZodDate) {\n      return \"2000-01-01\";\n    } else if (zodType instanceof z.ZodLiteral) {\n      return zodType.value;\n    } else if (zodType instanceof z.ZodRecord || zodType instanceof z.ZodMap) {\n      const kvDef = (\n        zodType as z.ZodRecord<any, z.ZodType> | z.ZodMap<z.ZodType, z.ZodType>\n      ).def;\n      const key = this.zodTypeToReqDefault(kvDef.keyType, name) as any;\n      const value = this.zodTypeToReqDefault(kvDef.valueType, name);\n      return { [key]: value };\n    } else if (zodType instanceof z.ZodSet) {\n      return [\n        this.zodTypeToReqDefault(\n          (zodType as z.ZodSet<z.ZodType>).def.valueType,\n          name\n        ),\n      ];\n    } else if (zodType instanceof z.ZodIntersection) {\n      return this.zodTypeToReqDefault(\n        (zodType as z.ZodIntersection<z.ZodType, z.ZodType>).def.right,\n        name\n      );\n    } else if (zodType instanceof z.ZodDefault) {\n      return this.zodTypeToReqDefault(\n        (zodType as z.ZodDefault<z.ZodType>).def.innerType,\n        name\n      );\n    } else {\n      // console.log(zodType);\n      return `unknown-${zodType.type}`;\n    }\n  }\n\n  resolveApiParams(\n    api: ExtendedApi,\n    references: { [typeName: string]: z.ZodObject<any> }\n  ): { [key: string]: unknown } {\n    const reqType = getZodObjectFromApi(api, references);\n    try {\n      const def = this.zodTypeToReqDefault(reqType, \"unknownName\") as {\n        [key: string]: unknown;\n      };\n      return def;\n    } catch (error) {\n      console.error(error);\n      throw new Error(\n        `Invalid zod type detected on ${api.modelName}:${api.methodName}`\n      );\n    }\n  }\n}\n"],"names":["qs","z","getZodObjectFromApi","Template","prettier","Sonamu","Template__generated_http","getTargetAndPath","dir","config","api","target","path","render","syncer","types","apis","route","prefix","lines","Promise","all","map","reqObject","resolveApiParams","dataLines","options","httpMethod","querystring","stringify","encode","split","join","body","format","JSON","parser","contentType","importKeys","zodTypeToReqDefault","zodType","name","ZodObject","Object","fromEntries","keys","shape","key","ZodArray","element","ZodString","endsWith","toUpperCase","ZodNumber","minValue","Number","MIN_SAFE_INTEGER","ZodBoolean","ZodEnum","ZodOptional","def","innerType","ZodNullable","ZodUnion","ZodUnknown","ZodTuple","items","item","ZodDate","ZodLiteral","value","ZodRecord","ZodMap","kvDef","keyType","valueType","ZodSet","ZodIntersection","right","ZodDefault","type","references","reqType","error","console","Error","modelName","methodName"],"mappings":"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"}

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

@@ -1,7 +1,7 @@
-import { TemplateOptions } from "../types/types";
-import { Template } from "./base-template";
+import { TemplateOptions } from "../../types/types";
+import { Template } from "../template";
 import { SourceCode } from "./generated.template";
-import { Entity } from "../entity/entity";
+import { Entity } from "../../entity/entity";
 export declare class Template__generated_sso extends Template {
     constructor();
     getTargetAndPath(): {

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

@@ -0,0 +1 @@
+{"version":3,"file":"generated_sso.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/generated_sso.template.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAIlD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,qBAAa,uBAAwB,SAAQ,QAAQ;;IAKnD,gBAAgB;;;;IAShB,MAAM,CAAC,EAAE,EAAE,eAAe,CAAC,eAAe,CAAC;;;;;;;IA2E3C,2BAA2B,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,GAAG,IAAI;CAkCnE"}

package/dist/template/implementations/generated_sso.template.js

@@ -0,0 +1,105 @@
+import { isManyToManyRelationProp } from "../../types/types.js";
+import { EntityManager } from "../../entity/entity-manager.js";
+import { Template } from "../template.js";
+import inflection from "inflection";
+import * as _ from "lodash-es";
+import { nonNullable } from "../../utils/utils.js";
+import { Sonamu } from "../../api/index.js";
+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));
+        const sourceCodes = entities.map((entity)=>{
+            if (entity.parentId !== undefined || Object.keys(entity.subsets).length === 0) {
+                return null;
+            }
+            const subsetKeys = Object.keys(entity.subsets);
+            const subsetQueryObject = subsetKeys.reduce((r, subsetKey)=>{
+                const subsetQuery = entity.getSubsetQuery(subsetKey);
+                r[subsetKey] = subsetQuery;
+                return r;
+            }, {});
+            const subsetKeyTypeName = `${entity.names.module}SubsetKey`;
+            return {
+                label: `SubsetQuery: ${entity.id}`,
+                lines: [
+                    `export const ${inflection.camelize(entity.id, true)}SubsetQueries:{ [key in ${subsetKeyTypeName}]: SubsetQuery} = ${JSON.stringify(subsetQueryObject)};`,
+                    ""
+                ],
+                importKeys: [
+                    subsetKeyTypeName
+                ]
+            };
+        }).filter(nonNullable);
+        // DatabaseSchema 생성
+        const dbSchemaSourceCode = this.getDatabaseSchemaSourceCode(entities);
+        if (dbSchemaSourceCode) {
+            sourceCodes.push(dbSchemaSourceCode);
+        }
+        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
+                ])
+            };
+        }, {
+            lines: [],
+            importKeys: []
+        });
+        const body = sourceCode.lines.join("\n");
+        const isUsingManyToManyBaseSchema = body.includes("ManyToManyBaseSchema");
+        return {
+            ...this.getTargetAndPath(),
+            body: sourceCode.lines.join("\n"),
+            importKeys: sourceCode.importKeys,
+            customHeaders: [
+                `import { SubsetQuery, ${isUsingManyToManyBaseSchema ? "ManyToManyBaseSchema" : ""} } from "sonamu";`
+            ]
+        };
+    }
+    getDatabaseSchemaSourceCode(entities) {
+        if (entities.length === 0) {
+            return null;
+        }
+        const entitySchemaLines = entities.map((entity)=>`${entity.table}: ${entity.id}BaseSchema;`);
+        const joinTableSchemaLines = _.uniq(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 `${prop.joinTable}: ManyToManyBaseSchema<"${fromTableKey}", "${toTableKey}">;`;
+            })));
+        return {
+            label: `DatabaseSchema`,
+            lines: [
+                `declare module "sonamu" {`,
+                `  export interface DatabaseSchemaExtend {`,
+                ...entitySchemaLines,
+                ...joinTableSchemaLines,
+                `  }`,
+                `}`
+            ],
+            importKeys: entities.map((entity)=>`${entity.id}BaseSchema`)
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/generated_sso.template.ts"],"sourcesContent":["import {\n  isManyToManyRelationProp,\n  SubsetQuery,\n  TemplateOptions,\n} from \"../../types/types\";\nimport { EntityManager } from \"../../entity/entity-manager\";\nimport { Template } from \"../template\";\nimport inflection from \"inflection\";\nimport { SourceCode } from \"./generated.template\";\nimport * as _ from \"lodash-es\";\nimport { nonNullable } from \"../../utils/utils\";\nimport { Sonamu } from \"../../api\";\nimport { Entity } from \"../../entity/entity\";\n\nexport class Template__generated_sso extends Template {\n  constructor() {\n    super(\"generated_sso\");\n  }\n\n  getTargetAndPath() {\n    const { dir } = Sonamu.config.api;\n\n    return {\n      target: `${dir}/src/application`,\n      path: `sonamu.generated.sso.ts`,\n    };\n  }\n\n  render({}: TemplateOptions[\"generated_sso\"]) {\n    const entityIds = EntityManager.getAllIds();\n    const entities = entityIds.map((id) => EntityManager.get(id));\n\n    const sourceCodes: SourceCode[] = entities\n      .map((entity) => {\n        if (\n          entity.parentId !== undefined ||\n          Object.keys(entity.subsets).length === 0\n        ) {\n          return null;\n        }\n        const subsetKeys = Object.keys(entity.subsets);\n        const subsetQueryObject = subsetKeys.reduce(\n          (r, subsetKey) => {\n            const subsetQuery = entity.getSubsetQuery(subsetKey);\n            r[subsetKey] = subsetQuery;\n            return r;\n          },\n          {} as {\n            [key: string]: SubsetQuery;\n          }\n        );\n\n        const subsetKeyTypeName = `${entity.names.module}SubsetKey`;\n        return {\n          label: `SubsetQuery: ${entity.id}`,\n          lines: [\n            `export const ${inflection.camelize(\n              entity.id,\n              true\n            )}SubsetQueries:{ [key in ${subsetKeyTypeName}]: SubsetQuery} = ${JSON.stringify(\n              subsetQueryObject\n            )};`,\n            \"\",\n          ],\n          importKeys: [subsetKeyTypeName],\n        };\n      })\n      .filter(nonNullable);\n\n    // DatabaseSchema 생성\n    const dbSchemaSourceCode = this.getDatabaseSchemaSourceCode(entities);\n    if (dbSchemaSourceCode) {\n      sourceCodes.push(dbSchemaSourceCode);\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]),\n        };\n      },\n      {\n        lines: [],\n        importKeys: [],\n      } as Omit<SourceCode, \"label\">\n    );\n\n    const body = sourceCode.lines.join(\"\\n\");\n    const isUsingManyToManyBaseSchema = body.includes(\"ManyToManyBaseSchema\");\n    return {\n      ...this.getTargetAndPath(),\n      body: sourceCode.lines.join(\"\\n\"),\n      importKeys: sourceCode.importKeys,\n      customHeaders: [\n        `import { SubsetQuery, ${isUsingManyToManyBaseSchema ? \"ManyToManyBaseSchema\" : \"\"} } from \"sonamu\";`,\n      ],\n    };\n  }\n\n  getDatabaseSchemaSourceCode(entities: Entity[]): SourceCode | null {\n    if (entities.length === 0) {\n      return null;\n    }\n\n    const entitySchemaLines = entities.map(\n      (entity) => `${entity.table}: ${entity.id}BaseSchema;`\n    );\n\n    const joinTableSchemaLines = _.uniq(\n      entities.flatMap((entity) =>\n        entity.props.filter(isManyToManyRelationProp).map((prop) => {\n          const fromTableKey = inflection.singularize(entity.table);\n          const toTableKey = inflection.singularize(\n            EntityManager.get(prop.with).table\n          );\n          return `${prop.joinTable}: ManyToManyBaseSchema<\"${fromTableKey}\", \"${toTableKey}\">;`;\n        })\n      )\n    );\n\n    return {\n      label: `DatabaseSchema`,\n      lines: [\n        `declare module \"sonamu\" {`,\n        `  export interface DatabaseSchemaExtend {`,\n        ...entitySchemaLines,\n        ...joinTableSchemaLines,\n        `  }`,\n        `}`,\n      ],\n      importKeys: entities.map((entity) => `${entity.id}BaseSchema`),\n    };\n  }\n}\n"],"names":["isManyToManyRelationProp","EntityManager","Template","inflection","_","nonNullable","Sonamu","Template__generated_sso","getTargetAndPath","dir","config","api","target","path","render","entityIds","getAllIds","entities","map","id","get","sourceCodes","entity","parentId","undefined","Object","keys","subsets","length","subsetKeys","subsetQueryObject","reduce","r","subsetKey","subsetQuery","getSubsetQuery","subsetKeyTypeName","names","module","label","lines","camelize","JSON","stringify","importKeys","filter","dbSchemaSourceCode","getDatabaseSchemaSourceCode","push","sourceCode","result","ts","uniq","body","join","isUsingManyToManyBaseSchema","includes","customHeaders","entitySchemaLines","table","joinTableSchemaLines","flatMap","props","prop","fromTableKey","singularize","toTableKey","with","joinTable"],"mappings":"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"}

package/dist/{templates → template/implementations}/init_types.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__init_types extends Template {
     constructor();
     getTargetAndPath(names: EntityNamesRecord): {

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

@@ -0,0 +1 @@
+{"version":3,"file":"init_types.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/init_types.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,oBAAqB,SAAQ,QAAQ;;IAKhD,gBAAgB,CAAC,KAAK,EAAE,iBAAiB;;;;IASzC,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,eAAe,CAAC,YAAY,CAAC;;;;;;CA4BnD"}

package/dist/template/implementations/init_types.template.js

@@ -0,0 +1,38 @@
+import { EntityManager } from "../../entity/entity-manager.js";
+import { Template } from "../template.js";
+import { Sonamu } from "../../api/index.js";
+export class Template__init_types extends Template {
+    constructor(){
+        super("init_types");
+    }
+    getTargetAndPath(names) {
+        const { dir } = Sonamu.config.api;
+        return {
+            target: `${dir}/src/application`,
+            path: `${names.fs}/${names.fs}.types.ts`
+        };
+    }
+    render({ entityId }) {
+        const names = EntityManager.getNamesFromId(entityId);
+        const hasCreatedAt = EntityManager.get(entityId).props.find((prop)=>prop.name === "created_at") !== undefined;
+        return {
+            ...this.getTargetAndPath(names),
+            body: `
+import { z } from "zod";
+import { ${entityId}BaseSchema, ${entityId}BaseListParams } from "../sonamu.generated";
+
+// ${entityId} - ListParams
+export const ${entityId}ListParams = ${entityId}BaseListParams;
+export type ${entityId}ListParams = z.infer<typeof ${entityId}ListParams>;
+
+// ${entityId} - SaveParams
+export const ${entityId}SaveParams = ${entityId}BaseSchema.partial({ id: true${hasCreatedAt ? ", created_at: true" : ""} });
+export type ${entityId}SaveParams = z.infer<typeof ${entityId}SaveParams>;
+
+      `.trim(),
+            importKeys: []
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/template/implementations/model.template.d.ts

@@ -0,0 +1,17 @@
+import { TemplateOptions } from "../../types/types";
+import { EntityNamesRecord } from "../../entity/entity-manager";
+import { Template } from "../template";
+export declare class Template__model extends Template {
+    constructor();
+    getTargetAndPath(names: EntityNamesRecord): {
+        target: string;
+        path: string;
+    };
+    render({ entityId }: TemplateOptions["model"]): Promise<{
+        body: string;
+        importKeys: never[];
+        target: string;
+        path: string;
+    }>;
+}
+//# sourceMappingURL=model.template.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/model.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;AAKvC,qBAAa,eAAgB,SAAQ,QAAQ;;IAK3C,gBAAgB,CAAC,KAAK,EAAE,iBAAiB;;;;IASnC,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,eAAe,CAAC,OAAO,CAAC;;;;;;CA2JpD"}

package/dist/template/implementations/model.template.js

@@ -0,0 +1,171 @@
+import { EntityManager } from "../../entity/entity-manager.js";
+import { Template } from "../template.js";
+import { Template__view_list } from "./view_list.template.js";
+import { Sonamu } from "../../api/index.js";
+import { getZodTypeById, zodTypeToRenderingNode } from "../zod-converter.js";
+export class Template__model extends Template {
+    constructor(){
+        super("model");
+    }
+    getTargetAndPath(names) {
+        const { dir } = Sonamu.config.api;
+        return {
+            target: `${dir}/src/application`,
+            path: `${names.fs}/${names.fs}.model.ts`
+        };
+    }
+    async render({ entityId }) {
+        const listParamsZodType = await getZodTypeById(`${entityId}ListParams`);
+        const listParamsNode = zodTypeToRenderingNode(listParamsZodType);
+        const names = EntityManager.getNamesFromId(entityId);
+        const entity = EntityManager.get(entityId);
+        const vlTpl = new Template__view_list();
+        if (listParamsNode?.children === undefined) {
+            throw new Error(`listParamsNode가 없습니다. ${entityId}`);
+        }
+        const def = vlTpl.getDefault(listParamsNode.children);
+        return {
+            ...this.getTargetAndPath(names),
+            body: `
+import { BaseModelClass, ListResult, asArray, NotFoundException, BadRequestException, api } from 'sonamu';
+import {
+  ${entityId}SubsetKey,
+  ${entityId}SubsetMapping,
+} from "../sonamu.generated";
+import {
+  ${names.camel}SubsetQueries,
+} from "../sonamu.generated.sso";
+import { ${entityId}ListParams, ${entityId}SaveParams } from "./${names.fs}.types";
+
+/*
+  ${entityId} Model
+*/
+class ${entityId}ModelClass extends BaseModelClass {
+  modelName = "${entityId}";
+
+  @api({ httpMethod: "GET", clients: ["axios", "swr"], resourceName: "${entityId}" })
+  async findById<T extends ${entityId}SubsetKey>(
+    subset: T,
+    id: number
+  ): Promise<${entityId}SubsetMapping[T]> {
+    const { rows } = await this.findMany(subset, {
+      id,
+      num: 1,
+      page: 1,
+    });
+    if (!rows[0]) {
+      throw new NotFoundException(\`존재하지 않는 ${names.capital} ID \${id}\`);
+    }
+
+    return rows[0];
+  }
+
+  async findOne<T extends ${entityId}SubsetKey>(
+    subset: T,
+    listParams: ${entityId}ListParams
+  ): Promise<${entityId}SubsetMapping[T] | null> {
+    const { rows } = await this.findMany(subset, {
+      ...listParams,
+      num: 1,
+      page: 1,
+    });
+
+    return rows[0] ?? null;
+  }
+
+  @api({ httpMethod: "GET", clients: ["axios", "swr"], resourceName: "${names.capitalPlural}" })
+  async findMany<T extends ${entityId}SubsetKey>(
+    subset: T,
+    params: ${entityId}ListParams = {}
+  ): Promise<ListResult<${entityId}SubsetMapping[T]>> {
+    // params with defaults
+    params = {
+      num: 24,
+      page: 1,
+      search: "${def.search}",
+      orderBy: "${def.orderBy}",
+      ...params,
+    };
+
+    // build queries
+    let { rows, total } = await this.runSubsetQuery({
+      subset,
+      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,
+    });
+
+    return {
+      rows,
+      total,
+    };
+  }
+
+  @api({ httpMethod: "POST" })
+  async save(
+    spa: ${entityId}SaveParams[]
+  ): Promise<number[]> {
+    const wdb = this.getPuri("w");
+
+    // register
+    spa.map((sp) => {
+      wdb.ubRegister("${entity.table}", sp);
+    });
+
+    // transaction
+    return wdb.transaction(async (trx) => {
+      const ids = await trx.ubUpsert("${entity.table}");
+
+      return ids;
+    });
+  }
+
+  @api({ httpMethod: "POST", guards: [ "admin" ] })
+  async del(ids: number[]): Promise<number> {
+    const wdb = this.getPuri("w");
+
+    // transaction
+    await wdb.transaction(async (trx) => {
+      return trx.table("${entity.table}").whereIn("${entity.table}.id", ids).delete();
+    });
+
+    return ids.length;
+  }
+}
+
+export const ${entityId}Model = new ${entityId}ModelClass();
+      `.trim(),
+            importKeys: []
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/model.template.ts"],"sourcesContent":["import { TemplateOptions } from \"../../types/types\";\nimport { EntityManager, EntityNamesRecord } from \"../../entity/entity-manager\";\nimport { Template } from \"../template\";\nimport { Template__view_list } from \"./view_list.template\";\nimport { Sonamu } from \"../../api\";\nimport { getZodTypeById, zodTypeToRenderingNode } from \"../zod-converter\";\n\nexport class Template__model extends Template {\n  constructor() {\n    super(\"model\");\n  }\n\n  getTargetAndPath(names: EntityNamesRecord) {\n    const { dir } = Sonamu.config.api;\n\n    return {\n      target: `${dir}/src/application`,\n      path: `${names.fs}/${names.fs}.model.ts`,\n    };\n  }\n\n  async render({ entityId }: TemplateOptions[\"model\"]) {\n    const listParamsZodType = await getZodTypeById(`${entityId}ListParams`);\n    const listParamsNode = zodTypeToRenderingNode(listParamsZodType);\n\n    const names = EntityManager.getNamesFromId(entityId);\n    const entity = EntityManager.get(entityId);\n\n    const vlTpl = new Template__view_list();\n    if (listParamsNode?.children === undefined) {\n      throw new Error(`listParamsNode가 없습니다. ${entityId}`);\n    }\n    const def = vlTpl.getDefault(listParamsNode.children);\n\n    return {\n      ...this.getTargetAndPath(names),\n      body: `\nimport { BaseModelClass, ListResult, asArray, NotFoundException, BadRequestException, api } from 'sonamu';\nimport {\n  ${entityId}SubsetKey,\n  ${entityId}SubsetMapping,\n} from \"../sonamu.generated\";\nimport {\n  ${names.camel}SubsetQueries,\n} from \"../sonamu.generated.sso\";\nimport { ${entityId}ListParams, ${entityId}SaveParams } from \"./${names.fs}.types\";\n\n/*\n  ${entityId} Model\n*/\nclass ${entityId}ModelClass extends BaseModelClass {\n  modelName = \"${entityId}\";\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"swr\"], resourceName: \"${entityId}\" })\n  async findById<T extends ${entityId}SubsetKey>(\n    subset: T,\n    id: number\n  ): Promise<${entityId}SubsetMapping[T]> {\n    const { rows } = await this.findMany(subset, {\n      id,\n      num: 1,\n      page: 1,\n    });\n    if (!rows[0]) {\n      throw new NotFoundException(\\`존재하지 않는 ${names.capital} ID \\${id}\\`);\n    }\n\n    return rows[0];\n  }\n\n  async findOne<T extends ${entityId}SubsetKey>(\n    subset: T,\n    listParams: ${entityId}ListParams\n  ): Promise<${entityId}SubsetMapping[T] | null> {\n    const { rows } = await this.findMany(subset, {\n      ...listParams,\n      num: 1,\n      page: 1,\n    });\n\n    return rows[0] ?? null;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"swr\"], resourceName: \"${names.capitalPlural}\" })\n  async findMany<T extends ${entityId}SubsetKey>(\n    subset: T,\n    params: ${entityId}ListParams = {}\n  ): Promise<ListResult<${entityId}SubsetMapping[T]>> {\n    // params with defaults\n    params = {\n      num: 24,\n      page: 1,\n      search: \"${def.search}\",\n      orderBy: \"${def.orderBy}\",\n      ...params,\n    };\n\n    // build queries\n    let { rows, total } = await this.runSubsetQuery({\n      subset,\n      params,\n      subsetQuery: ${names.camel}SubsetQueries[subset],\n      build: ({ qb }) => {\n        // id\n        if (params.id) {\n          qb.whereIn(\"${entity.table}.id\", asArray(params.id));\n        }\n\n        // search-keyword\n        if (params.search && params.keyword && params.keyword.length > 0) {\n          if (params.search === \"id\") {\n            qb.where(\"${entity.table}.id\", params.keyword);\n          // } else if (params.search === \"field\") {\n          //   qb.where(\"${entity.table}.field\", \"like\", \\`%\\${params.keyword}%\\`);\n          } else {\n            throw new BadRequestException(\n              \\`구현되지 않은 검색 필드 \\${params.search}\\`\n            );\n          }\n        }\n\n        // orderBy\n        if (params.orderBy) {\n          // default orderBy\n          const [orderByField, orderByDirec] = params.orderBy.split(\"-\");\n          qb.orderBy(\"${entity.table}.\" + orderByField, orderByDirec);\n        }\n\n        return qb;\n      },\n      debug: false,\n    });\n\n    return {\n      rows,\n      total,\n    };\n  }\n\n  @api({ httpMethod: \"POST\" })\n  async save(\n    spa: ${entityId}SaveParams[]\n  ): Promise<number[]> {\n    const wdb = this.getPuri(\"w\");\n\n    // register\n    spa.map((sp) => {\n      wdb.ubRegister(\"${entity.table}\", sp);\n    });\n\n    // transaction\n    return wdb.transaction(async (trx) => {\n      const ids = await trx.ubUpsert(\"${entity.table}\");\n\n      return ids;\n    });\n  }\n\n  @api({ httpMethod: \"POST\", guards: [ \"admin\" ] })\n  async del(ids: number[]): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n\n    // transaction\n    await wdb.transaction(async (trx) => {\n      return trx.table(\"${entity.table}\").whereIn(\"${entity.table}.id\", ids).delete();\n    });\n\n    return ids.length;\n  }\n}\n\nexport const ${entityId}Model = new ${entityId}ModelClass();\n      `.trim(),\n      importKeys: [],\n    };\n  }\n}\n"],"names":["EntityManager","Template","Template__view_list","Sonamu","getZodTypeById","zodTypeToRenderingNode","Template__model","getTargetAndPath","names","dir","config","api","target","path","fs","render","entityId","listParamsZodType","listParamsNode","getNamesFromId","entity","get","vlTpl","children","undefined","Error","def","getDefault","body","camel","capital","capitalPlural","search","orderBy","table","trim","importKeys"],"mappings":"AACA,SAASA,aAAa,QAA2B,iCAA8B;AAC/E,SAASC,QAAQ,QAAQ,iBAAc;AACvC,SAASC,mBAAmB,QAAQ,0BAAuB;AAC3D,SAASC,MAAM,QAAQ,qBAAY;AACnC,SAASC,cAAc,EAAEC,sBAAsB,QAAQ,sBAAmB;AAE1E,OAAO,MAAMC,wBAAwBL;IACnC,aAAc;QACZ,KAAK,CAAC;IACR;IAEAM,iBAAiBC,KAAwB,EAAE;QACzC,MAAM,EAAEC,GAAG,EAAE,GAAGN,OAAOO,MAAM,CAACC,GAAG;QAEjC,OAAO;YACLC,QAAQ,GAAGH,IAAI,gBAAgB,CAAC;YAChCI,MAAM,GAAGL,MAAMM,EAAE,CAAC,CAAC,EAAEN,MAAMM,EAAE,CAAC,SAAS,CAAC;QAC1C;IACF;IAEA,MAAMC,OAAO,EAAEC,QAAQ,EAA4B,EAAE;QACnD,MAAMC,oBAAoB,MAAMb,eAAe,GAAGY,SAAS,UAAU,CAAC;QACtE,MAAME,iBAAiBb,uBAAuBY;QAE9C,MAAMT,QAAQR,cAAcmB,cAAc,CAACH;QAC3C,MAAMI,SAASpB,cAAcqB,GAAG,CAACL;QAEjC,MAAMM,QAAQ,IAAIpB;QAClB,IAAIgB,gBAAgBK,aAAaC,WAAW;YAC1C,MAAM,IAAIC,MAAM,CAAC,sBAAsB,EAAET,UAAU;QACrD;QACA,MAAMU,MAAMJ,MAAMK,UAAU,CAACT,eAAeK,QAAQ;QAEpD,OAAO;YACL,GAAG,IAAI,CAAChB,gBAAgB,CAACC,MAAM;YAC/BoB,MAAM,CAAC;;;EAGX,EAAEZ,SAAS;EACX,EAAEA,SAAS;;;EAGX,EAAER,MAAMqB,KAAK,CAAC;;SAEP,EAAEb,SAAS,YAAY,EAAEA,SAAS,qBAAqB,EAAER,MAAMM,EAAE,CAAC;;;EAGzE,EAAEE,SAAS;;MAEP,EAAEA,SAAS;eACF,EAAEA,SAAS;;sEAE4C,EAAEA,SAAS;2BACtD,EAAEA,SAAS;;;aAGzB,EAAEA,SAAS;;;;;;;4CAOoB,EAAER,MAAMsB,OAAO,CAAC;;;;;;0BAMlC,EAAEd,SAAS;;gBAErB,EAAEA,SAAS;aACd,EAAEA,SAAS;;;;;;;;;;sEAU8C,EAAER,MAAMuB,aAAa,CAAC;2BACjE,EAAEf,SAAS;;YAE1B,EAAEA,SAAS;wBACC,EAAEA,SAAS;;;;;eAKpB,EAAEU,IAAIM,MAAM,CAAC;gBACZ,EAAEN,IAAIO,OAAO,CAAC;;;;;;;;mBAQX,EAAEzB,MAAMqB,KAAK,CAAC;;;;sBAIX,EAAET,OAAOc,KAAK,CAAC;;;;;;sBAMf,EAAEd,OAAOc,KAAK,CAAC;;yBAEZ,EAAEd,OAAOc,KAAK,CAAC;;;;;;;;;;;;sBAYlB,EAAEd,OAAOc,KAAK,CAAC;;;;;;;;;;;;;;;;SAgB5B,EAAElB,SAAS;;;;;;sBAME,EAAEI,OAAOc,KAAK,CAAC;;;;;sCAKC,EAAEd,OAAOc,KAAK,CAAC;;;;;;;;;;;;wBAY7B,EAAEd,OAAOc,KAAK,CAAC,YAAY,EAAEd,OAAOc,KAAK,CAAC;;;;;;;aAOrD,EAAElB,SAAS,YAAY,EAAEA,SAAS;MACzC,CAAC,CAACmB,IAAI;YACNC,YAAY,EAAE;QAChB;IACF;AACF"}

package/dist/{templates → template/implementations}/model_test.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__model_test extends Template {
     constructor();
     getTargetAndPath(names: EntityNamesRecord): {

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

@@ -0,0 +1 @@
+{"version":3,"file":"model_test.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/model_test.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,oBAAqB,SAAQ,QAAQ;;IAKhD,gBAAgB,CAAC,KAAK,EAAE,iBAAiB;;;;IASzC,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,eAAe,CAAC,YAAY,CAAC;;;;;;CAmBnD"}

package/dist/template/implementations/model_test.template.js

@@ -0,0 +1,35 @@
+import { EntityManager } from "../../entity/entity-manager.js";
+import { Template } from "../template.js";
+import { Sonamu } from "../../api/index.js";
+export class Template__model_test extends Template {
+    constructor(){
+        super("model_test");
+    }
+    getTargetAndPath(names) {
+        const { dir } = Sonamu.config.api;
+        return {
+            target: `${dir}/src/application`,
+            path: `${names.fs}/${names.fs}.model.test.ts`
+        };
+    }
+    render({ entityId }) {
+        const names = EntityManager.getNamesFromId(entityId);
+        return {
+            ...this.getTargetAndPath(names),
+            body: `
+import { describe, test, expect } from "vitest";
+import { bootstrap } from '../../testing/bootstrap';
+
+bootstrap();
+describe.skip("${entityId}ModelTest", () => {
+  test("Query", async () => {
+    expect(true).toBe(true);
+  });
+});
+      `.trim(),
+            importKeys: []
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,15 +1,15 @@
-import { TemplateOptions } from "../types/types";
-import { EntityNamesRecord } from "../entity/entity-manager";
-import { ApiParam } from "../types/types";
-import { ExtendedApi } from "../api/decorators";
-import { Template } from "./base-template";
+import { TemplateOptions } from "../../types/types";
+import { EntityNamesRecord } from "../../entity/entity-manager";
+import { ApiParam } from "../../types/types";
+import { ExtendedApi } from "../../api/decorators";
+import { Template } from "../template";
 export declare class Template__service extends Template {
     constructor();
     getTargetAndPath(names: EntityNamesRecord): {
         target: string;
         path: string;
     };
-    render({ namesRecord }: TemplateOptions["service"], apis: ExtendedApi[]): {
+    render({ namesRecord }: TemplateOptions["service"]): {
         body: string;
         importKeys: string[];
         customHeaders: string[];