sonamu 0.0.42 → 0.1.0

package/src/{smd → entity}/migrator.ts

@@ -3,9 +3,11 @@ import _, {
   differenceBy,
   differenceWith,
   groupBy,
+  intersection,
   intersectionBy,
   pick,
   sortBy,
+  sum,
   uniq,
   uniqBy,
 } from "lodash";
@@ -51,14 +53,34 @@ import {
   RelationOn,
 } from "../types/types";
 import { propIf } from "../utils/lodash-able";
-import { SMDManager } from "./smd-manager";
-import { SMD } from "./smd";
+import { EntityManager } from "./entity-manager";
+import { Entity } from "./entity";
 import { Sonamu } from "../api";
+import { ServiceUnavailableException } from "../exceptions/so-exceptions";
+import { nonNullable } from "../utils/utils";
 
 type MigratorMode = "dev" | "deploy";
 export type MigratorOptions = {
   readonly mode: MigratorMode;
 };
+type MigrationCode = {
+  name: string;
+  path: string;
+};
+type ConnString = `${"mysql2"}://${string}@${string}:${number}/${string}`; // mysql2://account@host:port/database
+export type MigrationStatus = {
+  codes: MigrationCode[];
+  conns: {
+    name: string;
+    connKey: string;
+    connString: ConnString;
+    currentVersion: string;
+    status: string | number;
+    pending: string[];
+  }[];
+  preparedCodes: GenMigrationCode[];
+};
+
 export class Migrator {
   readonly mode: MigratorMode;
 
@@ -108,6 +130,279 @@ export class Migrator {
     }
   }
 
