sonamu 0.5.6 → 0.6.0

package/dist/syncer/code-generator.js

@@ -0,0 +1,141 @@
+import path from "path";
+import { Sonamu } from "../api/sonamu.js";
+import { AlreadyProcessedException } from "../exceptions/so-exceptions.js";
+import { everyAsync, filterAsync } from "../utils/async-utils.js";
+import { exists } from "../utils/fs-utils.js";
+import chalk from "chalk";
+import { mkdir, writeFile } from "node:fs/promises";
+import * as _ from "lodash-es";
+import { Template } from "../template/template.js";
+import { EntityManager } from "../entity/entity-manager.js";
+import { wrapIf } from "../utils/lodash-able.js";
+import prettier from "prettier";
+/**
+ * 템플릿을 렌더링하고 파일로 생성합니다.
+ * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.
+ * @param key - 템플릿 키 (예: "entity", "model", "service" 등)
+ * @param templateOptions - 템플릿 렌더링에 필요한 옵션
+ * @param _generateOptions - 생성 옵션 (overwrite 여부)
+ * @returns 생성된 파일 경로 배열
+ */ export async function generateTemplate(key, templateOptions, _generateOptions) {
+    const generateOptions = {
+        overwrite: false,
+        ..._generateOptions
+    };
+    // 키 children
+    const keys = [
+        key
+    ];
+    // 템플릿 렌더
+    const pathAndCodes = (await Promise.all(keys.map(async (key)=>{
+        return await renderTemplate(key, templateOptions);
+    }))).flat();
+    const filteredPathAndCodes = await (async ()=>{
+        if (generateOptions.overwrite === true) {
+            return pathAndCodes;
+        } else {
+            return await filterAsync(pathAndCodes, async (pathAndCode)=>{
+                const { targets } = Sonamu.config.sync;
+                const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;
+                const dstFilePaths = targets.map((target)=>filePath.replace("/:target/", `/${target}/`));
+                return await everyAsync(dstFilePaths, async (dstPath)=>!await exists(dstPath));
+            });
+        }
+    })();
+    if (filteredPathAndCodes.length === 0) {
+        throw new AlreadyProcessedException("이미 경로에 모든 파일이 존재합니다.");
+    }
+    return (await Promise.all(filteredPathAndCodes.map((pathAndCode)=>writeCodeToPathEachTarget(pathAndCode)))).flat();
+}
+/**
+ * 템플릿을 렌더링하여 PathAndCode 객체를 반환합니다.
+ * 파일로 쓰지 않고 메모리상에서만 렌더링합니다.
+ * @param key - 템플릿 키
+ * @param options - 템플릿 렌더링 옵션
+ * @returns 경로와 코드 쌍의 배열
+ */ export async function renderTemplate(key, options) {
+    const template = Template.find(key);
+    const rendered = await template.render(options);
+    const resolved = await resolveRenderedTemplate(key, rendered);
+    let preTemplateResolved = [];
+    if (rendered.preTemplates) {
+        preTemplateResolved = (await Promise.all(rendered.preTemplates.map(({ key, options })=>{
+            return renderTemplate(key, options);
+        }))).flat();
+    }
+    return [
+        resolved,
+        ...preTemplateResolved
+    ];
+}
+async function resolveRenderedTemplate(key, result) {
+    const { target, path: filePath, body, importKeys, customHeaders } = result;
+    // import 할 대상의 대상 path 추출
+    const importDefs = importKeys.reduce((r, importKey)=>{
+        const modulePath = EntityManager.getModulePath(importKey);
+        let importPath = modulePath;
+        if (modulePath.includes("/") || modulePath.includes(".")) {
+            importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p)=>[
+                    p.startsWith(".") === false,
+                    "./" + p
+                ]);
+        }
+        // 같은 파일에서 import 하는 경우 keys 로 나열 처리
+        const existsOne = r.find((importDef)=>importDef.from === importPath);
+        if (existsOne) {
+            existsOne.keys = _.uniq(existsOne.keys.concat(importKey));
+        } else {
+            r.push({
+                keys: [
+                    importKey
+                ],
+                from: importPath
+            });
+        }
+        return r;
+    }, [])// 셀프 참조 방지
+    .filter((importDef)=>filePath.endsWith(importDef.from.replace("./", "") + ".ts") === false);
+    // 커스텀 헤더 포함하여 헤더 생성
+    const header = [
+        ...customHeaders ?? [],
+        ...importDefs.map((importDef)=>`import { ${importDef.keys.join(", ")} } from '${importDef.from}'`)
+    ].join("\n");
+    const formatted = await (async ()=>{
+        if (key === "generated_http") {
+            return [
+                header,
+                body
+            ].join("\n\n");
+        } else {
+            return prettier.format([
+                header,
+                body
+            ].join("\n\n"), {
+                parser: key === "entity" ? "json" : "typescript"
+            });
+        }
+    })();
+    return {
+        path: target + "/" + filePath,
+        code: formatted
+    };
+}
+async function writeCodeToPathEachTarget(pathAndCode) {
+    const { targets } = Sonamu.config.sync;
+    const { appRootPath } = Sonamu;
+    const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;
+    const dstFilePaths = _.uniq(targets.map((target)=>filePath.replace("/:target/", `/${target}/`)));
+    return await Promise.all(dstFilePaths.map(async (dstFilePath)=>{
+        const dir = path.dirname(dstFilePath);
+        if (!await exists(dir)) {
+            await mkdir(dir, {
+                recursive: true
+            });
+        }
+        await writeFile(dstFilePath, pathAndCode.code);
+        console.log(chalk.bold("Generated: ") + chalk.blue(`${dstFilePath.replace(appRootPath + "/", "")}`));
+        return dstFilePath;
+    }));
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/code-generator.ts"],"sourcesContent":["import path from \"path\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\nimport {\n  GenerateOptions,\n  PathAndCode,\n  TemplateKey,\n  TemplateOptions,\n} from \"../types/types\";\nimport { everyAsync, filterAsync } from \"../utils/async-utils\";\nimport { exists } from \"../utils/fs-utils\";\nimport chalk from \"chalk\";\nimport { mkdir, writeFile } from \"fs/promises\";\nimport * as _ from \"lodash-es\";\nimport { Template } from \"../template/template\";\nimport { RenderedTemplate } from \"../template/template\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { wrapIf } from \"../utils/lodash-able\";\nimport prettier from \"prettier\";\nimport { AbsolutePath } from \"../utils/path-utils\";\n\n/**\n * 템플릿을 렌더링하고 파일로 생성합니다.\n * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.\n * @param key - 템플릿 키 (예: \"entity\", \"model\", \"service\" 등)\n * @param templateOptions - 템플릿 렌더링에 필요한 옵션\n * @param _generateOptions - 생성 옵션 (overwrite 여부)\n * @returns 생성된 파일 경로 배열\n */\nexport async function generateTemplate(\n  key: TemplateKey,\n  templateOptions: any,\n  _generateOptions?: GenerateOptions\n): Promise<AbsolutePath[]> {\n  const generateOptions = {\n    overwrite: false,\n    ..._generateOptions,\n  };\n\n  // 키 children\n  const keys: TemplateKey[] = [key];\n\n  // 템플릿 렌더\n  const pathAndCodes = (\n    await Promise.all(\n      keys.map(async (key) => {\n        return await renderTemplate(key, templateOptions);\n      })\n    )\n  ).flat();\n\n  const filteredPathAndCodes: PathAndCode[] = await (async () => {\n    if (generateOptions.overwrite === true) {\n      return pathAndCodes;\n    } else {\n      return await filterAsync(pathAndCodes, async (pathAndCode) => {\n        const { targets } = Sonamu.config.sync;\n        const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;\n        const dstFilePaths = targets.map((target) =>\n          filePath.replace(\"/:target/\", `/${target}/`)\n        );\n        return await everyAsync(\n          dstFilePaths,\n          async (dstPath) => !(await exists(dstPath))\n        );\n      });\n    }\n  })();\n  \n  if (filteredPathAndCodes.length === 0) {\n    throw new AlreadyProcessedException(\"이미 경로에 모든 파일이 존재합니다.\");\n  }\n\n  return (await Promise.all(\n    filteredPathAndCodes.map((pathAndCode) => writeCodeToPathEachTarget(pathAndCode))\n  )).flat();\n}\n\n/**\n * 템플릿을 렌더링하여 PathAndCode 객체를 반환합니다.\n * 파일로 쓰지 않고 메모리상에서만 렌더링합니다.\n * @param key - 템플릿 키\n * @param options - 템플릿 렌더링 옵션\n * @returns 경로와 코드 쌍의 배열\n */\nexport async function renderTemplate<T extends keyof TemplateOptions>(\n  key: T,\n  options: TemplateOptions[T]\n): Promise<PathAndCode[]> {\n  const template = Template.find(key);\n\n  const rendered = await template.render(options);\n  const resolved = await resolveRenderedTemplate(key, rendered);\n\n  let preTemplateResolved: PathAndCode[] = [];\n  if (rendered.preTemplates) {\n    preTemplateResolved = (\n      await Promise.all(\n        rendered.preTemplates.map(({ key, options }) => {\n          return renderTemplate(key, options);\n        })\n      )\n    ).flat();\n  }\n\n  return [resolved, ...preTemplateResolved];\n}\n\nasync function resolveRenderedTemplate(\n  key: TemplateKey,\n  result: RenderedTemplate\n): Promise<PathAndCode> {\n  const { target, path: filePath, body, importKeys, customHeaders } = result;\n\n  // import 할 대상의 대상 path 추출\n  const importDefs = importKeys\n    .reduce(\n      (r, importKey) => {\n        const modulePath = EntityManager.getModulePath(importKey);\n        let importPath = modulePath;\n        if (modulePath.includes(\"/\") || modulePath.includes(\".\")) {\n          importPath = wrapIf(\n            path.relative(path.dirname(filePath), modulePath),\n            (p) => [p.startsWith(\".\") === false, \"./\" + p]\n          );\n        }\n\n        // 같은 파일에서 import 하는 경우 keys 로 나열 처리\n        const existsOne = r.find((importDef) => importDef.from === importPath);\n        if (existsOne) {\n          existsOne.keys = _.uniq(existsOne.keys.concat(importKey));\n        } else {\n          r.push({\n            keys: [importKey],\n            from: importPath,\n          });\n        }\n        return r;\n      },\n      [] as {\n        keys: string[];\n        from: string;\n      }[]\n    )\n    // 셀프 참조 방지\n    .filter(\n      (importDef) =>\n        filePath.endsWith(importDef.from.replace(\"./\", \"\") + \".ts\") === false\n    );\n\n  // 커스텀 헤더 포함하여 헤더 생성\n  const header = [\n    ...(customHeaders ?? []),\n    ...importDefs.map(\n      (importDef) =>\n        `import { ${importDef.keys.join(\", \")} } from '${importDef.from}'`\n    ),\n  ].join(\"\\n\");\n\n  const formatted = await (async () => {\n    if (key === \"generated_http\") {\n      return [header, body].join(\"\\n\\n\");\n    } else {\n      return prettier.format([header, body].join(\"\\n\\n\"), {\n        parser: key === \"entity\" ? \"json\" : \"typescript\",\n      });\n    }\n  })();\n\n  return {\n    path: target + \"/\" + filePath,\n    code: formatted,\n  };\n}\n\nasync function writeCodeToPathEachTarget(\n  pathAndCode: PathAndCode\n): Promise<AbsolutePath[]> {\n  const { targets } = Sonamu.config.sync;\n  const { appRootPath } = Sonamu;\n  const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}` as AbsolutePath;\n\n  const dstFilePaths = _.uniq(\n    targets.map((target) =>\n      filePath.replace(\"/:target/\", `/${target}/`)\n    ) as AbsolutePath[]\n  );\n  return await Promise.all(\n    dstFilePaths.map(async (dstFilePath) => {\n      const dir = path.dirname(dstFilePath);\n      if (!(await exists(dir))) {\n        await mkdir(dir, { recursive: true });\n      }\n      await writeFile(dstFilePath, pathAndCode.code);\n      console.log(\n        chalk.bold(\"Generated: \") +\n          chalk.blue(`${dstFilePath.replace(appRootPath + \"/\", \"\")}`)\n      );\n      return dstFilePath;\n    })\n  );\n}\n"],"names":["path","Sonamu","AlreadyProcessedException","everyAsync","filterAsync","exists","chalk","mkdir","writeFile","_","Template","EntityManager","wrapIf","prettier","generateTemplate","key","templateOptions","_generateOptions","generateOptions","overwrite","keys","pathAndCodes","Promise","all","map","renderTemplate","flat","filteredPathAndCodes","pathAndCode","targets","config","sync","filePath","appRootPath","dstFilePaths","target","replace","dstPath","length","writeCodeToPathEachTarget","options","template","find","rendered","render","resolved","resolveRenderedTemplate","preTemplateResolved","preTemplates","result","body","importKeys","customHeaders","importDefs","reduce","r","importKey","modulePath","getModulePath","importPath","includes","relative","dirname","p","startsWith","existsOne","importDef","from","uniq","concat","push","filter","endsWith","header","join","formatted","format","parser","code","dstFilePath","dir","recursive","console","log","bold","blue"],"mappings":"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"}

