sonamu 0.5.7 → 0.7.0

package/src/migration/migrator.ts

@@ -1,135 +1,48 @@
-import _ from "lodash";
-import knex, { Knex } from "knex";
+import assert from "assert";
 import chalk from "chalk";
-import { DateTime } from "luxon";
 import { mkdir, readdir, unlink, writeFile } from "fs/promises";
-import { exists } from "../utils/fs-utils";
-import prompts from "prompts";
-import { execSync } from "child_process";
+import knex, { type Knex } from "knex";
 import path from "path";
-import { GenMigrationCode, MigrationSet } from "../types/types";
-import { EntityManager } from "../entity/entity-manager";
+import { group, sum, unique } from "radashi";
 import { Sonamu } from "../api";
+import { DB, type SonamuDBConfig } from "../database/db";
+import { EntityManager } from "../entity/entity-manager";
 import { ServiceUnavailableException } from "../exceptions/so-exceptions";
-import { SonamuDBConfig } from "../database/db";
-import { generateCreateCode, generateAlterCode } from "./code-generation";
-import { MigrationStatus, MigrationCode, ConnString } from "./types";
-import { getMigrationSetFromDB } from "./migration-set";
+import { Naite } from "../naite/naite";
+import type { GenMigrationCode, MigrationSet } from "../types/types";
+import { isTest } from "../utils/controller";
+import { exists } from "../utils/fs-utils";
+import { generateAlterCode, generateCreateCode } from "./code-generation";
 import { getMigrationSetFromEntity } from "./migration-set";
+import { PostgreSQLSchemaReader } from "./postgresql-schema-reader";
+import type { ConnString, MigrationCode, MigrationStatus } from "./types";
 
