sonamu 0.6.0 → 0.7.0

package/dist/syncer/syncer.js

@@ -1,23 +1,26 @@
-import path, { dirname } from "path";
+import { hot } from "@sonamu-kit/hot-hook";
+import assert from "assert";
+import chalk from "chalk";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { exists } from "../utils/fs-utils.js";
-import * as _ from "lodash-es";
+import { minimatch } from "minimatch";
+import path, { dirname } from "path";
+import { group, unique } from "radashi";
+import { registeredApis } from "../api/decorators.js";
+import { Sonamu } from "../api/sonamu.js";
 import { EntityManager } from "../entity/entity-manager.js";
-import chalk from "chalk";
+import { Naite } from "../naite/naite.js";
+import { TemplateManager } from "../template/template-manager.js";
 import { TemplateKey } from "../types/types.js";
-import { Sonamu } from "../api/sonamu.js";
-import assert from "assert";
-import { minimatch } from "minimatch";
 import { mapAsync, reduceAsync } from "../utils/async-utils.js";
 import { centerText } from "../utils/console-util.js";
+import { isTest } from "../utils/controller.js";
+import { exists } from "../utils/fs-utils.js";
 import { runWithGracefulShutdown } from "../utils/process-utils.js";
+import { areFilesSame, findChangedFilesUsingChecksums, renewChecksums } from "./checksum.js";
 import { generateTemplate, renderTemplate } from "./code-generator.js";
-import { Template } from "../template/index.js";
+import { createEntity, delEntity } from "./entity-operations.js";
 import { getChecksumPatternGroupInAbsolutePath } from "./file-patterns.js";
-import { findChangedFilesUsingChecksums, renewChecksums, areFilesSame } from "./checksum.js";
 import { loadApis, loadModels, loadTypes } from "./module-loader.js";