+  async getMigrationCodes(): Promise<{
+    normal: MigrationCode[];
+    onlyTs: MigrationCode[];
+    onlyJs: MigrationCode[];
+  }> {
+    const srcMigrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
+    const distMigrationsDir = `${Sonamu.apiRootPath}/dist/migrations`;
+    const srcMigrations = readdirSync(srcMigrationsDir)
+      .filter((f) => f.endsWith(".ts"))
+      .map((f) => f.split(".")[0]);
+    const distMigrations = readdirSync(distMigrationsDir)
+      .filter((f) => f.endsWith(".js"))
+      .map((f) => f.split(".")[0]);
+
+    const normal = intersection(srcMigrations, distMigrations)
+      .map((filename) => {
+        return {
+          name: filename,
+          path: path.join(srcMigrationsDir, filename) + ".ts",
+        };
+      })
+      .sort((a, b) => (a > b ? 1 : -1));
+
+    const onlyTs = difference(srcMigrations, distMigrations).map((filename) => {
+      return {
+        name: filename,
+        path: path.join(srcMigrationsDir, filename) + ".ts",
+      };
+    });
+
+    const onlyJs = difference(distMigrations, srcMigrations).map((filename) => {
+      return {
+        name: filename,
+        path: path.join(distMigrationsDir, filename) + ".js",
+      };
+    });
+
+    return {
+      normal,
+      onlyTs,
+      onlyJs,
+    };
+  }
+
+  async getStatus(): Promise<MigrationStatus> {
+    const { normal, onlyTs, onlyJs } = await this.getMigrationCodes();
+    if (onlyTs.length > 0) {
+      console.debug({ onlyTs });
+      throw new ServiceUnavailableException(
+        `There is an un-compiled TS migration files.\nPlease run the dev:serve\n\n${onlyTs
+          .map((f) => f.name)
+          .join("\n")}`
+      );
+    }
+    if (onlyJs.length > 0) {
+      console.debug({ onlyJs });
+      await Promise.all(
+        onlyJs.map(async (f) => {
+          execSync(
+            `rm -f ${f.path.replace("/src/", "/dist/").replace(".ts", ".js")}`
+          );
+        })
+      );
+    }
+
+    const connKeys = Object.keys(Sonamu.dbConfig).filter(
+      (key) => key.endsWith("_slave") === false
+    ) as (keyof typeof Sonamu.dbConfig)[];
+
+    const statuses = await Promise.all(
+      connKeys.map(async (connKey) => {
+        const knexOptions = Sonamu.dbConfig[connKey];
+        const tConn = knex(knexOptions);
+        const status = await (async () => {
+          try {
+            return tConn.migrate.status();
+          } catch (err) {
+            return "error";
+          }
+        })();
+        const pending = await (async () => {
+          try {
+            const [, fdList] = await tConn.migrate.list();
+            return fdList.map((fd: { file: string }) =>
+              fd.file.replace(".js", "")
+            );
+          } catch (err) {
+            return [];
+          }
+        })();
+        const currentVersion = await (async () => {
+          try {
+            return tConn.migrate.currentVersion();
+          } catch (err) {
+            return "error";
+          }
+        })();
+
+        const connection =
+          knexOptions.connection as Knex.MySql2ConnectionConfig;
+
+        await tConn.destroy();
+
+        return {
+          name: connKey.replace("_master", ""),
+          connKey,
+          connString: `${knexOptions.client}://${connection.user ?? ""}@${
+            connection.host
+          }:${connection.port ?? 3306}/${connection.database}` as ConnString,
+          currentVersion,
+          status,
+          pending,
+        };
+      })
+    );
+
+    const preparedCodes: GenMigrationCode[] = await (async () => {
+      const status0conn = statuses.find((status) => status.status === 0);
+      if (status0conn === undefined) {
+        return [];
+      }
+
+      const compareDBconn = knex(Sonamu.dbConfig[status0conn.connKey]);
+      const genCodes = await this.compareMigrations(compareDBconn);
+
+      await compareDBconn.destroy();
+
+      return genCodes;
+    })();
+
+    return {
+      conns: statuses,
+      codes: normal,
+      preparedCodes,
+    };
+    /*
+      TS/JS 코드 컴파일 상태 확인
+      1. 원본 파일 없는 JS파일이 존재하는 경우: 삭제
+      2. 컴파일 되지 않은 TS파일이 존재하는 경우: throw 쳐서 데브 서버 오픈 요청
+
+      DB 마이그레이션 상태 확인
+      1. 전체 DB설정에 대해서 현재 마이그레이션 상태 확인
+        - connKey: string
+        - status: number
+        - currentVersion: string
+        - list: { file: string; directory: string }[]
+
+    */
+  }
+
+  async runAction(
+    action: "latest" | "rollback",
+    targets: string[]
+  ): Promise<
+    {
+      connKey: string;
+      batchNo: number;
+      applied: string[];
+    }[]
+  > {
+    // get connections
+    const conns = (
+      await Promise.all(
+        targets.map(async (target) => {
+          const knexOptions =
+            Sonamu.dbConfig[target as keyof typeof Sonamu.dbConfig];
+          if (knexOptions === undefined) {
+            return null;
+          }
+
+          return {
+            connKey: target,
+            knex: knex(knexOptions),
+          };
+        })
+      )
+    ).filter(nonNullable);
+
+    // action
+    const result = await (async () => {
+      switch (action) {
+        case "latest":
+          return Promise.all(
+            conns.map(async ({ connKey, knex }) => {
+              const [batchNo, applied] = await knex.migrate.latest();
+              return {
+                connKey,
+                batchNo,
+                applied,
+              };
+            })
+          );
+        case "rollback":
+          return Promise.all(
+            conns.map(async ({ connKey, knex }) => {
+              const [batchNo, applied] = await knex.migrate.rollback();
+              return {
+                connKey,
+                batchNo,
+                applied,
+              };
+            })
+          );
+      }
+    })();
+
+    // destroy
+    await Promise.all(
+      conns.map(({ knex }) => {
+        return knex.destroy();
+      })
+    );
+
+    return result;
+  }
+
+  async delCodes(codeNames: string[]): Promise<number> {
+    const { conns } = await this.getStatus();
+    if (
+      conns.some((conn) => {
+        return codeNames.some(
+          (codeName) => conn.pending.includes(codeName) === false
+        );
+      })
+    ) {
+      throw new Error(
+        "You cannot delete a migration file if there is already applied."
+      );
+    }
+
+    const delFiles = codeNames
+      .map((codeName) => [
+        `${Sonamu.apiRootPath}/src/migrations/${codeName}.ts`,
+        `${Sonamu.apiRootPath}/dist/migrations/${codeName}.js`,
+      ])
+      .flat();
+
+    const res = await Promise.all(
+      delFiles.map((delFile) => {
+        if (existsSync(delFile)) {
+          console.log(chalk.red(`DELETE: ${delFile}`));
+          unlinkSync(delFile);
+          return delFiles.includes(".ts") ? 1 : 0;
+        }
+        return 0;
+      })
+    );
+    return sum(res);
+  }
+
+  async generatePreparedCodes(): Promise<number> {
+    const { preparedCodes } = await this.getStatus();
+    if (preparedCodes.length === 0) {
+      console.log(chalk.green("\n현재 모두 싱크된 상태입니다."));
+      return 0;
+    }
+
+    // 실제 코드 생성
+    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
+    preparedCodes
+      .filter((pcode) => pcode.formatted)
+      .map((pcode, index) => {
+        const dateTag = DateTime.local()
+          .plus({ seconds: index })
+          .toFormat("yyyyMMddHHmmss");
+        const filePath = `${migrationsDir}/${dateTag}_${pcode.title}.ts`;
+        writeFileSync(filePath, pcode.formatted!);
+        console.log(chalk.green(`MIGRTAION CRETATED ${filePath}`));
+      });
+
+    return preparedCodes.length;
+  }
+
   async clearPendingList(): Promise<void> {
     const [, pendingList] = (await this.targets.pending.migrate.list()) as [
       unknown,
@@ -129,7 +424,7 @@ export class Migrator {
   }
 
   async check(): Promise<void> {
-    const codes = await this.compareMigrations();
+    const codes = await this.compareMigrations(this.targets.compare!);
     if (codes.length === 0) {
       console.log(chalk.green("\n현재 모두 싱크된 상태입니다."));
       return;
@@ -161,27 +456,24 @@ export class Migrator {
       }
 
       console.time(chalk.blue("Migrator - runShadowTest"));
-      const result = await this.runShadowTest();
+      await this.runShadowTest();
       console.timeEnd(chalk.blue("Migrator - runShadowTest"));
-      if (result === true) {
-        await Promise.all(
-          this.targets.apply.map(async (applyDb) => {
-            const label = chalk.green(
-              `APPLIED ${
-                applyDb.client.connectionSettings.host
-              } ${applyDb.client.database()}`
-            );
-            console.time(label);
-            const [,] = await applyDb.migrate.latest();
-            console.timeEnd(label);
-          })
-        );
-      }
-      return;
+      await Promise.all(
+        this.targets.apply.map(async (applyDb) => {
+          const label = chalk.green(
+            `APPLIED ${
+              applyDb.client.connectionSettings.host
+            } ${applyDb.client.database()}`
+          );
+          console.time(label);
+          const [,] = await applyDb.migrate.latest();
+          console.timeEnd(label);
+        })
+      );
     }
 
     // MD-DB간 비교하여 코드 생성 리턴
-    const codes = await this.compareMigrations();
+    const codes = await this.compareMigrations(this.targets.compare!);
     if (codes.length === 0) {
       console.log(chalk.green("\n현재 모두 싱크된 상태입니다."));
       return;
@@ -299,7 +591,13 @@ export class Migrator {
     }
   }
 
-  async runShadowTest(): Promise<boolean> {
+  async runShadowTest(): Promise<
+    {
+      connKey: string;
+      batchNo: number;
+      applied: string[];
+    }[]
+  > {
     // ShadowDB 생성 후 테스트 진행
     const tdb = knex(Sonamu.dbConfig.test);
     const tdbConn = Sonamu.dbConfig.test.connection as Knex.ConnectionConfig;
@@ -337,24 +635,31 @@ export class Migrator {
       connection: {
         ...tdbConn,
         database: shadowDatabase,
+        password: tdbConn.password,
       },
     });
 
     try {
-      const [batchNo, log] = await sdb.migrate.latest();
+      const [batchNo, applied] = await sdb.migrate.latest();
       console.log(chalk.green("Shadow DB 테스트에 성공했습니다!"), {
         batchNo,
-        log,
+        applied,
       });
 
       // 생성한 Shadow DB 삭제
       console.log(chalk.magenta(`${shadowDatabase} 삭제`));
       await sdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase};`);
 
-      return true;
+      return [
+        {
+          connKey: "shadow",
+          batchNo,
+          applied,
+        },
+      ];
     } catch (e) {
-      console.error(chalk.red("Shadow DB 테스트 진행 중 에러"), e);
-      return false;
+      console.error(e);
+      throw new ServiceUnavailableException("Shadow DB 테스트 진행 중 에러");
     } finally {
       await sdb.destroy();
     }
@@ -388,45 +693,54 @@ export class Migrator {
     console.timeEnd(chalk.red("delete migration files"));
   }
 
-  async compareMigrations(): Promise<GenMigrationCode[]> {
+  async compareMigrations(compareDB: Knex): Promise<GenMigrationCode[]> {
     // MD 순회하여 싱크
-    const smdIds = SMDManager.getAllIds();
+    const entityIds = EntityManager.getAllIds();
 
     // 조인테이블 포함하여 MD에서 MigrationSet 추출
-    const smdSetsWithJoinTable = smdIds
-      .filter((smdId) => {
-        const smd = SMDManager.get(smdId);
-        return smd.props.length > 0;
+    const entitySetsWithJoinTable = entityIds
+      .filter((entityId) => {
+        const entity = EntityManager.get(entityId);
+        return entity.props.length > 0;
       })
-      .map((smdId) => {
-        const smd = SMDManager.get(smdId);
-        return this.getMigrationSetFromMD(smd);
+      .map((entityId) => {
+        const entity = EntityManager.get(entityId);
+        return this.getMigrationSetFromMD(entity);
       });
 
     // 조인테이블만 추출
     const joinTables = uniqBy(
-      smdSetsWithJoinTable.map((smdSet) => smdSet.joinTables).flat(),
+      entitySetsWithJoinTable.map((entitySet) => entitySet.joinTables).flat(),
       (joinTable) => {
         return joinTable.table;
       }
     );
 
     // 조인테이블 포함하여 MigrationSet 배열
-    const smdSets: MigrationSet[] = [...smdSetsWithJoinTable, ...joinTables];
+    const entitySets: MigrationSet[] = [
+      ...entitySetsWithJoinTable,
+      ...joinTables,
+    ];
 
     let codes: GenMigrationCode[] = (
       await Promise.all(
-        smdSets.map(async (smdSet) => {
-          const dbSet = await this.getMigrationSetFromDB(smdSet.table);
+        entitySets.map(async (entitySet) => {
+          const dbSet = await this.getMigrationSetFromDB(
+            compareDB,
+            entitySet.table
+          );
           if (dbSet === null) {
             // 기존 테이블 없음, 새로 테이블 생성
             return [
               this.generateCreateCode_ColumnAndIndexes(
-                smdSet.table,
-                smdSet.columns,
-                smdSet.indexes
+                entitySet.table,
+                entitySet.columns,
+                entitySet.indexes
+              ),
+              ...this.generateCreateCode_Foreign(
+                entitySet.table,
+                entitySet.foreigns
               ),
-              ...this.generateCreateCode_Foreign(smdSet.table, smdSet.foreigns),
             ];
           }
 
@@ -436,20 +750,20 @@ export class Migrator {
           ).map((key) => {
             // 배열 원소의 순서가 달라서 불일치가 발생하는걸 방지하기 위해 각 항목별로 정렬 처리 후 비교
             if (key === "columnsAndIndexes") {
-              const smdColumns = sortBy(smdSet.columns, (a) => a.name);
+              const entityColumns = sortBy(entitySet.columns, (a) => a.name);
               const dbColumns = sortBy(dbSet.columns, (a) => a.name);
 
               /* 디버깅용 코드, 특정 컬럼에서 불일치 발생할 때 확인
-              const smdCreatedAt = smdSet.columns.find(
+              const entityCreatedAt = entitySet.columns.find(
                 (col) => col.name === "created_at"
               );
               const dbCreatedAt = dbSet.columns.find(
                 (col) => col.name === "created_at"
               );
-              console.debug({ smdCreatedAt, dbCreatedAt });
+              console.debug({ entityCreatedAt, dbCreatedAt });
               */
 
-              const smdIndexes = sortBy(smdSet.indexes, (a) =>
+              const entityIndexes = sortBy(entitySet.indexes, (a) =>
                 [
                   a.type,
                   ...a.columns.sort((c1, c2) => (c1 > c2 ? 1 : -1)),
@@ -462,17 +776,17 @@ export class Migrator {
                 ].join("-")
               );
 
-              const isEqualColumns = equal(smdColumns, dbColumns);
-              const isEqualIndexes = equal(smdIndexes, dbIndexes);
+              const isEqualColumns = equal(entityColumns, dbColumns);
+              const isEqualIndexes = equal(entityIndexes, dbIndexes);
               if (isEqualColumns && isEqualIndexes) {
                 return null;
               } else {
-                // this.showMigrationSet("MD", smdSet);
+                // this.showMigrationSet("MD", entitySet);
                 // this.showMigrationSet("DB", dbSet);
                 return this.generateAlterCode_ColumnAndIndexes(
-                  smdSet.table,
-                  smdColumns,
-                  smdIndexes,
+                  entitySet.table,
+                  entityColumns,
+                  entityIndexes,
                   dbColumns,
                   dbIndexes
                 );
@@ -488,18 +802,18 @@ export class Migrator {
                 };
               };
 
-              const smdForeigns = sortBy(smdSet.foreigns, (a) =>
+              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(smdForeigns, dbForeigns) === false) {
-                console.dir({ smdForeigns, dbForeigns }, { depth: null });
+              if (equal(entityForeigns, dbForeigns) === false) {
+                console.dir({ entityForeigns, dbForeigns }, { depth: null });
                 return this.generateAlterCode_Foreigns(
-                  smdSet.table,
-                  smdForeigns,
+                  entitySet.table,
+                  entityForeigns,
                   dbForeigns
                 );
               }
@@ -536,10 +850,16 @@ export class Migrator {
   /*
     기존 테이블 정보 읽어서 MigrationSet 형식으로 리턴
   */
-  async getMigrationSetFromDB(table: string): Promise<MigrationSet | null> {
+  async getMigrationSetFromDB(
+    compareDB: Knex,
+    table: string
+  ): Promise<MigrationSet | null> {
     let dbColumns: DBColumn[], dbIndexes: DBIndex[], dbForeigns: DBForeign[];
     try {
-      [dbColumns, dbIndexes, dbForeigns] = await this.readTable(table);
+      [dbColumns, dbIndexes, dbForeigns] = await this.readTable(
+        compareDB,
+        table
+      );
     } catch (e: unknown) {
       if (isKnexError(e) && e.code === "ER_NO_SUCH_TABLE") {
         return null;
@@ -695,19 +1015,14 @@ export class Migrator {
     기존 테이블 읽어서 cols, indexes 반환
   */
   async readTable(
+    compareDB: Knex,
     tableName: string
   ): Promise<[DBColumn[], DBIndex[], DBForeign[]]> {
     // 테이블 정보
     try {
-      const [cols] = await this.targets.compare!.raw(
-        `SHOW FIELDS FROM ${tableName}`
-      );
-      const [indexes] = await this.targets.compare!.raw(
-        `SHOW INDEX FROM ${tableName}`
-      );
-      const [[row]] = await this.targets.compare!.raw(
-        `SHOW CREATE TABLE ${tableName}`
-      );
+      const [cols] = await compareDB.raw(`SHOW FIELDS FROM ${tableName}`);
+      const [indexes] = await compareDB.raw(`SHOW INDEX FROM ${tableName}`);
+      const [[row]] = await compareDB.raw(`SHOW CREATE TABLE ${tableName}`);
       const ddl = row["Create Table"];
       const matched = ddl.match(/CONSTRAINT .+/g);
       const foreignKeys = (matched ?? []).map((line: string) => {
@@ -766,8 +1081,8 @@ export class Migrator {
   /*
     MD 내용 읽어서 MigrationSetAndJoinTable 추출
   */
-  getMigrationSetFromMD(smd: SMD): MigrationSetAndJoinTable {
-    const migrationSet: MigrationSetAndJoinTable = smd.props.reduce(
+  getMigrationSetFromMD(entity: Entity): MigrationSetAndJoinTable {
+    const migrationSet: MigrationSetAndJoinTable = entity.props.reduce(
       (r, prop) => {
         // virtual 필드 제외
         if (isVirtualProp(prop)) {
@@ -818,10 +1133,10 @@ export class Migrator {
 
         if (isManyToManyRelationProp(prop)) {
           // ManyToMany 케이스
-          const relMd = SMDManager.get(prop.with);
+          const relMd = EntityManager.get(prop.with);
           const [table1, table2] = prop.joinTable.split("__");
           const join = {
-            from: `${smd.table}.id`,
+            from: `${entity.table}.id`,
             through: {
               from: `${prop.joinTable}.${singularize(table1)}_id`,
               to: `${prop.joinTable}.${singularize(table2)}_id`,
@@ -840,7 +1155,7 @@ export class Migrator {
                 columns: ["uuid"],
               },
               // 조인 테이블에 걸린 인덱스 찾아와서 연결
-              ...smd.indexes
+              ...entity.indexes
                 .filter((index) =>
                   index.columns.find((col) =>
                     col.includes(prop.joinTable + ".")
@@ -907,7 +1222,7 @@ export class Migrator {
         return r;
       },
       {
-        table: smd.table,
+        table: entity.table,
         columns: [] as MigrationColumn[],
         indexes: [] as MigrationIndex[],
         foreigns: [] as MigrationForeign[],
@@ -916,7 +1231,7 @@ export class Migrator {
     );
 
     // indexes
-    migrationSet.indexes = smd.indexes.filter((index) =>
+    migrationSet.indexes = entity.indexes.filter((index) =>
       index.columns.find((col) => col.includes(".") === false)
     );
 
@@ -1183,8 +1498,8 @@ export class Migrator {
 
   generateAlterCode_ColumnAndIndexes(
     table: string,
-    smdColumns: MigrationColumn[],
-    smdIndexes: MigrationIndex[],
+    entityColumns: MigrationColumn[],
+    entityIndexes: MigrationIndex[],
     dbColumns: MigrationColumn[],
     dbIndexes: MigrationIndex[]
   ): GenMigrationCode[] {
@@ -1201,16 +1516,16 @@ export class Migrator {
     */
 
     // 각 컬럼 이름 기준으로 add, drop, alter 여부 확인
-    const alterColumnsTo = this.getAlterColumnsTo(smdColumns, dbColumns);
+    const alterColumnsTo = this.getAlterColumnsTo(entityColumns, dbColumns);
 
     // 추출된 컬럼들을 기준으로 각각 라인 생성
     const alterColumnLinesTo = this.getAlterColumnLinesTo(
       alterColumnsTo,
-      smdColumns
+      entityColumns
     );
 
     // 인덱스의 add, drop 여부 확인
-    const alterIndexesTo = this.getAlterIndexesTo(smdIndexes, dbIndexes);
+    const alterIndexesTo = this.getAlterIndexesTo(entityIndexes, dbIndexes);
 
     // 추출된 인덱스들을 기준으로 각각 라인 생성
     const alterIndexLinesTo = this.getAlterIndexLinesTo(
@@ -1275,7 +1590,7 @@ export class Migrator {
   }
 
   getAlterColumnsTo(
-    smdColumns: MigrationColumn[],
+    entityColumns: MigrationColumn[],
     dbColumns: MigrationColumn[]
   ) {
     const columnsTo = {
@@ -1286,11 +1601,11 @@ export class Migrator {
 
     // 컬럼명 기준 비교
     const extraColumns = {
-      db: differenceBy(dbColumns, smdColumns, (col) => col.name),
-      smd: differenceBy(smdColumns, dbColumns, (col) => col.name),
+      db: differenceBy(dbColumns, entityColumns, (col) => col.name),
+      entity: differenceBy(entityColumns, dbColumns, (col) => col.name),
     };
-    if (extraColumns.smd.length > 0) {
-      columnsTo.add = columnsTo.add.concat(extraColumns.smd);
+    if (extraColumns.entity.length > 0) {
+      columnsTo.add = columnsTo.add.concat(extraColumns.entity);
     }
     if (extraColumns.db.length > 0) {
       columnsTo.drop = columnsTo.drop.concat(extraColumns.db);
@@ -1299,11 +1614,11 @@ export class Migrator {
     // 동일 컬럼명의 세부 필드 비교
     const sameDbColumns = intersectionBy(
       dbColumns,
-      smdColumns,
+      entityColumns,
       (col) => col.name
     );
     const sameMdColumns = intersectionBy(
-      smdColumns,
+      entityColumns,
       dbColumns,
       (col) => col.name
     );
@@ -1316,7 +1631,7 @@ export class Migrator {
 
   getAlterColumnLinesTo(
     columnsTo: ReturnType<Migrator["getAlterColumnsTo"]>,
-    smdColumns: MigrationColumn[]
+    entityColumns: MigrationColumn[]
   ) {
     let linesTo = {
       add: {
@@ -1356,19 +1671,21 @@ export class Migrator {
     };
     linesTo.alter = columnsTo.alter.reduce(
       (r, dbColumn) => {
-        const smdColumn = smdColumns.find((col) => col.name == dbColumn.name);
-        if (smdColumn === undefined) {
+        const entityColumn = entityColumns.find(
+          (col) => col.name == dbColumn.name
+        );
+        if (entityColumn === undefined) {
           return r;
         }
 
         // 컬럼 변경사항
         const columnDiffUp = difference(
-          this.genColumnDefinitions([smdColumn]),
+          this.genColumnDefinitions([entityColumn]),
           this.genColumnDefinitions([dbColumn])
         );
         const columnDiffDown = difference(
           this.genColumnDefinitions([dbColumn]),
-          this.genColumnDefinitions([smdColumn])
+          this.genColumnDefinitions([entityColumn])
         );
         if (columnDiffUp.length > 0) {
           r.up = [
@@ -1394,22 +1711,25 @@ export class Migrator {
     return linesTo;
   }
 
-  getAlterIndexesTo(smdIndexes: MigrationIndex[], dbIndexes: MigrationIndex[]) {
+  getAlterIndexesTo(
+    entityIndexes: MigrationIndex[],
+    dbIndexes: MigrationIndex[]
+  ) {
     // 인덱스 비교
     let indexesTo = {
       add: [] as MigrationIndex[],
       drop: [] as MigrationIndex[],
     };
     const extraIndexes = {
-      db: differenceBy(dbIndexes, smdIndexes, (col) =>
+      db: differenceBy(dbIndexes, entityIndexes, (col) =>
         [col.type, col.columns.join("-")].join("//")
       ),
-      smd: differenceBy(smdIndexes, dbIndexes, (col) =>
+      entity: differenceBy(entityIndexes, dbIndexes, (col) =>
         [col.type, col.columns.join("-")].join("//")
       ),
     };
-    if (extraIndexes.smd.length > 0) {
-      indexesTo.add = indexesTo.add.concat(extraIndexes.smd);
+    if (extraIndexes.entity.length > 0) {
+      indexesTo.add = indexesTo.add.concat(extraIndexes.entity);
     }
     if (extraIndexes.db.length > 0) {
       indexesTo.drop = indexesTo.drop.concat(extraIndexes.db);
@@ -1481,27 +1801,27 @@ export class Migrator {
 
   generateAlterCode_Foreigns(
     table: string,
-    smdForeigns: MigrationForeign[],
+    entityForeigns: MigrationForeign[],
     dbForeigns: MigrationForeign[]
   ): GenMigrationCode[] {
-    // console.log({ smdForeigns, dbForeigns });
+    // console.log({ entityForeigns, dbForeigns });
 
     const getKey = (mf: MigrationForeign): string => {
       return [mf.columns.join("-"), mf.to].join("///");
     };
-    const fkTo = smdForeigns.reduce(
-      (result, smdF) => {
+    const fkTo = entityForeigns.reduce(
+      (result, entityF) => {
         const matchingDbF = dbForeigns.find(
-          (dbF) => getKey(smdF) === getKey(dbF)
+          (dbF) => getKey(entityF) === getKey(dbF)
         );
         if (!matchingDbF) {
-          result.add.push(smdF);
+          result.add.push(entityF);
           return result;
         }
 
-        if (equal(smdF, matchingDbF) === false) {
+        if (equal(entityF, matchingDbF) === false) {
           result.alterSrc.push(matchingDbF);
-          result.alterDst.push(smdF);
+          result.alterDst.push(entityF);
           return result;
         }
         return result;