sonamu 0.6.0 → 0.7.0

package/src/syncer/syncer.ts

@@ -1,40 +1,36 @@
-import path, { dirname } from "path";
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { exists } from "../utils/fs-utils";
-import * as _ from "lodash-es";
-import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
-import { GenerateOptions } from "../types/types";
-import chalk from "chalk";
-import { TemplateKey, TemplateOptions } from "../types/types";
-import { Sonamu } from "../api/sonamu";
+import { hot } from "@sonamu-kit/hot-hook";
 import assert from "assert";
+import chalk from "chalk";
+import { mkdir, readFile, writeFile } from "fs/promises";
 import { minimatch } from "minimatch";
+import path, { dirname } from "path";
+import { group, unique } from "radashi";
+import type { z } from "zod";
+import { registeredApis } from "../api/decorators";
+import { Sonamu } from "../api/sonamu";
+import { EntityManager, type EntityNamesRecord } from "../entity/entity-manager";
+import { Naite } from "../naite/naite";
+import { TemplateManager } from "../template/template-manager";
+import type { GenerateOptions, PathAndCode } from "../types/types";
+import { TemplateKey, type TemplateOptions } from "../types/types";
 import { mapAsync, reduceAsync } from "../utils/async-utils";
 import { centerText } from "../utils/console-util";
+import { isTest } from "../utils/controller";
+import { exists } from "../utils/fs-utils";
+import type { AbsolutePath } from "../utils/path-utils";
 import { runWithGracefulShutdown } from "../utils/process-utils";
-import { AbsolutePath } from "../utils/path-utils";
+import { areFilesSame, findChangedFilesUsingChecksums, renewChecksums } from "./checksum";
 import { generateTemplate, renderTemplate } from "./code-generator";
-import { Template } from "../template";
-import {
-  FileType,
-  getChecksumPatternGroupInAbsolutePath,
-} from "./file-patterns";
-import {
-  findChangedFilesUsingChecksums,
-  renewChecksums,
-  areFilesSame,
-} from "./checksum";
+import { createEntity, delEntity } from "./entity-operations";
+import { type FileType, getChecksumPatternGroupInAbsolutePath } from "./file-patterns";
 import {
+  type LoadedApis,
+  type LoadedModels,
+  type LoadedTypes,
   loadApis,
   loadModels,
   loadTypes,
-  LoadedApis,
-  LoadedModels,
-  LoadedTypes,
 } from "./module-loader";
-import { createEntity, delEntity } from "./entity-operations";
-import { z } from "zod";
-import { hot } from "@sonamu-kit/hot-hook";
 
 type DiffGroups = {
   [key in FileType]: AbsolutePath[];
@@ -74,7 +70,7 @@ export class Syncer {
         // 싱크 액션이 끝나면 항상 체크섬을 다시 갱신합니다.
         await renewChecksums();
       },
-      { whenThisHappens: "SIGUSR2", waitForUpTo: 20000 }
+      { whenThisHappens: "SIGUSR2", waitForUpTo: 20000 },
     );
   }
 
@@ -84,10 +80,7 @@ export class Syncer {
    * 체크섬 파일 업데이트는 여기에서 하지 않습니다. 호출자가 합니다.
    * @param diffFilePath - 변경 파일들. 프로젝트 루트부터 "src/" 또는 "dist/"로 시작하는 상대 경로입니다. 예시: "src/application/user/user.model.ts"
    */
-  async syncFromWatcher(
-    event: string,
-    diffFilePath: AbsolutePath
-  ): Promise<void> {
+  async syncFromWatcher(event: string, diffFilePath: AbsolutePath): Promise<void> {
     if (event !== "change" && event !== "add" && event !== "unlink") {
       return;
     }
@@ -95,18 +88,33 @@ 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)) as AbsolutePath[];
+
+      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));
+    const isInCheckPatternGroup = Object.values(getChecksumPatternGroupInAbsolutePath()).some(
+      (pattern) => minimatch(diffFilePath, pattern),
+    );
 
     // 할 일(sync)이 있으면 합니다.
     if (isInCheckPatternGroup) {
@@ -122,25 +130,48 @@ export class Syncer {
     this.syncUI();
   }
 
-  private async copySharedToTargets(targets: string[]): Promise<void> {
+  removeInvalidatedRegisteredApis(
+    invalidatedPath: AbsolutePath,
+  ): (typeof registeredApis)[number][] {
+    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: string[]): Promise<void> {
     for (const target of targets) {
       // 지금 가져가려는 이 파일은 Sonamu 코드베이스의 일부입니다.
       // 그런데 dist 속 빌드된 소스 코드 파일이 필요한 것이 아니고, src에만 있는 텍스트 파일이 필요합니다.
       // 따라서 /src/에서 찾습니다.
       const srcPath = path.join(
         import.meta.dirname.replace("/dist/", "/src/"),
-        `../shared/${target}.shared.ts.txt`
+        `../shared/${target}.shared.ts.txt`,
       );
       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;
@@ -148,10 +179,10 @@ export class Syncer {
 
       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)),
+        );
     }
   }
 