-type MigratorMode = "dev" | "deploy";
-export type MigratorOptions = {
-  readonly mode: MigratorMode;
-};
+export type MigrationResult = {
+  connKey: string;
+  batchNo: number;
+  applied: string[];
+}[];
 
 export class Migrator {
-  targets: {
-    compare?: Knex;
-    pending: Knex;
-    shadow: Knex;
-    apply: Knex[];
-  };
-
-  constructor(private readonly options: MigratorOptions) {
-    const { dbConfig } = Sonamu;
-
-    if (this.options.mode === "dev") {
-      const devDB = knex(dbConfig.development_master);
-      const testDB = knex(dbConfig.test);
-      const fixtureLocalDB = knex(dbConfig.fixture_local);
-
-      const applyDBs = [devDB, testDB, fixtureLocalDB];
-      if (
-        (dbConfig.fixture_local.connection as Knex.MySql2ConnectionConfig)
-          .host !==
-          (dbConfig.fixture_remote.connection as Knex.MySql2ConnectionConfig)
-            .host ||
-        (dbConfig.fixture_local.connection as Knex.MySql2ConnectionConfig)
-          .database !==
-          (dbConfig.fixture_remote.connection as Knex.MySql2ConnectionConfig)
-            .database
-      ) {
-        const fixtureRemoteDB = knex(dbConfig.fixture_remote);
-        applyDBs.push(fixtureRemoteDB);
-      }
-
-      this.targets = {
-        compare: devDB,
-        pending: devDB,
-        shadow: testDB,
-        apply: applyDBs,
-      };
-    } else if (this.options.mode === "deploy") {
-      const productionDB = knex(dbConfig.production_master);
-      const testDB = knex(dbConfig.test);
-
-      this.targets = {
-        pending: productionDB,
-        shadow: testDB,
-        apply: [productionDB],
-      };
-    } else {
-      throw new Error(`잘못된 모드 ${this.options.mode} 입력`);
-    }
-  }
-
-  private async getMigrationCodes(): Promise<{
-    normal: MigrationCode[];
-    onlyTs: MigrationCode[];
-    onlyJs: MigrationCode[];
-  }> {
-    const srcMigrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
-    const distMigrationsDir = `${Sonamu.apiRootPath}/dist/migrations`;
+  private async getMigrationCodes(): Promise<MigrationCode[]> {
+    const srcMigrationsDir = path.join(Sonamu.apiRootPath, "src", "migrations"); // 이건 환경에 관계없이 항상 src에서 찾아야 해요.
 
     if (!(await exists(srcMigrationsDir))) {
       await mkdir(srcMigrationsDir, {
         recursive: true,
       });
     }
-    if (!(await exists(distMigrationsDir))) {
-      await mkdir(distMigrationsDir, {
-        recursive: true,
-      });
-    }
-    const srcMigrations = (await readdir(srcMigrationsDir))
-      .filter((f) => f.endsWith(".ts"))
-      .map((f) => f.split(".")[0]);
-    const distMigrations = (await readdir(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",
-        };
-      }
-    );
+    const codes = (await readdir(srcMigrationsDir))
+      .filter((f) => f.endsWith(".ts"))
+      .map((f) => ({
+        name: f.replace(".ts", ""),
+        path: path.join(srcMigrationsDir, f),
+      }))
+      .sort((a, b) => (a.name < b.name ? 1 : -1)); // 이름 내림차순 정렬(최신순)
 
-    return {
-      normal,
-      onlyTs,
-      onlyJs,
-    };
+    Naite.t("migrator:getMigrationCodes:results", codes);
+    return codes;
   }
 
   /**
@@ -142,30 +55,15 @@ export class Migrator {
    * @returns
    */
   async getStatus(): Promise<MigrationStatus> {
-    const { normal, onlyTs, onlyJs } = await this.getMigrationCodes();
-    if (onlyTs.length > 0) {
-      console.debug({ onlyTs });
-      throw new ServiceUnavailableException(
-        `There are un-compiled TS migration files.\nPlease compile them first. You might want to run a development server with HMR.\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 codes = await this.getMigrationCodes();
+    Naite.t("migrator:getStatus:codes", codes);
 
     const connKeys = Object.keys(Sonamu.dbConfig).filter(
-      (key) => key.endsWith("_slave") === false
+      (key) => key.endsWith("_slave") === false,
     ) as (keyof typeof Sonamu.dbConfig)[];
 
+    let migrationStatusError: string | undefined;
+
     const statuses = await Promise.all(
       connKeys.map(async (connKey) => {
         const knexOptions = Sonamu.dbConfig[connKey];
@@ -177,51 +75,59 @@ export class Migrator {
           } catch (err) {
             console.warn(
               chalk.yellow(
-                `${connKey}의 마이그레이션 상태를 가져오는 데에 실패하였습니다. 데이터베이스가 올바르게 구성되지 않은 것 같습니다. 확인하시고 다시 시도해주세요.\n시도한 연결 설정:\n${JSON.stringify(knexOptions.connection, null, 2)}\n발생한 에러:\n${err}\n`
-              )
+                `${connKey}의 마이그레이션 상태를 가져오는 데에 실패하였습니다. 데이터베이스가 올바르게 구성되지 않은 것 같습니다. 확인하시고 다시 시도해주세요.\n시도한 연결 설정:\n${JSON.stringify(knexOptions.connection, null, 2)}\n발생한 에러:\n${err}\n`,
+              ),
             );
-            return "error" /*클라이언트에서 에러 체크에 사용하는 리터럴입니다.*/;
+            migrationStatusError = err instanceof Error ? err.message : String(err);
+            return "error";
           }
         })();
-        const pending = await (async () => {
+        const pending: string[] = await (async () => {
           try {
             const [, fdList] = await tConn.migrate.list();
-            return fdList.map((fd: { file: string }) =>
-              fd.file.replace(".js", "")
-            );
+            return fdList.map((fd: { file: string }) => fd.file.replace(".ts", ""));
           } catch (err) {
+            migrationStatusError = err instanceof Error ? err.message : String(err);
             return [];
           }
         })();
         const currentVersion = await (async () => {
           try {
             return await tConn.migrate.currentVersion();
-          } catch (err) {
+          } catch (_err) {
+            migrationStatusError = _err instanceof Error ? _err.message : String(_err);
             return "error";
           }
         })();
+        Naite.t("migrator:getStatus:status", status);
 
-        const connection =
-          knexOptions.connection as Knex.MySql2ConnectionConfig;
+        const connection = knexOptions.connection as Knex.PgConnectionConfig;
 
         await tConn.destroy();
 
         return {
           name: connKey.replace("_master", ""),
           connKey,
-          connString: `mysql2://${connection.user ?? ""}@${connection.host}:${
+          connString: `pg://${connection.user ?? ""}@${connection.host}:${
             connection.port
           }/${connection.database}` as ConnString,
           currentVersion,
-          status,
+          status: status as number | "error",
           pending,
         };
-      })
+      }),
     );
 
