sonamu 0.2.31 → 0.2.33

package/src/entity/migrator.ts

@@ -429,7 +429,7 @@ export class Migrator {
       {
         file: string;
         directory: string;
-      }[]
+      }[],
     ];
     const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
     const delList = pendingList.map((df) => {
@@ -752,50 +752,50 @@ export class Migrator {
           if (dbSet === null) {
             // 기존 테이블 없음, 새로 테이블 생성
             return [
-              this.generateCreateCode_ColumnAndIndexes(
+              await this.generateCreateCode_ColumnAndIndexes(
                 entitySet.table,
                 entitySet.columns,
                 entitySet.indexes
               ),
-              ...this.generateCreateCode_Foreign(
+              ...(await this.generateCreateCode_Foreign(
                 entitySet.table,
                 entitySet.foreigns
-              ),
+              )),
             ];
           }
 
           // 기존 테이블 존재하는 케이스
-          const alterCodes: (GenMigrationCode | GenMigrationCode[] | null)[] = (
-            ["columnsAndIndexes", "foreigns"] as const
-          ).map((key) => {
-            // 배열 원소의 순서가 달라서 불일치가 발생하는걸 방지하기 위해 각 항목별로 정렬 처리 후 비교
-            if (key === "columnsAndIndexes") {
-              const replaceColumnDefaultTo = (col: MigrationColumn) => {
-                // float인 경우 기본값을 0으로 지정하는 경우 "0.00"으로 변환되는 케이스 대응
-                if (
-                  col.type === "float" &&
-                  col.defaultTo &&
-                  col.defaultTo.includes('"') === false
-                ) {
-                  col.defaultTo = `"${Number(col.defaultTo).toFixed(
-                    col.scale ?? 2
-                  )}"`;
-                }
-                // string인 경우 기본값이 빈 스트링인 경우 대응
-                if (col.type === "string" && col.defaultTo === "") {
-                  col.defaultTo = '""';
-                }
-                return col;
-              };
-              const entityColumns = sortBy(
-                entitySet.columns,
-                (a) => a.name
-              ).map(replaceColumnDefaultTo);
-              const dbColumns = sortBy(dbSet.columns, (a) => a.name).map(
-                replaceColumnDefaultTo
-              );
-
-              /* 디버깅용 코드, 특정 컬럼에서 불일치 발생할 때 확인
+          const alterCodes: (GenMigrationCode | GenMigrationCode[] | null)[] =
+            await Promise.all(
+              (["columnsAndIndexes", "foreigns"] as const).map((key) => {
+                // 배열 원소의 순서가 달라서 불일치가 발생하는걸 방지하기 위해 각 항목별로 정렬 처리 후 비교
+                if (key === "columnsAndIndexes") {
+                  const replaceColumnDefaultTo = (col: MigrationColumn) => {
+                    // float인 경우 기본값을 0으로 지정하는 경우 "0.00"으로 변환되는 케이스 대응
+                    if (
+                      col.type === "float" &&
+                      col.defaultTo &&
+                      col.defaultTo.includes('"') === false
+                    ) {
+                      col.defaultTo = `"${Number(col.defaultTo).toFixed(
+                        col.scale ?? 2
+                      )}"`;
+                    }
+                    // string인 경우 기본값이 빈 스트링인 경우 대응
+                    if (col.type === "string" && col.defaultTo === "") {
+                      col.defaultTo = '""';
+                    }
+                    return col;
+                  };
+                  const entityColumns = sortBy(
+                    entitySet.columns,
+                    (a) => a.name
+                  ).map(replaceColumnDefaultTo);
+                  const dbColumns = sortBy(dbSet.columns, (a) => a.name).map(
+                    replaceColumnDefaultTo
+                  );
+
+                  /* 디버깅용 코드, 특정 컬럼에서 불일치 발생할 때 확인
               const entityColumn = entitySet.columns.find(
                 (col) => col.name === "price_krw"
               );
@@ -805,63 +805,66 @@ export class Migrator {
               console.debug({ entityColumn, dbColumn });
                */
 
-              const entityIndexes = sortBy(entitySet.indexes, (a) =>
-                [
-                  a.type,
-                  ...a.columns.sort((c1, c2) => (c1 > c2 ? 1 : -1)),
-                ].join("-")
-              );
-              const dbIndexes = sortBy(dbSet.indexes, (a) =>
-                [
-                  a.type,
-                  ...a.columns.sort((c1, c2) => (c1 > c2 ? 1 : -1)),
-                ].join("-")
-              );
-
-              const isEqualColumns = equal(entityColumns, dbColumns);
-              const isEqualIndexes = equal(entityIndexes, dbIndexes);
-              if (isEqualColumns && isEqualIndexes) {
+                  const entityIndexes = sortBy(entitySet.indexes, (a) =>
+                    [
+                      a.type,
+                      ...a.columns.sort((c1, c2) => (c1 > c2 ? 1 : -1)),
+                    ].join("-")
+                  );
+                  const dbIndexes = sortBy(dbSet.indexes, (a) =>
+                    [
+                      a.type,
+                      ...a.columns.sort((c1, c2) => (c1 > c2 ? 1 : -1)),
+                    ].join("-")
+                  );
+
+                  const isEqualColumns = equal(entityColumns, dbColumns);
+                  const isEqualIndexes = equal(entityIndexes, dbIndexes);
+                  if (isEqualColumns && isEqualIndexes) {
+                    return null;
+                  } else {
+                    // this.showMigrationSet("MD", entitySet);
+                    // this.showMigrationSet("DB", dbSet);
+                    return this.generateAlterCode_ColumnAndIndexes(
+                      entitySet.table,
+                      entityColumns,
+                      entityIndexes,
+                      dbColumns,
+                      dbIndexes
+                    );
+                  }
+                } else {
+                  const replaceNoActionOnMySQL = (f: MigrationForeign) => {
+                    // MySQL에서 RESTRICT와 NO ACTION은 동일함
+                    const { onDelete, onUpdate } = f;
+                    return {
+                      ...f,
+                      onUpdate:
+                        onUpdate === "RESTRICT" ? "NO ACTION" : onUpdate,
+                      onDelete:
+                        onDelete === "RESTRICT" ? "NO ACTION" : onDelete,
+                    };
+                  };
+
+                  const entityForeigns = sortBy(entitySet.foreigns, (a) =>
+                    [a.to, ...a.columns].join("-")
+                  ).map((f) => replaceNoActionOnMySQL(f));
+                  const dbForeigns = sortBy(dbSet.foreigns, (a) =>
+                    [a.to, ...a.columns].join("-")
+                  ).map((f) => replaceNoActionOnMySQL(f));
+
+                  if (equal(entityForeigns, dbForeigns) === false) {
+                    // console.dir({ entityForeigns, dbForeigns }, { depth: null });
+                    return this.generateAlterCode_Foreigns(
+                      entitySet.table,
+                      entityForeigns,
+                      dbForeigns
+                    );
+                  }
+                }
                 return null;
-              } else {
-                // this.showMigrationSet("MD", entitySet);
-                // this.showMigrationSet("DB", dbSet);
-                return this.generateAlterCode_ColumnAndIndexes(
-                  entitySet.table,
-                  entityColumns,
-                  entityIndexes,
-                  dbColumns,
-                  dbIndexes
-                );
-              }
-            } else {
-              const replaceNoActionOnMySQL = (f: MigrationForeign) => {
-                // MySQL에서 RESTRICT와 NO ACTION은 동일함
-                const { onDelete, onUpdate } = f;
-                return {
-                  ...f,
-                  onUpdate: onUpdate === "RESTRICT" ? "NO ACTION" : onUpdate,
-                  onDelete: onDelete === "RESTRICT" ? "NO ACTION" : onDelete,
-                };
-              };
-
-              const entityForeigns = sortBy(entitySet.foreigns, (a) =>
-                [a.to, ...a.columns].join("-")
-              ).map((f) => replaceNoActionOnMySQL(f));
-              const dbForeigns = sortBy(dbSet.foreigns, (a) =>
-                [a.to, ...a.columns].join("-")
-              ).map((f) => replaceNoActionOnMySQL(f));
-
-              if (equal(entityForeigns, dbForeigns) === false) {
-                // console.dir({ entityForeigns, dbForeigns }, { depth: null });
-                return this.generateAlterCode_Foreigns(
-                  entitySet.table,
-                  entityForeigns,
-                  dbForeigns
-                );
-              }
-            }
-            return null;
-          });
+              })
+            );
           if (alterCodes.every((alterCode) => alterCode === null)) {
             return null;
           } else {
@@ -1398,11 +1401,11 @@ export class Migrator {
   /*
     테이블 생성하는 케이스 - 컬럼/인덱스 생성
   */
-  generateCreateCode_ColumnAndIndexes(
+  async generateCreateCode_ColumnAndIndexes(
     table: string,
     columns: MigrationColumn[],
     indexes: MigrationIndex[]
-  ): GenMigrationCode {
+  ): Promise<GenMigrationCode> {
     // 컬럼, 인덱스 처리
     const lines: string[] = [
       'import { Knex } from "knex";',
@@ -1425,7 +1428,7 @@ export class Migrator {
       table,
       type: "normal",
       title: `create__${table}`,
-      formatted: prettier.format(lines.join("\n"), {
+      formatted: await prettier.format(lines.join("\n"), {
         parser: "typescript",
       }),
     };
@@ -1433,10 +1436,10 @@ export class Migrator {
   /*
   테이블 생성하는 케이스 - FK 생성
 */
-  generateCreateCode_Foreign(
+  async generateCreateCode_Foreign(
     table: string,
     foreigns: MigrationForeign[]
-  ): GenMigrationCode[] {
+  ): Promise<GenMigrationCode[]> {
     if (foreigns.length === 0) {
       return [];
     }
@@ -1473,7 +1476,7 @@ export class Migrator {
         table,
         type: "foreign",
         title: `foreign__${table}__${foreignKeysString}`,
-        formatted: prettier.format(lines.join("\n"), {
+        formatted: await prettier.format(lines.join("\n"), {
           parser: "typescript",
         }),
       },
@@ -1550,13 +1553,13 @@ export class Migrator {
     }
   }
 
-  generateAlterCode_ColumnAndIndexes(
+  async generateAlterCode_ColumnAndIndexes(
     table: string,
     entityColumns: MigrationColumn[],
     entityIndexes: MigrationIndex[],
     dbColumns: MigrationColumn[],
     dbIndexes: MigrationIndex[]
-  ): GenMigrationCode[] {
+  ): Promise<GenMigrationCode[]> {
     /*
       세부 비교 후 다른점 찾아서 코드 생성
 
@@ -1615,7 +1618,7 @@ export class Migrator {
       "}",
     ];
 
-    const formatted = prettier.format(lines.join("\n"), {
+    const formatted = await prettier.format(lines.join("\n"), {
       parser: "typescript",
     });
 
@@ -1853,11 +1856,11 @@ export class Migrator {
     return linesTo;
   }
 
-  generateAlterCode_Foreigns(
+  async generateAlterCode_Foreigns(
     table: string,
     entityForeigns: MigrationForeign[],
     dbForeigns: MigrationForeign[]
-  ): GenMigrationCode[] {
+  ): Promise<GenMigrationCode[]> {
     // console.log({ entityForeigns, dbForeigns });
 
     const getKey = (mf: MigrationForeign): string => {
@@ -1913,7 +1916,7 @@ export class Migrator {
       "}",
     ];
 
-    const formatted = prettier.format(lines.join("\n"), {
+    const formatted = await prettier.format(lines.join("\n"), {
       parser: "typescript",
     });
 

package/src/syncer/syncer.ts

@@ -121,7 +121,7 @@ export class Syncer {
   models: { [modelName: string]: unknown } = {};
 
   get checksumsPath(): string {
-    return path.join(Sonamu.apiRootPath, "/.tf-checksum");
+    return path.join(Sonamu.apiRootPath, "/.so-checksum");
   }
   public constructor() {}
 
@@ -705,7 +705,12 @@ export class Syncer {
     );
     // console.debug(chalk.yellow(`autoload:models @ ${pathPattern}`));
 
-    const filePaths = await globAsync(pathPattern);
+    const filePaths = (await globAsync(pathPattern)).filter((path) => {
+      // src 디렉터리 내에 있는 해당 파일이 존재할 경우에만 로드
+      // 삭제된 파일이지만 dist에 남아있는 경우 BaseSchema undefined 에러 방지
+      const srcPath = path.replace("/dist/", "/src/").replace(".js", ".ts");
+      return existsSync(srcPath);
+    });
     const modules = await importMultiple(filePaths);
     const functions = modules
       .map(({ imported }) => Object.entries(imported))
@@ -731,7 +736,14 @@ export class Syncer {
 
     const filePaths = (
       await Promise.all(pathPatterns.map((pattern) => globAsync(pattern)))
-    ).flat();
+    )
+      .flat()
+      .filter((path) => {
+        // src 디렉터리 내에 있는 해당 파일이 존재할 경우에만 로드
+        // 삭제된 파일이지만 dist에 남아있는 경우 BaseSchema undefined 에러 방지
+        const srcPath = path.replace("/dist/", "/src/").replace(".js", ".ts");
+        return existsSync(srcPath);
+      });
     const modules = await importMultiple(filePaths, doRefresh);
     const functions = modules
       .map(({ imported }) => Object.entries(imported))
@@ -822,7 +834,7 @@ export class Syncer {
       }
     }
 
-    const rendered = template.render(options, ...extra);
+    const rendered = await template.render(options, ...extra);
     const resolved = await this.resolveRenderedTemplate(key, rendered);
 
     let preTemplateResolved: PathAndCode[] = [];
@@ -896,7 +908,7 @@ export class Syncer {
       if (key === "generated_http") {
         return [header, body].join("\n\n");
       } else {
-        return await prettier.format([header, body].join("\n\n"), {
+        return prettier.format([header, body].join("\n\n"), {
           parser: key === "entity" ? "json" : "typescript",
         });
       }
@@ -954,32 +966,17 @@ export class Syncer {
       )
     ).flat();
 
-    /*
-    overwrite가 true일 때
-    - 생각하지 않고 그냥 다 덮어씀
-    overwrite가 false일 때
-     - 옵션1 (현재구현): 그냥 파일 하나라도 있으면 코드 생성 안함
-     - 옵션2 : 있는 파일은 전부 그대로 두고 없는 파일만 싹 생성함
-     - 옵션3 : 메인 파일만 그대로 두고, 파생 파일은 전부 생성함 => 이게 맞지 않나?
-    */
-
     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;
-          }
+        return pathAndCodes.filter((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) => existsSync(dstPath) === false);
         });
       }
     })();
@@ -1026,32 +1023,38 @@ export class Syncer {
       (name) => name !== names.constant
     );
 
-    return keys.reduce((result, key) => {
-      const tpl = this.getTemplate(key);
-      if (key.startsWith("view_enums")) {
-        enumsKeys.map((componentId) => {
-          const { target, path: p } = tpl.getTargetAndPath(names, componentId);
-          result[`${key}__${componentId}`] = existsSync(
-            path.join(Sonamu.appRootPath, target, p)
-          );
-        });
-        return result;
-      }
+    return keys.reduce(
+      (result, key) => {
+        const tpl = this.getTemplate(key);
+        if (key.startsWith("view_enums")) {
+          enumsKeys.map((componentId) => {
+            const { target, path: p } = tpl.getTargetAndPath(
+              names,
+              componentId
+            );
+            result[`${key}__${componentId}`] = existsSync(
+              path.join(Sonamu.appRootPath, target, p)
+            );
+          });
+          return result;
+        }
 
-      const { target, path: p } = tpl.getTargetAndPath(names);
-      const { targets } = Sonamu.config.sync;
-      if (target.includes(":target")) {
-        targets.map((t) => {
-          result[`${key}__${t}`] = existsSync(
-            path.join(Sonamu.appRootPath, target.replace(":target", t), p)
-          );
-        });
-      } else {
-        result[key] = existsSync(path.join(Sonamu.appRootPath, target, p));
-      }
+        const { target, path: p } = tpl.getTargetAndPath(names);
+        const { targets } = Sonamu.config.sync;
+        if (target.includes(":target")) {
+          targets.map((t) => {
+            result[`${key}__${t}`] = existsSync(
+              path.join(Sonamu.appRootPath, target.replace(":target", t), p)
+            );
+          });
+        } else {
+          result[key] = existsSync(path.join(Sonamu.appRootPath, target, p));
+        }
 
-      return result;
-    }, {} as Record<`${TemplateKey}${string}`, boolean>);
+        return result;
+      },
+      {} as Record<`${TemplateKey}${string}`, boolean>
+    );
   }
 
   async getZodTypeById(zodTypeId: string): Promise<z.ZodTypeAny> {
@@ -1096,9 +1099,8 @@ export class Syncer {
       const obj = await propNode.children.reduce(
         async (promise, childPropNode) => {
           const result = await promise;
-          result[childPropNode.prop!.name] = await this.propNodeToZodType(
-            childPropNode
-          );
+          result[childPropNode.prop!.name] =
+            await this.propNodeToZodType(childPropNode);
           return result;
         },
         {} as any
@@ -1332,10 +1334,8 @@ export class Syncer {
     table?: string,
     title?: string
   ) {
-    if (/^[a-zA-Z_$][a-zA-Z_$0-9]*$/.test(entityId) === false) {
-      throw new BadRequestException(
-        "entityId는 자바스크립트 변수명 규칙을 따라야 합니다."
-      );
+    if (!/^[A-Z][a-zA-Z0-9]*$/.test(entityId)) {
+      throw new BadRequestException("entityId는 CamelCase 형식이어야 합니다.");
     }
 
     await this.generateTemplate("entity", {

package/src/templates/base-template.ts

@@ -7,7 +7,7 @@ export abstract class Template {
   public abstract render(
     options: TemplateOptions[TemplateKey],
     ...extra: unknown[]
-  ): RenderedTemplate;
+  ): RenderedTemplate | Promise<RenderedTemplate>;
 
   public abstract getTargetAndPath(
     names?: EntityNamesRecord,

package/src/templates/generated_http.template.ts

@@ -21,7 +21,7 @@ export class Template__generated_http extends Template {
     };
   }
 
-  render({}: TemplateOptions["generated_http"]) {
+  async render({}: TemplateOptions["generated_http"]) {
     const {
       syncer: { types, apis },
       config: {
@@ -29,42 +29,44 @@ export class Template__generated_http extends Template {
       },
     } = Sonamu;
 
-    const lines = apis.map((api) => {
-      const reqObject = this.resolveApiParams(api, types);
+    const lines = await Promise.all(
+      apis.map(async (api) => {
+        const reqObject = this.resolveApiParams(api, types);
 
-      const dataLines = (() => {
-        if ((api.options.httpMethod ?? "GET") === "GET") {
-          return {
-            querystring: [
-              qs
-                .stringify(reqObject, { encode: false })
-                .split("&")
-                .join("\n\t&"),
-            ],
-            body: [],
-          };
-        } else {
-          return {
-            querystring: [],
-            body: [
-              "",
-              prettier.format(JSON.stringify(reqObject), {
-                parser: "json",
-              }),
-            ],
-          };
-        }
-      })();
+        const dataLines = await (async () => {
+          if ((api.options.httpMethod ?? "GET") === "GET") {
+            return {
+              querystring: [
+                qs
+                  .stringify(reqObject, { encode: false })
+                  .split("&")
+                  .join("\n\t&"),
+              ],
+              body: [],
+            };
+          } else {
+            return {
+              querystring: [],
+              body: [
+                "",
+                await prettier.format(JSON.stringify(reqObject), {
+                  parser: "json",
+                }),
+              ],
+            };
+          }
+        })();
 
-      return [
-        [
-          `${api.options.httpMethod ?? "GET"} {{baseUrl}}${prefix}${api.path}`,
-          ...dataLines.querystring,
-        ].join("\n\t?"),
-        `Content-Type: ${api.options.contentType ?? "application/json"}`,
-        ...dataLines.body,
-      ].join("\n");
-    });
+        return [
+          [
+            `${api.options.httpMethod ?? "GET"} {{baseUrl}}${prefix}${api.path}`,
+            ...dataLines.querystring,
+          ].join("\n\t?"),
+          `Content-Type: ${api.options.contentType ?? "application/json"}`,
+          ...dataLines.body,
+        ].join("\n");
+      })
+    );
 
     return {
       ...this.getTargetAndPath(),