sonamu 0.1.0 → 0.1.4

package/src/entity/migrator.ts

@@ -137,6 +137,17 @@ export class Migrator {
   }> {
     const srcMigrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
     const distMigrationsDir = `${Sonamu.apiRootPath}/dist/migrations`;
+
+    if (existsSync(srcMigrationsDir) === false) {
+      mkdirSync(srcMigrationsDir, {
+        recursive: true,
+      });
+    }
+    if (existsSync(distMigrationsDir) === false) {
+      mkdirSync(distMigrationsDir, {
+        recursive: true,
+      });
+    }
     const srcMigrations = readdirSync(srcMigrationsDir)
       .filter((f) => f.endsWith(".ts"))
       .map((f) => f.split(".")[0]);
@@ -203,9 +214,10 @@ export class Migrator {
       connKeys.map(async (connKey) => {
         const knexOptions = Sonamu.dbConfig[connKey];
         const tConn = knex(knexOptions);
+
         const status = await (async () => {
           try {
-            return tConn.migrate.status();
+            return await tConn.migrate.status();
           } catch (err) {
             return "error";
           }
@@ -874,12 +886,14 @@ export class Migrator {
         name: dbColumn.Field,
         nullable: dbColumn.Null !== "NO",
         ...dbColType,
-        ...propIf(dbColumn.Default !== null, {
-          defaultTo:
-            dbColType.type === "float"
-              ? parseFloat(dbColumn.Default ?? "0").toString()
-              : dbColumn.Default,
-        }),
+        ...(() => {
+          if (dbColumn.Default !== null) {
+            return {
+              defaultTo: dbColumn.Default,
+            };
+          }
+          return {};
+        })(),
       };
     });
 
@@ -1020,7 +1034,23 @@ export class Migrator {
   ): Promise<[DBColumn[], DBIndex[], DBForeign[]]> {
     // 테이블 정보
     try {
-      const [cols] = await compareDB.raw(`SHOW FIELDS FROM ${tableName}`);
+      const [_cols] = (await compareDB.raw(
+        `SHOW FIELDS FROM ${tableName}`
+      )) as [DBColumn[]];
+      const cols = _cols.map((col) => ({
+        ...col,
+        // Default 값은 숫자나 MySQL Expression이 아닌 경우 ""로 감싸줌
+        ...(col.Default !== null
+          ? {
+              Default:
+                col.Default.replace(/[0-9]+/g, "").length > 0 &&
+                col.Extra !== "DEFAULT_GENERATED"
+                  ? `"${col.Default}"`
+                  : col.Default,
+            }
+          : {}),
+      }));
+
       const [indexes] = await compareDB.raw(`SHOW INDEX FROM ${tableName}`);
       const [[row]] = await compareDB.raw(`SHOW CREATE TABLE ${tableName}`);
       const ddl = row["Create Table"];
@@ -1115,10 +1145,14 @@ export class Migrator {
               ? { length: prop.length }
               : {}),
             nullable: prop.nullable === true,
-            // DB에선 무조건 string으로 리턴되므로 반드시 string 처리
-            ...propIf(prop.dbDefault !== undefined, {
-              defaultTo: "" + prop.dbDefault,
-            }),
+            ...(() => {
+              if (prop.dbDefault !== undefined) {
+                return {
+                  defaultTo: prop.dbDefault,
+                };
+              }
+              return {};
+            })(),
             // Decimal, Float 타입의 경우 precision, scale 추가
             ...(isDecimalProp(prop) || isFloatProp(prop)
               ? {
@@ -1286,7 +1320,14 @@ export class Migrator {
 
       // defaultTo
       if (column.defaultTo !== undefined) {
-        chains.push(`defaultTo(knex.raw('${column.defaultTo}'))`);
+        if (
+          typeof column.defaultTo === "string" &&
+          column.defaultTo.startsWith(`"`)
+        ) {
+          chains.push(`defaultTo(${column.defaultTo})`);
+        } else {
+          chains.push(`defaultTo(knex.raw('${column.defaultTo}'))`);
+        }
       }
 
       return `table.${chains.join(".")};`;

package/src/syncer/syncer.ts

@@ -159,7 +159,7 @@ export class Syncer {
     );
 
     // 현재 checksums
-    const currentChecksums = await this.getCurrentChecksums();
+    let currentChecksums = await this.getCurrentChecksums();
     // 이전 checksums
     const previousChecksums = await this.getPreviousChecksums();
 
@@ -190,12 +190,26 @@ export class Syncer {
     // 변경된 파일들을 타입별로 분리하여 각 타입별 액션 처리
     const diffTypes = Object.keys(diffGroups);
 
-    // 트리거: entity
+    // 트리거: entity, types
     // 액션: 스키마 생성
-    if (diffTypes.includes("entity")) {
+    if (diffTypes.includes("entity") || diffTypes.includes("types")) {
       console.log("// 액션: 스키마 생성");
-      const entityIds = this.getEntityIdFromPath(diffGroups["entity"]);
+      const entityIds = this.getEntityIdFromPath([
+        ...(diffGroups["entity"] ?? []),
+        ...(diffGroups["types"] ?? []),
+      ]);
       await this.actionGenerateSchemas(entityIds);
+
+      // 타입이 변경된 경우 generated 싱크까지 동시에 처리 후 체크섬 갱신
+      if (diffTypes.includes("types")) {
+        diffGroups["generated"] = uniq([
+          ...(diffGroups["generated"] ?? []),
+          ...diffGroups["types"].map((p) =>
+            p.replace(".types.ts", ".generated.ts")
+          ),
+        ]);
+        currentChecksums = await this.getCurrentChecksums();
+      }
     }
 
     // 트리거: types, enums, generated 변경시
@@ -207,11 +221,13 @@ export class Syncer {
     ) {
       console.log("// 액션: 파일 싱크 types / functions / generated");
 
-      const tsPaths = [
-        ...(diffGroups["types"] ?? []),
-        ...(diffGroups["functions"] ?? []),
-        ...(diffGroups["generated"] ?? []),
-      ].map((p) => p.replace("/dist/", "/src/").replace(".js", ".ts"));
+      const tsPaths = uniq(
+        [
+          ...(diffGroups["types"] ?? []),
+          ...(diffGroups["functions"] ?? []),
+          ...(diffGroups["generated"] ?? []),
+        ].map((p) => p.replace("/dist/", "/src/").replace(".js", ".ts"))
+      );
       await this.actionSyncFilesToTargets(tsPaths);
     }
 
@@ -229,10 +245,12 @@ export class Syncer {
   }
 
   getEntityIdFromPath(filePaths: string[]): string[] {
-    return filePaths.map((p) => {
-      const matched = p.match(/application\/(.+)\//);
-      return camelize(matched![1].replace(/\-/g, "_"));
-    });
+    return uniq(
+      filePaths.map((p) => {
+        const matched = p.match(/application\/(.+)\//);
+        return camelize(matched![1].replace(/\-/g, "_"));
+      })
+    );
   }
 
   async actionGenerateSchemas(entityIds: string[]): Promise<string[]> {
@@ -702,8 +720,10 @@ export class Syncer {
     return this.models;
   }
 
-  async autoloadTypes(): Promise<{ [typeName: string]: z.ZodObject<any> }> {
-    if (Object.keys(this.types).length > 0) {
+  async autoloadTypes(
+    doRefresh: boolean = false
+  ): Promise<{ [typeName: string]: z.ZodObject<any> }> {
+    if (!doRefresh && Object.keys(this.types).length > 0) {
       return this.types;
     }
 
@@ -716,7 +736,7 @@ export class Syncer {
     const filePaths = (
       await Promise.all(pathPatterns.map((pattern) => globAsync(pattern)))
     ).flat();
-    const modules = await importMultiple(filePaths);
+    const modules = await importMultiple(filePaths, doRefresh);
     const functions = modules
       .map(({ imported }) => Object.entries(imported))
       .flat();
@@ -917,10 +937,7 @@ export class Syncer {
     };
 
     // 키 children
-    let keys: TemplateKey[] = [key];
-    // if (key === "entity") {
-    //   keys = ["entity", "init_generated", "init_types"];
-    // }
+    const keys: TemplateKey[] = [key];
 
     // 템플릿 렌더
     const pathAndCodes = (
@@ -940,27 +957,30 @@ export class Syncer {
      - 옵션3 : 메인 파일만 그대로 두고, 파생 파일은 전부 생성함 => 이게 맞지 않나?
     */
 
-    let filteredPathAndCodes: PathAndCode[] = [];
-    if (generateOptions.overwrite === true) {
-      filteredPathAndCodes = pathAndCodes;
-    } else {
-      filteredPathAndCodes = pathAndCodes.filter((pathAndCode, index) => {
-        if (index === 0) {
-          const { targets } = Sonamu.config.sync;
-          const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;
-          const dstFilePaths = targets.map((target) =>
-            filePath.replace("/:target/", `/${target}/`)
-          );
-          return dstFilePaths.every((dstPath) => existsSync(dstPath) === false);
-        } else {
-          return true;
-        }
-      });
-      if (filteredPathAndCodes.length === 0) {
-        throw new AlreadyProcessedException(
-          "이미 경로에 모든 파일이 존재합니다."
-        );
+    const filteredPathAndCodes: PathAndCode[] = (() => {
+      if (generateOptions.overwrite === true) {
+        return pathAndCodes;
+      } else {
+        return pathAndCodes.filter((pathAndCode, index) => {
+          if (index === 0) {
+            const { targets } = Sonamu.config.sync;
+            const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;
+            const dstFilePaths = targets.map((target) =>
+              filePath.replace("/:target/", `/${target}/`)
+            );
+            return dstFilePaths.every(
+              (dstPath) => existsSync(dstPath) === false
+            );
+          } else {
+            return true;
+          }
+        });
       }
+    })();
+    if (filteredPathAndCodes.length === 0) {
+      throw new AlreadyProcessedException(
+        "이미 경로에 모든 파일이 존재합니다."
+      );
     }
 
     return Promise.all(
@@ -970,6 +990,24 @@ export class Syncer {
     );
   }
 
+  checkExistsGenCode(
+    entityId: string,
+    templateKey: TemplateKey,
+    enumId?: string
+  ): { subPath: string; fullPath: string; isExists: boolean } {
+    const { target, path: genPath } = this.getTemplate(
+      templateKey
+    ).getTargetAndPath(EntityManager.getNamesFromId(entityId), enumId);
+
+    const fullPath = path.join(Sonamu.appRootPath, target, genPath);
+    const subPath = path.join(target, genPath);
+    return {
+      subPath,
+      fullPath,
+      isExists: existsSync(fullPath),
+    };
+  }
+
   checkExists(
     entityId: string,
     enums: {
@@ -1296,12 +1334,14 @@ export class Syncer {
     await EntityManager.reload();
 
     // generate schemas
-    await this.actionGenerateSchemas([entityId]);
+    await this.actionGenerateSchemas([parentId ?? entityId]);
 
     // generate types
-    await this.generateTemplate("init_types", {
-      entityId,
-    });
+    if (parentId === undefined) {
+      await this.generateTemplate("init_types", {
+        entityId,
+      });
+    }
   }
 
   async delEntity(entityId: string): Promise<{ delPaths: string[] }> {

package/src/templates/entity.template.ts

@@ -7,10 +7,10 @@ export class Template__entity extends Template {
     super("entity");
   }
 
-  getTargetAndPath(names: EntityNamesRecord) {
+  getTargetAndPath(names: EntityNamesRecord, parentNames?: EntityNamesRecord) {
     return {
       target: "api/src/application",
-      path: `${names.fs}/${names.fs}.entity.json`,
+      path: `${(parentNames ?? names).fs}/${names.fs}.entity.json`,
     };
   }
 
@@ -18,30 +18,63 @@ export class Template__entity extends Template {
     const { entityId, title, parentId, table } = options;
     const names = EntityManager.getNamesFromId(entityId);
 
+    const parent = (() => {
+      if (parentId) {
+        return {
+          names: EntityManager.getNamesFromId(parentId),
+          entity: EntityManager.get(parentId),
+        };
+      } else {
+        return null;
+      }
+    })();
+
     return {
-      ...this.getTargetAndPath(names),
+      ...this.getTargetAndPath(names, parent?.names ?? names),
       body: JSON.stringify({
         id: entityId,
         title: title ?? entityId,
         parentId,
         table: table ?? names.fsPlural.replace(/\-/g, "_"),
         props: [
-          { name: "id", type: "integer", unsigned: true },
+          { name: "id", type: "integer", unsigned: true, desc: "ID" },
+          ...(parent
+            ? [
+                {
+                  type: "relation",
+                  name: parent.names.camel,
+                  relationType: "BelongsToOne",
+                  with: parentId,
+                  onUpdate: "CASCADE",
+                  onDelete: "CASCADE",
+                  desc: parent.entity.title,
+                },
+              ]
+            : []),
           {
             name: "created_at",
             type: "timestamp",
+            desc: "등록일시",
             dbDefault: "CURRENT_TIMESTAMP",
           },
         ],
         indexes: [],
         subsets: {
-          A: ["id", "created_at"],
+          ...(parentId
+            ? {}
+            : {
+                A: ["id", "created_at"],
+              }),
         },
         enums: {
-          [`${names.capital}OrderBy`]: {
-            "id-desc": "ID최신순",
-          },
-          [`${names.capital}SearchField`]: { id: "ID" },
+          ...(parentId
+            ? {}
+            : {
+                [`${names.capital}OrderBy`]: {
+                  "id-desc": "ID최신순",
+                },
+                [`${names.capital}SearchField`]: { id: "ID" },
+              }),
         },
       }).trim(),
       importKeys: [],

package/src/templates/generated.template.ts

@@ -9,7 +9,7 @@ import {
 import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
 import { Entity } from "../entity/entity";
 import { EntityPropNode, SubsetQuery } from "../types/types";
-import { propNodeToZodTypeDef } from "../api/code-converters";
+import { propNodeToZodTypeDef, zodTypeToZodCode } from "../api/code-converters";
 import { Template } from "./base-template";
 
 export class Template__generated extends Template {
@@ -33,7 +33,7 @@ export class Template__generated extends Template {
       ...(entity.parentId === undefined
         ? [
             this.getBaseListParamsTypeSource(entity),
-            this.getSubsetTypeSource(entity),
+            this.getSubsetTypeSource(entity)!,
           ]
         : []),
     ].reduce(
@@ -52,6 +52,31 @@ export class Template__generated extends Template {
       }
     );
 
+    // .types.ts의 타입을 참조하는 경우 순환참조(상호참조)가 발생하므로 해당 타입을 가져와 인라인 처리
+    const entityTypeKeys = Object.keys(entity.types);
+    const cdImportKeys = uniq(typeSource.importKeys).filter((importKey) =>
+      entityTypeKeys.includes(importKey)
+    );
+    if (cdImportKeys.length > 0) {
+      typeSource.lines = [
+        ...cdImportKeys
+          .map((importKey) => [
+            `// Imported CustomScalar: ${importKey}`,
+            `const ${importKey} = ${zodTypeToZodCode(
+              entity.types[importKey]
+            )};`,
+            `type ${importKey} = z.infer<typeof ${importKey}>`,
+            "",
+          ])
+          .flat(),
+        "",
+        ...typeSource.lines,
+      ];
+      typeSource.importKeys = typeSource.importKeys.filter(
+        (importKey) => !cdImportKeys.includes(importKey)
+      );
+    }
+
     // targetAndPath
     const names = EntityManager.getNamesFromId(entityId);
     const targetAndPath = this.getTargetAndPath(names);

package/src/types/types.ts

@@ -41,7 +41,7 @@ export type CommonProp = {
   nullable?: boolean;
   toFilter?: true;
   desc?: string;
-  dbDefault?: string | number | { raw: string };
+  dbDefault?: string;
 };
 export type IntegerProp = CommonProp & {
   type: "integer";
@@ -73,6 +73,8 @@ export type FloatProp = CommonProp & {
 export type DoubleProp = CommonProp & {
   type: "double";
   unsigned?: true;
+  precision: number;
+  scale: number;
 };
 export type DecimalProp = CommonProp & {
   type: "decimal";
@@ -113,7 +115,6 @@ export type RelationType =
   | "ManyToMany"
   | "OneToOne";
 export type RelationOn =
-  | "UPDATE"
   | "CASCADE"
   | "SET NULL"
   | "NO ACTION"
@@ -394,7 +395,7 @@ export type MigrationColumn = {
   nullable: boolean;
   unsigned?: boolean;
   length?: number;
-  defaultTo?: string | number;
+  defaultTo?: string;
   precision?: number;
   scale?: number;
 };

package/src/utils/utils.ts

@@ -14,11 +14,15 @@ export function globAsync(pathPattern: string): Promise<string[]> {
   });
 }
 export async function importMultiple(
-  filePaths: string[]
+  filePaths: string[],
+  doRefresh: boolean = false
 ): Promise<{ filePath: string; imported: any }[]> {
   return Promise.all(
     filePaths.map(async (filePath) => {
       const importPath = "./" + path.relative(__dirname, filePath);
+      if (doRefresh) {
+        delete require.cache[require.resolve(importPath)];
+      }
       const imported = await import(importPath);
       return {
         filePath,