+    Naite.t("migrator:getStatus:conns", statuses);
+
     const preparedCodes: GenMigrationCode[] = await (async () => {
       const status0conn = statuses.find((status) => status.status === 0);
       if (status0conn === undefined) {
+        console.warn(
+          chalk.yellow(
+            `While trying to prepare migration codes, we found that there is no database to compare migrations. We need at least one database where every migration is applied(status === 0). You might want to apply your existing migrations to one of the databases.`,
+          ),
+        );
         return [];
       }
 
@@ -233,24 +139,14 @@ export class Migrator {
       return genCodes;
     })();
 
+    Naite.t("migrator:getStatus:preparedCodes", preparedCodes);
+
     return {
       conns: statuses,
-      codes: normal,
+      codes,
       preparedCodes,
+      error: migrationStatusError,
     };
-    /*
-    TS/JS 코드 컴파일 상태 확인
-    1. 원본 파일 없는 JS파일이 존재하는 경우: 삭제
-    2. 컴파일 되지 않은 TS파일이 존재하는 경우: throw 쳐서 데브 서버 오픈 요청
-    
-    DB 마이그레이션 상태 확인
-    1. 전체 DB설정에 대해서 현재 마이그레이션 상태 확인
-    - connKey: string
-    - status: number
-    - currentVersion: string
-    - list: { file: string; directory: string }[]
-    
-    */
   }
 
   /**
@@ -265,16 +161,13 @@ export class Migrator {
    */
   async runAction(
     action: "apply" | "rollback",
-    targets: (keyof SonamuDBConfig)[]
-  ): Promise<
-    {
-      connKey: string;
-      batchNo: number;
-      applied: string[];
-    }[]
-  > {
+    targets: (keyof SonamuDBConfig)[],
+  ): Promise<MigrationResult> {
+    Naite.t("migrator:runAction:action", action);
+    Naite.t("migrator:runAction:targets", targets);
+
     // get uniq knex configs
-    const configs = _.uniqBy(
+    const configs = unique(
       targets
         .map((target) => ({
           connKey: target,
@@ -282,9 +175,9 @@ export class Migrator {
         }))
         .filter((c) => c.options !== undefined),
       ({ options }) =>
-        `${(options.connection as Knex.MySql2ConnectionConfig).host}:${
-          (options.connection as Knex.MySql2ConnectionConfig).port ?? 3306
-        }/${(options.connection as Knex.MySql2ConnectionConfig).database}`
+        `${(options.connection as Knex.PgConnectionConfig).host}:${
+          (options.connection as Knex.PgConnectionConfig).port ?? 5432
+        }/${(options.connection as Knex.PgConnectionConfig).database}`,
     );
 
     // get connections
@@ -292,7 +185,7 @@ export class Migrator {
       configs.map(async (config) => ({
         connKey: config.connKey,
         knex: knex(config.options),
-      }))
+      })),
     );
 
     // action
@@ -305,9 +198,9 @@ export class Migrator {
               return {
                 connKey,
                 batchNo,
-                applied,
+                applied, // 이번 latest 호출로 인해 "up"이 적용된 마이그레이션 이름(e.g. "20251124233557_create__companies.ts")들의 배열입니다. 참고: https://github.com/knex/knex/blob/01b177c485d696f1b72858dee728ba143c4fad76/lib/migrations/migrate/Migrator.js#L560
               };
-            })
+            }),
           );
         case "rollback":
           return Promise.all(
@@ -316,9 +209,9 @@ export class Migrator {
               return {
                 connKey,
                 batchNo,
-                applied,
+                applied, // 이번 rollback 호출로 인해 "down"이 적용된(=롤백된) 마이그레이션 이름(e.g. "20251124233557_create__companies.ts")들의 배열입니다. 참고: https://github.com/knex/knex/blob/01b177c485d696f1b72858dee728ba143c4fad76/lib/migrations/migrate/Migrator.js#L611
               };
-            })
+            }),
           );
       }
     })();
