sonamu 0.5.7 → 0.7.0

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

@@ -0,0 +1,249 @@
+import assert from "assert";
+import { unique } from "radashi";
+import { Sonamu } from "../../api/index.js";
+import { EntityManager } from "../../entity/entity-manager.js";
+import { Naite } from "../../naite/naite.js";
+import { isVirtualProp } from "../../types/types.js";
+import { nonNullable } from "../../utils/utils.js";
+import { Template } from "../template.js";
+import { propNodeToZodTypeDef, zodTypeToZodCode } from "../zod-converter.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.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"
+        ];
+        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: unique([
+                    ...result.importKeys,
+                    ...ts.importKeys
+                ].sort())
+            };
+        }, {
+            lines: [],
+            importKeys: []
+        });
+        // .types.ts의 타입을 참조하는 경우 순환참조(상호참조)가 발생하므로 타입을 가져와 인라인 처리
+        const allTypeKeys = entities.flatMap((entity)=>Object.keys(entity.types));
+        const cdImportKeys = sourceCode.importKeys.filter((importKey)=>allTypeKeys.includes(importKey));
+        if (cdImportKeys.length > 0) {
+            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));
+        }
+        const body = sourceCode.lines.join("\n");
+        Naite.t("Template__generated:body", body);
+        // import
+        const sonamuImports = [
+            "zArrayable",
+            "SQLDateTimeString",
+            "SubsetQuery",
+            "SonamuQueryMode"
+        ].filter((mod)=>body.includes(mod));
+        return {
+            ...this.getTargetAndPath(),
+            body,
+            importKeys: sourceCode.importKeys,
+            customHeaders: [
+                "/** biome-ignore-all lint: generated는 무시 */",
+                "/** biome-ignore-all assist: generated는 무시 */",
+                "",
+                `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).flatMap(([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)};`
+                    ])
+            ],
+            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 = (()=>{
+            const result = propNodeToZodTypeDef(propNode, importKeys);
+            if (result.endsWith(",")) {
+                return result.slice(0, -1);
+            }
+            return result;
+        })();
+        // fulltext index에 포함된 컬럼들 추출
+        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 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 {
+            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.flatMap((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.replace(/,$/, "")};`,
+                    `export type ${schemaName} = z.infer<typeof ${schemaName}>;`
+                ];
+            }),
+            `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: unique(importKeys)
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/generated.template.ts"],"sourcesContent":["import assert from \"assert\";\nimport { unique } from \"radashi\";\nimport { Sonamu } from \"../../api\";\nimport type { Entity } from \"../../entity/entity\";\nimport { EntityManager } from \"../../entity/entity-manager\";\nimport { Naite } from \"../../naite/naite\";\nimport { type EntityPropNode, isVirtualProp } from \"../../types/types\";\nimport { nonNullable } from \"../../utils/utils\";\nimport { Template } from \"../template\";\nimport { propNodeToZodTypeDef, zodTypeToZodCode } from \"../zod-converter\";\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    return {\n      target: `${dir}/src/application`,\n      path: `sonamu.generated.ts`,\n    };\n  }\n  render() {\n    const entityIds = EntityManager.getAllIds();\n    const entities = entityIds.map((id) => EntityManager.get(id));\n\n    // 전체 SourceCode 생성\n    const sourceCodes = entities.flatMap((entity) => {\n      return [\n        this.getEnumsSourceCode(entity),\n        this.getBaseSchemaSourceCode(entity),\n        this.getBaseListParamsSourceCode(entity),\n        this.getSubsetSourceCode(entity),\n      ].filter(nonNullable);\n    });\n    Naite.t(\"Template__generated:sourceCodes\", sourceCodes);\n\n    // Sort\n    const LABEL_KEY_ORDER = [\"Enums\", \"BaseSchema\", \"BaseListParams\", \"Subsets\", \"SubsetQueries\"];\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: unique([...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.flatMap((entity) => Object.keys(entity.types));\n    const cdImportKeys = sourceCode.importKeys.filter((importKey) =>\n      allTypeKeys.includes(importKey),\n    );\n    if (cdImportKeys.length > 0) {\n      const customScalarLines = cdImportKeys.flatMap((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        assert(zodType);\n\n        return [\n          `// CustomScalar: ${importKey}`,\n          `const ${importKey} = ${zodTypeToZodCode(zodType)};`,\n          `type ${importKey} = z.infer<typeof ${importKey}>`,\n          \"\",\n        ];\n      });\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    Naite.t(\"Template__generated:body\", body);\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        \"/** biome-ignore-all lint: generated는 무시 */\",\n        \"/** biome-ignore-all assist: generated는 무시 */\",\n        \"\",\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          .flatMap(([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      ],\n      importKeys: [],\n    };\n  }\n\n  getBaseSchemaSourceCode(entity: Entity, importKeys: string[] = []): 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 = (() => {\n      const result = propNodeToZodTypeDef(propNode, importKeys);\n      if (result.endsWith(\",\")) {\n        return result.slice(0, -1);\n      }\n\n      return result;\n    })();\n\n    // fulltext index에 포함된 컬럼들 추출\n    const fulltextColumns = unique(\n      entity.indexes.filter((index) => index.type === \"fulltext\").flatMap((index) => index.columns),\n    );\n\n    // virtual props\n    const virtualProps = entity.props\n      .filter((prop) => isVirtualProp(prop))\n      .map((prop) => prop.name);\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        (virtualProps.length > 0\n          ? ` & { readonly __virtual__: readonly [${virtualProps\n              .map((prop) => `\"${prop}\"`)\n              .join(\", \")}] }`\n          : \"\") +\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.flatMap((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.replace(/,$/, \"\")};`,\n          `export type ${schemaName} = z.infer<typeof ${schemaName}>;`,\n        ];\n      }),\n      `export type ${entity.names.module}SubsetMapping = {`,\n      ...subsetKeys.map((subsetKey) => `  ${subsetKey}: ${entity.names.module}Subset${subsetKey};`),\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: unique(importKeys),\n    };\n  }\n}\n"],"names":["assert","unique","Sonamu","EntityManager","Naite","isVirtualProp","nonNullable","Template","propNodeToZodTypeDef","zodTypeToZodCode","Template__generated","getTargetAndPath","dir","config","api","target","path","render","entityIds","getAllIds","entities","map","id","get","sourceCodes","flatMap","entity","getEnumsSourceCode","getBaseSchemaSourceCode","getBaseListParamsSourceCode","getSubsetSourceCode","filter","t","LABEL_KEY_ORDER","sort","a","b","aKey","label","split","bKey","aIndex","indexOf","bIndex","sourceCode","reduce","result","ts","lines","importKeys","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","endsWith","slice","fulltextColumns","indexes","index","type","columns","virtualProps","name","col","parentId","undefined","filterProps","toFilter","propNodes","filterBody","trim","subsets","subsetKeys","subsetKey","fieldExprs","fieldExprsToPropNodes","replace","k"],"mappings":"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"}

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