-import { createEntity, delEntity } from "./entity-operations.js";
-import { hot } from "@sonamu-kit/hot-hook";
 export class Syncer {
     apis = [];
     types = {};
@@ -61,9 +64,23 @@ export class Syncer {
         // 일단 변경된 파일과 dependent 파일들을 invalidate 합니다.
         // 한 번 이상 import된 친구들에 대해서만 실제 작업이 일어납니다.
         // 그러니 안심하고 invalidate 해도 됩니다.
-        const invalidatedPaths = await hot.invalidateFile(diffFilePath, event);
-        if (invalidatedPaths.length > 0) {
-            console.log(chalk.bold(`🔄 Invalidated:\n${chalk.blue(invalidatedPaths.map((p)=>`- ${path.relative(Sonamu.apiRootPath, p)}`).join("\n"))}`));
+        // 테스트 환경에서는 hot.invalidateFile시 초기 에러가 발생하기 때문에 invalidate 하지 않습니다.
+        if (!isTest()) {
+            const invalidatedPaths = await hot.invalidateFile(diffFilePath, event);
+            if (invalidatedPaths.length > 0) {
+                console.log(chalk.bold(`🔄 Invalidated:`));
+                for (const invalidatedPath of invalidatedPaths){
+                    // 만약 model.ts 파일이 변경(invalidate)되었다? 그러면 registeredApis 중에서 이 모델에 해당하는 api들은 지워줘요.
+                    // registeredApis는 통으로 다 날려버릴 수 없습니다. registeredApis에 올라오는 친구들은 초기 로드시 또는 HMR시에만 등록되기 때문입니다.
+                    // 따라서 model.ts 파일의 변경으로 다음번 새로운 eval이 예상되는 이 시점에서만, 이 모델에서 나온 registeredApis들을 지워줄 수 있습니다.
+                    const removedApis = this.removeInvalidatedRegisteredApis(invalidatedPath);
+                    if (removedApis.length > 0) {
+                        console.log(chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`), chalk.gray(`(with ${removedApis.length} APIs)`));
+                    } else {
+                        console.log(chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`));
+                    }
+                }
+            }
         }
         const isInCheckPatternGroup = Object.values(getChecksumPatternGroupInAbsolutePath()).some((pattern)=>minimatch(diffFilePath, pattern));
         // 할 일(sync)이 있으면 합니다.
@@ -79,6 +96,17 @@ export class Syncer {
         await this.autoloadApis();
         this.syncUI();
     }
+    removeInvalidatedRegisteredApis(invalidatedPath) {
+        if (!invalidatedPath.endsWith(".model.ts" /*소스 코드를 다루는 상황이니 .ts 경로로 봅니다.*/ )) {
+            return [];
+        }
+        const entityId = EntityManager.getEntityIdFromPath(invalidatedPath);
+        const toRemove = registeredApis.filter((api)=>api.modelName === `${entityId}Model`);
+        for (const api of toRemove){
+            registeredApis.splice(registeredApis.indexOf(api), 1);
+        }
+        return toRemove;
+    }
     async copySharedToTargets(targets) {
         for (const target of targets){
             // 지금 가져가려는 이 파일은 Sonamu 코드베이스의 일부입니다.
@@ -88,13 +116,23 @@ export class Syncer {
             if (!await exists(srcPath)) {
                 return;
             }
+            if (!await exists(path.join(Sonamu.appRootPath, target))) {
+                throw new Error(`Tried to copy sonamu.shared.ts to target '${target}' but the target directory does not exist. Please check your project directory structure.`);
+            }
             // 이건 프로젝트에 .ts 소스 코드 파일을 생성하는 것이므로 src의 .ts 경로로 갑니다.
-            const destPath = path.join(Sonamu.appRootPath, target, "src/services/sonamu.shared.ts");
+            const destPath = path.join(Sonamu.appRootPath, target, "./sonamu.shared.ts");
+            // 정말 혹시나지만 target 디렉토리는 있어도 src/services 디렉토리는 없을 수 있으므로 미리 생성해줍니다.
+            if (!await exists(path.dirname(destPath))) {
+                await mkdir(path.dirname(destPath), {
+                    recursive: true
+                });
+                console.warn(`Created directory '${path.dirname(destPath)}' because it did not exist.`);
+            }
             if (await areFilesSame(srcPath, destPath)) {
                 return;
             }
             await writeFile(destPath, await readFile(srcPath));
-            console.log(chalk.bold("Copied: ") + chalk.blue(path.relative(Sonamu.appRootPath, destPath)));
+            !isTest() && console.log(chalk.bold("Copied: ") + chalk.blue(path.relative(Sonamu.appRootPath, destPath)));
         }
     }
     async autoloadTypes() {
@@ -137,21 +175,20 @@ export class Syncer {
         };
     }
     calculateDiffGroups(diffFiles) {
-        return _.groupBy(diffFiles, (r)=>{
+        return group(diffFiles, (r)=>{
             const matched = r.match(/\.(model|types|functions|entity|generated|frame|config)\.[tj]s/);
             return matched?.[1] ?? "unknown";
         });
     }
     async handleEntityChange(diffGroups, diffTypes) {
-        // console.log(
-        //   chalk.gray(
-        //     `[Processing] Handling entity changes: ${diffGroups["entity"]?.map((p) => path.relative(Sonamu.apiRootPath, p)).join(", ")}`
-        //   )
-        // );
+        Naite.t("handleEntityChange", {
+            diffGroups,
+            diffTypes
+        });
         await EntityManager.reload();
         // types 생성(entity 새로 추가된 경우)
         // parentId가 없고, types가 없는 경우에만 생성
-        const entityId = EntityManager.getEntityIdFromPath(diffGroups["entity"]?.[0]);
+        const entityId = EntityManager.getEntityIdFromPath(diffGroups.entity?.[0]);
         if (entityId) {
             const entity = EntityManager.get(entityId);
             // 프로젝트에 생성되어야 하는 .ts 파일의 경로입니다.
@@ -163,18 +200,21 @@ export class Syncer {
             }
         }
         await this.actionGenerateSchemas();
-        diffGroups["generated"] = _.uniq([
-            ...diffGroups["generated"] ?? [],
+        diffGroups.generated = unique([
+            ...diffGroups.generated ?? [],
             path.join(Sonamu.apiRootPath, "src/application/sonamu.generated.ts")
         ]);
         diffTypes.push("generated");
     }
     async handleTypesOrFunctionsOrGeneratedChange(diffGroups) {
-        const tsPaths = _.uniq([
-            ...diffGroups["types"] ?? [],
-            ...diffGroups["functions"] ?? [],
-            ...diffGroups["generated"] ?? []
+        const tsPaths = unique([
+            ...diffGroups.types ?? [],
+            ...diffGroups.functions ?? [],
+            ...diffGroups.generated ?? []
         ]);
+        Naite.t("handleTypesOrFunctionsOrGeneratedChange", {
+            diffGroups
+        });
         // console.log(
         //   chalk.gray(
         //     `[Processing] Handling types/functions/generated changes: ${tsPaths.map((p) => path.relative(Sonamu.apiRootPath, p)).join(", ")}`
@@ -184,9 +224,12 @@ export class Syncer {
         return [];
     }
     async handleModelOrFrameChange(diffGroups) {
+        Naite.t("handleModelOrFrameChange", {
+            diffGroups
+        });
         const mergedGroup = [
-            ...diffGroups["model"] ?? [],
-            ...diffGroups["frame"] ?? []
+            ...diffGroups.model ?? [],
+            ...diffGroups.frame ?? []
         ];
         // console.log(
         //   chalk.gray(
@@ -222,6 +265,9 @@ export class Syncer {
     async actionSyncConfig() {
         const { host, port } = Sonamu.config.server.listen ?? {};
         const content = `API_HOST=${host ?? "localhost"}\nAPI_PORT=${port ?? 3000}`;
+        Naite.t("actionSyncConfig", {
+            content
+        });
         await Promise.all(Sonamu.config.sync.targets.map(async (target)=>{
             await writeFile(path.join(Sonamu.appRootPath, target, ".sonamu.env"), content);
         }));
@@ -244,6 +290,7 @@ export class Syncer {
    * @param paramsArray
    * @returns 생성된 파일 경로 배열.
    */ async actionGenerateServices(paramsArray) {
+        Naite.t("actionGenerateServices", paramsArray);
         return (await Promise.all(paramsArray.map(async (params)=>generateTemplate("service", params, {
                 overwrite: true
             })))).flat().flat();
@@ -252,7 +299,9 @@ export class Syncer {
    * sonamu.generated.http를 생성합니다.
    * @returns 생성된 파일 경로.
    */ async actionGenerateHttps() {
-        const [res] = await generateTemplate("generated_http", {}, {
+        const [res] = await generateTemplate("generated_http", {
+            entityId: "dummy"
+        }, {
             overwrite: true
         });
         assert(res);
@@ -273,7 +322,7 @@ export class Syncer {
                         recursive: true
                     });
                 }
-                console.log(chalk.bold("Copied: ") + chalk.blue(dst.replace(Sonamu.appRootPath + "/", "")));
+                !isTest() && console.log(chalk.bold("Copied: ") + chalk.blue(dst.replace(`${Sonamu.appRootPath}/`, "")));
                 await this.copyFileWithReplaceCoreToShared(realSrc, dst);
                 return dst;
             }))))).flat();
@@ -284,12 +333,8 @@ export class Syncer {
         }
         const oldFileContent = (await readFile(fromPath)).toString();
         const newFileContent = (()=>{
-            const nfc = oldFileContent.replace(/from "sonamu"/g, `from "src/services/sonamu.shared"`);
-            if (toPath.includes("/web/")) {
-                return nfc; // .replace(/from "lodash";/g, `from "lodash-es";`); // TODO 흠? 필요없을듯.
-            } else {
-                return nfc;
-            }
+            const nfc = oldFileContent.replace(/from "sonamu"/g, `from "./sonamu.shared"`);
+            return nfc;
         })();
         return writeFile(toPath, newFileContent);
     }
@@ -300,7 +345,7 @@ export class Syncer {
    * @param enumId 열거형 ID
    * @returns 생성된 코드가 존재하는지 여부
    */ async checkExistsGenCode(entityId, templateKey, enumId) {
-        const { target, path: genPath } = Template.find(templateKey).getTargetAndPath(EntityManager.getNamesFromId(entityId), enumId);
+        const { target, path: genPath } = TemplateManager.get(templateKey).getTargetAndPath(EntityManager.getNamesFromId(entityId), enumId);
         const subPath = path.join(target, genPath);
         const fullPath = path.join(Sonamu.appRootPath, subPath);
         return {
@@ -319,7 +364,7 @@ export class Syncer {
         const names = EntityManager.getNamesFromId(entityId);
         const enumsKeys = Object.keys(enums).filter((name)=>name !== names.constant);
         return await reduceAsync(keys, async (result, key)=>{
-            const tpl = Template.find(key);
+            const tpl = TemplateManager.get(key);
             if (key.startsWith("view_enums")) {
                 await mapAsync(enumsKeys, async (componentId)=>{
                     const { target, path: p } = tpl.getTargetAndPath(names, componentId);
@@ -341,9 +386,11 @@ export class Syncer {
     }
     syncUI() {
         const uiPort = Sonamu.config.ui?.port ?? 57000;
-        fetch(`http://127.0.0.1:${uiPort}/api/reload`, {
-            method: "GET"
-        }).catch((e)=>console.log(chalk.dim(`Failed to reload Sonamu UI: ${e.message}`)));
+        if (!isTest()) {
+            fetch(`http://127.0.0.1:${uiPort}/api/reload`, {
+                method: "GET"
+            }).catch((e)=>console.log(chalk.dim(`Failed to reload Sonamu UI: ${e.message}`)));
+        }
     }
     /**
    * 하위호환용 프록시 메소드입니다.
@@ -372,4 +419,4 @@ export class Syncer {
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/syncer.ts"],"sourcesContent":["import path, { dirname } from \"path\";\nimport { mkdir, readFile, writeFile } from \"fs/promises\";\nimport { exists } from \"../utils/fs-utils\";\nimport * as _ from \"lodash-es\";\nimport { EntityManager, EntityNamesRecord } from \"../entity/entity-manager\";\nimport { GenerateOptions } from \"../types/types\";\nimport chalk from \"chalk\";\nimport { TemplateKey, TemplateOptions } from \"../types/types\";\nimport { Sonamu } from \"../api/sonamu\";\nimport assert from \"assert\";\nimport { minimatch } from \"minimatch\";\nimport { mapAsync, reduceAsync } from \"../utils/async-utils\";\nimport { centerText } from \"../utils/console-util\";\nimport { runWithGracefulShutdown } from \"../utils/process-utils\";\nimport { AbsolutePath } from \"../utils/path-utils\";\nimport { generateTemplate, renderTemplate } from \"./code-generator\";\nimport { Template } from \"../template\";\nimport {\n  FileType,\n  getChecksumPatternGroupInAbsolutePath,\n} from \"./file-patterns\";\nimport {\n  findChangedFilesUsingChecksums,\n  renewChecksums,\n  areFilesSame,\n} from \"./checksum\";\nimport {\n  loadApis,\n  loadModels,\n  loadTypes,\n  LoadedApis,\n  LoadedModels,\n  LoadedTypes,\n} from \"./module-loader\";\nimport { createEntity, delEntity } from \"./entity-operations\";\nimport { z } from \"zod\";\nimport { hot } from \"@sonamu-kit/hot-hook\";\n\ntype DiffGroups = {\n  [key in FileType]: AbsolutePath[];\n};\n\nexport class Syncer {\n  apis: LoadedApis = [];\n  types: LoadedTypes = {};\n  models: LoadedModels = {};\n  isSyncing: boolean = false;\n\n  /**\n   * 체크섬이 변경된 부분에 대해 싱크를 진행합니다.\n   * 다만 sonamu.shared.ts는 체크섬 비교 없이 무조건 싱크(복사)합니다.\n   * @returns\n   */\n  async sync(): Promise<void> {\n    const { targets } = Sonamu.config.sync;\n\n    // sonamu.shared.ts는 무조건 싱크(복사)합니다.\n    await this.copySharedToTargets(targets);\n\n    // 그 다음부터는 변경된 파일을 찾아서 동기화 작업을 실행합니다.\n    const changedFiles = await findChangedFilesUsingChecksums();\n    if (changedFiles.length === 0) {\n      console.log(chalk.black.bgGreen(centerText(\"All files are synced!\")));\n      return;\n    }\n\n    // 만약 싱크 중에 프로세스가 죽으면 꼬여버리기 때문에,\n    // 시그널에도 잠시 버틸 수 있는 환경 속에서 싱크를 실행합니다.\n    await runWithGracefulShutdown(\n      async () => {\n        // 얘가 싱크 작업 수행하는 본체입니다.\n        await this.doSyncActions(changedFiles);\n\n        // 싱크 액션이 끝나면 항상 체크섬을 다시 갱신합니다.\n        await renewChecksums();\n      },\n      { whenThisHappens: \"SIGUSR2\", waitForUpTo: 20000 }\n    );\n  }\n\n  /**\n   * Watcher가 감지한 파일 변경 사항에 대해 싱크를 진행합니다.\n   * 주어진 변경 파일들 중 체크섬 관리 대상인 것들만 가져다가 싱크를 진행합니다.\n   * 체크섬 파일 업데이트는 여기에서 하지 않습니다. 호출자가 합니다.\n   * @param diffFilePath - 변경 파일들. 프로젝트 루트부터 \"src/\" 또는 \"dist/\"로 시작하는 상대 경로입니다. 예시: \"src/application/user/user.model.ts\"\n   */\n  async syncFromWatcher(\n    event: string,\n    diffFilePath: AbsolutePath\n  ): Promise<void> {\n    if (event !== \"change\" && event !== \"add\" && event !== \"unlink\") {\n      return;\n    }\n\n    // 일단 변경된 파일과 dependent 파일들을 invalidate 합니다.\n    // 한 번 이상 import된 친구들에 대해서만 실제 작업이 일어납니다.\n    // 그러니 안심하고 invalidate 해도 됩니다.\n    const invalidatedPaths = await hot.invalidateFile(diffFilePath, event);\n    if (invalidatedPaths.length > 0) {\n      console.log(\n        chalk.bold(\n          `🔄 Invalidated:\\n${chalk.blue(invalidatedPaths.map((p) => `- ${path.relative(Sonamu.apiRootPath, p)}`).join(\"\\n\"))}`\n        )\n      );\n    }\n\n    const isInCheckPatternGroup = Object.values(\n      getChecksumPatternGroupInAbsolutePath()\n    ).some((pattern) => minimatch(diffFilePath, pattern));\n\n    // 할 일(sync)이 있으면 합니다.\n    if (isInCheckPatternGroup) {\n      await this.doSyncActions([diffFilePath]);\n    }\n\n    // 싱크 작업이 끝나면 모든 모듈을 로드합니다.\n    // hot-hook에 의해 invalidate된 부분들이 아니라면 캐시 그대로 유지합니다.\n    await this.autoloadTypes();\n    await this.autoloadModels();\n    await this.autoloadApis();\n\n    this.syncUI();\n  }\n\n  private async copySharedToTargets(targets: string[]): Promise<void> {\n    for (const target of targets) {\n      // 지금 가져가려는 이 파일은 Sonamu 코드베이스의 일부입니다.\n      // 그런데 dist 속 빌드된 소스 코드 파일이 필요한 것이 아니고, src에만 있는 텍스트 파일이 필요합니다.\n      // 따라서 /src/에서 찾습니다.\n      const srcPath = path.join(\n        import.meta.dirname.replace(\"/dist/\", \"/src/\"),\n        `../shared/${target}.shared.ts.txt`\n      );\n      if (!(await exists(srcPath))) {\n        return;\n      }\n\n      // 이건 프로젝트에 .ts 소스 코드 파일을 생성하는 것이므로 src의 .ts 경로로 갑니다.\n      const destPath = path.join(\n        Sonamu.appRootPath,\n        target,\n        \"src/services/sonamu.shared.ts\"\n      );\n\n      if (await areFilesSame(srcPath, destPath)) {\n        return;\n      }\n\n      await writeFile(destPath, await readFile(srcPath));\n\n      console.log(\n        chalk.bold(\"Copied: \") +\n          chalk.blue(path.relative(Sonamu.appRootPath, destPath))\n      );\n    }\n  }\n\n  async autoloadTypes() {\n    this.types = await loadTypes();\n  }\n\n  async autoloadModels() {\n    this.models = await loadModels();\n  }\n\n  async autoloadApis() {\n    this.apis = await loadApis();\n  }\n\n  /**\n   * 실제 싱크를 수행하는 본체입니다.\n   * 변경된 파일들을 타입별로 분류하고 각 타입에 맞는 액션을 실행합니다.\n   * @param diffFilePaths - 변경된 파일들의 절대 경로 목록\n   * @returns diffTypes - 변경된 파일의 타입 목록 (entity, types, model 등)\n   */\n  private async doSyncActions(\n    diffFilePaths: AbsolutePath[]\n  ): Promise<{ diffTypes: string[] }> {\n    const diffGroups = this.calculateDiffGroups(diffFilePaths);\n    const diffTypes = Object.keys(diffGroups);\n\n    // 트리거: entity, types\n    // 액션: 스키마 생성\n    if (diffTypes.includes(\"entity\")) {\n      await this.handleEntityChange(diffGroups, diffTypes);\n    }\n\n    // 트리거: types, enums, generated 변경시\n    // 액션: 파일 싱크 types, enums, generated\n    if (\n      diffTypes.includes(\"types\") ||\n      diffTypes.includes(\"functions\") ||\n      diffTypes.includes(\"generated\")\n    ) {\n      await this.handleTypesOrFunctionsOrGeneratedChange(diffGroups);\n    }\n\n    // 트리거: model\n    if (diffTypes.includes(\"model\") || diffTypes.includes(\"frame\")) {\n      await this.handleModelOrFrameChange(diffGroups);\n    }\n\n    // 트리거: config\n    if (diffTypes.includes(\"config\")) {\n      await this.actionSyncConfig();\n    }\n\n    return {\n      diffTypes,\n    };\n  }\n\n  private calculateDiffGroups(diffFiles: AbsolutePath[]): DiffGroups {\n    return _.groupBy(diffFiles, (r) => {\n      const matched = r.match(\n        /\\.(model|types|functions|entity|generated|frame|config)\\.[tj]s/\n      );\n      return matched?.[1] ?? \"unknown\";\n    }) as unknown as DiffGroups;\n  }\n\n  private async handleEntityChange(\n    diffGroups: DiffGroups,\n    diffTypes: string[]\n  ): Promise<void> {\n    // console.log(\n    //   chalk.gray(\n    //     `[Processing] Handling entity changes: ${diffGroups[\"entity\"]?.map((p) => path.relative(Sonamu.apiRootPath, p)).join(\", \")}`\n    //   )\n    // );\n\n    await EntityManager.reload();\n\n    // types 생성(entity 새로 추가된 경우)\n    // parentId가 없고, types가 없는 경우에만 생성\n    const entityId = EntityManager.getEntityIdFromPath(\n      diffGroups[\"entity\"]?.[0]\n    );\n\n    if (entityId) {\n      const entity = EntityManager.get(entityId);\n      // 프로젝트에 생성되어야 하는 .ts 파일의 경로입니다.\n      const typeFilePath = path.join(\n        Sonamu.apiRootPath,\n        `src/application/${entity.names.fs}/${entity.names.fs}.types.ts`\n      );\n      if (entity.parentId === undefined && !(await exists(typeFilePath))) {\n        await generateTemplate(\"init_types\", { entityId });\n      }\n    }\n\n    await this.actionGenerateSchemas();\n\n    diffGroups[\"generated\"] = _.uniq([\n      ...(diffGroups[\"generated\"] ?? []),\n      path.join(\n        Sonamu.apiRootPath,\n        \"src/application/sonamu.generated.ts\"\n      ) as AbsolutePath,\n    ]);\n    diffTypes.push(\"generated\");\n  }\n\n  private async handleTypesOrFunctionsOrGeneratedChange(\n    diffGroups: DiffGroups\n  ): Promise<FileType[]> {\n    const tsPaths = _.uniq([\n      ...(diffGroups[\"types\"] ?? []),\n      ...(diffGroups[\"functions\"] ?? []),\n      ...(diffGroups[\"generated\"] ?? []),\n    ]);\n\n    // console.log(\n    //   chalk.gray(\n    //     `[Processing] Handling types/functions/generated changes: ${tsPaths.map((p) => path.relative(Sonamu.apiRootPath, p)).join(\", \")}`\n    //   )\n    // );\n\n    await this.actionSyncFilesToTargets(tsPaths);\n\n    return [];\n  }\n\n  private async handleModelOrFrameChange(\n    diffGroups: DiffGroups\n  ): Promise<void> {\n    const mergedGroup = [\n      ...(diffGroups[\"model\"] ?? []),\n      ...(diffGroups[\"frame\"] ?? []),\n    ];\n\n    // console.log(\n    //   chalk.gray(\n    //     `[Processing] Handling model/frame changes: ${mergedGroup.map((p) => path.relative(Sonamu.apiRootPath, p)).join(\", \")}`\n    //   )\n    // );\n\n    // generated_http.template.ts에서 syncer.types를 씁니다.\n    // service.template.ts에서 syncer.apis를 씁니다.\n    await this.autoloadModels();\n    await this.autoloadTypes();\n    await this.autoloadApis();\n\n    const params: {\n      namesRecord: EntityNamesRecord;\n    }[] = mergedGroup.map((modelPath) => {\n      if (modelPath.endsWith(\".model.ts\")) {\n        const entityId = EntityManager.getEntityIdFromPath(modelPath);\n        assert(entityId);\n        return {\n          namesRecord: EntityManager.getNamesFromId(entityId),\n        };\n      }\n      if (modelPath.endsWith(\"frame.ts\")) {\n        const [, frameName] = modelPath.match(/.+\\/(.+)\\.frame.js$/) ?? [];\n        assert(frameName);\n        return {\n          namesRecord: EntityManager.getNamesFromId(frameName),\n        };\n      }\n      throw new Error(\"not reachable\");\n    });\n\n    await this.actionGenerateServices(params);\n    await this.actionGenerateHttps();\n  }\n\n  // web/.sonamu.env 에 현재 설정값 저장\n  async actionSyncConfig() {\n    const { host, port } = Sonamu.config.server.listen ?? {};\n    const content = `API_HOST=${host ?? \"localhost\"}\\nAPI_PORT=${port ?? 3000}`;\n\n    await Promise.all(\n      Sonamu.config.sync.targets.map(async (target) => {\n        await writeFile(\n          path.join(Sonamu.appRootPath, target, \".sonamu.env\"),\n          content\n        );\n      })\n    );\n  }\n\n  /**\n   * sonamu.generated.ts와 sonamu.generated.sso.ts를 생성합니다.\n   * @returns 생성된 파일 경로 배열.\n   */\n  private async actionGenerateSchemas(): Promise<AbsolutePath[]> {\n    return (\n      await Promise.all([\n        generateTemplate(\"generated_sso\", {}, { overwrite: true }),\n        generateTemplate(\"generated\", {}, { overwrite: true }),\n      ])\n    )\n      .flat()\n      .flat();\n  }\n\n  /**\n   * *.service.ts를 생성합니다.\n   * @param paramsArray\n   * @returns 생성된 파일 경로 배열.\n   */\n  private async actionGenerateServices(\n    paramsArray: {\n      namesRecord: EntityNamesRecord;\n    }[]\n  ): Promise<string[]> {\n    return (\n      await Promise.all(\n        paramsArray.map(async (params) =>\n          generateTemplate(\"service\", params, {\n            overwrite: true,\n          })\n        )\n      )\n    )\n      .flat()\n      .flat();\n  }\n\n  /**\n   * sonamu.generated.http를 생성합니다.\n   * @returns 생성된 파일 경로.\n   */\n  private async actionGenerateHttps(): Promise<AbsolutePath> {\n    const [res] = await generateTemplate(\n      \"generated_http\",\n      {},\n      { overwrite: true }\n    );\n    assert(res);\n    return res;\n  }\n\n  /**\n   * *.types.ts, *.functions.ts, *.generated.ts를 타겟 디렉토리에 복사합니다.\n   * @param tsPaths\n   * @returns 복사된 파일 경로 배열.\n   */\n  private async actionSyncFilesToTargets(\n    tsPaths: AbsolutePath[]\n  ): Promise<string[]> {\n    const { targets } = Sonamu.config.sync;\n    const { dir: apiDir } = Sonamu.config.api;\n\n    return (\n      await Promise.all(\n        targets.map(async (target) =>\n          Promise.all(\n            tsPaths.map(async (realSrc) => {\n              const dst = realSrc\n                .replace(`/${apiDir}/`, `/${target}/`)\n                .replace(\"/application/\", \"/services/\");\n              const dir = dirname(dst);\n              if (!(await exists(dir))) {\n                await mkdir(dir, { recursive: true });\n              }\n              console.log(\n                chalk.bold(\"Copied: \") +\n                  chalk.blue(dst.replace(Sonamu.appRootPath + \"/\", \"\"))\n              );\n              await this.copyFileWithReplaceCoreToShared(realSrc, dst);\n              return dst;\n            })\n          )\n        )\n      )\n    ).flat();\n  }\n\n  private async copyFileWithReplaceCoreToShared(\n    fromPath: string,\n    toPath: string\n  ) {\n    if (!(await exists(fromPath))) {\n      return;\n    }\n\n    const oldFileContent = (await readFile(fromPath)).toString();\n\n    const newFileContent = (() => {\n      const nfc = oldFileContent.replace(\n        /from \"sonamu\"/g,\n        `from \"src/services/sonamu.shared\"`\n      );\n\n      if (toPath.includes(\"/web/\")) {\n        return nfc; // .replace(/from \"lodash\";/g, `from \"lodash-es\";`); // TODO 흠? 필요없을듯.\n      } else {\n        return nfc;\n      }\n    })();\n    return writeFile(toPath, newFileContent);\n  }\n\n  /**\n   * 주어진 엔티티와 템플릿 키에 대해, 생성된 코드가 존재하는지 확인합니다.\n   * @param entityId 엔티티 ID\n   * @param templateKey 템플릿 키\n   * @param enumId 열거형 ID\n   * @returns 생성된 코드가 존재하는지 여부\n   */\n  async checkExistsGenCode(\n    entityId: string,\n    templateKey: TemplateKey,\n    enumId?: string\n  ): Promise<{ subPath: string; fullPath: string; isExists: boolean }> {\n    const { target, path: genPath } = Template.find(\n      templateKey\n    ).getTargetAndPath(EntityManager.getNamesFromId(entityId), enumId);\n\n    const subPath = path.join(target, genPath);\n    const fullPath = path.join(Sonamu.appRootPath, subPath);\n    return {\n      subPath,\n      fullPath,\n      isExists: await exists(fullPath),\n    };\n  }\n\n  /**\n   * 주어진 엔티티와 열거형에 대해, 생성된 코드가 존재하는지 확인합니다.\n   * @param entityId 엔티티 ID\n   * @param enums 열거형 레이블\n   * @returns 생성된 코드가 존재하는지 여부\n   */\n  async checkExists(\n    entityId: string,\n    enums: {\n      [name: string]: z.ZodEnum<any>;\n    }\n  ): Promise<Record<`${TemplateKey}${string}`, boolean>> {\n    const keys: TemplateKey[] = TemplateKey.options;\n    const names = EntityManager.getNamesFromId(entityId);\n    const enumsKeys = Object.keys(enums).filter(\n      (name) => name !== names.constant\n    );\n\n    return await reduceAsync(\n      keys,\n      async (result, key) => {\n        const tpl = Template.find(key);\n        if (key.startsWith(\"view_enums\")) {\n          await mapAsync(enumsKeys, async (componentId) => {\n            const { target, path: p } = tpl.getTargetAndPath(\n              names,\n              componentId\n            );\n            result[`${key}__${componentId}`] = await exists(\n              path.join(Sonamu.appRootPath, target, p)\n            );\n          });\n          return result;\n        }\n\n        const { target, path: p } = tpl.getTargetAndPath(names);\n        const { targets } = Sonamu.config.sync;\n        if (target.includes(\":target\")) {\n          await mapAsync(targets, async (t) => {\n            result[`${key}__${t}`] = await exists(\n              path.join(Sonamu.appRootPath, target.replace(\":target\", t), p)\n            );\n          });\n        } else {\n          result[key] = await exists(path.join(Sonamu.appRootPath, target, p));\n        }\n\n        return result;\n      },\n      {} as Record<`${TemplateKey}${string}`, boolean>\n    );\n  }\n\n  syncUI() {\n    const uiPort = Sonamu.config.ui?.port ?? 57000;\n\n    fetch(`http://127.0.0.1:${uiPort}/api/reload`, {\n      method: \"GET\",\n    }).catch((e) =>\n      console.log(chalk.dim(`Failed to reload Sonamu UI: ${e.message}`))\n    );\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async createEntity(\n    form: Omit<TemplateOptions[\"entity\"], \"title\"> & { title?: string }\n  ) {\n    return await createEntity(form);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async delEntity(entityId: string): Promise<{ delPaths: string[] }> {\n    return await delEntity(entityId);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async generateTemplate(\n    key: TemplateKey,\n    templateOptions: any,\n    _generateOptions?: GenerateOptions\n  ) {\n    return await generateTemplate(key, templateOptions, _generateOptions);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async renderTemplate(key: TemplateKey, templateOptions: any) {\n    return await renderTemplate(key, templateOptions);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async renewChecksums(): Promise<void> {\n    return await renewChecksums();\n  }\n}\n"],"names":["path","dirname","mkdir","readFile","writeFile","exists","_","EntityManager","chalk","TemplateKey","Sonamu","assert","minimatch","mapAsync","reduceAsync","centerText","runWithGracefulShutdown","generateTemplate","renderTemplate","Template","getChecksumPatternGroupInAbsolutePath","findChangedFilesUsingChecksums","renewChecksums","areFilesSame","loadApis","loadModels","loadTypes","createEntity","delEntity","hot","Syncer","apis","types","models","isSyncing","sync","targets","config","copySharedToTargets","changedFiles","length","console","log","black","bgGreen","doSyncActions","whenThisHappens","waitForUpTo","syncFromWatcher","event","diffFilePath","invalidatedPaths","invalidateFile","bold","blue","map","p","relative","apiRootPath","join","isInCheckPatternGroup","Object","values","some","pattern","autoloadTypes","autoloadModels","autoloadApis","syncUI","target","srcPath","replace","destPath","appRootPath","diffFilePaths","diffGroups","calculateDiffGroups","diffTypes","keys","includes","handleEntityChange","handleTypesOrFunctionsOrGeneratedChange","handleModelOrFrameChange","actionSyncConfig","diffFiles","groupBy","r","matched","match","reload","entityId","getEntityIdFromPath","entity","get","typeFilePath","names","fs","parentId","undefined","actionGenerateSchemas","uniq","push","tsPaths","actionSyncFilesToTargets","mergedGroup","params","modelPath","endsWith","namesRecord","getNamesFromId","frameName","Error","actionGenerateServices","actionGenerateHttps","host","port","server","listen","content","Promise","all","overwrite","flat","paramsArray","res","dir","apiDir","api","realSrc","dst","recursive","copyFileWithReplaceCoreToShared","fromPath","toPath","oldFileContent","toString","newFileContent","nfc","checkExistsGenCode","templateKey","enumId","genPath","find","getTargetAndPath","subPath","fullPath","isExists","checkExists","enums","options","enumsKeys","filter","name","constant","result","key","tpl","startsWith","componentId","t","uiPort","ui","fetch","method","catch","e","dim","message","form","templateOptions","_generateOptions"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/syncer.ts"],"sourcesContent":["import { hot } from \"@sonamu-kit/hot-hook\";\nimport assert from \"assert\";\nimport chalk from \"chalk\";\nimport { mkdir, readFile, writeFile } from \"fs/promises\";\nimport { minimatch } from \"minimatch\";\nimport path, { dirname } from \"path\";\nimport { group, unique } from \"radashi\";\nimport type { z } from \"zod\";\nimport { registeredApis } from \"../api/decorators\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { EntityManager, type EntityNamesRecord } from \"../entity/entity-manager\";\nimport { Naite } from \"../naite/naite\";\nimport { TemplateManager } from \"../template/template-manager\";\nimport type { GenerateOptions, PathAndCode } from \"../types/types\";\nimport { TemplateKey, type TemplateOptions } from \"../types/types\";\nimport { mapAsync, reduceAsync } from \"../utils/async-utils\";\nimport { centerText } from \"../utils/console-util\";\nimport { isTest } from \"../utils/controller\";\nimport { exists } from \"../utils/fs-utils\";\nimport type { AbsolutePath } from \"../utils/path-utils\";\nimport { runWithGracefulShutdown } from \"../utils/process-utils\";\nimport { areFilesSame, findChangedFilesUsingChecksums, renewChecksums } from \"./checksum\";\nimport { generateTemplate, renderTemplate } from \"./code-generator\";\nimport { createEntity, delEntity } from \"./entity-operations\";\nimport { type FileType, getChecksumPatternGroupInAbsolutePath } from \"./file-patterns\";\nimport {\n  type LoadedApis,\n  type LoadedModels,\n  type LoadedTypes,\n  loadApis,\n  loadModels,\n  loadTypes,\n} from \"./module-loader\";\n\ntype DiffGroups = {\n  [key in FileType]: AbsolutePath[];\n};\n\nexport class Syncer {\n  apis: LoadedApis = [];\n  types: LoadedTypes = {};\n  models: LoadedModels = {};\n  isSyncing: boolean = false;\n\n  /**\n   * 체크섬이 변경된 부분에 대해 싱크를 진행합니다.\n   * 다만 sonamu.shared.ts는 체크섬 비교 없이 무조건 싱크(복사)합니다.\n   * @returns\n   */\n  async sync(): Promise<void> {\n    const { targets } = Sonamu.config.sync;\n\n    // sonamu.shared.ts는 무조건 싱크(복사)합니다.\n    await this.copySharedToTargets(targets);\n\n    // 그 다음부터는 변경된 파일을 찾아서 동기화 작업을 실행합니다.\n    const changedFiles = await findChangedFilesUsingChecksums();\n    if (changedFiles.length === 0) {\n      console.log(chalk.black.bgGreen(centerText(\"All files are synced!\")));\n      return;\n    }\n\n    // 만약 싱크 중에 프로세스가 죽으면 꼬여버리기 때문에,\n    // 시그널에도 잠시 버틸 수 있는 환경 속에서 싱크를 실행합니다.\n    await runWithGracefulShutdown(\n      async () => {\n        // 얘가 싱크 작업 수행하는 본체입니다.\n        await this.doSyncActions(changedFiles);\n\n        // 싱크 액션이 끝나면 항상 체크섬을 다시 갱신합니다.\n        await renewChecksums();\n      },\n      { whenThisHappens: \"SIGUSR2\", waitForUpTo: 20000 },\n    );\n  }\n\n  /**\n   * Watcher가 감지한 파일 변경 사항에 대해 싱크를 진행합니다.\n   * 주어진 변경 파일들 중 체크섬 관리 대상인 것들만 가져다가 싱크를 진행합니다.\n   * 체크섬 파일 업데이트는 여기에서 하지 않습니다. 호출자가 합니다.\n   * @param diffFilePath - 변경 파일들. 프로젝트 루트부터 \"src/\" 또는 \"dist/\"로 시작하는 상대 경로입니다. 예시: \"src/application/user/user.model.ts\"\n   */\n  async syncFromWatcher(event: string, diffFilePath: AbsolutePath): Promise<void> {\n    if (event !== \"change\" && event !== \"add\" && event !== \"unlink\") {\n      return;\n    }\n\n    // 일단 변경된 파일과 dependent 파일들을 invalidate 합니다.\n    // 한 번 이상 import된 친구들에 대해서만 실제 작업이 일어납니다.\n    // 그러니 안심하고 invalidate 해도 됩니다.\n    // 테스트 환경에서는 hot.invalidateFile시 초기 에러가 발생하기 때문에 invalidate 하지 않습니다.\n    if (!isTest()) {\n      const invalidatedPaths = (await hot.invalidateFile(diffFilePath, event)) as AbsolutePath[];\n\n      if (invalidatedPaths.length > 0) {\n        console.log(chalk.bold(`🔄 Invalidated:`));\n\n        for (const invalidatedPath of invalidatedPaths) {\n          // 만약 model.ts 파일이 변경(invalidate)되었다? 그러면 registeredApis 중에서 이 모델에 해당하는 api들은 지워줘요.\n          // registeredApis는 통으로 다 날려버릴 수 없습니다. registeredApis에 올라오는 친구들은 초기 로드시 또는 HMR시에만 등록되기 때문입니다.\n          // 따라서 model.ts 파일의 변경으로 다음번 새로운 eval이 예상되는 이 시점에서만, 이 모델에서 나온 registeredApis들을 지워줄 수 있습니다.\n          const removedApis = this.removeInvalidatedRegisteredApis(invalidatedPath);\n          if (removedApis.length > 0) {\n            console.log(\n              chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`),\n              chalk.gray(`(with ${removedApis.length} APIs)`),\n            );\n          } else {\n            console.log(chalk.blue(`- ${path.relative(Sonamu.apiRootPath, invalidatedPath)}`));\n          }\n        }\n      }\n    }\n\n    const isInCheckPatternGroup = Object.values(getChecksumPatternGroupInAbsolutePath()).some(\n      (pattern) => minimatch(diffFilePath, pattern),\n    );\n\n    // 할 일(sync)이 있으면 합니다.\n    if (isInCheckPatternGroup) {\n      await this.doSyncActions([diffFilePath]);\n    }\n\n    // 싱크 작업이 끝나면 모든 모듈을 로드합니다.\n    // hot-hook에 의해 invalidate된 부분들이 아니라면 캐시 그대로 유지합니다.\n    await this.autoloadTypes();\n    await this.autoloadModels();\n    await this.autoloadApis();\n\n    this.syncUI();\n  }\n\n  removeInvalidatedRegisteredApis(\n    invalidatedPath: AbsolutePath,\n  ): (typeof registeredApis)[number][] {\n    if (!invalidatedPath.endsWith(\".model.ts\" /*소스 코드를 다루는 상황이니 .ts 경로로 봅니다.*/)) {\n      return [];\n    }\n\n    const entityId = EntityManager.getEntityIdFromPath(invalidatedPath);\n    const toRemove = registeredApis.filter((api) => api.modelName === `${entityId}Model`);\n    for (const api of toRemove) {\n      registeredApis.splice(registeredApis.indexOf(api), 1);\n    }\n\n    return toRemove;\n  }\n\n  async copySharedToTargets(targets: string[]): Promise<void> {\n    for (const target of targets) {\n      // 지금 가져가려는 이 파일은 Sonamu 코드베이스의 일부입니다.\n      // 그런데 dist 속 빌드된 소스 코드 파일이 필요한 것이 아니고, src에만 있는 텍스트 파일이 필요합니다.\n      // 따라서 /src/에서 찾습니다.\n      const srcPath = path.join(\n        import.meta.dirname.replace(\"/dist/\", \"/src/\"),\n        `../shared/${target}.shared.ts.txt`,\n      );\n      if (!(await exists(srcPath))) {\n        return;\n      }\n      if (!(await exists(path.join(Sonamu.appRootPath, target)))) {\n        throw new Error(\n          `Tried to copy sonamu.shared.ts to target '${target}' but the target directory does not exist. Please check your project directory structure.`,\n        );\n      }\n\n      // 이건 프로젝트에 .ts 소스 코드 파일을 생성하는 것이므로 src의 .ts 경로로 갑니다.\n      const destPath = path.join(Sonamu.appRootPath, target, \"./sonamu.shared.ts\");\n\n      // 정말 혹시나지만 target 디렉토리는 있어도 src/services 디렉토리는 없을 수 있으므로 미리 생성해줍니다.\n      if (!(await exists(path.dirname(destPath)))) {\n        await mkdir(path.dirname(destPath), { recursive: true });\n        console.warn(`Created directory '${path.dirname(destPath)}' because it did not exist.`);\n      }\n\n      if (await areFilesSame(srcPath, destPath)) {\n        return;\n      }\n\n      await writeFile(destPath, await readFile(srcPath));\n\n      !isTest() &&\n        console.log(\n          chalk.bold(\"Copied: \") + chalk.blue(path.relative(Sonamu.appRootPath, destPath)),\n        );\n    }\n  }\n\n  async autoloadTypes() {\n    this.types = await loadTypes();\n  }\n\n  async autoloadModels() {\n    this.models = await loadModels();\n  }\n\n  async autoloadApis() {\n    this.apis = await loadApis();\n  }\n\n  /**\n   * 실제 싱크를 수행하는 본체입니다.\n   * 변경된 파일들을 타입별로 분류하고 각 타입에 맞는 액션을 실행합니다.\n   * @param diffFilePaths - 변경된 파일들의 절대 경로 목록\n   * @returns diffTypes - 변경된 파일의 타입 목록 (entity, types, model 등)\n   */\n  async doSyncActions(diffFilePaths: AbsolutePath[]): Promise<{ diffTypes: string[] }> {\n    const diffGroups = this.calculateDiffGroups(diffFilePaths);\n    const diffTypes = Object.keys(diffGroups);\n\n    // 트리거: entity, types\n    // 액션: 스키마 생성\n    if (diffTypes.includes(\"entity\")) {\n      await this.handleEntityChange(diffGroups, diffTypes);\n    }\n\n    // 트리거: types, enums, generated 변경시\n    // 액션: 파일 싱크 types, enums, generated\n    if (\n      diffTypes.includes(\"types\") ||\n      diffTypes.includes(\"functions\") ||\n      diffTypes.includes(\"generated\")\n    ) {\n      await this.handleTypesOrFunctionsOrGeneratedChange(diffGroups);\n    }\n\n    // 트리거: model\n    if (diffTypes.includes(\"model\") || diffTypes.includes(\"frame\")) {\n      await this.handleModelOrFrameChange(diffGroups);\n    }\n\n    // 트리거: config\n    if (diffTypes.includes(\"config\")) {\n      await this.actionSyncConfig();\n    }\n\n    return {\n      diffTypes,\n    };\n  }\n\n  calculateDiffGroups(diffFiles: AbsolutePath[]): DiffGroups {\n    return group(diffFiles, (r) => {\n      const matched = r.match(/\\.(model|types|functions|entity|generated|frame|config)\\.[tj]s/);\n      return matched?.[1] ?? \"unknown\";\n    }) as unknown as DiffGroups;\n  }\n\n  async handleEntityChange(diffGroups: DiffGroups, diffTypes: string[]): Promise<void> {\n    Naite.t(\"handleEntityChange\", { diffGroups, diffTypes });\n\n    await EntityManager.reload();\n\n    // types 생성(entity 새로 추가된 경우)\n    // parentId가 없고, types가 없는 경우에만 생성\n    const entityId = EntityManager.getEntityIdFromPath(diffGroups.entity?.[0]);\n\n    if (entityId) {\n      const entity = EntityManager.get(entityId);\n      // 프로젝트에 생성되어야 하는 .ts 파일의 경로입니다.\n      const typeFilePath = path.join(\n        Sonamu.apiRootPath,\n        `src/application/${entity.names.fs}/${entity.names.fs}.types.ts`,\n      );\n      if (entity.parentId === undefined && !(await exists(typeFilePath))) {\n        await generateTemplate(\"init_types\", { entityId });\n      }\n    }\n\n    await this.actionGenerateSchemas();\n\n    diffGroups.generated = unique([\n      ...(diffGroups.generated ?? []),\n      path.join(Sonamu.apiRootPath, \"src/application/sonamu.generated.ts\") as AbsolutePath,\n    ]);\n    diffTypes.push(\"generated\");\n  }\n\n  async handleTypesOrFunctionsOrGeneratedChange(diffGroups: DiffGroups): Promise<FileType[]> {\n    const tsPaths = unique([\n      ...(diffGroups.types ?? []),\n      ...(diffGroups.functions ?? []),\n      ...(diffGroups.generated ?? []),\n    ]);\n    Naite.t(\"handleTypesOrFunctionsOrGeneratedChange\", { diffGroups });\n\n    // console.log(\n    //   chalk.gray(\n    //     `[Processing] Handling types/functions/generated changes: ${tsPaths.map((p) => path.relative(Sonamu.apiRootPath, p)).join(\", \")}`\n    //   )\n    // );\n\n    await this.actionSyncFilesToTargets(tsPaths);\n\n    return [];\n  }\n\n  async handleModelOrFrameChange(diffGroups: DiffGroups): Promise<void> {\n    Naite.t(\"handleModelOrFrameChange\", { diffGroups });\n    const mergedGroup = [...(diffGroups.model ?? []), ...(diffGroups.frame ?? [])];\n\n    // console.log(\n    //   chalk.gray(\n    //     `[Processing] Handling model/frame changes: ${mergedGroup.map((p) => path.relative(Sonamu.apiRootPath, p)).join(\", \")}`\n    //   )\n    // );\n\n    // generated_http.template.ts에서 syncer.types를 씁니다.\n    // service.template.ts에서 syncer.apis를 씁니다.\n    await this.autoloadModels();\n    await this.autoloadTypes();\n    await this.autoloadApis();\n\n    const params: {\n      namesRecord: EntityNamesRecord;\n    }[] = mergedGroup.map((modelPath) => {\n      if (modelPath.endsWith(\".model.ts\")) {\n        const entityId = EntityManager.getEntityIdFromPath(modelPath);\n        assert(entityId);\n        return {\n          namesRecord: EntityManager.getNamesFromId(entityId),\n        };\n      }\n      if (modelPath.endsWith(\"frame.ts\")) {\n        const [, frameName] = modelPath.match(/.+\\/(.+)\\.frame.js$/) ?? [];\n        assert(frameName);\n        return {\n          namesRecord: EntityManager.getNamesFromId(frameName),\n        };\n      }\n      throw new Error(\"not reachable\");\n    });\n\n    await this.actionGenerateServices(params);\n    await this.actionGenerateHttps();\n  }\n\n  // web/.sonamu.env 에 현재 설정값 저장\n  async actionSyncConfig() {\n    const { host, port } = Sonamu.config.server.listen ?? {};\n    const content = `API_HOST=${host ?? \"localhost\"}\\nAPI_PORT=${port ?? 3000}`;\n\n    Naite.t(\"actionSyncConfig\", { content });\n    await Promise.all(\n      Sonamu.config.sync.targets.map(async (target) => {\n        await writeFile(path.join(Sonamu.appRootPath, target, \".sonamu.env\"), content);\n      }),\n    );\n  }\n\n  /**\n   * sonamu.generated.ts와 sonamu.generated.sso.ts를 생성합니다.\n   * @returns 생성된 파일 경로 배열.\n   */\n  async actionGenerateSchemas(): Promise<AbsolutePath[]> {\n    return (\n      await Promise.all([\n        generateTemplate(\"generated_sso\", {}, { overwrite: true }),\n        generateTemplate(\"generated\", {}, { overwrite: true }),\n      ])\n    )\n      .flat()\n      .flat();\n  }\n\n  /**\n   * *.service.ts를 생성합니다.\n   * @param paramsArray\n   * @returns 생성된 파일 경로 배열.\n   */\n  async actionGenerateServices(\n    paramsArray: {\n      namesRecord: EntityNamesRecord;\n    }[],\n  ): Promise<string[]> {\n    Naite.t(\"actionGenerateServices\", paramsArray);\n    return (\n      await Promise.all(\n        paramsArray.map(async (params) =>\n          generateTemplate(\"service\", params as TemplateOptions[\"service\"], {\n            overwrite: true,\n          }),\n        ),\n      )\n    )\n      .flat()\n      .flat();\n  }\n\n  /**\n   * sonamu.generated.http를 생성합니다.\n   * @returns 생성된 파일 경로.\n   */\n  async actionGenerateHttps(): Promise<AbsolutePath> {\n    const [res] = await generateTemplate(\n      \"generated_http\",\n      { entityId: \"dummy\" },\n      { overwrite: true },\n    );\n    assert(res);\n    return res;\n  }\n\n  /**\n   * *.types.ts, *.functions.ts, *.generated.ts를 타겟 디렉토리에 복사합니다.\n   * @param tsPaths\n   * @returns 복사된 파일 경로 배열.\n   */\n  async actionSyncFilesToTargets(tsPaths: AbsolutePath[]): Promise<string[]> {\n    const { targets } = Sonamu.config.sync;\n    const { dir: apiDir } = Sonamu.config.api;\n\n    return (\n      await Promise.all(\n        targets.map(async (target) =>\n          Promise.all(\n            tsPaths.map(async (realSrc) => {\n              const dst = realSrc\n                .replace(`/${apiDir}/`, `/${target}/`)\n                .replace(\"/application/\", \"/services/\");\n              const dir = dirname(dst);\n              if (!(await exists(dir))) {\n                await mkdir(dir, { recursive: true });\n              }\n              !isTest() &&\n                console.log(\n                  chalk.bold(\"Copied: \") + chalk.blue(dst.replace(`${Sonamu.appRootPath}/`, \"\")),\n                );\n              await this.copyFileWithReplaceCoreToShared(realSrc, dst);\n              return dst;\n            }),\n          ),\n        ),\n      )\n    ).flat();\n  }\n\n  private async copyFileWithReplaceCoreToShared(fromPath: string, toPath: string) {\n    if (!(await exists(fromPath))) {\n      return;\n    }\n\n    const oldFileContent = (await readFile(fromPath)).toString();\n\n    const newFileContent = (() => {\n      const nfc = oldFileContent.replace(/from \"sonamu\"/g, `from \"./sonamu.shared\"`);\n      return nfc;\n    })();\n    return writeFile(toPath, newFileContent);\n  }\n\n  /**\n   * 주어진 엔티티와 템플릿 키에 대해, 생성된 코드가 존재하는지 확인합니다.\n   * @param entityId 엔티티 ID\n   * @param templateKey 템플릿 키\n   * @param enumId 열거형 ID\n   * @returns 생성된 코드가 존재하는지 여부\n   */\n  async checkExistsGenCode(\n    entityId: string,\n    templateKey: TemplateKey,\n    enumId?: string,\n  ): Promise<{ subPath: string; fullPath: string; isExists: boolean }> {\n    const { target, path: genPath } = TemplateManager.get(templateKey).getTargetAndPath(\n      EntityManager.getNamesFromId(entityId),\n      enumId,\n    );\n\n    const subPath = path.join(target, genPath);\n    const fullPath = path.join(Sonamu.appRootPath, subPath);\n    return {\n      subPath,\n      fullPath,\n      isExists: await exists(fullPath),\n    };\n  }\n\n  /**\n   * 주어진 엔티티와 열거형에 대해, 생성된 코드가 존재하는지 확인합니다.\n   * @param entityId 엔티티 ID\n   * @param enums 열거형 레이블\n   * @returns 생성된 코드가 존재하는지 여부\n   */\n  async checkExists(\n    entityId: string,\n    enums: {\n      [name: string]: z.ZodEnum<Readonly<Record<string, string | number>>>;\n    },\n  ): Promise<Record<`${TemplateKey}${string}`, boolean>> {\n    const keys: TemplateKey[] = TemplateKey.options;\n    const names = EntityManager.getNamesFromId(entityId);\n    const enumsKeys = Object.keys(enums).filter((name) => name !== names.constant);\n\n    return await reduceAsync(\n      keys,\n      async (result, key) => {\n        const tpl = TemplateManager.get(key);\n        if (key.startsWith(\"view_enums\")) {\n          await mapAsync(enumsKeys, async (componentId) => {\n            const { target, path: p } = tpl.getTargetAndPath(names, componentId);\n            result[`${key}__${componentId}`] = await exists(\n              path.join(Sonamu.appRootPath, target, p),\n            );\n          });\n          return result;\n        }\n\n        const { target, path: p } = tpl.getTargetAndPath(names);\n        const { targets } = Sonamu.config.sync;\n        if (target.includes(\":target\")) {\n          await mapAsync(targets, async (t) => {\n            result[`${key}__${t}`] = await exists(\n              path.join(Sonamu.appRootPath, target.replace(\":target\", t), p),\n            );\n          });\n        } else {\n          result[key] = await exists(path.join(Sonamu.appRootPath, target, p));\n        }\n\n        return result;\n      },\n      {} as Record<`${TemplateKey}${string}`, boolean>,\n    );\n  }\n\n  syncUI() {\n    const uiPort = Sonamu.config.ui?.port ?? 57000;\n\n    if (!isTest()) {\n      fetch(`http://127.0.0.1:${uiPort}/api/reload`, {\n        method: \"GET\",\n      }).catch((e) => console.log(chalk.dim(`Failed to reload Sonamu UI: ${e.message}`)));\n    }\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async createEntity(form: TemplateOptions[\"entity\"]) {\n    return await createEntity(form);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async delEntity(entityId: string): Promise<{ delPaths: string[] }> {\n    return await delEntity(entityId);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async generateTemplate<T extends TemplateKey>(\n    key: T,\n    templateOptions: TemplateOptions[T],\n    _generateOptions?: GenerateOptions,\n  ): Promise<AbsolutePath[]> {\n    return await generateTemplate(key, templateOptions, _generateOptions);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async renderTemplate<T extends keyof TemplateOptions>(\n    key: T,\n    templateOptions: TemplateOptions[T],\n  ): Promise<PathAndCode[]> {\n    return await renderTemplate(key, templateOptions);\n  }\n\n  /**\n   * 하위호환용 프록시 메소드입니다.\n   */\n  async renewChecksums(): Promise<void> {\n    return await renewChecksums();\n  }\n}\n"],"names":["hot","assert","chalk","mkdir","readFile","writeFile","minimatch","path","dirname","group","unique","registeredApis","Sonamu","EntityManager","Naite","TemplateManager","TemplateKey","mapAsync","reduceAsync","centerText","isTest","exists","runWithGracefulShutdown","areFilesSame","findChangedFilesUsingChecksums","renewChecksums","generateTemplate","renderTemplate","createEntity","delEntity","getChecksumPatternGroupInAbsolutePath","loadApis","loadModels","loadTypes","Syncer","apis","types","models","isSyncing","sync","targets","config","copySharedToTargets","changedFiles","length","console","log","black","bgGreen","doSyncActions","whenThisHappens","waitForUpTo","syncFromWatcher","event","diffFilePath","invalidatedPaths","invalidateFile","bold","invalidatedPath","removedApis","removeInvalidatedRegisteredApis","blue","relative","apiRootPath","gray","isInCheckPatternGroup","Object","values","some","pattern","autoloadTypes","autoloadModels","autoloadApis","syncUI","endsWith","entityId","getEntityIdFromPath","toRemove","filter","api","modelName","splice","indexOf","target","srcPath","join","replace","appRootPath","Error","destPath","recursive","warn","diffFilePaths","diffGroups","calculateDiffGroups","diffTypes","keys","includes","handleEntityChange","handleTypesOrFunctionsOrGeneratedChange","handleModelOrFrameChange","actionSyncConfig","diffFiles","r","matched","match","t","reload","entity","get","typeFilePath","names","fs","parentId","undefined","actionGenerateSchemas","generated","push","tsPaths","functions","actionSyncFilesToTargets","mergedGroup","model","frame","params","map","modelPath","namesRecord","getNamesFromId","frameName","actionGenerateServices","actionGenerateHttps","host","port","server","listen","content","Promise","all","overwrite","flat","paramsArray","res","dir","apiDir","realSrc","dst","copyFileWithReplaceCoreToShared","fromPath","toPath","oldFileContent","toString","newFileContent","nfc","checkExistsGenCode","templateKey","enumId","genPath","getTargetAndPath","subPath","fullPath","isExists","checkExists","enums","options","enumsKeys","name","constant","result","key","tpl","startsWith","componentId","p","uiPort","ui","fetch","method","catch","e","dim","message","form","templateOptions","_generateOptions"],"mappings":"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"}

package/dist/template/entity-converter.d.ts

@@ -1,5 +1,5 @@
 import z from "zod";
-import { EntityPropNode, RenderingNode } from "../types/types";
+import type { EntityPropNode, RenderingNode } from "../types/types";
 /**
  * 엔티티의 특정 subset을 RenderingNode로 변환합니다.
  * subset의 필드들을 Zod 타입으로 변환한 후 UI 렌더링용 노드로 만듭니다.

package/dist/template/entity-converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entity-converter.d.ts","sourceRoot":"","sources":["../../src/template/entity-converter.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAG/D;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,aAAa,CAAC,CA4DxB;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,CAwCvB"}
+{"version":3,"file":"entity-converter.d.ts","sourceRoot":"","sources":["../../src/template/entity-converter.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGpE;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAyDhG;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,CAsCvF"}

package/dist/template/entity-converter.js

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

package/dist/template/helpers.d.ts

@@ -1,5 +1,5 @@
-import { EntityNamesRecord } from "../entity/entity-manager";
-import { RelationProp } from "../types/types";
+import { type EntityNamesRecord } from "../entity/entity-manager";
+import { type RelationProp } from "../types/types";
 /**
  * Enum의 표시용 라벨을 가져옵니다.
  * OrderBy, SearchField 등 특수한 경우와 일반 Enum을 구분하여 처리합니다.

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

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