@@ -327,12 +220,32 @@ export class Migrator {
     await Promise.all(
       conns.map(({ knex }) => {
         return knex.destroy();
-      })
+      }),
     );
 
+    Naite.t("migrator:runAction:result", result);
+
     return result;
   }
 
+  /**
+   * 삭제 가능한 마이그레이션 코드 파일을 검증합니다.
+   *
+   * @param conns 마이그레이션 상태 배열
+   * @param codeNames 삭제할 마이그레이션 코드 파일 이름 배열
+   * @returns 삭제 가능 여부 및 적용된 마이그레이션 코드 파일 이름
+   */
+  validateDeletable(conns: MigrationStatus["conns"], codeNames: string[]) {
+    const appliedCodes = codeNames.filter((codeName) =>
+      conns.some((conn) => conn.pending.includes(codeName) === false),
+    );
+
+    return {
+      canDelete: appliedCodes.length === 0,
+      appliedCodes,
+    };
+  }
+
   /**
    * 마이그레이션 코드 파일을 삭제합니다.
    *
@@ -343,36 +256,38 @@ export class Migrator {
    */
   async delCodes(codeNames: string[]): Promise<number> {
     const { conns } = await this.getStatus();
-    if (
-      conns.some((conn) => {
-        return codeNames.some(
-          (codeName) => conn.pending.includes(codeName) === false
-        );
-      })
-    ) {
+    const { canDelete, appliedCodes } = this.validateDeletable(conns, codeNames);
+    if (!canDelete) {
       throw new Error(
-        "You cannot delete a migration file if there is already applied."
+        `You cannot delete a migration file if there is already applied. Applied codes: ${appliedCodes.join(", ")}`,
       );
     }
 
-    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(async (delFile) => {
-        if (await exists(delFile)) {
-          console.log(chalk.red(`DELETE: ${delFile}`));
-          await unlink(delFile);
-          return delFiles.includes(".ts") ? 1 : 0;
-        }
-        return 0;
-      })
+    return sum(
+      await Promise.all(
+        codeNames.map(async (codeName) => {
+          const filePath = `${Sonamu.apiRootPath}/src/migrations/${codeName}.ts`;
+          if (await exists(filePath)) {
+            await unlink(filePath);
+            return 1;
+          }
+          return 0;
+        }),
+      ),
+    );
+  }
+
+  private genDateTag(index: number, baseDate: Date = new Date()): string {
+    const date = new Date(baseDate.getTime() + index * 1000);
+    const pad = (num: number, size: number = 2) => num.toString().padStart(size, "0");
+    return (
+      date.getFullYear().toString() +
+      pad(date.getMonth() + 1) +
+      pad(date.getDate()) +
+      pad(date.getHours()) +
+      pad(date.getMinutes()) +
+      pad(date.getSeconds())
     );
-    return _.sum(res);
   }
 
   /**
@@ -384,6 +299,7 @@ export class Migrator {
    */
   async generatePreparedCodes(): Promise<number> {
     const { preparedCodes } = await this.getStatus();
+    Naite.t("migrator:generatePreparedCodes:preparedCodes", preparedCodes);
     if (preparedCodes.length === 0) {
       console.log(chalk.green("\n현재 모두 싱크된 상태입니다."));
       return 0;
@@ -394,392 +310,54 @@ export class Migrator {
 
     for (const [index, pcode] of preparedCodes.entries()) {
       if (pcode.formatted) {
-        const dateTag = DateTime.local()
-          .plus({ seconds: index })
-          .toFormat("yyyyMMddHHmmss");
+        const dateTag = this.genDateTag(index);
         const filePath = `${migrationsDir}/${dateTag}_${pcode.title}.ts`;
-        await writeFile(filePath, pcode.formatted!);
-        console.log(chalk.green(`MIGRTAION CREATED ${filePath}`));
+        await writeFile(filePath, pcode.formatted);
+        !isTest() && console.log(chalk.green(`MIGRTAION CREATED ${filePath}`));
       }
     }
 
     return preparedCodes.length;
   }
 
-  /**
-   * pending 마이그레이션 목록을 삭제합니다.
-   *
-   * CLI에서 사용됩니다.
-   */
-  async clearPendingList(): Promise<void> {
-    const [, pendingList] = (await this.targets.pending.migrate.list()) as [
-      unknown,
-      {
-        file: string;
-        directory: string;
-      }[],
-    ];
-    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
-    const delList = pendingList.map((df) => {
-      return path.join(migrationsDir, df.file).replace(".js", ".ts");
-    });
-    for (let p of delList) {
-      if (await exists(p)) {
-        await unlink(p);
-      }
-    }
-    await this.cleanUpDist(true);
-  }
-
-  /**
-   * 마이그레이션 코드 파일을 확인합니다.
-   *
-   * CLI에서 사용됩니다.
-   */
-  async check(): Promise<void> {
-    const codes = await this.compareMigrations(this.targets.compare!);
-    if (codes.length === 0) {
-      console.log(chalk.green("\n현재 모두 싱크된 상태입니다."));
-      return;
-    }
-
-    // 현재 생성된 코드 표기
-    console.table(codes, ["type", "title"]);
-    console.log(codes[0]);
-  }
-
-  /**
-   * 마이그레이션을 수행합니다.
-   *
-   * runAction이 인자로 들어온 타겟들에 대해 주어진 동작(apply/rollback)을 수행한다면,
-   * 이 함수는 생성자로 들어온 connection(knex)들에 대해 마이그레이션을 수행합니다.
-   *
-   * CLI에서 사용됩니다.
-   */
-  async run(): Promise<void> {
-    // pending 마이그레이션 확인
-    const [, pendingList] = await this.targets.pending.migrate.list();
-    if (pendingList.length > 0) {
-      console.log(
-        chalk.red("pending 된 마이그레이션이 존재합니다."),
-        pendingList.map((pending: any) => pending.file)
-      );
-
-      // pending이 있는 경우 Shadow DB 테스트 진행 여부 컨펌
-      const answer = await prompts({
-        type: "confirm",
-        name: "value",
-        message: "Shadow DB 테스트를 진행하시겠습니까?",
-        initial: true,
-      });
-      if (answer.value === false) {
-        return;
-      }
-
-      console.time(chalk.blue("Migrator - runShadowTest"));
-      await this.runShadowTest();
-      console.timeEnd(chalk.blue("Migrator - runShadowTest"));
-      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);
-        })
-      );
-    }
-
-    // Entity-DB간 비교하여 코드 생성 리턴
-    const codes = await this.compareMigrations(this.targets.compare!);
-    if (codes.length === 0) {
-      console.log(chalk.green("\n현재 모두 싱크된 상태입니다."));
-      return;
-    }
-
-    // 현재 생성된 코드 표기
-    console.table(codes, ["type", "title"]);
-
-    /* DEBUG: 디버깅용 코드
-    codes.map((code) => console.log(code.formatted));
-    process.exit();
-     */
-
-    // 실제 파일 생성 프롬프트
-    const answer = await prompts({
-      type: "confirm",
-      name: "value",
-      message: "마이그레이션 코드를 생성하시겠습니까?",
-      initial: false,
-    });
-    if (answer.value === false) {
-      return;
-    }
-
-    // 실제 코드 생성
-    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
-
-    for (const [index, code] of codes.entries()) {
-      if (code.formatted) {
-        const dateTag = DateTime.local()
-          .plus({ seconds: index })
-          .toFormat("yyyyMMddHHmmss");
-        const filePath = `${migrationsDir}/${dateTag}_${code.title}.ts`;
-        await writeFile(filePath, code.formatted!);
-        console.log(chalk.green(`MIGRTAION CREATED ${filePath}`));
-      }
-    }
-  }
-
-  /**
-   * 타겟으로 지정된 DB를 롤백합니다.
-   *
-   * runAction이 인자로 들어온 타겟들에 대해 주어진 동작(apply/rollback)을 수행한다면,
-   * 이 함수는 생성자로 들어온 connection(knex)들에 대해 롤백을 수행합니다.
-   *
-   * CLI에서 사용됩니다.
-   */
-  async rollback() {
-    console.time(chalk.red("rollback:"));
-    const rollbackAllResult = await Promise.all(
-      this.targets.apply.map(async (db) => {
-        await db.migrate.forceFreeMigrationsLock();
-        return db.migrate.rollback(undefined, false);
-      })
-    );
-    console.dir({ rollbackAllResult }, { depth: null });
-    console.timeEnd(chalk.red("rollback:"));
-  }
-
-  /**
-   * 빌드된 마이그레이션 파일을 삭제합니다.
-   *
-   * CLI에서 사용됩니다.
-   *
-   * @param force 강제 삭제 여부
-   * @returns
-   */
-  async cleanUpDist(force: boolean = false): Promise<void> {
-    async function getFilesUnder(dir: string): Promise<string[]> {
-      const migrationPath = path.join(Sonamu.apiRootPath, dir, "migrations");
-      if (!(await exists(migrationPath))) {
-        await mkdir(migrationPath, {
-          recursive: true,
-        });
-      }
-      return (await readdir(migrationPath)).filter(
-        (filename) => filename.startsWith(".") === false
-      );
-    }
-
-    const files = {
-      src: await getFilesUnder("src"),
-      dist: await getFilesUnder("dist"),
-    };
-
-    const diffOnSrc = _.differenceBy(
-      files.src,
-      files.dist,
-      (filename) => filename.split(".")[0]
-    );
-    if (diffOnSrc.length > 0) {
-      throw new Error(
-        "컴파일 되지 않은 파일이 있습니다.\n" + diffOnSrc.join("\n")
-      );
-    }
-
-    const diffOnDist = _.differenceBy(
-      files.dist,
-      files.src,
-      (filename) => filename.split(".")[0]
-    );
-    if (diffOnDist.length > 0) {
-      console.log(chalk.red("원본 ts파일을 찾을 수 없는 js파일이 있습니다."));
-      console.log(diffOnDist);
-
-      if (!force) {
-        const answer = await prompts({
-          type: "confirm",
-          name: "value",
-          message: "삭제를 진행하시겠습니까?",
-          initial: true,
-        });
-        if (answer.value === false) {
-          return;
-        }
-      }
-
-      const filesToRm = diffOnDist.map((filename) => {
-        return path.join(Sonamu.apiRootPath, "dist", "migrations", filename);
-      });
-      for (const filePath of filesToRm) {
-        await unlink(filePath);
-      }
-      console.log(chalk.green(`${filesToRm.length}건 삭제되었습니다!`));
-    }
-  }
-
-  /**
-   * Shadow DB 테스트를 진행합니다.
-   *
-   * Sonamu UI에서 사용됩니다.
-   *
-   * @returns Shadow DB 테스트 결과
-   */
-  async runShadowTest(): Promise<
-    {
-      connKey: string;
-      batchNo: number;
-      applied: string[];
-    }[]
-  > {
-    // ShadowDB 생성 후 테스트 진행
-    const tdb = knex(Sonamu.dbConfig.test);
-    const tdbConn = Sonamu.dbConfig.test
-      .connection as Knex.MySql2ConnectionConfig;
-    const shadowDatabase = tdbConn.database + "__migration_shadow";
-    const tmpSqlPath = `/tmp/${shadowDatabase}.sql`;
-
-    // 테스트DB 덤프 후 Database명 치환
-    console.log(
-      chalk.magenta(`${tdbConn.database}의 데이터 ${tmpSqlPath}로 덤프`)
-    );
-    execSync(
-      `mysqldump -h${tdbConn.host} -P${tdbConn.port ?? 3306} -u${tdbConn.user} -p'${tdbConn.password}' ${tdbConn.database} --single-transaction --no-create-db --triggers > ${tmpSqlPath};`
-    );
-    execSync(
-      `sed -i'' -e 's/\`${tdbConn.database}\`/\`${shadowDatabase}\`/g' ${tmpSqlPath};`
-    );
-
-    // 기존 ShadowDB 리셋
-    console.log(chalk.magenta(`${shadowDatabase} 리셋`));
-    await tdb.raw(`DROP DATABASE IF EXISTS \`${shadowDatabase}\`;`);
-    await tdb.raw(`CREATE DATABASE \`${shadowDatabase}\`;`);
-
-    // ShadowDB 테이블 + 데이터 생성
-    console.log(chalk.magenta(`${shadowDatabase} 데이터베이스 생성`));
-    execSync(
-      `mysql -h${tdbConn.host} -P${tdbConn.port ?? 3306} -u${tdbConn.user} -p'${tdbConn.password}' ${shadowDatabase} < ${tmpSqlPath};`
-    );
-
-    // shadow db 테스트 진행
-    const sdb = knex({
-      ...Sonamu.dbConfig.test,
-      connection: {
-        ...tdbConn,
-        database: shadowDatabase,
-        password: tdbConn.password,
-      },
-    });
-
-    // shadow db 테스트 진행
-    try {
-      const [batchNo, applied] = await sdb.migrate.latest();
-      console.log(chalk.green("Shadow DB 테스트에 성공했습니다!"), {
-        batchNo,
-        applied,
-      });
-
-      // 생성한 Shadow DB 삭제
-      console.log(chalk.magenta(`${shadowDatabase} 삭제`));
-      await tdb.raw(`DROP DATABASE IF EXISTS \`${shadowDatabase}\`;`);
-
-      return [
-        {
-          connKey: "shadow",
-          batchNo,
-          applied,
-        },
-      ];
-    } catch (e) {
-      console.error(e);
-      throw new ServiceUnavailableException("Shadow DB 테스트 진행 중 에러");
-    } finally {
-      await tdb.destroy();
-    }
-  }
-
-  /**
-   * 모든 DB를 롤백하고 전체 마이그레이션 파일을 삭제합니다.
-   *
-   * CLI에서 사용됩니다.
-   *
-   * @returns
-   */
-  async resetAll() {
-    const answer = await prompts({
-      type: "confirm",
-      name: "value",
-      message: "모든 DB를 롤백하고 전체 마이그레이션 파일을 삭제하시겠습니까?",
-      initial: false,
-    });
-    if (answer.value === false) {
-      return;
-    }
-
-    console.time(chalk.red("rollback-all:"));
-    const rollbackAllResult = await Promise.all(
-      this.targets.apply.map(async (db) => {
-        await db.migrate.forceFreeMigrationsLock();
-        return db.migrate.rollback(undefined, true);
-      })
-    );
-    console.log({ rollbackAllResult });
-    console.timeEnd(chalk.red("rollback-all:"));
-
-    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
-    console.time(chalk.red("delete migration files"));
-    execSync(`rm -f ${migrationsDir}/*`);
-    execSync(`rm -f ${migrationsDir.replace("/src/", "/dist/")}/*`);
-    console.timeEnd(chalk.red("delete migration files"));
-  }
-
-  private async compareMigrations(
-    compareDB: Knex
-  ): Promise<GenMigrationCode[]> {
+  async compareMigrations(compareDB: Knex): Promise<GenMigrationCode[]> {
     // Entity 순회하여 싱크
     const entityIds = EntityManager.getAllIds();
 
     // 조인테이블 포함하여 Entity에서 MigrationSet 추출
     const entitySetsWithJoinTable = entityIds
       .filter((entityId) => EntityManager.get(entityId).props.length > 0)
-      .map((entityId) =>
-        getMigrationSetFromEntity(EntityManager.get(entityId))
-      );
+      .map((entityId) => getMigrationSetFromEntity(EntityManager.get(entityId)));
 
     // 조인테이블만 추출
-    const joinTablesWithDup = entitySetsWithJoinTable
-      .map((entitySet) => entitySet.joinTables)
-      .flat();
+    const joinTablesWithDup = entitySetsWithJoinTable.flatMap((entitySet) => entitySet.joinTables);
     // 중복 제거 (중복인 경우 indexes를 병합)
-    const joinTables = Object.values(
-      _.groupBy(joinTablesWithDup, (jt) => jt.table)
-    ).map((tables) => {
+    const joinTables = Object.values(group(joinTablesWithDup, (jt) => jt.table)).map((tables) => {
+      assert(tables !== undefined, "tables is undefined");
       if (tables.length === 1) {
         return tables[0];
       }
       return {
         ...tables[0],
-        indexes: _.uniqBy(
+        indexes: unique(
           tables.flatMap((t) => t.indexes),
-          (index) => [index.type, ...index.columns.sort()].join("-")
+          (index) => [index.type, ...index.columns.sort()].join("-"),
         ),
       };
     });
 
     // 조인테이블 포함하여 MigrationSet 배열
-    const entitySets: MigrationSet[] = [
-      ...entitySetsWithJoinTable,
-      ...joinTables,
-    ];
+    const entitySets: MigrationSet[] = [...entitySetsWithJoinTable, ...joinTables];
 
     const codes: GenMigrationCode[] = (
       await Promise.all(
         entitySets.map(async (entitySet) => {
-          const dbSet = await getMigrationSetFromDB(compareDB, entitySet.table);
+          const dbSet = await PostgreSQLSchemaReader.getMigrationSetFromDB(
+            compareDB,
+            entitySet.table,
+          );
+          Naite.t(`migrator:compareMigrations:entitySet:${entitySet.table}`, entitySet);
+          Naite.t(`migrator:compareMigrations:dbSet:${entitySet.table}`, dbSet);
 
           if (dbSet === null) {
             // 기존 테이블 없음, 새로 테이블 생성
@@ -788,13 +366,13 @@ export class Migrator {
             // 기존 테이블 존재하는 케이스
             return await generateAlterCode(entitySet, dbSet);
           }
-        })
+        }),
       )
     ).flat();
 
     // normal 타입이 앞으로, foreign이 뒤로
     codes.sort((codeA, codeB) => {
-      if (codeA.type === "foreign" && codeB.type == "normal") {
+      if (codeA.type === "foreign" && codeB.type === "normal") {
         return 1;
       } else if (codeA.type === "normal" && codeB.type === "foreign") {
         return -1;
@@ -807,17 +385,67 @@ export class Migrator {
   }
 
   /**
-   * 마이그레이션 대상 커넥션을 종료합니다.
+   * Shadow DB 테스트를 진행합니다.
    *
-   * CLI에서 사용됩니다.
+   * Sonamu UI에서 사용됩니다.
    *
-   * @returns {Promise<void>} 종료 결과
+   * @returns Shadow DB 테스트 결과
    */
-  async destroy(): Promise<void> {
-    await Promise.all(
-      this.targets.apply.map((db) => {
-        return db.destroy();
-      })
-    );
+  async runShadowTest(): Promise<MigrationResult> {
+    const tdbConn = Sonamu.dbConfig.test.connection as Knex.PgConnectionConfig;
+    const shadowDatabase = `${tdbConn.database}__migration_shadow`;
+
+    // 테스트 상황에서는 트랜잭션을 초기화하고, 새 데이터베이스 커넥션을 가져와야 함
+    if (isTest()) {
+      await DB.clearTestTransaction();
+      await DB.destroy();
+    }
+
+    // 기존 Shadow DB 삭제 후 Shadow DB 생성
+    const tdb = knex(Sonamu.dbConfig.test);
+    !isTest() && console.log(chalk.magenta(`${shadowDatabase} 삭제`));
+    await tdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase}`);
+    await tdb.raw(`CREATE DATABASE ${shadowDatabase} TEMPLATE ${tdbConn.database}`);
+
+    // Shadow DB에 연결
+    const sdb = knex({
+      ...Sonamu.dbConfig.test,
+      connection: {
+        ...tdbConn,
+        database: shadowDatabase,
+        password: tdbConn.password,
+      },
+    });
+
+    // shadow DB 테스트 진행
+    try {
+      const [batchNo, applied] = await sdb.migrate.latest();
+      !isTest() &&
+        console.log(chalk.green("Shadow DB 테스트에 성공했습니다!"), {
+          batchNo,
+          applied,
+        });
+
+      return [
+        {
+          connKey: "shadow",
+          batchNo,
+          applied,
+        },
+      ];
+    } catch (e) {
+      console.error(e);
+      throw new ServiceUnavailableException("Shadow DB 테스트 진행 중 에러");
+    } finally {
+      // Shadow DB 연결 종료
+      await sdb.destroy();
+
+      // Shadow DB 삭제
+      !isTest() && console.log(chalk.magenta(`${shadowDatabase} 삭제`));
+      await tdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase}`);
+
+      // Test DB 연결 종료
+      await tdb.destroy();
+    }
   }
 }