@@ -173,9 +204,7 @@ export class Syncer {
    * @param diffFilePaths - 변경된 파일들의 절대 경로 목록
    * @returns diffTypes - 변경된 파일의 타입 목록 (entity, types, model 등)
    */
-  private async doSyncActions(
-    diffFilePaths: AbsolutePath[]
-  ): Promise<{ diffTypes: string[] }> {
+  async doSyncActions(diffFilePaths: AbsolutePath[]): Promise<{ diffTypes: string[] }> {
     const diffGroups = this.calculateDiffGroups(diffFilePaths);
     const diffTypes = Object.keys(diffGroups);
 
@@ -210,39 +239,28 @@ export class Syncer {
     };
   }
 
-  private calculateDiffGroups(diffFiles: AbsolutePath[]): DiffGroups {
-    return _.groupBy(diffFiles, (r) => {
-      const matched = r.match(
-        /\.(model|types|functions|entity|generated|frame|config)\.[tj]s/
-      );
+  calculateDiffGroups(diffFiles: AbsolutePath[]): DiffGroups {
+    return group(diffFiles, (r) => {
+      const matched = r.match(/\.(model|types|functions|entity|generated|frame|config)\.[tj]s/);
       return matched?.[1] ?? "unknown";
     }) as unknown as DiffGroups;
   }
 
-  private async handleEntityChange(
-    diffGroups: DiffGroups,
-    diffTypes: string[]
-  ): Promise<void> {
-    // console.log(
-    //   chalk.gray(
-    //     `[Processing] Handling entity changes: ${diffGroups["entity"]?.map((p) => path.relative(Sonamu.apiRootPath, p)).join(", ")}`
-    //   )
-    // );
+  async handleEntityChange(diffGroups: DiffGroups, diffTypes: string[]): Promise<void> {
+    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 파일의 경로입니다.
       const typeFilePath = path.join(
         Sonamu.apiRootPath,
-        `src/application/${entity.names.fs}/${entity.names.fs}.types.ts`
+        `src/application/${entity.names.fs}/${entity.names.fs}.types.ts`,
       );
       if (entity.parentId === undefined && !(await exists(typeFilePath))) {
         await generateTemplate("init_types", { entityId });
@@ -251,24 +269,20 @@ export class Syncer {
 
     await this.actionGenerateSchemas();
 
-    diffGroups["generated"] = _.uniq([
-      ...(diffGroups["generated"] ?? []),
-      path.join(
-        Sonamu.apiRootPath,
-        "src/application/sonamu.generated.ts"
-      ) as AbsolutePath,
+    diffGroups.generated = unique([
+      ...(diffGroups.generated ?? []),
+      path.join(Sonamu.apiRootPath, "src/application/sonamu.generated.ts") as AbsolutePath,
     ]);
     diffTypes.push("generated");
   }
 
-  private async handleTypesOrFunctionsOrGeneratedChange(
-    diffGroups: DiffGroups
-  ): Promise<FileType[]> {
-    const tsPaths = _.uniq([
-      ...(diffGroups["types"] ?? []),
-      ...(diffGroups["functions"] ?? []),
-      ...(diffGroups["generated"] ?? []),
+  async handleTypesOrFunctionsOrGeneratedChange(diffGroups: DiffGroups): Promise<FileType[]> {
+    const tsPaths = unique([
+      ...(diffGroups.types ?? []),
+      ...(diffGroups.functions ?? []),
+      ...(diffGroups.generated ?? []),
     ]);
+    Naite.t("handleTypesOrFunctionsOrGeneratedChange", { diffGroups });
 
     // console.log(
     //   chalk.gray(
@@ -281,13 +295,9 @@ export class Syncer {
     return [];
   }
 
-  private async handleModelOrFrameChange(
-    diffGroups: DiffGroups
-  ): Promise<void> {
-    const mergedGroup = [
-      ...(diffGroups["model"] ?? []),
-      ...(diffGroups["frame"] ?? []),
-    ];
+  async handleModelOrFrameChange(diffGroups: DiffGroups): Promise<void> {
+    Naite.t("handleModelOrFrameChange", { diffGroups });
+    const mergedGroup = [...(diffGroups.model ?? []), ...(diffGroups.frame ?? [])];
 
     // console.log(
     //   chalk.gray(
@@ -330,13 +340,11 @@ export class Syncer {
     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
-        );
-      })
+        await writeFile(path.join(Sonamu.appRootPath, target, ".sonamu.env"), content);
+      }),
     );
   }
 
@@ -344,7 +352,7 @@ export class Syncer {
    * sonamu.generated.ts와 sonamu.generated.sso.ts를 생성합니다.
    * @returns 생성된 파일 경로 배열.
    */
-  private async actionGenerateSchemas(): Promise<AbsolutePath[]> {
+  async actionGenerateSchemas(): Promise<AbsolutePath[]> {
     return (
       await Promise.all([
         generateTemplate("generated_sso", {}, { overwrite: true }),
@@ -360,18 +368,19 @@ export class Syncer {
    * @param paramsArray
    * @returns 생성된 파일 경로 배열.
    */
-  private async actionGenerateServices(
+  async actionGenerateServices(
     paramsArray: {
       namesRecord: EntityNamesRecord;
-    }[]
+    }[],
   ): Promise<string[]> {
+    Naite.t("actionGenerateServices", paramsArray);
     return (
       await Promise.all(
         paramsArray.map(async (params) =>
-          generateTemplate("service", params, {
+          generateTemplate("service", params as TemplateOptions["service"], {
             overwrite: true,
-          })
-        )
+          }),
+        ),
       )
     )
       .flat()
@@ -382,11 +391,11 @@ export class Syncer {
    * sonamu.generated.http를 생성합니다.
    * @returns 생성된 파일 경로.
    */
-  private async actionGenerateHttps(): Promise<AbsolutePath> {
+  async actionGenerateHttps(): Promise<AbsolutePath> {
     const [res] = await generateTemplate(
       "generated_http",
-      {},
-      { overwrite: true }
+      { entityId: "dummy" },
+      { overwrite: true },
     );
     assert(res);
     return res;
@@ -397,9 +406,7 @@ export class Syncer {
    * @param tsPaths
    * @returns 복사된 파일 경로 배열.
    */
-  private async actionSyncFilesToTargets(
-    tsPaths: AbsolutePath[]
-  ): Promise<string[]> {
+  async actionSyncFilesToTargets(tsPaths: AbsolutePath[]): Promise<string[]> {
     const { targets } = Sonamu.config.sync;
     const { dir: apiDir } = Sonamu.config.api;
 
@@ -415,23 +422,20 @@ export class Syncer {
               if (!(await exists(dir))) {
                 await mkdir(dir, { 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();
   }
 
-  private async copyFileWithReplaceCoreToShared(
-    fromPath: string,
-    toPath: string
-  ) {
+  private async copyFileWithReplaceCoreToShared(fromPath: string, toPath: string) {
     if (!(await exists(fromPath))) {
       return;
     }
@@ -439,16 +443,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);
   }
@@ -463,11 +459,12 @@ export class Syncer {
   async checkExistsGenCode(
     entityId: string,
     templateKey: TemplateKey,
-    enumId?: string
+    enumId?: string,
   ): Promise<{ subPath: string; fullPath: string; isExists: boolean }> {
-    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);
@@ -487,27 +484,22 @@ export class Syncer {
   async checkExists(
     entityId: string,
     enums: {
-      [name: string]: z.ZodEnum<any>;
-    }
+      [name: string]: z.ZodEnum<Readonly<Record<string, string | number>>>;
+    },
   ): Promise<Record<`${TemplateKey}${string}`, boolean>> {
     const keys: TemplateKey[] = TemplateKey.options;
     const names = EntityManager.getNamesFromId(entityId);
-    const enumsKeys = Object.keys(enums).filter(
-      (name) => name !== names.constant
-    );
+    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
-            );
+            const { target, path: p } = tpl.getTargetAndPath(names, componentId);
             result[`${key}__${componentId}`] = await exists(
-              path.join(Sonamu.appRootPath, target, p)
+              path.join(Sonamu.appRootPath, target, p),
             );
           });
           return result;
@@ -518,7 +510,7 @@ export class Syncer {
         if (target.includes(":target")) {
           await mapAsync(targets, async (t) => {
             result[`${key}__${t}`] = await exists(
-              path.join(Sonamu.appRootPath, target.replace(":target", t), p)
+              path.join(Sonamu.appRootPath, target.replace(":target", t), p),
             );
           });
         } else {
@@ -527,26 +519,24 @@ export class Syncer {
 
         return result;
       },
-      {} as Record<`${TemplateKey}${string}`, boolean>
+      {} as Record<`${TemplateKey}${string}`, boolean>,
     );
   }
 
   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}`)));
+    }
   }
 
   /**
    * 하위호환용 프록시 메소드입니다.
    */
-  async createEntity(
-    form: Omit<TemplateOptions["entity"], "title"> & { title?: string }
-  ) {
+  async createEntity(form: TemplateOptions["entity"]) {
     return await createEntity(form);
   }
 
@@ -560,18 +550,21 @@ export class Syncer {
   /**
    * 하위호환용 프록시 메소드입니다.
    */
-  async generateTemplate(
-    key: TemplateKey,
-    templateOptions: any,
-    _generateOptions?: GenerateOptions
-  ) {
+  async generateTemplate<T extends TemplateKey>(
+    key: T,
+    templateOptions: TemplateOptions[T],
+    _generateOptions?: GenerateOptions,
+  ): Promise<AbsolutePath[]> {
     return await generateTemplate(key, templateOptions, _generateOptions);
   }
 
   /**
    * 하위호환용 프록시 메소드입니다.
    */
-  async renderTemplate(key: TemplateKey, templateOptions: any) {
+  async renderTemplate<T extends keyof TemplateOptions>(
+    key: T,
+    templateOptions: TemplateOptions[T],
+  ): Promise<PathAndCode[]> {
     return await renderTemplate(key, templateOptions);
   }
 

package/src/template/entity-converter.ts

@@ -1,18 +1,16 @@
+import assert from "assert";
 import z from "zod";
 import { EntityManager } from "../entity/entity-manager";
 import { ServiceUnavailableException } from "../exceptions/so-exceptions";
-import { EntityPropNode, RenderingNode } from "../types/types";
-import { zodTypeToRenderingNode, propToZodType } from "./zod-converter";
+import type { EntityPropNode, RenderingNode } from "../types/types";
+import { propToZodType, zodTypeToRenderingNode } from "./zod-converter";
 
 /**
  * 엔티티의 특정 subset을 RenderingNode로 변환합니다.
  * subset의 필드들을 Zod 타입으로 변환한 후 UI 렌더링용 노드로 만듭니다.
  * object와 array의 경우 적절한 pick 필드를 자동으로 선택합니다.
  */
-export async function getColumnsNode(
-  entityId: string,
-  subsetKey: string
-): Promise<RenderingNode> {
+export async function getColumnsNode(entityId: string, subsetKey: string): Promise<RenderingNode> {
   const entity = EntityManager.get(entityId);
   const subset = entity.subsets[subsetKey];
   if (subset === undefined) {
@@ -24,16 +22,15 @@ export async function getColumnsNode(
     children: propNodes,
   };
 
-  const columnsZodType = (await propNodeToZodType(
-    rootPropNode
-  )) as z.ZodObject<any>;
+  // biome-ignore lint/suspicious/noExplicitAny: zod 스키마를 로드할 때 사용하는 타입
+  const columnsZodType = (await propNodeToZodType(rootPropNode)) as z.ZodObject<any>;
 
   const columnsNode = zodTypeToRenderingNode(columnsZodType);
-  columnsNode.children = columnsNode.children!.map((child) => {
+  assert(columnsNode.children !== undefined, "columnsNode.children is undefined");
+  columnsNode.children = columnsNode.children.map((child) => {
     if (child.renderType === "object") {
-      const pickedCol = child.children!.find((cc) =>
-        ["title", "name"].includes(cc.name)
-      );
+      assert(child.children !== undefined, "child.children is undefined");
+      const pickedCol = child.children.find((cc) => ["title", "name"].includes(cc.name));
       if (pickedCol) {
         return {
           ...child,
@@ -50,9 +47,7 @@ export async function getColumnsNode(
       child.element &&
       child.element.renderType === "object"
     ) {
-      const pickedCol = child.element!.children!.find((cc) =>
-        ["title", "name"].includes(cc.name)
-      );
+      const pickedCol = child.element?.children?.find((cc) => ["title", "name"].includes(cc.name));
       if (pickedCol) {
         return {
           ...child,
@@ -78,9 +73,7 @@ export async function getColumnsNode(
  * EntityPropNode를 Zod 타입으로 변환합니다.
  * plain, array, object 세 가지 nodeType을 재귀적으로 처리합니다.
  */
-export async function propNodeToZodType(
-  propNode: EntityPropNode
-): Promise<z.ZodTypeAny> {
+export async function propNodeToZodType(propNode: EntityPropNode): Promise<z.ZodTypeAny> {
   if (propNode.nodeType === "plain") {
     return propToZodType(propNode.prop);
   } else if (propNode.nodeType === "array") {
@@ -102,15 +95,13 @@ export async function propNodeToZodType(
       }
     }
   } 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;
-      },
-      {} as any
+    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)] as const;
+      }),
     );
+    const obj = Object.fromEntries(entries);
 
     if (propNode.prop?.nullable === true) {
       return z.object(obj).nullable();