sonamu 0.4.14 → 0.5.1

package/src/syncer/syncer.ts

@@ -1,15 +1,19 @@
 import path, { dirname } from "path";
 import { globAsync, importMultiple } from "../utils/utils";
-import fs from "fs-extra";
+import { createReadStream } from "fs";
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { exists } from "../utils/fs-utils";
 import crypto from "crypto";
 import equal from "fast-deep-equal";
-import _ from "lodash";
+import _, { chunk } from "lodash";
 import inflection from "inflection";
 import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
 import ts from "typescript";
 import {
   ApiParam,
   ApiParamType,
+  EntityProp,
+  EntityPropNode,
   isBelongsToOneRelationProp,
   isBigIntegerProp,
   isBooleanProp,
@@ -29,9 +33,6 @@ import {
   isTimestampProp,
   isUuidProp,
   isVirtualProp,
-  EntityProp,
-  EntityPropNode,
-  SQLDateTimeString,
 } from "../types/types";
 import {
   ApiDecoratorOptions,
@@ -73,11 +74,17 @@ import { Template__view_search_input } from "../templates/view_search_input.temp
 import { Template__view_list_columns } from "../templates/view_list_columns.template";
 import { Template__generated_http } from "../templates/generated_http.template";
 import { Sonamu } from "../api/sonamu";
-import { execSync } from "child_process";
 import { Template__generated_sso } from "../templates/generated_sso.template";
-import { Template__kysely_interface } from "../templates/kysely_types.template";
-import { DB } from "../database/db";
 import { setTimeout as setTimeoutPromises } from "timers/promises";
+import assert from "assert";
+import * as swc from "@swc/core";
+import { minimatch } from "minimatch";
+import {
+  everyAsync,
+  filterAsync,
+  mapAsync,
+  reduceAsync,
+} from "../utils/async-utils";
 
 type FileType =
   | "model"
@@ -122,8 +129,19 @@ export class Syncer {
   models: { [modelName: string]: unknown } = {};
   isSyncing: boolean = false;
 
+  public checksumPatternGroup: GlobPattern = {
+    /* 원본 체크 */
+    entity: Sonamu.apiRootPath + "/src/application/**/*.entity.json",
+    types: Sonamu.apiRootPath + "/src/application/**/*.types.ts",
+    generated: Sonamu.apiRootPath + "/src/application/sonamu.generated.ts",
+    functions: Sonamu.apiRootPath + "/src/application/**/*.functions.ts",
+    /* compiled-JS 체크 */
+    model: Sonamu.apiRootPath + "/dist/application/**/*.model.js",
+    frame: Sonamu.apiRootPath + "/dist/application/**/*.frame.js",
+  };
+
   get checksumsPath(): string {
-    return path.join(Sonamu.apiRootPath, "/.so-checksum");
+    return path.join(Sonamu.apiRootPath, "/sonamu.lock");
   }
   public constructor() {}
 
@@ -141,7 +159,7 @@ export class Syncer {
         const srcCodePath = path
           .join(currentDirname, `../shared/${target}.shared.ts.txt`)
           .replace("/dist/", "/src/");
-        if (!fs.existsSync(srcCodePath)) {
+        if (!(await exists(srcCodePath))) {
           return;
         }
 
@@ -153,7 +171,7 @@ export class Syncer {
 
         const srcChecksum = await this.getChecksumOfFile(srcCodePath);
         const dstChecksum = await (async () => {
-          if (fs.existsSync(dstCodePath) === false) {
+          if (!(await exists(dstCodePath))) {
             return "";
           }
           return this.getChecksumOfFile(dstCodePath);
@@ -162,7 +180,7 @@ export class Syncer {
         if (srcChecksum === dstChecksum) {
           return;
         }
-        fs.writeFileSync(dstCodePath, fs.readFileSync(srcCodePath));
+        await writeFile(dstCodePath, await readFile(srcCodePath));
         console.log(chalk.blue("shared.ts is synced"));
       })
     );
@@ -175,7 +193,7 @@ export class Syncer {
     // 비교
     const isSame = equal(currentChecksums, previousChecksums);
     if (isSame) {
-      const msg = "Every files are synced!";
+      const msg = "All files are synced!";
       const margin = (process.stdout.columns - msg.length) / 2;
       console.log(
         chalk.black.bgGreen(" ".repeat(margin) + msg + " ".repeat(margin))
@@ -209,12 +227,35 @@ export class Syncer {
     const diffFiles = diff.map((r) => r.path);
     console.log("Changed Files: ", diffFiles);
 
+    const { changedChecksums } = await this.doSyncActions(
+      diffFiles,
+      currentChecksums
+    );
+    // checksum 오버라이드 (액션 실행 과정 중간에 체크섬이 바뀐 경우)
+    currentChecksums = changedChecksums ?? currentChecksums;
+
+    // 저장
+    await this.saveChecksums(currentChecksums);
+
+    // 싱크 종료
+    this.isSyncing = false;
+    abc.abort();
+    process.off("SIGUSR2", onSIGUSR2);
+  }
+
+  async doSyncActions(
+    diffFiles: string[],
+    currentChecksums?: PathAndChecksum[]
+  ): Promise<{
+    diffTypes: string[];
+    changedChecksums?: PathAndChecksum[];
+  }> {
     // 다른 부분 찾아 액션
     const diffGroups = _.groupBy(diffFiles, (r) => {
       const matched = r.match(
         /\.(model|types|functions|entity|generated|frame)\.[tj]s/
       );
-      return matched![1];
+      return matched?.[1] ?? "unknown";
     }) as unknown as DiffGroups;
 
     // 변경된 파일들을 타입별로 분리하여 각 타입별 액션 처리
@@ -223,19 +264,24 @@ export class Syncer {
     // 트리거: entity, types
     // 액션: 스키마 생성
     if (diffTypes.includes("entity") || diffTypes.includes("types")) {
-      console.log("// 액션: 스키마 생성");
+      await EntityManager.reload();
+
       await this.actionGenerateSchemas();
 
-      if (
-        DB.baseConfig?.client === "kysely" &&
-        DB.baseConfig.types?.enabled !== false
-      ) {
-        console.log("// 액션: kysely 인터페이스 생성");
-        await this.generateTemplate(
-          "kysely_interface",
-          {},
-          { overwrite: true }
+      // types 생성(entity 새로 추가된 경우)
+      // parentId가 없고, types가 없는 경우에만 생성
+      const entityId = this.getEntityIdFromPath([
+        ...(diffGroups["entity"] ?? []),
+      ])[0];
+      if (entityId) {
+        const entity = EntityManager.get(entityId);
+        const typeFilePath = path.join(
+          Sonamu.apiRootPath,
+          `src/application/${entity.names.fs}/${entity.names.fs}.types.ts`
         );
+        if (entity.parentId === undefined && !(await exists(typeFilePath))) {
+          await this.generateTemplate("init_types", { entityId });
+        }
       }
 
       // generated 싱크까지 동시에 처리 후 체크섬 갱신
@@ -244,7 +290,11 @@ export class Syncer {
         "/src/application/sonamu.generated.ts",
       ]);
       diffTypes.push("generated");
-      currentChecksums = await this.getCurrentChecksums();
+
+      // fullSync인 경우만 실행
+      if (currentChecksums) {
+        currentChecksums = await this.getCurrentChecksums();
+      }
     }
 
     // 트리거: types, enums, generated 변경시
@@ -254,8 +304,6 @@ export class Syncer {
       diffTypes.includes("functions") ||
       diffTypes.includes("generated")
     ) {
-      console.log("// 액션: 파일 싱크 types / functions / generated");
-
       const tsPaths = _.uniq(
         [
           ...(diffGroups["types"] ?? []),
@@ -268,15 +316,22 @@ export class Syncer {
 
     // 트리거: model
     if (diffTypes.includes("model") || diffTypes.includes("frame")) {
-      console.log("// 액션: 서비스 생성");
       const mergedGroup = [
         ...(diffGroups["model"] ?? []),
         ...(diffGroups["frame"] ?? []),
       ];
+
+      // registeredApis 초기화
+      await this.autoloadModels();
+
+      // Syncer.apis 초기화
+      await this.autoloadApis();
+
       const params: { namesRecord: EntityNamesRecord; modelTsPath: string }[] =
         mergedGroup.map((modelPath) => {
           if (modelPath.endsWith(".model.js")) {
             const entityId = this.getEntityIdFromPath([modelPath])[0];
+            assert(entityId);
             return {
               namesRecord: EntityManager.getNamesFromId(entityId),
               modelTsPath: path.join(
@@ -289,6 +344,7 @@ export class Syncer {
           }
           if (modelPath.endsWith("frame.js")) {
             const [, frameName] = modelPath.match(/.+\/(.+)\.frame.js$/) ?? [];
+            assert(frameName);
             return {
               namesRecord: EntityManager.getNamesFromId(frameName),
               modelTsPath: path.join(
@@ -303,24 +359,122 @@ export class Syncer {
         });
       await this.actionGenerateServices(params);
 
-      console.log("// 액션: HTTP파일 생성");
       await this.actionGenerateHttps();
     }
 
-    // 저장
-    await this.saveChecksums(currentChecksums);
+    return {
+      diffTypes,
+      changedChecksums: currentChecksums,
+    };
+  }
 
-    // 싱크 종료
-    this.isSyncing = false;
-    abc.abort();
-    process.off("SIGUSR2", onSIGUSR2);
+  async syncFromWatcher(diffFiles: string[]): Promise<void> {
+    const tsFiles = diffFiles.filter((file) => file.endsWith(".ts"));
+    const jsonFiles = diffFiles.filter((file) => file.endsWith(".json"));
+
+    // transpile (성능 이슈를 고려하여 5개 동시 실행)
+    const chunks = chunk(tsFiles, 5);
+    let transpiledFilePaths: string[] = [];
+    for (const chunk of chunks) {
+      const _transpiledFilePaths = await Promise.all(
+        chunk.map(async (diffFile) => {
+          const { code, map } = await swc.transformFile(diffFile, {
+            module: {
+              type: "commonjs",
+            },
+            jsc: {
+              parser: {
+                syntax: "typescript",
+                decorators: true,
+              },
+              target: "es5",
+            },
+            sourceMaps: true,
+          });
+
+          const jsPath = diffFile
+            .replace("/src/", "/dist/")
+            .replace(".ts", ".js");
+          await mkdir(path.dirname(jsPath), { recursive: true }); // 파일 새로 추가된 경우 디렉토리 생성
+          await writeFile(jsPath, code);
+
+          if (map) {
+            const mapPath = jsPath + ".map";
+            await mkdir(path.dirname(mapPath), { recursive: true });
+            await writeFile(mapPath, map);
+
+            const sourceMapComment =
+              "\n//# sourceMappingURL=" + path.basename(mapPath);
+            await writeFile(jsPath, sourceMapComment, {
+              flag: "a" /*파일 끝에 붙이기만 해요*/,
+            });
+          }
+
+          console.log(
+            chalk.bold("Transpiled: ") +
+              chalk.blue(`${jsPath.replace(Sonamu.apiRootPath, "api")}`)
+          );
+          return jsPath;
+        })
+      );
+      transpiledFilePaths.push(..._transpiledFilePaths);
+    }
+
+    // module reload - doSyncActions 전에 캐시 삭제
+    function clearModuleAndDependents(filePath: string) {
+      const resolved = require.resolve(filePath);
+      const toDelete = new Set([resolved]);
+
+      // 이 파일을 children으로 가진 모듈 찾기
+      Object.keys(require.cache).forEach((key) => {
+        const mod = require.cache[key];
+        if (mod?.children?.some((child) => child.id === resolved)) {
+          toDelete.add(key);
+        }
+      });
+
+      toDelete.forEach((key) => {
+        if (key.includes("dist/index.js")) {
+          process.kill(process.pid, "SIGUSR2");
+        }
+        delete require.cache[key];
+        // console.debug(
+        //   chalk.bold("ModuleCleared: ") +
+        //     chalk.blue(`${key.replace(Sonamu.apiRootPath, "api")}`)
+        // );
+      });
+    }
+    transpiledFilePaths.map((filePath) => {
+      clearModuleAndDependents(filePath);
+    });
+
+    // doSyncActions
+    const allFilePaths = [...tsFiles, ...transpiledFilePaths, ...jsonFiles];
+    const targetFilePaths = allFilePaths
+      .filter((filePath) => {
+        return Object.values(this.checksumPatternGroup).some((pattern) =>
+          minimatch(filePath, pattern)
+        );
+      })
+      .map((filePath) => "/" + path.relative(Sonamu.apiRootPath, filePath));
+    await this.doSyncActions(targetFilePaths);
+
+    this.apis = [];
+    this.types = {};
+    this.models = {};
+    await this.autoloadTypes();
+    await this.autoloadModels();
+    await this.autoloadApis();
+
+    this.syncUI();
   }
 
   getEntityIdFromPath(filePaths: string[]): string[] {
     return _.uniq(
       filePaths.map((p) => {
         const matched = p.match(/application\/(.+)\//);
-        return inflection.camelize(matched![1].replace(/\-/g, "_"));
+        assert(matched && matched[1]);
+        return inflection.camelize(matched[1].replace(/\-/g, "_"));
       })
     );
   }
@@ -361,15 +515,16 @@ export class Syncer {
       {},
       { overwrite: true }
     );
+    assert(res);
     return res;
   }
 
   async copyFileWithReplaceCoreToShared(fromPath: string, toPath: string) {
-    if (!fs.existsSync(fromPath)) {
+    if (!(await exists(fromPath))) {
       return;
     }
 
-    const oldFileContent = fs.readFileSync(fromPath).toString();
+    const oldFileContent = (await readFile(fromPath)).toString();
 
     const newFileContent = (() => {
       const nfc = oldFileContent.replace(
@@ -383,13 +538,12 @@ export class Syncer {
         return nfc;
       }
     })();
-    return fs.writeFile(toPath, newFileContent);
+    return writeFile(toPath, newFileContent);
   }
 
   async actionSyncFilesToTargets(tsPaths: string[]): Promise<string[]> {
     const { targets } = Sonamu.config.sync;
     const { dir: apiDir } = Sonamu.config.api;
-    const { appRootPath } = Sonamu;
 
     return (
       await Promise.all(
@@ -401,12 +555,14 @@ export class Syncer {
                 .replace(`/${apiDir}/`, `/${target}/`)
                 .replace("/application/", "/services/");
               const dir = dirname(dst);
-              if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
+              if (!(await exists(dir))) {
+                await mkdir(dir, { recursive: true });
               }
               console.log(
-                "COPIED ",
-                chalk.blue(dst.replace(appRootPath + "/", ""))
+                chalk.bold("Copied: ") +
+                  chalk.blue(
+                    `Copied: ${dst.replace(Sonamu.appRootPath + "/", "")}`
+                  )
               );
               await this.copyFileWithReplaceCoreToShared(realSrc, dst);
               return dst;
@@ -418,22 +574,13 @@ export class Syncer {
   }
 
   async getCurrentChecksums(): Promise<PathAndChecksum[]> {
-    const PatternGroup: GlobPattern = {
-      /* 원본 체크 */
-      entity: Sonamu.apiRootPath + "/src/application/**/*.entity.json",
-      types: Sonamu.apiRootPath + "/src/application/**/*.types.ts",
-      generated: Sonamu.apiRootPath + "/src/application/sonamu.generated.ts",
-      functions: Sonamu.apiRootPath + "/src/application/**/*.functions.ts",
-      /* compiled-JS 체크 */
-      model: Sonamu.apiRootPath + "/dist/application/**/*.model.js",
-      frame: Sonamu.apiRootPath + "/dist/application/**/*.frame.js",
-    };
-
     const filePaths = (
       await Promise.all(
-        Object.entries(PatternGroup).map(async ([_fileType, pattern]) => {
-          return globAsync(pattern);
-        })
+        Object.entries(this.checksumPatternGroup).map(
+          async ([_fileType, pattern]) => {
+            return globAsync(pattern);
+          }
+        )
       )
     )
       .flat()
@@ -454,27 +601,29 @@ export class Syncer {
   }
 
   async getPreviousChecksums(): Promise<PathAndChecksum[]> {
-    if (fs.existsSync(this.checksumsPath) === false) {
+    if (!(await exists(this.checksumsPath))) {
       return [];
     }
 
-    const previousChecksums = (await fs.readJSON(
-      this.checksumsPath
-    )) as PathAndChecksum[];
+    const previousChecksums = JSON.parse(
+      (await readFile(this.checksumsPath, "utf-8"))
+    ) as PathAndChecksum[];
     return previousChecksums;
   }
 
   async saveChecksums(checksums: PathAndChecksum[]): Promise<void> {
-    await fs.writeJSON(this.checksumsPath, checksums, {
-      spaces: 2,
-    });
+    await writeFile(
+      this.checksumsPath,
+      JSON.stringify(checksums, null, 2),
+      "utf-8"
+    );
     console.log("checksum saved", this.checksumsPath);
   }
 
   async getChecksumOfFile(filePath: string): Promise<string> {
     return new Promise<string>((resolve, reject) => {
       const hash = crypto.createHash("sha1");
-      const input = fs.createReadStream(filePath);
+      const input = createReadStream(filePath);
       input.on("error", reject);
       input.on("data", function (chunk: any) {
         hash.update(chunk);
@@ -488,7 +637,7 @@ export class Syncer {
   async readApisFromFile(filePath: string) {
     const sourceFile = ts.createSourceFile(
       filePath,
-      fs.readFileSync(filePath).toString(),
+      (await readFile(filePath)).toString(),
       ts.ScriptTarget.Latest
     );
 
@@ -647,6 +796,7 @@ export class Syncer {
           t: "object",
           props: literalNode.members.map((member) => {
             if (ts.isIndexSignatureDeclaration(member)) {
+              assert(member.parameters[0]);
               const res = this.resolveParamDec({
                 name: member.parameters[0].name as ts.Identifier,
                 type: member.parameters[0].type as ts.TypeNode,
@@ -791,12 +941,15 @@ export class Syncer {
     );
     // console.debug(chalk.yellow(`autoload:models @ ${pathPattern}`));
 
-    const filePaths = (await globAsync(pathPattern)).filter((path) => {
-      // src 디렉터리 내에 있는 해당 파일이 존재할 경우에만 로드
-      // 삭제된 파일이지만 dist에 남아있는 경우 BaseSchema undefined 에러 방지
-      const srcPath = path.replace("/dist/", "/src/").replace(".js", ".ts");
-      return fs.existsSync(srcPath);
-    });
+    const filePaths = await filterAsync(
+      await globAsync(pathPattern),
+      async (path) => {
+        // src 디렉터리 내에 있는 해당 파일이 존재할 경우에만 로드
+        // 삭제된 파일이지만 dist에 남아있는 경우 BaseSchema undefined 에러 방지
+        const srcPath = path.replace("/dist/", "/src/").replace(".js", ".ts");
+        return await exists(srcPath);
+      }
+    );
     const modules = await importMultiple(filePaths);
     const functions = modules
       .map(({ imported }) => Object.entries(imported))
@@ -822,16 +975,15 @@ export class Syncer {
     ];
     // console.debug(chalk.magenta(`autoload:types @ ${pathPatterns.join("\n")}`));
 
-    const filePaths = (
-      await Promise.all(pathPatterns.map((pattern) => globAsync(pattern)))
-    )
-      .flat()
-      .filter((path) => {
+    const filePaths = await filterAsync(
+      (await mapAsync(pathPatterns, globAsync)).flat(),
+      async (path) => {
         // src 디렉터리 내에 있는 해당 파일이 존재할 경우에만 로드
         // 삭제된 파일이지만 dist에 남아있는 경우 BaseSchema undefined 에러 방지
         const srcPath = path.replace("/dist/", "/src/").replace(".js", ".ts");
-        return fs.existsSync(srcPath);
-      });
+        return await exists(srcPath);
+      }
+    );
     const modules = await importMultiple(filePaths, doRefresh);
     const functions = modules
       .map(({ imported }) => Object.entries(imported))
@@ -877,8 +1029,6 @@ export class Syncer {
       return new Template__view_enums_dropdown();
     } else if (key === "view_enums_buttonset") {
       return new Template__view_enums_buttonset();
-    } else if (key === "kysely_interface") {
-      return new Template__kysely_interface();
     } else {
       throw new BadRequestException(`잘못된 템플릿 키 ${key}`);
     }
@@ -1012,13 +1162,13 @@ export class Syncer {
     return await Promise.all(
       dstFilePaths.map(async (dstFilePath) => {
         const dir = path.dirname(dstFilePath);
-        if (fs.existsSync(dir) === false) {
-          fs.mkdirSync(dir, { recursive: true });
+        if (!(await exists(dir))) {
+          await mkdir(dir, { recursive: true });
         }
-        fs.writeFileSync(dstFilePath, pathAndCode.code);
+        await writeFile(dstFilePath, pathAndCode.code);
         console.log(
-          "GENERATED ",
-          chalk.blue(dstFilePath.replace(appRootPath + "/", ""))
+          chalk.bold("Generated: ") +
+            chalk.blue(`${dstFilePath.replace(appRootPath + "/", "")}`)
         );
         return dstFilePath;
       })
@@ -1047,18 +1197,19 @@ export class Syncer {
       )
     ).flat();
 
-    const filteredPathAndCodes: PathAndCode[] = (() => {
+    const filteredPathAndCodes: PathAndCode[] = await (async () => {
       if (generateOptions.overwrite === true) {
         return pathAndCodes;
       } else {
-        return pathAndCodes.filter((pathAndCode) => {
+        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 dstFilePaths.every(
-            (dstPath) => fs.existsSync(dstPath) === false
+          return await everyAsync(
+            dstFilePaths,
+            async (dstPath) => !(await exists(dstPath))
           );
         });
       }
@@ -1076,11 +1227,11 @@ export class Syncer {
     );
   }
 
-  checkExistsGenCode(
+  async checkExistsGenCode(
     entityId: string,
     templateKey: TemplateKey,
     enumId?: string
-  ): { subPath: string; fullPath: string; isExists: boolean } {
+  ): Promise<{ subPath: string; fullPath: string; isExists: boolean }> {
     const { target, path: genPath } = this.getTemplate(
       templateKey
     ).getTargetAndPath(EntityManager.getNamesFromId(entityId), enumId);
@@ -1090,32 +1241,33 @@ export class Syncer {
     return {
       subPath,
       fullPath,
-      isExists: fs.existsSync(fullPath),
+      isExists: await exists(fullPath),
     };
   }
 
-  checkExists(
+  async checkExists(
     entityId: string,
     enums: {
       [name: string]: z.ZodEnum<any>;
     }
-  ): Record<`${TemplateKey}${string}`, boolean> {
+  ): 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
     );
 
-    return keys.reduce(
-      (result, key) => {
+    return await reduceAsync(
+      keys,
+      async (result, key) => {
         const tpl = this.getTemplate(key);
         if (key.startsWith("view_enums")) {
-          enumsKeys.map((componentId) => {
+          await mapAsync(enumsKeys, async (componentId) => {
             const { target, path: p } = tpl.getTargetAndPath(
               names,
               componentId
             );
-            result[`${key}__${componentId}`] = fs.existsSync(
+            result[`${key}__${componentId}`] = await exists(
               path.join(Sonamu.appRootPath, target, p)
             );
           });
@@ -1125,13 +1277,13 @@ export class Syncer {
         const { target, path: p } = tpl.getTargetAndPath(names);
         const { targets } = Sonamu.config.sync;
         if (target.includes(":target")) {
-          targets.map((t) => {
-            result[`${key}__${t}`] = fs.existsSync(
+          await mapAsync(targets, async (t) => {
+            result[`${key}__${t}`] = await exists(
               path.join(Sonamu.appRootPath, target.replace(":target", t), p)
             );
           });
         } else {
-          result[key] = fs.existsSync(path.join(Sonamu.appRootPath, target, p));
+          result[key] = await exists(path.join(Sonamu.appRootPath, target, p));
         }
 
         return result;
@@ -1221,13 +1373,13 @@ export class Syncer {
     } else if (isTimeProp(prop)) {
       zodType = z.string().length(8);
     } else if (isDateTimeProp(prop)) {
-      zodType = SQLDateTimeString;
+      zodType = z.date();
     } else if (isTimestampProp(prop)) {
-      zodType = SQLDateTimeString;
+      zodType = z.date();
     } else if (isJsonProp(prop)) {
       zodType = await this.getZodTypeById(prop.id);
     } else if (isUuidProp(prop)) {
-      zodType = z.string().uuid();
+      zodType = z.uuid();
     } else if (isVirtualProp(prop)) {
       zodType = await this.getZodTypeById(prop.id);
     } else if (isRelationProp(prop)) {
@@ -1255,7 +1407,9 @@ export class Syncer {
     key: string,
     zodType: z.ZodTypeAny
   ): RenderingNode["renderType"] {
-    if (zodType instanceof z.ZodString) {
+    if (zodType instanceof z.ZodDate) {
+      return "datetime";
+    } else if (zodType instanceof z.ZodString) {
       if (key.includes("img") || key.includes("image")) {
         return "string-image";
       } else if (zodType.description === "SQLDateTimeString") {
@@ -1286,11 +1440,12 @@ export class Syncer {
     } else if (zodType instanceof z.ZodLiteral) {
       return "string-plain";
     } else {
-      throw new Error(`타입 파싱 불가 ${key} ${zodType._def.typeName}`);
+      throw new Error(`타입 파싱 불가 ${key} ${zodType.def.type}`);
     }
   }
+
   zodTypeToRenderingNode(
-    zodType: z.ZodTypeAny,
+    zodType: z.ZodType<any>,
     baseKey: string = "root"
   ): RenderingNode {
     const def = {
@@ -1310,7 +1465,7 @@ export class Syncer {
         children,
       };
     } else if (zodType instanceof z.ZodArray) {
-      const innerType = zodType._def.type;
+      const innerType = (zodType as z.ZodArray<z.ZodType<any>>).def.element;
       if (innerType instanceof z.ZodString && baseKey.includes("images")) {
         return {
           ...def,
@@ -1323,19 +1478,19 @@ export class Syncer {
         element: this.zodTypeToRenderingNode(innerType, baseKey),
       };
     } else if (zodType instanceof z.ZodUnion) {
-      const optionNodes = zodType._def.options.map((opt: z.ZodTypeAny) =>
+      const optionNodes = (zodType as z.ZodUnion<z.ZodType[]>).def.options.map((opt) =>
         this.zodTypeToRenderingNode(opt, baseKey)
       );
       // TODO: ZodUnion이 들어있는 경우 핸들링
       return optionNodes[0];
     } else if (zodType instanceof z.ZodOptional) {
       return {
-        ...this.zodTypeToRenderingNode(zodType._def.innerType, baseKey),
+        ...this.zodTypeToRenderingNode((zodType as z.ZodOptional<z.ZodType>).def.innerType, baseKey),
         optional: true,
       };
     } else if (zodType instanceof z.ZodNullable) {
       return {
-        ...this.zodTypeToRenderingNode(zodType._def.innerType, baseKey),
+        ...this.zodTypeToRenderingNode((zodType as z.ZodNullable<z.ZodType>).def.innerType, baseKey),
         nullable: true,
       };
     } else {
@@ -1350,7 +1505,7 @@ export class Syncer {
     entityId: string,
     subsetKey: string
   ): Promise<RenderingNode> {
-    const entity = await EntityManager.get(entityId);
+    const entity = EntityManager.get(entityId);
     const subsetA = entity.subsets[subsetKey];
     if (subsetA === undefined) {
       throw new ServiceUnavailableException("SubsetA 가 없습니다.");
@@ -1423,17 +1578,19 @@ export class Syncer {
     // reload entities
     await EntityManager.reload();
 
-    // generate schemas, types
-    await Promise.all([
-      this.actionGenerateSchemas(),
-      ...(form.parentId === undefined
-        ? [
-            this.generateTemplate("init_types", {
-              entityId: form.entityId,
-            }),
-          ]
-        : []),
-    ]);
+    // syncFromWatcher에서 처리하므로 주석처리
+    // this.actionGenerateSchemas();
+
+    // // generate schemas, types
+    // await Promise.all([
+    //   ...(form.parentId === undefined
+    //     ? [
+    //         this.generateTemplate("init_types", {
+    //           entityId: form.entityId,
+    //         }),
+    //       ]
+    //     : []),
+    // ]);
   }
 
   async delEntity(entityId: string): Promise<{ delPaths: string[] }> {
@@ -1458,9 +1615,9 @@ export class Syncer {
     })(); // iife
 
     for await (const delPath of delPaths) {
-      if (fs.existsSync(delPath)) {
+      if (await exists(delPath)) {
         console.log(chalk.red(`DELETE ${delPath}`));
-        execSync(`rm -rf ${delPath}`);
+        await rm(delPath, { recursive: true, force: true });
       } else {
         console.log(chalk.yellow(`NOT_EXISTS ${delPath}`));
       }
@@ -1471,4 +1628,14 @@ export class Syncer {
 
     return { delPaths };
   }
+
+  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}`))
+    );
+  }
 }