@@ -1,14 +1,13 @@
 import { z } from "zod";
-import { TemplateOptions } from "../types/types";
-import { ExtendedApi } from "../api/decorators";
-import { Template } from "./base-template";
+import type { ExtendedApi } from "../../api/decorators";
+import { Template } from "../template";
 export declare class Template__generated_http extends Template {
     constructor();
     getTargetAndPath(): {
         target: string;
         path: string;
     };
-    render({}: TemplateOptions["generated_http"]): Promise<{
+    render(): Promise<{
         body: string;
         importKeys: never[];
         target: string;

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;AAExB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,qBAAa,wBAAyB,SAAQ,QAAQ;;IAKpD,gBAAgB;;;;IASV,MAAM;;;;;;IA8CZ,mBAAmB,CAAC,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO;IAgEvE,gBAAgB,CACd,GAAG,EAAE,WAAW,EAEhB,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;CAY9B"}

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 { Sonamu } from "../../api/sonamu.js";
+import { Template } from "../template.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: [
+                            "",
+                            JSON.stringify(reqObject, null, 2)
+                        ]
+                    };
+                }
+            })();
+            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) {
+            /** biome-ignore lint/suspicious/noExplicitAny: 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) {
+            // biome-ignore lint/suspicious/noExplicitAny: ZodRecord 타입 사용
+            const kvDef = zodType.def;
+            // biome-ignore lint/suspicious/noExplicitAny: ZodIntersection 타입 사용
+            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, // biome-ignore lint/suspicious/noExplicitAny: ZodObject 타입 사용
+    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 { getZodObjectFromApi } from \"../../api/code-converters\";\nimport type { ExtendedApi } from \"../../api/decorators\";\nimport { Sonamu } from \"../../api/sonamu\";\nimport { Template } from \"../template\";\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() {\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: [qs.stringify(reqObject, { encode: false }).split(\"&\").join(\"\\n\\t&\")],\n              body: [],\n            };\n          } else {\n            return {\n              querystring: [],\n              body: [\"\", JSON.stringify(reqObject, null, 2)],\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 [this.zodTypeToReqDefault((zodType as z.ZodArray<z.ZodType>).element, name)];\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((zodType as z.ZodOptional<z.ZodType>).def.innerType, name);\n    } else if (zodType instanceof z.ZodNullable) {\n      return null;\n    } else if (zodType instanceof z.ZodUnion) {\n      return this.zodTypeToReqDefault((zodType as z.ZodUnion<z.ZodType[]>).def.options[0], name);\n    } else if (zodType instanceof z.ZodUnknown) {\n      return \"unknown\";\n    } else if (zodType instanceof z.ZodTuple) {\n      /** biome-ignore lint/suspicious/noExplicitAny: ZodTuple 타입 사용 */\n      return zodType.def.items.map((item: any) => this.zodTypeToReqDefault(item, name));\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      // biome-ignore lint/suspicious/noExplicitAny: ZodRecord 타입 사용\n      const kvDef = (zodType as z.ZodRecord<any, z.ZodType> | z.ZodMap<z.ZodType, z.ZodType>).def;\n      // biome-ignore lint/suspicious/noExplicitAny: ZodIntersection 타입 사용\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 [this.zodTypeToReqDefault((zodType as z.ZodSet<z.ZodType>).def.valueType, name)];\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((zodType as z.ZodDefault<z.ZodType>).def.innerType, name);\n    } else {\n      // console.log(zodType);\n      return `unknown-${zodType.type}`;\n    }\n  }\n\n  resolveApiParams(\n    api: ExtendedApi,\n    // biome-ignore lint/suspicious/noExplicitAny: ZodObject 타입 사용\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(`Invalid zod type detected on ${api.modelName}:${api.methodName}`);\n    }\n  }\n}\n"],"names":["qs","z","getZodObjectFromApi","Sonamu","Template","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","JSON","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,14 +1,13 @@
-import { TemplateOptions } from "../types/types";
-import { Template } from "./base-template";
-import { SourceCode } from "./generated.template";
-import { Entity } from "../entity/entity";
+import type { Entity } from "../../entity/entity";
+import { Template } from "../template";
+import type { SourceCode } from "./generated.template";
 export declare class Template__generated_sso extends Template {
     constructor();
     getTargetAndPath(): {
         target: string;
         path: string;
     };
-    render({}: TemplateOptions["generated_sso"]): {
+    render(): {
         body: string;
         importKeys: string[];
         customHeaders: string[];

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":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAGlD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD,qBAAa,uBAAwB,SAAQ,QAAQ;;IAKnD,gBAAgB;;;;IAShB,MAAM;;;;;;;IA4FN,2BAA2B,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,GAAG,IAAI;CAkCnE"}