package/dist/syncer/entity-operations.d.ts

@@ -0,0 +1,17 @@
+import { TemplateOptions } from "../types/types";
+/**
+ * 새로운 엔티티를 생성합니다.
+ * entityId는 반드시 CamelCase 형식이어야 합니다.
+ */
+export declare function createEntity(form: Omit<TemplateOptions["entity"], "title"> & {
+    title?: string;
+}): Promise<void>;
+/**
+ * 엔티티를 삭제합니다.
+ * parentId가 있는 서브 엔티티의 경우 entity.json만 삭제하고,
+ * 루트 엔티티의 경우 디렉토리 전체와 타겟 디렉토리를 삭제합니다.
+ */
+export declare function delEntity(entityId: string): Promise<{
+    delPaths: string[];
+}>;
+//# sourceMappingURL=entity-operations.d.ts.map

package/dist/syncer/entity-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-operations.d.ts","sourceRoot":"","sources":["../../src/syncer/entity-operations.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAKjD;;;GAGG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,iBAUpE;AAED;;;;GAIG;AACH,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAkCjC"}

package/dist/syncer/entity-operations.js

@@ -0,0 +1,58 @@
+import { rm } from "node:fs/promises";
+import { exists } from "../utils/fs-utils.js";
+import chalk from "chalk";
+import { EntityManager } from "../entity/entity-manager.js";
+import { BadRequestException } from "../exceptions/so-exceptions.js";
+import { Sonamu } from "../api/sonamu.js";
+import { generateTemplate } from "./code-generator.js";
+/**
+ * 새로운 엔티티를 생성합니다.
+ * entityId는 반드시 CamelCase 형식이어야 합니다.
+ */ export async function createEntity(form) {
+    if (!/^[A-Z][a-zA-Z0-9]*$/.test(form.entityId)) {
+        throw new BadRequestException("entityId는 CamelCase 형식이어야 합니다.");
+    }
+    await generateTemplate("entity", form);
+    // reload entities
+    await EntityManager.reload();
+}
+/**
+ * 엔티티를 삭제합니다.
+ * parentId가 있는 서브 엔티티의 경우 entity.json만 삭제하고,
+ * 루트 엔티티의 경우 디렉토리 전체와 타겟 디렉토리를 삭제합니다.
+ */ export async function delEntity(entityId) {
+    const entity = EntityManager.get(entityId);
+    const delPaths = (()=>{
+        if (entity.parentId) {
+            return [
+                `${Sonamu.apiRootPath}/src/application/${entity.names.parentFs}/${entity.names.fs}.entity.json`
+            ];
+        } else {
+            return [
+                `${Sonamu.apiRootPath}/src/application/${entity.names.fs}`,
+                `${Sonamu.apiRootPath}/dist/application/${entity.names.fs}`,
+                ...Sonamu.config.sync.targets.map((target)=>[
+                        `${Sonamu.appRootPath}/${target}/src/services/${entity.names.fs}`
+                    ]).flat()
+            ];
+        }
+    })(); // iife
+    for await (const delPath of delPaths){
+        if (await exists(delPath)) {
+            console.log(chalk.red(`DELETE ${delPath}`));
+            await rm(delPath, {
+                recursive: true,
+                force: true
+            });
+        } else {
+            console.log(chalk.yellow(`NOT_EXISTS ${delPath}`));
+        }
+    }
+    // reload entities
+    await EntityManager.reload();
+    return {
+        delPaths
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zeW5jZXIvZW50aXR5LW9wZXJhdGlvbnMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgcm0gfSBmcm9tIFwiZnMvcHJvbWlzZXNcIjtcbmltcG9ydCB7IGV4aXN0cyB9IGZyb20gXCIuLi91dGlscy9mcy11dGlsc1wiO1xuaW1wb3J0IGNoYWxrIGZyb20gXCJjaGFsa1wiO1xuaW1wb3J0IHsgRW50aXR5TWFuYWdlciB9IGZyb20gXCIuLi9lbnRpdHkvZW50aXR5LW1hbmFnZXJcIjtcbmltcG9ydCB7IFRlbXBsYXRlT3B0aW9ucyB9IGZyb20gXCIuLi90eXBlcy90eXBlc1wiO1xuaW1wb3J0IHsgQmFkUmVxdWVzdEV4Y2VwdGlvbiB9IGZyb20gXCIuLi9leGNlcHRpb25zL3NvLWV4Y2VwdGlvbnNcIjtcbmltcG9ydCB7IFNvbmFtdSB9IGZyb20gXCIuLi9hcGkvc29uYW11XCI7XG5pbXBvcnQgeyBnZW5lcmF0ZVRlbXBsYXRlIH0gZnJvbSBcIi4vY29kZS1nZW5lcmF0b3JcIjtcblxuLyoqXG4gKiDsg4jroZzsmrQg7JeU7Yuw7Yuw66W8IOyDneyEse2VqeuLiOuLpC5cbiAqIGVudGl0eUlk64qUIOuwmOuTnOyLnCBDYW1lbENhc2Ug7ZiV7Iud7J207Ja07JW8IO2VqeuLiOuLpC5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGNyZWF0ZUVudGl0eShcbiAgZm9ybTogT21pdDxUZW1wbGF0ZU9wdGlvbnNbXCJlbnRpdHlcIl0sIFwidGl0bGVcIj4gJiB7IHRpdGxlPzogc3RyaW5nIH1cbikge1xuICBpZiAoIS9eW0EtWl1bYS16QS1aMC05XSokLy50ZXN0KGZvcm0uZW50aXR5SWQpKSB7XG4gICAgdGhyb3cgbmV3IEJhZFJlcXVlc3RFeGNlcHRpb24oXCJlbnRpdHlJZOuKlCBDYW1lbENhc2Ug7ZiV7Iud7J207Ja07JW8IO2VqeuLiOuLpC5cIik7XG4gIH1cblxuICBhd2FpdCBnZW5lcmF0ZVRlbXBsYXRlKFwiZW50aXR5XCIsIGZvcm0pO1xuXG4gIC8vIHJlbG9hZCBlbnRpdGllc1xuICBhd2FpdCBFbnRpdHlNYW5hZ2VyLnJlbG9hZCgpO1xufVxuXG4vKipcbiAqIOyXlO2LsO2LsOulvCDsgq3soJztlanri4jri6QuXG4gKiBwYXJlbnRJZOqwgCDsnojripQg7ISc67iMIOyXlO2LsO2LsOydmCDqsr3smrAgZW50aXR5Lmpzb27rp4wg7IKt7KCc7ZWY6rOgLFxuICog66Oo7Yq4IOyXlO2LsO2LsOydmCDqsr3smrAg65SU66CJ7Yag66asIOyghOyytOyZgCDtg4Dqsp8g65SU66CJ7Yag66as66W8IOyCreygnO2VqeuLiOuLpC5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGRlbEVudGl0eShcbiAgZW50aXR5SWQ6IHN0cmluZ1xuKTogUHJvbWlzZTx7IGRlbFBhdGhzOiBzdHJpbmdbXSB9PiB7XG4gIGNvbnN0IGVudGl0eSA9IEVudGl0eU1hbmFnZXIuZ2V0KGVudGl0eUlkKTtcblxuICBjb25zdCBkZWxQYXRocyA9ICgoKSA9PiB7XG4gICAgaWYgKGVudGl0eS5wYXJlbnRJZCkge1xuICAgICAgcmV0dXJuIFtcbiAgICAgICAgYCR7U29uYW11LmFwaVJvb3RQYXRofS9zcmMvYXBwbGljYXRpb24vJHtlbnRpdHkubmFtZXMucGFyZW50RnN9LyR7ZW50aXR5Lm5hbWVzLmZzfS5lbnRpdHkuanNvbmAsXG4gICAgICBdO1xuICAgIH0gZWxzZSB7XG4gICAgICByZXR1cm4gW1xuICAgICAgICBgJHtTb25hbXUuYXBpUm9vdFBhdGh9L3NyYy9hcHBsaWNhdGlvbi8ke2VudGl0eS5uYW1lcy5mc31gLFxuICAgICAgICBgJHtTb25hbXUuYXBpUm9vdFBhdGh9L2Rpc3QvYXBwbGljYXRpb24vJHtlbnRpdHkubmFtZXMuZnN9YCxcbiAgICAgICAgLi4uU29uYW11LmNvbmZpZy5zeW5jLnRhcmdldHNcbiAgICAgICAgICAubWFwKCh0YXJnZXQpID0+IFtcbiAgICAgICAgICAgIGAke1NvbmFtdS5hcHBSb290UGF0aH0vJHt0YXJnZXR9L3NyYy9zZXJ2aWNlcy8ke2VudGl0eS5uYW1lcy5mc31gLFxuICAgICAgICAgIF0pXG4gICAgICAgICAgLmZsYXQoKSxcbiAgICAgIF07XG4gICAgfVxuICB9KSgpOyAvLyBpaWZlXG5cbiAgZm9yIGF3YWl0IChjb25zdCBkZWxQYXRoIG9mIGRlbFBhdGhzKSB7XG4gICAgaWYgKGF3YWl0IGV4aXN0cyhkZWxQYXRoKSkge1xuICAgICAgY29uc29sZS5sb2coY2hhbGsucmVkKGBERUxFVEUgJHtkZWxQYXRofWApKTtcbiAgICAgIGF3YWl0IHJtKGRlbFBhdGgsIHsgcmVjdXJzaXZlOiB0cnVlLCBmb3JjZTogdHJ1ZSB9KTtcbiAgICB9IGVsc2Uge1xuICAgICAgY29uc29sZS5sb2coY2hhbGsueWVsbG93KGBOT1RfRVhJU1RTICR7ZGVsUGF0aH1gKSk7XG4gICAgfVxuICB9XG5cbiAgLy8gcmVsb2FkIGVudGl0aWVzXG4gIGF3YWl0IEVudGl0eU1hbmFnZXIucmVsb2FkKCk7XG5cbiAgcmV0dXJuIHsgZGVsUGF0aHMgfTtcbn1cbiJdLCJuYW1lcyI6WyJybSIsImV4aXN0cyIsImNoYWxrIiwiRW50aXR5TWFuYWdlciIsIkJhZFJlcXVlc3RFeGNlcHRpb24iLCJTb25hbXUiLCJnZW5lcmF0ZVRlbXBsYXRlIiwiY3JlYXRlRW50aXR5IiwiZm9ybSIsInRlc3QiLCJlbnRpdHlJZCIsInJlbG9hZCIsImRlbEVudGl0eSIsImVudGl0eSIsImdldCIsImRlbFBhdGhzIiwicGFyZW50SWQiLCJhcGlSb290UGF0aCIsIm5hbWVzIiwicGFyZW50RnMiLCJmcyIsImNvbmZpZyIsInN5bmMiLCJ0YXJnZXRzIiwibWFwIiwidGFyZ2V0IiwiYXBwUm9vdFBhdGgiLCJmbGF0IiwiZGVsUGF0aCIsImNvbnNvbGUiLCJsb2ciLCJyZWQiLCJyZWN1cnNpdmUiLCJmb3JjZSIsInllbGxvdyJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsRUFBRSxRQUFRLG1CQUFjO0FBQ2pDLFNBQVNDLE1BQU0sUUFBUSx1QkFBb0I7QUFDM0MsT0FBT0MsV0FBVyxRQUFRO0FBQzFCLFNBQVNDLGFBQWEsUUFBUSw4QkFBMkI7QUFFekQsU0FBU0MsbUJBQW1CLFFBQVEsaUNBQThCO0FBQ2xFLFNBQVNDLE1BQU0sUUFBUSxtQkFBZ0I7QUFDdkMsU0FBU0MsZ0JBQWdCLFFBQVEsc0JBQW1CO0FBRXBEOzs7Q0FHQyxHQUNELE9BQU8sZUFBZUMsYUFDcEJDLElBQW1FO0lBRW5FLElBQUksQ0FBQyxzQkFBc0JDLElBQUksQ0FBQ0QsS0FBS0UsUUFBUSxHQUFHO1FBQzlDLE1BQU0sSUFBSU4sb0JBQW9CO0lBQ2hDO0lBRUEsTUFBTUUsaUJBQWlCLFVBQVVFO0lBRWpDLGtCQUFrQjtJQUNsQixNQUFNTCxjQUFjUSxNQUFNO0FBQzVCO0FBRUE7Ozs7Q0FJQyxHQUNELE9BQU8sZUFBZUMsVUFDcEJGLFFBQWdCO0lBRWhCLE1BQU1HLFNBQVNWLGNBQWNXLEdBQUcsQ0FBQ0o7SUFFakMsTUFBTUssV0FBVyxBQUFDLENBQUE7UUFDaEIsSUFBSUYsT0FBT0csUUFBUSxFQUFFO1lBQ25CLE9BQU87Z0JBQ0wsR0FBR1gsT0FBT1ksV0FBVyxDQUFDLGlCQUFpQixFQUFFSixPQUFPSyxLQUFLLENBQUNDLFFBQVEsQ0FBQyxDQUFDLEVBQUVOLE9BQU9LLEtBQUssQ0FBQ0UsRUFBRSxDQUFDLFlBQVksQ0FBQzthQUNoRztRQUNILE9BQU87WUFDTCxPQUFPO2dCQUNMLEdBQUdmLE9BQU9ZLFdBQVcsQ0FBQyxpQkFBaUIsRUFBRUosT0FBT0ssS0FBSyxDQUFDRSxFQUFFLEVBQUU7Z0JBQzFELEdBQUdmLE9BQU9ZLFdBQVcsQ0FBQyxrQkFBa0IsRUFBRUosT0FBT0ssS0FBSyxDQUFDRSxFQUFFLEVBQUU7bUJBQ3hEZixPQUFPZ0IsTUFBTSxDQUFDQyxJQUFJLENBQUNDLE9BQU8sQ0FDMUJDLEdBQUcsQ0FBQyxDQUFDQyxTQUFXO3dCQUNmLEdBQUdwQixPQUFPcUIsV0FBVyxDQUFDLENBQUMsRUFBRUQsT0FBTyxjQUFjLEVBQUVaLE9BQU9LLEtBQUssQ0FBQ0UsRUFBRSxFQUFFO3FCQUNsRSxFQUNBTyxJQUFJO2FBQ1I7UUFDSDtJQUNGLENBQUEsS0FBTSxPQUFPO0lBRWIsV0FBVyxNQUFNQyxXQUFXYixTQUFVO1FBQ3BDLElBQUksTUFBTWQsT0FBTzJCLFVBQVU7WUFDekJDLFFBQVFDLEdBQUcsQ0FBQzVCLE1BQU02QixHQUFHLENBQUMsQ0FBQyxPQUFPLEVBQUVILFNBQVM7WUFDekMsTUFBTTVCLEdBQUc0QixTQUFTO2dCQUFFSSxXQUFXO2dCQUFNQyxPQUFPO1lBQUs7UUFDbkQsT0FBTztZQUNMSixRQUFRQyxHQUFHLENBQUM1QixNQUFNZ0MsTUFBTSxDQUFDLENBQUMsV0FBVyxFQUFFTixTQUFTO1FBQ2xEO0lBQ0Y7SUFFQSxrQkFBa0I7SUFDbEIsTUFBTXpCLGNBQWNRLE1BQU07SUFFMUIsT0FBTztRQUFFSTtJQUFTO0FBQ3BCIn0=

package/dist/syncer/file-patterns.d.ts

@@ -0,0 +1,29 @@
+import { AbsolutePath, ApiRelativePath } from "../utils/path-utils";
+export type FileType = "model" | "types" | "functions" | "generated" | "entity" | "frame" | "config";
+export type GlobPattern<T extends ApiRelativePath | AbsolutePath> = {
+    [key in FileType]: T;
+};
+/**
+ * Syncer가 관심 가지고 지켜보는 파일들입니다.
+ * 이 파일들에 변경이 생기면 추가적인 작업(이하 "싱크" 또는 "싱크 액션")을 수행합니다.
+ * 이 작업이라 함은 파일 복사 또는 템플릿 렌더링을 통한 code generation을 의미합니다.
+ *
+ * **경로 형식**: API 상대 경로 (src/로 시작)
+ * **사용**: getChecksumPatternGroupInAbsolutePath()로 절대 경로 변환 후 glob 사용
+ */
+export declare const checksumPatternGroup: GlobPattern<ApiRelativePath>;
+/**
+ * API 상대 경로 패턴을 절대 경로 패턴으로 변환합니다.
+ *
+ * **목적**: Glob 패턴을 파일시스템에서 사용할 수 있는 절대 경로로 변환
+ *
+ * **사용처**: checksum.ts에서 실제 파일을 찾을 때
+ *
+ * @returns 절대 경로 기반 Glob 패턴 맵
+ *
+ * @example
+ * // 입력: { entity: "src/application/**\/*.entity.json" }
+ * // 출력: { entity: "/Users/.../api/src/application/**\/*.entity.json" }
+ */
+export declare function getChecksumPatternGroupInAbsolutePath(): GlobPattern<AbsolutePath>;
+//# sourceMappingURL=file-patterns.d.ts.map

package/dist/syncer/file-patterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-patterns.d.ts","sourceRoot":"","sources":["../../src/syncer/file-patterns.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEpE,MAAM,MAAM,QAAQ,GAChB,OAAO,GACP,OAAO,GACP,WAAW,GACX,WAAW,GACX,QAAQ,GACR,OAAO,GACP,QAAQ,CAAC;AAEb,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,eAAe,GAAG,YAAY,IAAI;KACjE,GAAG,IAAI,QAAQ,GAAG,CAAC;CACrB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,eAAe,CAQ7D,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAgB,qCAAqC,IAAI,WAAW,CAAC,YAAY,CAAC,CAOjF"}

package/dist/syncer/file-patterns.js

@@ -0,0 +1,38 @@
+import path from "path";
+import { Sonamu } from "../api/sonamu.js";
+/**
+ * Syncer가 관심 가지고 지켜보는 파일들입니다.
+ * 이 파일들에 변경이 생기면 추가적인 작업(이하 "싱크" 또는 "싱크 액션")을 수행합니다.
+ * 이 작업이라 함은 파일 복사 또는 템플릿 렌더링을 통한 code generation을 의미합니다.
+ *
+ * **경로 형식**: API 상대 경로 (src/로 시작)
+ * **사용**: getChecksumPatternGroupInAbsolutePath()로 절대 경로 변환 후 glob 사용
+ */ export const checksumPatternGroup = {
+    entity: "src/application/**/*.entity.json",
+    types: "src/application/**/*.types.ts",
+    generated: "src/application/sonamu.generated.ts",
+    model: "src/application/**/*.model.ts",
+    frame: "src/application/**/*.frame.ts",
+    functions: "src/application/**/*.functions.ts",
+    config: "sonamu.config.ts"
+};
+/**
+ * API 상대 경로 패턴을 절대 경로 패턴으로 변환합니다.
+ *
+ * **목적**: Glob 패턴을 파일시스템에서 사용할 수 있는 절대 경로로 변환
+ *
+ * **사용처**: checksum.ts에서 실제 파일을 찾을 때
+ *
+ * @returns 절대 경로 기반 Glob 패턴 맵
+ *
+ * @example
+ * // 입력: { entity: "src/application/**\/*.entity.json" }
+ * // 출력: { entity: "/Users/.../api/src/application/**\/*.entity.json" }
+ */ export function getChecksumPatternGroupInAbsolutePath() {
+    return Object.fromEntries(Object.entries(checksumPatternGroup).map(([key, value])=>[
+            key,
+            path.join(Sonamu.apiRootPath, value)
+        ]));
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/syncer/index.d.ts

@@ -1,2 +1,8 @@
 export * from "./syncer";
+export * from "./code-generator";
+export * from "./module-loader";
+export * from "./entity-operations";
+export * from "./file-patterns";
+export * from "./checksum";
+export * from "./api-parser";
 //# sourceMappingURL=index.d.ts.map

package/dist/syncer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/syncer/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/syncer/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC"}

package/dist/syncer/index.js

@@ -1,2 +1,9 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});_export_star(require("./syncer"),exports);function _export_star(from,to){Object.keys(from).forEach(function(k){if(k!=="default"&&!Object.prototype.hasOwnProperty.call(to,k)){Object.defineProperty(to,k,{enumerable:true,get:function(){return from[k]}})}});return from}
-//# sourceMappingURL=index.js.map
+export * from "./syncer.js";
+export * from "./code-generator.js";
+export * from "./module-loader.js";
+export * from "./entity-operations.js";
+export * from "./file-patterns.js";
+export * from "./checksum.js";
+export * from "./api-parser.js";
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zeW5jZXIvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vc3luY2VyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb2RlLWdlbmVyYXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbW9kdWxlLWxvYWRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZW50aXR5LW9wZXJhdGlvbnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ZpbGUtcGF0dGVybnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NoZWNrc3VtXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9hcGktcGFyc2VyXCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFXO0FBQ3pCLGNBQWMsc0JBQW1CO0FBQ2pDLGNBQWMscUJBQWtCO0FBQ2hDLGNBQWMseUJBQXNCO0FBQ3BDLGNBQWMscUJBQWtCO0FBQ2hDLGNBQWMsZ0JBQWE7QUFDM0IsY0FBYyxrQkFBZSJ9

package/dist/syncer/module-loader.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { BaseFrameClass } from "../api/base-frame";
+import { BaseModelClass } from "../database/base-model";
+import { ApiParam, ApiParamType } from "../types/types";
+import { ApiDecoratorOptions } from "../api/decorators";
+export type LoadedApis = {
+    typeParameters: ApiParamType.TypeParam[];
+    parameters: ApiParam[];
+    returnType: ApiParamType;
+    modelName: string;
+    methodName: string;
+    path: string;
+    options: ApiDecoratorOptions;
+}[];
+export type LoadedTypes = {
+    [typeName: string]: z.ZodObject<any>;
+};
+export type LoadedModels = {
+    [modelName: string]: BaseModelClass | BaseFrameClass;
+};
+/**
+ * *.model.ts와 *.frame.ts 파일들에서 API 메소드를 파싱하여 로드합니다.
+ * registeredApis에 API가 등록되어 있어야 하기 때문에, *.model.ts 파일들을 먼저 import해야 합니다.
+ * 따라서 loadModels()를 먼저 호출해야 합니다.
+ */
+export declare function loadApis(): Promise<LoadedApis>;
+/**
+ * *.model.ts와 *.frame.ts 파일들에서 Model/Frame 클래스 인스턴스를 로드합니다.
+ */
+export declare function loadModels(): Promise<LoadedModels>;
+/**
+ * *.types.ts와 *.generated.ts 파일들에서 Zod 스키마를 로드합니다.
+ */
+export declare function loadTypes(): Promise<LoadedTypes>;
+//# sourceMappingURL=module-loader.d.ts.map

package/dist/syncer/module-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-loader.d.ts","sourceRoot":"","sources":["../../src/syncer/module-loader.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,MAAM,MAAM,UAAU,GAAG;IACvB,cAAc,EAAE,YAAY,CAAC,SAAS,EAAE,CAAC;IACzC,UAAU,EAAE,QAAQ,EAAE,CAAC;IACvB,UAAU,EAAE,YAAY,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,mBAAmB,CAAC;CAC9B,EAAE,CAAC;AAEJ,MAAM,MAAM,WAAW,GAAG;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;CAAE,CAAC;AAEnE,MAAM,MAAM,YAAY,GAAG;IACzB,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;CACtD,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC,CAuBpD;AAED;;GAEG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,YAAY,CAAC,CA4BxD;AAED;;GAEG;AACH,wBAAsB,SAAS,IAAI,OAAO,CAAC,WAAW,CAAC,CA8BtD"}

package/dist/syncer/module-loader.js

@@ -0,0 +1,82 @@
+import path from "path";
+import { globAsync } from "../utils/async-utils.js";
+import { importMembers } from "../utils/esm-utils.js";
+import { z } from "zod";
+import { Sonamu } from "../api/sonamu.js";
+import { readApisFromFile } from "./api-parser.js";
+import { runtimePath } from "../utils/path-utils.js";
+/**
+ * *.model.ts와 *.frame.ts 파일들에서 API 메소드를 파싱하여 로드합니다.
+ * registeredApis에 API가 등록되어 있어야 하기 때문에, *.model.ts 파일들을 먼저 import해야 합니다.
+ * 따라서 loadModels()를 먼저 호출해야 합니다.
+ */ export async function loadApis() {
+    // 얘는 특이하게도 환경에 따라 .ts나 .js를 import하는 경우가 아니고,
+    // 타입이 살아있는 .ts 소스 코드만을 읽어야 합니다.
+    // 이것은 dev서버(hot reload)가 아닌 production 환경에서도 동일합니다.
+    // 모델들의 .ts 파일이 있어야 이를 읽어서 라우트를 등록할 수 있어요!
+    const modelPathsPattern = path.join(Sonamu.apiRootPath, "src/application/**/*.{model,frame}.ts" // !! runtimePath 안 씀 주의 !!
+    );
+    const modelPaths = await globAsync(modelPathsPattern);
+    const apis = [];
+    let count = 0;
+    for (const filePath of modelPaths){
+        const parsedApis = await readApisFromFile(filePath);
+        apis.push(...parsedApis);
+        count++;
+    }
+    // console.log(
+    //   chalk.gray(`[Loading] Loaded APIs from "*.model.ts" files: ${count} files.`)
+    // );
+    return apis;
+}
+/**
+ * *.model.ts와 *.frame.ts 파일들에서 Model/Frame 클래스 인스턴스를 로드합니다.
+ */ export async function loadModels() {
+    const modelPathsPattern = path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.{model,frame}.ts"));
+    const modelPaths = await globAsync(modelPathsPattern);
+    const models = {};
+    let count = 0;
+    for (const filePath of modelPaths){
+        const importedMembers = await importMembers(filePath);
+        for (const { name, value } of importedMembers){
+            if (name.endsWith("Model") || name.endsWith("Frame")) {
+                models[name] = value;
+            }
+        }
+        count++;
+    }
+    // console.log(
+    //   chalk.gray(
+    //     `[Loading] Loaded model/frame instances from ${runtimePath("*.{model,frame}.ts")} files: ${count} files.`
+    //   )
+    // );
+    return models;
+}
+/**
+ * *.types.ts와 *.generated.ts 파일들에서 Zod 스키마를 로드합니다.
+ */ export async function loadTypes() {
+    const typePathsPatterns = [
+        path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.types.ts")),
+        path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.generated.ts"))
+    ];
+    const typePaths = (await Promise.all(typePathsPatterns.map(globAsync))).flat();
+    const types = {};
+    let count = 0;
+    for (const filePath of typePaths){
+        const importedMembers = await importMembers(filePath);
+        for (const { name, value } of importedMembers){
+            if (value instanceof z.ZodObject) {
+                types[name] = value;
+            }
+        }
+        count++;
+    }
+    // console.log(
+    //   chalk.gray(
+    //     `[Loading] Loaded zod types from ${runtimePath("*.types.ts")} and ${runtimePath("*.generated.ts")} files: ${count} files.`
+    //   )
+    // );
+    return types;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/module-loader.ts"],"sourcesContent":["import path from \"path\";\nimport { globAsync } from \"../utils/async-utils\";\nimport { importMembers } from \"../utils/esm-utils\";\nimport { z } from \"zod\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { readApisFromFile } from \"./api-parser\";\nimport { BaseFrameClass } from \"../api/base-frame\";\nimport { BaseModelClass } from \"../database/base-model\";\nimport { AbsolutePath, runtimePath } from \"../utils/path-utils\";\nimport { ApiParam, ApiParamType } from \"../types/types\";\nimport { ApiDecoratorOptions } from \"../api/decorators\";\n\nexport type LoadedApis = {\n  typeParameters: ApiParamType.TypeParam[];\n  parameters: ApiParam[];\n  returnType: ApiParamType;\n  modelName: string;\n  methodName: string;\n  path: string;\n  options: ApiDecoratorOptions;\n}[];\n\nexport type LoadedTypes = { [typeName: string]: z.ZodObject<any> };\n\nexport type LoadedModels = {\n  [modelName: string]: BaseModelClass | BaseFrameClass;\n};\n\n/**\n * *.model.ts와 *.frame.ts 파일들에서 API 메소드를 파싱하여 로드합니다.\n * registeredApis에 API가 등록되어 있어야 하기 때문에, *.model.ts 파일들을 먼저 import해야 합니다.\n * 따라서 loadModels()를 먼저 호출해야 합니다.\n */\nexport async function loadApis(): Promise<LoadedApis> {\n  // 얘는 특이하게도 환경에 따라 .ts나 .js를 import하는 경우가 아니고,\n  // 타입이 살아있는 .ts 소스 코드만을 읽어야 합니다.\n  // 이것은 dev서버(hot reload)가 아닌 production 환경에서도 동일합니다.\n  // 모델들의 .ts 파일이 있어야 이를 읽어서 라우트를 등록할 수 있어요!\n  const modelPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    \"src/application/**/*.{model,frame}.ts\" // !! runtimePath 안 씀 주의 !!\n  );\n  const modelPaths = (await globAsync(modelPathsPattern)) as AbsolutePath[];\n\n  const apis: LoadedApis = [];\n  let count = 0;\n  for (const filePath of modelPaths) {\n    const parsedApis = await readApisFromFile(filePath);\n    apis.push(...parsedApis);\n    count++;\n  }\n  // console.log(\n  //   chalk.gray(`[Loading] Loaded APIs from \"*.model.ts\" files: ${count} files.`)\n  // );\n\n  return apis;\n}\n\n/**\n * *.model.ts와 *.frame.ts 파일들에서 Model/Frame 클래스 인스턴스를 로드합니다.\n */\nexport async function loadModels(): Promise<LoadedModels> {\n  const modelPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    runtimePath(\"src/application/**/*.{model,frame}.ts\")\n  );\n  const modelPaths = await globAsync(modelPathsPattern);\n\n  const models: LoadedModels = {};\n  let count = 0;\n  for (const filePath of modelPaths) {\n    const importedMembers = await importMembers<\n      BaseModelClass | BaseFrameClass\n    >(filePath);\n\n    for (const { name, value } of importedMembers) {\n      if (name.endsWith(\"Model\") || name.endsWith(\"Frame\")) {\n        models[name] = value;\n      }\n    }\n    count++;\n  }\n  // console.log(\n  //   chalk.gray(\n  //     `[Loading] Loaded model/frame instances from ${runtimePath(\"*.{model,frame}.ts\")} files: ${count} files.`\n  //   )\n  // );\n\n  return models;\n}\n\n/**\n * *.types.ts와 *.generated.ts 파일들에서 Zod 스키마를 로드합니다.\n */\nexport async function loadTypes(): Promise<LoadedTypes> {\n  const typePathsPatterns = [\n    path.join(Sonamu.apiRootPath, runtimePath(\"src/application/**/*.types.ts\")),\n    path.join(\n      Sonamu.apiRootPath,\n      runtimePath(\"src/application/**/*.generated.ts\")\n    ),\n  ];\n  const typePaths = (\n    await Promise.all(typePathsPatterns.map(globAsync))\n  ).flat();\n\n  const types: LoadedTypes = {};\n  let count = 0;\n  for (const filePath of typePaths) {\n    const importedMembers = await importMembers<z.ZodObject<any>>(filePath);\n    for (const { name, value } of importedMembers) {\n      if (value instanceof z.ZodObject) {\n        types[name] = value;\n      }\n    }\n    count++;\n  }\n  // console.log(\n  //   chalk.gray(\n  //     `[Loading] Loaded zod types from ${runtimePath(\"*.types.ts\")} and ${runtimePath(\"*.generated.ts\")} files: ${count} files.`\n  //   )\n  // );\n\n  return types;\n}\n"],"names":["path","globAsync","importMembers","z","Sonamu","readApisFromFile","runtimePath","loadApis","modelPathsPattern","join","apiRootPath","modelPaths","apis","count","filePath","parsedApis","push","loadModels","models","importedMembers","name","value","endsWith","loadTypes","typePathsPatterns","typePaths","Promise","all","map","flat","types","ZodObject"],"mappings":"AAAA,OAAOA,UAAU,OAAO;AACxB,SAASC,SAAS,QAAQ,0BAAuB;AACjD,SAASC,aAAa,QAAQ,wBAAqB;AACnD,SAASC,CAAC,QAAQ,MAAM;AACxB,SAASC,MAAM,QAAQ,mBAAgB;AACvC,SAASC,gBAAgB,QAAQ,kBAAe;AAGhD,SAAuBC,WAAW,QAAQ,yBAAsB;AAoBhE;;;;CAIC,GACD,OAAO,eAAeC;IACpB,8CAA8C;IAC9C,gCAAgC;IAChC,oDAAoD;IACpD,0CAA0C;IAC1C,MAAMC,oBAAoBR,KAAKS,IAAI,CACjCL,OAAOM,WAAW,EAClB,wCAAwC,2BAA2B;;IAErE,MAAMC,aAAc,MAAMV,UAAUO;IAEpC,MAAMI,OAAmB,EAAE;IAC3B,IAAIC,QAAQ;IACZ,KAAK,MAAMC,YAAYH,WAAY;QACjC,MAAMI,aAAa,MAAMV,iBAAiBS;QAC1CF,KAAKI,IAAI,IAAID;QACbF;IACF;IACA,eAAe;IACf,iFAAiF;IACjF,KAAK;IAEL,OAAOD;AACT;AAEA;;CAEC,GACD,OAAO,eAAeK;IACpB,MAAMT,oBAAoBR,KAAKS,IAAI,CACjCL,OAAOM,WAAW,EAClBJ,YAAY;IAEd,MAAMK,aAAa,MAAMV,UAAUO;IAEnC,MAAMU,SAAuB,CAAC;IAC9B,IAAIL,QAAQ;IACZ,KAAK,MAAMC,YAAYH,WAAY;QACjC,MAAMQ,kBAAkB,MAAMjB,cAE5BY;QAEF,KAAK,MAAM,EAAEM,IAAI,EAAEC,KAAK,EAAE,IAAIF,gBAAiB;YAC7C,IAAIC,KAAKE,QAAQ,CAAC,YAAYF,KAAKE,QAAQ,CAAC,UAAU;gBACpDJ,MAAM,CAACE,KAAK,GAAGC;YACjB;QACF;QACAR;IACF;IACA,eAAe;IACf,gBAAgB;IAChB,gHAAgH;IAChH,MAAM;IACN,KAAK;IAEL,OAAOK;AACT;AAEA;;CAEC,GACD,OAAO,eAAeK;IACpB,MAAMC,oBAAoB;QACxBxB,KAAKS,IAAI,CAACL,OAAOM,WAAW,EAAEJ,YAAY;QAC1CN,KAAKS,IAAI,CACPL,OAAOM,WAAW,EAClBJ,YAAY;KAEf;IACD,MAAMmB,YAAY,AAChB,CAAA,MAAMC,QAAQC,GAAG,CAACH,kBAAkBI,GAAG,CAAC3B,WAAU,EAClD4B,IAAI;IAEN,MAAMC,QAAqB,CAAC;IAC5B,IAAIjB,QAAQ;IACZ,KAAK,MAAMC,YAAYW,UAAW;QAChC,MAAMN,kBAAkB,MAAMjB,cAAgCY;QAC9D,KAAK,MAAM,EAAEM,IAAI,EAAEC,KAAK,EAAE,IAAIF,gBAAiB;YAC7C,IAAIE,iBAAiBlB,EAAE4B,SAAS,EAAE;gBAChCD,KAAK,CAACV,KAAK,GAAGC;YAChB;QACF;QACAR;IACF;IACA,eAAe;IACf,gBAAgB;IAChB,iIAAiI;IACjI,MAAM;IACN,KAAK;IAEL,OAAOiB;AACT"}