sonamu 0.1.2 → 0.1.5

package/src/entity/entity.ts

@@ -24,6 +24,7 @@ import { existsSync, writeFileSync } from "fs";
 import { z } from "zod";
 import { Sonamu } from "../api/sonamu";
 import prettier from "prettier";
+import { nonNullable } from "../utils/utils";
 
 export class Entity {
   id: string;
@@ -414,9 +415,10 @@ export class Entity {
               };
             }
 
-            const prop = entity.propsDict[propName];
+            const prop = entity.props.find((p) => p.name === propName);
             if (prop === undefined) {
-              throw new Error(`${this.id} -- 잘못된 FieldExpr ${propName}`);
+              console.log({ propName, groups });
+              throw new Error(`${entity.id} -- 잘못된 FieldExpr ${propName}`);
             }
             return {
               nodeType: "plain" as const,
@@ -501,7 +503,21 @@ export class Entity {
   }
 
   getTableColumns(): string[] {
-    return this.props.map((prop) => prop.name);
+    return this.props
+      .map((prop) => {
+        if (prop.type === "relation") {
+          if (
+            prop.relationType === "BelongsToOne" ||
+            (prop.relationType === "OneToOne" && prop.hasJoinColumn === true)
+          ) {
+            return `${prop.name}_id`;
+          } else {
+            return null;
+          }
+        }
+        return prop.name;
+      })
+      .filter(nonNullable);
   }
 
   registerModulePaths() {
@@ -673,10 +689,40 @@ export class Entity {
     await this.save();
   }
 
+  analyzeSubsetField(subsetField: string): {
+    entityId: string;
+    propName: string;
+  }[] {
+    const arr = subsetField.split(".");
+
+    let entityId = this.id;
+    const result: {
+      entityId: string;
+      propName: string;
+    }[] = [];
+    for (let i = 0; i < arr.length; i++) {
+      const propName = arr[i];
+      result.push({
+        entityId,
+        propName,
+      });
+
+      const prop = EntityManager.get(entityId).props.find(
+        (p) => p.name === propName
+      );
+      if (!prop) {
+        throw new Error(`${entityId}의 잘못된 서브셋키 ${subsetField}`);
+      }
+      if (isRelationProp(prop)) {
+        entityId = prop.with;
+      }
+    }
+    return result;
+  }
+
   async modifyProp(newProp: EntityProp, at: number): Promise<void> {
-    // 프롭 수정
+    // 이전 프롭 이름 저장
     const oldName = this.props[at].name;
-    this.props[at] = newProp;
 
     // 저장할 엔티티
     const entities: Entity[] = [this];
@@ -690,30 +736,39 @@ export class Entity {
         const relEntitySubsetKeys = Object.keys(relEntity.subsets);
         for (const subsetKey of relEntitySubsetKeys) {
           const subset = relEntity.subsets[subsetKey];
-          const oldSubsetFields = subset.filter(
-            (field) =>
-              field.endsWith(oldName) &&
-              relEntity.getEntityIdFromSubsetField(field) === this.id
-          );
-          if (oldSubsetFields.length > 0) {
-            relEntity.subsets[subsetKey] = relEntity.subsets[subsetKey].map(
-              (oldField) =>
-                oldSubsetFields.includes(oldField)
-                  ? oldField.replace(`${oldName}`, `${newProp.name}`)
-                  : oldField
+
+          // 서브셋 필드를 순회하며, 엔티티-프롭 단위로 분석한 후 현재 엔티티-프롭과 일치하는 경우 수정 처리
+          const modifiedSubsetFields = subset.map((subsetField) => {
+            const analyzed = relEntity.analyzeSubsetField(subsetField);
+            const modified = analyzed.map((a) =>
+              a.propName === oldName && a.entityId === this.id
+                ? {
+                    ...a,
+                    propName: newProp.name,
+                  }
+                : a
             );
+            // 분석한 필드를 다시 서브셋 필드로 복구
+            return modified.map((a) => a.propName).join(".");
+          });
+
+          if (subset.join(",") !== modifiedSubsetFields.join(",")) {
+            relEntity.subsets[subsetKey] = modifiedSubsetFields;
             entities.push(relEntity);
           }
         }
       }
     }
 
+    // 프롭 수정
+    this.props[at] = newProp;
+
     await Promise.all(entities.map(async (entity) => entity.save()));
   }
 
   async delProp(at: number): Promise<void> {
+    // 이전 프롭 이름 저장
     const oldName = this.props[at].name;
-    this.props.splice(at, 1);
 
     // 저장할 엔티티
     const entities: Entity[] = [this];
@@ -725,20 +780,32 @@ export class Entity {
       const relEntitySubsetKeys = Object.keys(relEntity.subsets);
       for (const subsetKey of relEntitySubsetKeys) {
         const subset = relEntity.subsets[subsetKey];
-        const oldSubsetFields = subset.filter(
-          (field) =>
-            field.endsWith(oldName) &&
-            relEntity.getEntityIdFromSubsetField(field) === this.id
-        );
-        if (oldSubsetFields.length > 0) {
-          relEntity.subsets[subsetKey] = relEntity.subsets[subsetKey].filter(
-            (oldField) => oldSubsetFields.includes(oldField) === false
-          );
+        // 서브셋 필드를 순회하며, 엔티티-프롭 단위로 분석한 후 현재 엔티티-프롭과 일치하는 경우 이후의 필드를 제외
+        const modifiedSubsetFields = subset
+          .map((subsetField) => {
+            const analyzed = relEntity.analyzeSubsetField(subsetField);
+            if (
+              analyzed.find(
+                (a) => a.propName === oldName && a.entityId === this.id
+              )
+            ) {
+              return null;
+            } else {
+              return subsetField;
+            }
+          })
+          .filter(nonNullable);
+
+        if (subset.join(",") !== modifiedSubsetFields.join(",")) {
+          relEntity.subsets[subsetKey] = modifiedSubsetFields;
           entities.push(relEntity);
         }
       }
     }
 
+    // 프롭 삭제
+    this.props.splice(at, 1);
+
     await Promise.all(entities.map(async (entity) => entity.save()));
   }
 
@@ -751,15 +818,17 @@ export class Entity {
     const arr = subsetField.split(".").slice(0, -1);
 
     // 서브셋 필드를 내려가면서 마지막으로 relation된 엔티티를 찾음
-    const lastEntity = arr.reduce((entity, field) => {
-      const relProp = entity.props.find((p) => p.name === field);
+    const lastEntityId = arr.reduce((entityId, field) => {
+      const relProp = EntityManager.get(entityId).props.find(
+        (p) => p.name === field
+      );
       if (!relProp || relProp.type !== "relation") {
-        console.debug({ arr, thisId: this.id });
+        console.debug({ arr, thisId: this.id, entityId, field });
         throw new Error(`잘못된 서브셋키 ${subsetField}`);
       }
-      return EntityManager.get(relProp.with);
-    }, this as Entity);
-    return lastEntity.id;
+      return relProp.with;
+    }, this.id);
+    return lastEntityId;
   }
 
   async moveProp(at: number, to: number): Promise<void> {

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/shared/web.shared.ts.txt

@@ -4,6 +4,7 @@
 import type { AxiosRequestConfig } from "axios";
 import axios from "axios";
 import { z, ZodIssue } from "zod";
+import qs from 'qs';
 
 export async function fetch(options: AxiosRequestConfig) {
   try {
@@ -71,12 +72,23 @@ export type SWRError = {
   message: string;
   statusCode: number;
 };
-export async function swrFetcher(
-  url: string,
-  params: string = ""
-): Promise<any> {
+export async function swrFetcher(args: [string, object]): Promise<any> {
   try {
-    const res = await axios.get(url + "?" + params);
+    const [url, params] = args;
+    const res = await axios.get(`${url}?${qs.stringify(params)}`);
+    return res.data;
+  } catch (e: any) {
+    const error: any = new Error(
+      e.response.data.message ?? e.response.message ?? "Unknown"
+    );
+    error.statusCode = e.response?.data.statusCode ?? e.response.status;
+    throw error;
+  }
+}
+export async function swrPostFetcher(args: [string, object]): Promise<any> {
+  try {
+    const [url, params] = args;
+    const res = await axios.post(url, params);
     return res.data;
   } catch (e: any) {
     const error: any = new Error(
@@ -87,13 +99,13 @@ export async function swrFetcher(
   }
 }
 export function handleConditional(
-  route: string | string[],
+  args: [string, object],
   conditional?: () => boolean
-): string | string[] | null {
+): [string, object] | null {
   if (conditional) {
-    return conditional() ? route : null;
+    return conditional() ? args : null;
   }
-  return route;
+  return args;
 }
 
 /*

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: {
@@ -1217,7 +1255,10 @@ export class Syncer {
     }
   }
 
-  async getColumnsNode(entityId: string, subsetKey: string) {
+  async getColumnsNode(
+    entityId: string,
+    subsetKey: string
+  ): Promise<RenderingNode> {
     const entity = await EntityManager.get(entityId);
     const subsetA = entity.subsets[subsetKey];
     if (subsetA === undefined) {
@@ -1296,12 +1337,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: [],