sonamu 0.6.0 → 0.7.1

package/dist/migration/migrator.js

@@ -1,57 +1,20 @@
-import * as _ from "lodash-es";
-import knex from "knex";
+import assert from "assert";
 import chalk from "chalk";
-import { DateTime } from "luxon";
 import { mkdir, readdir, unlink, writeFile } from "node:fs/promises";
-import { exists } from "../utils/fs-utils.js";
-import prompts from "prompts";
-import { execSync } from "child_process";
+import knex from "knex";
 import path from "path";
-import { EntityManager } from "../entity/entity-manager.js";
+import { group, sum, unique } from "radashi";
 import { Sonamu } from "../api/index.js";
+import { DB } from "../database/db.js";
+import { EntityManager } from "../entity/entity-manager.js";
 import { ServiceUnavailableException } from "../exceptions/so-exceptions.js";
-import { generateCreateCode, generateAlterCode } from "./code-generation.js";
-import { getMigrationSetFromDB } from "./migration-set.js";
+import { Naite } from "../naite/naite.js";
+import { isTest } from "../utils/controller.js";
+import { exists } from "../utils/fs-utils.js";
+import { generateAlterCode, generateCreateCode } from "./code-generation.js";
 import { getMigrationSetFromEntity } from "./migration-set.js";
+import { PostgreSQLSchemaReader } from "./postgresql-schema-reader.js";
 export class Migrator {
-    options;
-    targets;
-    constructor(options){
-        this.options = options;
-        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.host !== dbConfig.fixture_remote.connection.host || dbConfig.fixture_local.connection.database !== dbConfig.fixture_remote.connection.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} 입력`);
-        }
-    }
     async getMigrationCodes() {
         const srcMigrationsDir = path.join(Sonamu.apiRootPath, "src", "migrations"); // 이건 환경에 관계없이 항상 src에서 찾아야 해요.
         if (!await exists(srcMigrationsDir)) {
@@ -63,6 +26,7 @@ export class Migrator {
                 name: f.replace(".ts", ""),
                 path: path.join(srcMigrationsDir, f)
             })).sort((a, b)=>a.name < b.name ? 1 : -1); // 이름 내림차순 정렬(최신순)
+        Naite.t("migrator:getMigrationCodes:results", codes);
         return codes;
     }
     /**
@@ -75,7 +39,9 @@ export class Migrator {
    * @returns
    */ async getStatus() {
         const codes = await this.getMigrationCodes();
+        Naite.t("migrator:getStatus:codes", codes);
         const connKeys = Object.keys(Sonamu.dbConfig).filter((key)=>key.endsWith("_slave") === false);
+        let migrationStatusError;
         const statuses = await Promise.all(connKeys.map(async (connKey)=>{
             const knexOptions = Sonamu.dbConfig[connKey];
             const tConn = knex(knexOptions);
@@ -84,7 +50,8 @@ export class Migrator {
                     return await tConn.migrate.status();
                 } catch (err) {
                     console.warn(chalk.yellow(`${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 ()=>{
@@ -92,27 +59,31 @@ export class Migrator {
                     const [, fdList] = await tConn.migrate.list();
                     return fdList.map((fd)=>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;
             await tConn.destroy();
             return {
                 name: connKey.replace("_master", ""),
                 connKey,
-                connString: `mysql2://${connection.user ?? ""}@${connection.host}:${connection.port}/${connection.database}`,
+                connString: `pg://${connection.user ?? ""}@${connection.host}:${connection.port}/${connection.database}`,
                 currentVersion,
-                status,
+                status: status,
                 pending
             };
         }));
+        Naite.t("migrator:getStatus:conns", statuses);
         const preparedCodes = await (async ()=>{
             const status0conn = statuses.find((status)=>status.status === 0);
             if (status0conn === undefined) {
@@ -124,20 +95,14 @@ export class Migrator {
             await compareDBconn.destroy();
             return genCodes;
         })();
+        Naite.t("migrator:getStatus:preparedCodes", preparedCodes);
         return {
             conns: statuses,
             codes,
-            preparedCodes
+            preparedCodes,
+            error: migrationStatusError
         };
-    /*
-    DB 마이그레이션 상태 확인
-    1. 전체 DB설정에 대해서 현재 마이그레이션 상태 확인
-    - connKey: string
-    - status: number
-    - currentVersion: string
-    - list: { file: string; directory: string }[]
-    
-    */ }
+    }
     /**
    * 마이그레이션을 적용하거나 롤백합니다.
    * Sonamu UI에서 마이그레이션 작업을 수행할 때 사용됩니다.
@@ -148,11 +113,13 @@ export class Migrator {
    * @param targets 작업 대상 DB 설정 키 (keyof SonamuDBConfig)
    * @returns 작업 결과
    */ async runAction(action, targets) {
+        Naite.t("migrator:runAction:action", action);
+        Naite.t("migrator:runAction:targets", targets);
         // get uniq knex configs
-        const configs = _.uniqBy(targets.map((target)=>({
+        const configs = unique(targets.map((target)=>({
                 connKey: target,
                 options: Sonamu.dbConfig[target]
-            })).filter((c)=>c.options !== undefined), ({ options })=>`${options.connection.host}:${options.connection.port ?? 3306}/${options.connection.database}`);
+            })).filter((c)=>c.options !== undefined), ({ options })=>`${options.connection.host}:${options.connection.port ?? 5432}/${options.connection.database}`);
         // get connections
         const conns = await Promise.all(configs.map(async (config)=>({
                 connKey: config.connKey,
@@ -185,9 +152,23 @@ 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, codeNames) {
+        const appliedCodes = codeNames.filter((codeName)=>conns.some((conn)=>conn.pending.includes(codeName) === false));
+        return {
+            canDelete: appliedCodes.length === 0,
+            appliedCodes
+        };
+    }
+    /**
    * 마이그레이션 코드 파일을 삭제합니다.
    *
    * Sonamu UI에서 사용됩니다.
@@ -196,21 +177,23 @@ export class Migrator {
    * @returns 삭제된 마이그레이션 코드 파일 개수
    */ async delCodes(codeNames) {
         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 { canDelete, appliedCodes } = this.validateDeletable(conns, codeNames);
+        if (!canDelete) {
+            throw new Error(`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`);
-        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 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;
-        }));
-        return _.sum(res);
+        })));
+    }
+    genDateTag(index, baseDate = new Date()) {
+        const date = new Date(baseDate.getTime() + index * 1000);
+        const pad = (num, size = 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());
     }
     /**
    * 마이그레이션 코드 파일을 생성합니다.
@@ -220,6 +203,7 @@ export class Migrator {
    * @returns 생성된 마이그레이션 코드 파일 개수
    */ async generatePreparedCodes() {
         const { preparedCodes } = await this.getStatus();
+        Naite.t("migrator:generatePreparedCodes:preparedCodes", preparedCodes);
         if (preparedCodes.length === 0) {
             console.log(chalk.green("\n현재 모두 싱크된 상태입니다."));
             return 0;
@@ -228,240 +212,30 @@ export class Migrator {
         const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
         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}`));
+                !isTest() && console.log(chalk.green(`MIGRTAION CREATED ${filePath}`));
             }
         }
         return preparedCodes.length;
     }
-    /**
-   * pending 마이그레이션 목록을 삭제합니다.
-   *
-   * CLI에서 사용됩니다.
-   */ async clearPendingList() {
-        const [, pendingList] = await this.targets.pending.migrate.list();
-        const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
-        const delList = pendingList.map((df)=>{
-            return path.join(migrationsDir, df.file);
-        });
-        for (let p of delList){
-            if (await exists(p)) {
-                await unlink(p);
-            }
-        }
-    }
-    /**
-   * 마이그레이션 코드 파일을 확인합니다.
-   *
-   * CLI에서 사용됩니다.
-   */ async check() {
-        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() {
-        // pending 마이그레이션 확인
-        const [, pendingList] = await this.targets.pending.migrate.list();
-        if (pendingList.length > 0) {
-            console.log(chalk.red("pending 된 마이그레이션이 존재합니다."), pendingList.map((pending)=>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:"));
-    }
-    /**
-   * Shadow DB 테스트를 진행합니다.
-   *
-   * Sonamu UI에서 사용됩니다.
-   *
-   * @returns Shadow DB 테스트 결과
-   */ async runShadowTest() {
-        // ShadowDB 생성 후 테스트 진행
-        const tdb = knex(Sonamu.dbConfig.test);
-        const tdbConn = Sonamu.dbConfig.test.connection;
-        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"));
-    }
     async compareMigrations(compareDB) {
         // Entity 순회하여 싱크
         const entityIds = EntityManager.getAllIds();
         // 조인테이블 포함하여 Entity에서 MigrationSet 추출
         const entitySetsWithJoinTable = entityIds.filter((entityId)=>EntityManager.get(entityId).props.length > 0).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(tables.flatMap((t)=>t.indexes), (index)=>[
+                indexes: unique(tables.flatMap((t)=>t.indexes), (index)=>[
                         index.type,
                         ...index.columns.sort()
                     ].join("-"))
@@ -473,7 +247,9 @@ export class Migrator {
             ...joinTables
         ];
         const codes = (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) {
                 // 기존 테이블 없음, 새로 테이블 생성
                 return await generateCreateCode(entitySet);
@@ -484,7 +260,7 @@ export class Migrator {
         }))).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;
@@ -495,16 +271,60 @@ export class Migrator {
         return codes;
     }
     /**
-   * 마이그레이션 대상 커넥션을 종료합니다.
+   * Shadow DB 테스트를 진행합니다.
    *
-   * CLI에서 사용됩니다.
+   * Sonamu UI에서 사용됩니다.
    *
-   * @returns {Promise<void>} 종료 결과
-   */ async destroy() {
-        await Promise.all(this.targets.apply.map((db)=>{
-            return db.destroy();
-        }));
+   * @returns Shadow DB 테스트 결과
+   */ async runShadowTest() {
+        const tdbConn = Sonamu.dbConfig.test.connection;
+        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();
+        }
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/migration/migrator.ts"],"sourcesContent":["import * as _ from \"lodash-es\";\nimport knex, { Knex } from \"knex\";\nimport chalk from \"chalk\";\nimport { DateTime } from \"luxon\";\nimport { mkdir, readdir, unlink, writeFile } from \"fs/promises\";\nimport { exists } from \"../utils/fs-utils\";\nimport prompts from \"prompts\";\nimport { execSync } from \"child_process\";\nimport path from \"path\";\nimport { GenMigrationCode, MigrationSet } from \"../types/types\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { Sonamu } from \"../api\";\nimport { ServiceUnavailableException } from \"../exceptions/so-exceptions\";\nimport { SonamuDBConfig } from \"../database/db\";\nimport { generateCreateCode, generateAlterCode } from \"./code-generation\";\nimport { MigrationStatus, MigrationCode, ConnString } from \"./types\";\nimport { getMigrationSetFromDB } from \"./migration-set\";\nimport { getMigrationSetFromEntity } from \"./migration-set\";\n\ntype MigratorMode = \"dev\" | \"deploy\";\nexport type MigratorOptions = {\n  readonly mode: MigratorMode;\n};\n\nexport class Migrator {\n  targets: {\n    compare?: Knex;\n    pending: Knex;\n    shadow: Knex;\n    apply: Knex[];\n  };\n\n  constructor(private readonly options: MigratorOptions) {\n    const { dbConfig } = Sonamu;\n\n    if (this.options.mode === \"dev\") {\n      const devDB = knex(dbConfig.development_master);\n      const testDB = knex(dbConfig.test);\n      const fixtureLocalDB = knex(dbConfig.fixture_local);\n\n      const applyDBs = [devDB, testDB, fixtureLocalDB];\n      if (\n        (dbConfig.fixture_local.connection as Knex.MySql2ConnectionConfig)\n          .host !==\n          (dbConfig.fixture_remote.connection as Knex.MySql2ConnectionConfig)\n            .host ||\n        (dbConfig.fixture_local.connection as Knex.MySql2ConnectionConfig)\n          .database !==\n          (dbConfig.fixture_remote.connection as Knex.MySql2ConnectionConfig)\n            .database\n      ) {\n        const fixtureRemoteDB = knex(dbConfig.fixture_remote);\n        applyDBs.push(fixtureRemoteDB);\n      }\n\n      this.targets = {\n        compare: devDB,\n        pending: devDB,\n        shadow: testDB,\n        apply: applyDBs,\n      };\n    } else if (this.options.mode === \"deploy\") {\n      const productionDB = knex(dbConfig.production_master);\n      const testDB = knex(dbConfig.test);\n\n      this.targets = {\n        pending: productionDB,\n        shadow: testDB,\n        apply: [productionDB],\n      };\n    } else {\n      throw new Error(`잘못된 모드 ${this.options.mode} 입력`);\n    }\n  }\n\n  private async getMigrationCodes(): Promise<MigrationCode[]> {\n    const srcMigrationsDir = path.join(Sonamu.apiRootPath, \"src\", \"migrations\"); // 이건 환경에 관계없이 항상 src에서 찾아야 해요.\n\n    if (!(await exists(srcMigrationsDir))) {\n      await mkdir(srcMigrationsDir, {\n        recursive: true,\n      });\n    }\n\n    const codes = (await readdir(srcMigrationsDir))\n      .filter((f) => f.endsWith(\".ts\"))\n      .map((f) => ({\n        name: f.replace(\".ts\", \"\"),\n        path: path.join(srcMigrationsDir, f),\n      }))\n      .sort((a, b) => (a.name < b.name ? 1 : -1)); // 이름 내림차순 정렬(최신순)\n\n    return codes;\n  }\n\n  /**\n   * 타겟별 마이그레이션 상태와 코드 생성/준비 상태를 구해옵니다.\n   * 실제로 DB에 접근도 하고 마이그레이션 코드 파일도 확인하고,\n   * 필요하다면 적용할 수 있는 코드를 생성까지 해옵니다.\n   *\n   * CLI와 Sonamu UI에서 사용됩니다.\n   *\n   * @returns\n   */\n  async getStatus(): Promise<MigrationStatus> {\n    const codes = await this.getMigrationCodes();\n\n    const connKeys = Object.keys(Sonamu.dbConfig).filter(\n      (key) => key.endsWith(\"_slave\") === false\n    ) as (keyof typeof Sonamu.dbConfig)[];\n\n    const statuses = await Promise.all(\n      connKeys.map(async (connKey) => {\n        const knexOptions = Sonamu.dbConfig[connKey];\n        const tConn = knex(knexOptions);\n\n        const status = await (async () => {\n          try {\n            return await tConn.migrate.status();\n          } catch (err) {\n            console.warn(\n              chalk.yellow(\n                `${connKey}의 마이그레이션 상태를 가져오는 데에 실패하였습니다. 데이터베이스가 올바르게 구성되지 않은 것 같습니다. 확인하시고 다시 시도해주세요.\\n시도한 연결 설정:\\n${JSON.stringify(knexOptions.connection, null, 2)}\\n발생한 에러:\\n${err}\\n`\n              )\n            );\n            return \"error\" /*클라이언트에서 에러 체크에 사용하는 리터럴입니다.*/;\n          }\n        })();\n        const pending = await (async () => {\n          try {\n            const [, fdList] = await tConn.migrate.list();\n            return fdList.map((fd: { file: string }) =>\n              fd.file.replace(\".ts\", \"\")\n            );\n          } catch (err) {\n            return [];\n          }\n        })();\n        const currentVersion = await (async () => {\n          try {\n            return await tConn.migrate.currentVersion();\n          } catch (err) {\n            return \"error\";\n          }\n        })();\n\n        const connection =\n          knexOptions.connection as Knex.MySql2ConnectionConfig;\n\n        await tConn.destroy();\n\n        return {\n          name: connKey.replace(\"_master\", \"\"),\n          connKey,\n          connString: `mysql2://${connection.user ?? \"\"}@${connection.host}:${\n            connection.port\n          }/${connection.database}` as ConnString,\n          currentVersion,\n          status,\n          pending,\n        };\n      })\n    );\n\n    const preparedCodes: GenMigrationCode[] = await (async () => {\n      const status0conn = statuses.find((status) => status.status === 0);\n      if (status0conn === undefined) {\n        console.warn(\n          chalk.yellow(\n            `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.`\n          )\n        );\n        return [];\n      }\n\n      const compareDBconn = knex(Sonamu.dbConfig[status0conn.connKey]);\n      const genCodes = await this.compareMigrations(compareDBconn);\n\n      await compareDBconn.destroy();\n\n      return genCodes;\n    })();\n\n    return {\n      conns: statuses,\n      codes,\n      preparedCodes,\n    };\n    /*\n    DB 마이그레이션 상태 확인\n    1. 전체 DB설정에 대해서 현재 마이그레이션 상태 확인\n    - connKey: string\n    - status: number\n    - currentVersion: string\n    - list: { file: string; directory: string }[]\n    \n    */\n  }\n\n  /**\n   * 마이그레이션을 적용하거나 롤백합니다.\n   * Sonamu UI에서 마이그레이션 작업을 수행할 때 사용됩니다.\n   *\n   * CLI와 Sonamu UI에서 사용됩니다.\n   *\n   * @param action 작업 유형 (apply/rollback)\n   * @param targets 작업 대상 DB 설정 키 (keyof SonamuDBConfig)\n   * @returns 작업 결과\n   */\n  async runAction(\n    action: \"apply\" | \"rollback\",\n    targets: (keyof SonamuDBConfig)[]\n  ): Promise<\n    {\n      connKey: string;\n      batchNo: number;\n      applied: string[];\n    }[]\n  > {\n    // get uniq knex configs\n    const configs = _.uniqBy(\n      targets\n        .map((target) => ({\n          connKey: target,\n          options: Sonamu.dbConfig[target as keyof typeof Sonamu.dbConfig],\n        }))\n        .filter((c) => c.options !== undefined),\n      ({ options }) =>\n        `${(options.connection as Knex.MySql2ConnectionConfig).host}:${\n          (options.connection as Knex.MySql2ConnectionConfig).port ?? 3306\n        }/${(options.connection as Knex.MySql2ConnectionConfig).database}`\n    );\n\n    // get connections\n    const conns = await Promise.all(\n      configs.map(async (config) => ({\n        connKey: config.connKey,\n        knex: knex(config.options),\n      }))\n    );\n\n    // action\n    const result = await (async () => {\n      switch (action) {\n        case \"apply\":\n          return Promise.all(\n            conns.map(async ({ connKey, knex }) => {\n              const [batchNo, applied] = await knex.migrate.latest();\n              return {\n                connKey,\n                batchNo,\n                applied,\n              };\n            })\n          );\n        case \"rollback\":\n          return Promise.all(\n            conns.map(async ({ connKey, knex }) => {\n              const [batchNo, applied] = await knex.migrate.rollback();\n              return {\n                connKey,\n                batchNo,\n                applied,\n              };\n            })\n          );\n      }\n    })();\n\n    // destroy\n    await Promise.all(\n      conns.map(({ knex }) => {\n        return knex.destroy();\n      })\n    );\n\n    return result;\n  }\n\n  /**\n   * 마이그레이션 코드 파일을 삭제합니다.\n   *\n   * Sonamu UI에서 사용됩니다.\n   *\n   * @param codeNames 삭제할 마이그레이션 코드 파일 이름 배열\n   * @returns 삭제된 마이그레이션 코드 파일 개수\n   */\n  async delCodes(codeNames: string[]): Promise<number> {\n    const { conns } = await this.getStatus();\n    if (\n      conns.some((conn) => {\n        return codeNames.some(\n          (codeName) => conn.pending.includes(codeName) === false\n        );\n      })\n    ) {\n      throw new Error(\n        \"You cannot delete a migration file if there is already applied.\"\n      );\n    }\n\n    const delFiles = codeNames.map(\n      (codeName) => `${Sonamu.apiRootPath}/src/migrations/${codeName}.ts`\n    );\n\n    const res = await Promise.all(\n      delFiles.map(async (delFile) => {\n        if (await exists(delFile)) {\n          console.log(chalk.red(`DELETE: ${delFile}`));\n          await unlink(delFile);\n          return delFiles.includes(\".ts\") ? 1 : 0;\n        }\n        return 0;\n      })\n    );\n    return _.sum(res);\n  }\n\n  /**\n   * 마이그레이션 코드 파일을 생성합니다.\n   *\n   * Sonamu UI에서 사용됩니다.\n   *\n   * @returns 생성된 마이그레이션 코드 파일 개수\n   */\n  async generatePreparedCodes(): Promise<number> {\n    const { preparedCodes } = await this.getStatus();\n    if (preparedCodes.length === 0) {\n      console.log(chalk.green(\"\\n현재 모두 싱크된 상태입니다.\"));\n      return 0;\n    }\n\n    // 실제 코드 생성\n    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;\n\n    for (const [index, pcode] of preparedCodes.entries()) {\n      if (pcode.formatted) {\n        const dateTag = DateTime.local()\n          .plus({ seconds: index })\n          .toFormat(\"yyyyMMddHHmmss\");\n        const filePath = `${migrationsDir}/${dateTag}_${pcode.title}.ts`;\n        await writeFile(filePath, pcode.formatted!);\n        console.log(chalk.green(`MIGRTAION CREATED ${filePath}`));\n      }\n    }\n\n    return preparedCodes.length;\n  }\n\n  /**\n   * pending 마이그레이션 목록을 삭제합니다.\n   *\n   * CLI에서 사용됩니다.\n   */\n  async clearPendingList(): Promise<void> {\n    const [, pendingList] = (await this.targets.pending.migrate.list()) as [\n      unknown,\n      {\n        file: string;\n        directory: string;\n      }[],\n    ];\n    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;\n    const delList = pendingList.map((df) => {\n      return path.join(migrationsDir, df.file);\n    });\n    for (let p of delList) {\n      if (await exists(p)) {\n        await unlink(p);\n      }\n    }\n  }\n\n  /**\n   * 마이그레이션 코드 파일을 확인합니다.\n   *\n   * CLI에서 사용됩니다.\n   */\n  async check(): Promise<void> {\n    const codes = await this.compareMigrations(this.targets.compare!);\n    if (codes.length === 0) {\n      console.log(chalk.green(\"\\n현재 모두 싱크된 상태입니다.\"));\n      return;\n    }\n\n    // 현재 생성된 코드 표기\n    console.table(codes, [\"type\", \"title\"]);\n    console.log(codes[0]);\n  }\n\n  /**\n   * 마이그레이션을 수행합니다.\n   *\n   * runAction이 인자로 들어온 타겟들에 대해 주어진 동작(apply/rollback)을 수행한다면,\n   * 이 함수는 생성자로 들어온 connection(knex)들에 대해 마이그레이션을 수행합니다.\n   *\n   * CLI에서 사용됩니다.\n   */\n  async run(): Promise<void> {\n    // pending 마이그레이션 확인\n    const [, pendingList] = await this.targets.pending.migrate.list();\n    if (pendingList.length > 0) {\n      console.log(\n        chalk.red(\"pending 된 마이그레이션이 존재합니다.\"),\n        pendingList.map((pending: any) => pending.file)\n      );\n\n      // pending이 있는 경우 Shadow DB 테스트 진행 여부 컨펌\n      const answer = await prompts({\n        type: \"confirm\",\n        name: \"value\",\n        message: \"Shadow DB 테스트를 진행하시겠습니까?\",\n        initial: true,\n      });\n      if (answer.value === false) {\n        return;\n      }\n\n      console.time(chalk.blue(\"Migrator - runShadowTest\"));\n      await this.runShadowTest();\n      console.timeEnd(chalk.blue(\"Migrator - runShadowTest\"));\n      await Promise.all(\n        this.targets.apply.map(async (applyDb) => {\n          const label = chalk.green(\n            `APPLIED ${\n              applyDb.client.connectionSettings.host\n            } ${applyDb.client.database()}`\n          );\n          console.time(label);\n          const [,] = await applyDb.migrate.latest();\n          console.timeEnd(label);\n        })\n      );\n    }\n\n    // Entity-DB간 비교하여 코드 생성 리턴\n    const codes = await this.compareMigrations(this.targets.compare!);\n    if (codes.length === 0) {\n      console.log(chalk.green(\"\\n현재 모두 싱크된 상태입니다.\"));\n      return;\n    }\n\n    // 현재 생성된 코드 표기\n    console.table(codes, [\"type\", \"title\"]);\n\n    /* DEBUG: 디버깅용 코드\n    codes.map((code) => console.log(code.formatted));\n    process.exit();\n     */\n\n    // 실제 파일 생성 프롬프트\n    const answer = await prompts({\n      type: \"confirm\",\n      name: \"value\",\n      message: \"마이그레이션 코드를 생성하시겠습니까?\",\n      initial: false,\n    });\n    if (answer.value === false) {\n      return;\n    }\n\n    // 실제 코드 생성\n    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;\n\n    for (const [index, code] of codes.entries()) {\n      if (code.formatted) {\n        const dateTag = DateTime.local()\n          .plus({ seconds: index })\n          .toFormat(\"yyyyMMddHHmmss\");\n        const filePath = `${migrationsDir}/${dateTag}_${code.title}.ts`;\n        await writeFile(filePath, code.formatted!);\n        console.log(chalk.green(`MIGRTAION CREATED ${filePath}`));\n      }\n    }\n  }\n\n  /**\n   * 타겟으로 지정된 DB를 롤백합니다.\n   *\n   * runAction이 인자로 들어온 타겟들에 대해 주어진 동작(apply/rollback)을 수행한다면,\n   * 이 함수는 생성자로 들어온 connection(knex)들에 대해 롤백을 수행합니다.\n   *\n   * CLI에서 사용됩니다.\n   */\n  async rollback() {\n    console.time(chalk.red(\"rollback:\"));\n    const rollbackAllResult = await Promise.all(\n      this.targets.apply.map(async (db) => {\n        await db.migrate.forceFreeMigrationsLock();\n        return db.migrate.rollback(undefined, false);\n      })\n    );\n    console.dir({ rollbackAllResult }, { depth: null });\n    console.timeEnd(chalk.red(\"rollback:\"));\n  }\n  /**\n   * Shadow DB 테스트를 진행합니다.\n   *\n   * Sonamu UI에서 사용됩니다.\n   *\n   * @returns Shadow DB 테스트 결과\n   */\n  async runShadowTest(): Promise<\n    {\n      connKey: string;\n      batchNo: number;\n      applied: string[];\n    }[]\n  > {\n    // ShadowDB 생성 후 테스트 진행\n    const tdb = knex(Sonamu.dbConfig.test);\n    const tdbConn = Sonamu.dbConfig.test\n      .connection as Knex.MySql2ConnectionConfig;\n    const shadowDatabase = tdbConn.database + \"__migration_shadow\";\n    const tmpSqlPath = `/tmp/${shadowDatabase}.sql`;\n\n    // 테스트DB 덤프 후 Database명 치환\n    console.log(\n      chalk.magenta(`${tdbConn.database}의 데이터 ${tmpSqlPath}로 덤프`)\n    );\n    execSync(\n      `mysqldump -h${tdbConn.host} -P${tdbConn.port ?? 3306} -u${tdbConn.user} -p'${tdbConn.password}' ${tdbConn.database} --single-transaction --no-create-db --triggers > ${tmpSqlPath};`\n    );\n    execSync(\n      `sed -i'' -e 's/\\`${tdbConn.database}\\`/\\`${shadowDatabase}\\`/g' ${tmpSqlPath};`\n    );\n\n    // 기존 ShadowDB 리셋\n    console.log(chalk.magenta(`${shadowDatabase} 리셋`));\n    await tdb.raw(`DROP DATABASE IF EXISTS \\`${shadowDatabase}\\`;`);\n    await tdb.raw(`CREATE DATABASE \\`${shadowDatabase}\\`;`);\n\n    // ShadowDB 테이블 + 데이터 생성\n    console.log(chalk.magenta(`${shadowDatabase} 데이터베이스 생성`));\n    execSync(\n      `mysql -h${tdbConn.host} -P${tdbConn.port ?? 3306} -u${tdbConn.user} -p'${tdbConn.password}' ${shadowDatabase} < ${tmpSqlPath};`\n    );\n\n    // shadow db 테스트 진행\n    const sdb = knex({\n      ...Sonamu.dbConfig.test,\n      connection: {\n        ...tdbConn,\n        database: shadowDatabase,\n        password: tdbConn.password,\n      },\n    });\n\n    // shadow db 테스트 진행\n    try {\n      const [batchNo, applied] = await sdb.migrate.latest();\n      console.log(chalk.green(\"Shadow DB 테스트에 성공했습니다!\"), {\n        batchNo,\n        applied,\n      });\n\n      // 생성한 Shadow DB 삭제\n      console.log(chalk.magenta(`${shadowDatabase} 삭제`));\n      await tdb.raw(`DROP DATABASE IF EXISTS \\`${shadowDatabase}\\`;`);\n\n      return [\n        {\n          connKey: \"shadow\",\n          batchNo,\n          applied,\n        },\n      ];\n    } catch (e) {\n      console.error(e);\n      throw new ServiceUnavailableException(\"Shadow DB 테스트 진행 중 에러\");\n    } finally {\n      await tdb.destroy();\n    }\n  }\n\n  /**\n   * 모든 DB를 롤백하고 전체 마이그레이션 파일을 삭제합니다.\n   *\n   * CLI에서 사용됩니다.\n   *\n   * @returns\n   */\n  async resetAll() {\n    const answer = await prompts({\n      type: \"confirm\",\n      name: \"value\",\n      message: \"모든 DB를 롤백하고 전체 마이그레이션 파일을 삭제하시겠습니까?\",\n      initial: false,\n    });\n    if (answer.value === false) {\n      return;\n    }\n\n    console.time(chalk.red(\"rollback-all:\"));\n    const rollbackAllResult = await Promise.all(\n      this.targets.apply.map(async (db) => {\n        await db.migrate.forceFreeMigrationsLock();\n        return db.migrate.rollback(undefined, true);\n      })\n    );\n    console.log({ rollbackAllResult });\n    console.timeEnd(chalk.red(\"rollback-all:\"));\n\n    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;\n    console.time(chalk.red(\"delete migration files\"));\n    execSync(`rm -f ${migrationsDir}/*`);\n    execSync(`rm -f ${migrationsDir.replace(\"/src/\", \"/dist/\")}/*`);\n    console.timeEnd(chalk.red(\"delete migration files\"));\n  }\n\n  private async compareMigrations(\n    compareDB: Knex\n  ): Promise<GenMigrationCode[]> {\n    // Entity 순회하여 싱크\n    const entityIds = EntityManager.getAllIds();\n\n    // 조인테이블 포함하여 Entity에서 MigrationSet 추출\n    const entitySetsWithJoinTable = entityIds\n      .filter((entityId) => EntityManager.get(entityId).props.length > 0)\n      .map((entityId) =>\n        getMigrationSetFromEntity(EntityManager.get(entityId))\n      );\n\n    // 조인테이블만 추출\n    const joinTablesWithDup = entitySetsWithJoinTable\n      .map((entitySet) => entitySet.joinTables)\n      .flat();\n    // 중복 제거 (중복인 경우 indexes를 병합)\n    const joinTables = Object.values(\n      _.groupBy(joinTablesWithDup, (jt) => jt.table)\n    ).map((tables) => {\n      if (tables.length === 1) {\n        return tables[0];\n      }\n      return {\n        ...tables[0],\n        indexes: _.uniqBy(\n          tables.flatMap((t) => t.indexes),\n          (index) => [index.type, ...index.columns.sort()].join(\"-\")\n        ),\n      };\n    });\n\n    // 조인테이블 포함하여 MigrationSet 배열\n    const entitySets: MigrationSet[] = [\n      ...entitySetsWithJoinTable,\n      ...joinTables,\n    ];\n\n    const codes: GenMigrationCode[] = (\n      await Promise.all(\n        entitySets.map(async (entitySet) => {\n          const dbSet = await getMigrationSetFromDB(compareDB, entitySet.table);\n\n          if (dbSet === null) {\n            // 기존 테이블 없음, 새로 테이블 생성\n            return await generateCreateCode(entitySet);\n          } else {\n            // 기존 테이블 존재하는 케이스\n            return await generateAlterCode(entitySet, dbSet);\n          }\n        })\n      )\n    ).flat();\n\n    // normal 타입이 앞으로, foreign이 뒤로\n    codes.sort((codeA, codeB) => {\n      if (codeA.type === \"foreign\" && codeB.type == \"normal\") {\n        return 1;\n      } else if (codeA.type === \"normal\" && codeB.type === \"foreign\") {\n        return -1;\n      } else {\n        return 0;\n      }\n    });\n\n    return codes;\n  }\n\n  /**\n   * 마이그레이션 대상 커넥션을 종료합니다.\n   *\n   * CLI에서 사용됩니다.\n   *\n   * @returns {Promise<void>} 종료 결과\n   */\n  async destroy(): Promise<void> {\n    await Promise.all(\n      this.targets.apply.map((db) => {\n        return db.destroy();\n      })\n    );\n  }\n}\n"],"names":["_","knex","chalk","DateTime","mkdir","readdir","unlink","writeFile","exists","prompts","execSync","path","EntityManager","Sonamu","ServiceUnavailableException","generateCreateCode","generateAlterCode","getMigrationSetFromDB","getMigrationSetFromEntity","Migrator","targets","options","dbConfig","mode","devDB","development_master","testDB","test","fixtureLocalDB","fixture_local","applyDBs","connection","host","fixture_remote","database","fixtureRemoteDB","push","compare","pending","shadow","apply","productionDB","production_master","Error","getMigrationCodes","srcMigrationsDir","join","apiRootPath","recursive","codes","filter","f","endsWith","map","name","replace","sort","a","b","getStatus","connKeys","Object","keys","key","statuses","Promise","all","connKey","knexOptions","tConn","status","migrate","err","console","warn","yellow","JSON","stringify","fdList","list","fd","file","currentVersion","destroy","connString","user","port","preparedCodes","status0conn","find","undefined","compareDBconn","genCodes","compareMigrations","conns","runAction","action","configs","uniqBy","target","c","config","result","batchNo","applied","latest","rollback","delCodes","codeNames","some","conn","codeName","includes","delFiles","res","delFile","log","red","sum","generatePreparedCodes","length","green","migrationsDir","index","pcode","entries","formatted","dateTag","local","plus","seconds","toFormat","filePath","title","clearPendingList","pendingList","delList","df","p","check","table","run","answer","type","message","initial","value","time","blue","runShadowTest","timeEnd","applyDb","label","client","connectionSettings","code","rollbackAllResult","db","forceFreeMigrationsLock","dir","depth","tdb","tdbConn","shadowDatabase","tmpSqlPath","magenta","password","raw","sdb","e","error","resetAll","compareDB","entityIds","getAllIds","entitySetsWithJoinTable","entityId","get","props","joinTablesWithDup","entitySet","joinTables","flat","values","groupBy","jt","tables","indexes","flatMap","t","columns","entitySets","dbSet","codeA","codeB"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/migration/migrator.ts"],"sourcesContent":["import assert from \"assert\";\nimport chalk from \"chalk\";\nimport { mkdir, readdir, unlink, writeFile } from \"fs/promises\";\nimport knex, { type Knex } from \"knex\";\nimport path from \"path\";\nimport { group, sum, unique } from \"radashi\";\nimport { Sonamu } from \"../api\";\nimport { DB, type SonamuDBConfig } from \"../database/db\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { ServiceUnavailableException } from \"../exceptions/so-exceptions\";\nimport { Naite } from \"../naite/naite\";\nimport type { GenMigrationCode, MigrationSet } from \"../types/types\";\nimport { isTest } from \"../utils/controller\";\nimport { exists } from \"../utils/fs-utils\";\nimport { generateAlterCode, generateCreateCode } from \"./code-generation\";\nimport { getMigrationSetFromEntity } from \"./migration-set\";\nimport { PostgreSQLSchemaReader } from \"./postgresql-schema-reader\";\nimport type { ConnString, MigrationCode, MigrationStatus } from \"./types\";\n\nexport type MigrationResult = {\n  connKey: string;\n  batchNo: number;\n  applied: string[];\n}[];\n\nexport class Migrator {\n  private async getMigrationCodes(): Promise<MigrationCode[]> {\n    const srcMigrationsDir = path.join(Sonamu.apiRootPath, \"src\", \"migrations\"); // 이건 환경에 관계없이 항상 src에서 찾아야 해요.\n\n    if (!(await exists(srcMigrationsDir))) {\n      await mkdir(srcMigrationsDir, {\n        recursive: true,\n      });\n    }\n\n    const codes = (await readdir(srcMigrationsDir))\n      .filter((f) => f.endsWith(\".ts\"))\n      .map((f) => ({\n        name: f.replace(\".ts\", \"\"),\n        path: path.join(srcMigrationsDir, f),\n      }))\n      .sort((a, b) => (a.name < b.name ? 1 : -1)); // 이름 내림차순 정렬(최신순)\n\n    Naite.t(\"migrator:getMigrationCodes:results\", codes);\n    return codes;\n  }\n\n  /**\n   * 타겟별 마이그레이션 상태와 코드 생성/준비 상태를 구해옵니다.\n   * 실제로 DB에 접근도 하고 마이그레이션 코드 파일도 확인하고,\n   * 필요하다면 적용할 수 있는 코드를 생성까지 해옵니다.\n   *\n   * CLI와 Sonamu UI에서 사용됩니다.\n   *\n   * @returns\n   */\n  async getStatus(): Promise<MigrationStatus> {\n    const codes = await this.getMigrationCodes();\n    Naite.t(\"migrator:getStatus:codes\", codes);\n\n    const connKeys = Object.keys(Sonamu.dbConfig).filter(\n      (key) => key.endsWith(\"_slave\") === false,\n    ) as (keyof typeof Sonamu.dbConfig)[];\n\n    let migrationStatusError: string | undefined;\n\n    const statuses = await Promise.all(\n      connKeys.map(async (connKey) => {\n        const knexOptions = Sonamu.dbConfig[connKey];\n        const tConn = knex(knexOptions);\n\n        const status = await (async () => {\n          try {\n            return await tConn.migrate.status();\n          } catch (err) {\n            console.warn(\n              chalk.yellow(\n                `${connKey}의 마이그레이션 상태를 가져오는 데에 실패하였습니다. 데이터베이스가 올바르게 구성되지 않은 것 같습니다. 확인하시고 다시 시도해주세요.\\n시도한 연결 설정:\\n${JSON.stringify(knexOptions.connection, null, 2)}\\n발생한 에러:\\n${err}\\n`,\n              ),\n            );\n            migrationStatusError = err instanceof Error ? err.message : String(err);\n            return \"error\";\n          }\n        })();\n        const pending: string[] = await (async () => {\n          try {\n            const [, fdList] = await tConn.migrate.list();\n            return fdList.map((fd: { file: string }) => fd.file.replace(\".ts\", \"\"));\n          } catch (err) {\n            migrationStatusError = err instanceof Error ? err.message : String(err);\n            return [];\n          }\n        })();\n        const currentVersion = await (async () => {\n          try {\n            return await tConn.migrate.currentVersion();\n          } catch (_err) {\n            migrationStatusError = _err instanceof Error ? _err.message : String(_err);\n            return \"error\";\n          }\n        })();\n        Naite.t(\"migrator:getStatus:status\", status);\n\n        const connection = knexOptions.connection as Knex.PgConnectionConfig;\n\n        await tConn.destroy();\n\n        return {\n          name: connKey.replace(\"_master\", \"\"),\n          connKey,\n          connString: `pg://${connection.user ?? \"\"}@${connection.host}:${\n            connection.port\n          }/${connection.database}` as ConnString,\n          currentVersion,\n          status: status as number | \"error\",\n          pending,\n        };\n      }),\n    );\n\n    Naite.t(\"migrator:getStatus:conns\", statuses);\n\n    const preparedCodes: GenMigrationCode[] = await (async () => {\n      const status0conn = statuses.find((status) => status.status === 0);\n      if (status0conn === undefined) {\n        console.warn(\n          chalk.yellow(\n            `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.`,\n          ),\n        );\n        return [];\n      }\n\n      const compareDBconn = knex(Sonamu.dbConfig[status0conn.connKey]);\n      const genCodes = await this.compareMigrations(compareDBconn);\n\n      await compareDBconn.destroy();\n\n      return genCodes;\n    })();\n\n    Naite.t(\"migrator:getStatus:preparedCodes\", preparedCodes);\n\n    return {\n      conns: statuses,\n      codes,\n      preparedCodes,\n      error: migrationStatusError,\n    };\n  }\n\n  /**\n   * 마이그레이션을 적용하거나 롤백합니다.\n   * Sonamu UI에서 마이그레이션 작업을 수행할 때 사용됩니다.\n   *\n   * CLI와 Sonamu UI에서 사용됩니다.\n   *\n   * @param action 작업 유형 (apply/rollback)\n   * @param targets 작업 대상 DB 설정 키 (keyof SonamuDBConfig)\n   * @returns 작업 결과\n   */\n  async runAction(\n    action: \"apply\" | \"rollback\",\n    targets: (keyof SonamuDBConfig)[],\n  ): Promise<MigrationResult> {\n    Naite.t(\"migrator:runAction:action\", action);\n    Naite.t(\"migrator:runAction:targets\", targets);\n\n    // get uniq knex configs\n    const configs = unique(\n      targets\n        .map((target) => ({\n          connKey: target,\n          options: Sonamu.dbConfig[target as keyof typeof Sonamu.dbConfig],\n        }))\n        .filter((c) => c.options !== undefined),\n      ({ options }) =>\n        `${(options.connection as Knex.PgConnectionConfig).host}:${\n          (options.connection as Knex.PgConnectionConfig).port ?? 5432\n        }/${(options.connection as Knex.PgConnectionConfig).database}`,\n    );\n\n    // get connections\n    const conns = await Promise.all(\n      configs.map(async (config) => ({\n        connKey: config.connKey,\n        knex: knex(config.options),\n      })),\n    );\n\n    // action\n    const result = await (async () => {\n      switch (action) {\n        case \"apply\":\n          return Promise.all(\n            conns.map(async ({ connKey, knex }) => {\n              const [batchNo, applied] = await knex.migrate.latest();\n              return {\n                connKey,\n                batchNo,\n                applied, // 이번 latest 호출로 인해 \"up\"이 적용된 마이그레이션 이름(e.g. \"20251124233557_create__companies.ts\")들의 배열입니다. 참고: https://github.com/knex/knex/blob/01b177c485d696f1b72858dee728ba143c4fad76/lib/migrations/migrate/Migrator.js#L560\n              };\n            }),\n          );\n        case \"rollback\":\n          return Promise.all(\n            conns.map(async ({ connKey, knex }) => {\n              const [batchNo, applied] = await knex.migrate.rollback();\n              return {\n                connKey,\n                batchNo,\n                applied, // 이번 rollback 호출로 인해 \"down\"이 적용된(=롤백된) 마이그레이션 이름(e.g. \"20251124233557_create__companies.ts\")들의 배열입니다. 참고: https://github.com/knex/knex/blob/01b177c485d696f1b72858dee728ba143c4fad76/lib/migrations/migrate/Migrator.js#L611\n              };\n            }),\n          );\n      }\n    })();\n\n    // destroy\n    await Promise.all(\n      conns.map(({ knex }) => {\n        return knex.destroy();\n      }),\n    );\n\n    Naite.t(\"migrator:runAction:result\", result);\n\n    return result;\n  }\n\n  /**\n   * 삭제 가능한 마이그레이션 코드 파일을 검증합니다.\n   *\n   * @param conns 마이그레이션 상태 배열\n   * @param codeNames 삭제할 마이그레이션 코드 파일 이름 배열\n   * @returns 삭제 가능 여부 및 적용된 마이그레이션 코드 파일 이름\n   */\n  validateDeletable(conns: MigrationStatus[\"conns\"], codeNames: string[]) {\n    const appliedCodes = codeNames.filter((codeName) =>\n      conns.some((conn) => conn.pending.includes(codeName) === false),\n    );\n\n    return {\n      canDelete: appliedCodes.length === 0,\n      appliedCodes,\n    };\n  }\n\n  /**\n   * 마이그레이션 코드 파일을 삭제합니다.\n   *\n   * Sonamu UI에서 사용됩니다.\n   *\n   * @param codeNames 삭제할 마이그레이션 코드 파일 이름 배열\n   * @returns 삭제된 마이그레이션 코드 파일 개수\n   */\n  async delCodes(codeNames: string[]): Promise<number> {\n    const { conns } = await this.getStatus();\n    const { canDelete, appliedCodes } = this.validateDeletable(conns, codeNames);\n    if (!canDelete) {\n      throw new Error(\n        `You cannot delete a migration file if there is already applied. Applied codes: ${appliedCodes.join(\", \")}`,\n      );\n    }\n\n    return sum(\n      await Promise.all(\n        codeNames.map(async (codeName) => {\n          const filePath = `${Sonamu.apiRootPath}/src/migrations/${codeName}.ts`;\n          if (await exists(filePath)) {\n            await unlink(filePath);\n            return 1;\n          }\n          return 0;\n        }),\n      ),\n    );\n  }\n\n  private genDateTag(index: number, baseDate: Date = new Date()): string {\n    const date = new Date(baseDate.getTime() + index * 1000);\n    const pad = (num: number, size: number = 2) => num.toString().padStart(size, \"0\");\n    return (\n      date.getFullYear().toString() +\n      pad(date.getMonth() + 1) +\n      pad(date.getDate()) +\n      pad(date.getHours()) +\n      pad(date.getMinutes()) +\n      pad(date.getSeconds())\n    );\n  }\n\n  /**\n   * 마이그레이션 코드 파일을 생성합니다.\n   *\n   * Sonamu UI에서 사용됩니다.\n   *\n   * @returns 생성된 마이그레이션 코드 파일 개수\n   */\n  async generatePreparedCodes(): Promise<number> {\n    const { preparedCodes } = await this.getStatus();\n    Naite.t(\"migrator:generatePreparedCodes:preparedCodes\", preparedCodes);\n    if (preparedCodes.length === 0) {\n      console.log(chalk.green(\"\\n현재 모두 싱크된 상태입니다.\"));\n      return 0;\n    }\n\n    // 실제 코드 생성\n    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;\n\n    for (const [index, pcode] of preparedCodes.entries()) {\n      if (pcode.formatted) {\n        const dateTag = this.genDateTag(index);\n        const filePath = `${migrationsDir}/${dateTag}_${pcode.title}.ts`;\n        await writeFile(filePath, pcode.formatted);\n        !isTest() && console.log(chalk.green(`MIGRTAION CREATED ${filePath}`));\n      }\n    }\n\n    return preparedCodes.length;\n  }\n\n  async compareMigrations(compareDB: Knex): Promise<GenMigrationCode[]> {\n    // Entity 순회하여 싱크\n    const entityIds = EntityManager.getAllIds();\n\n    // 조인테이블 포함하여 Entity에서 MigrationSet 추출\n    const entitySetsWithJoinTable = entityIds\n      .filter((entityId) => EntityManager.get(entityId).props.length > 0)\n      .map((entityId) => getMigrationSetFromEntity(EntityManager.get(entityId)));\n\n    // 조인테이블만 추출\n    const joinTablesWithDup = entitySetsWithJoinTable.flatMap((entitySet) => entitySet.joinTables);\n    // 중복 제거 (중복인 경우 indexes를 병합)\n    const joinTables = Object.values(group(joinTablesWithDup, (jt) => jt.table)).map((tables) => {\n      assert(tables !== undefined, \"tables is undefined\");\n      if (tables.length === 1) {\n        return tables[0];\n      }\n      return {\n        ...tables[0],\n        indexes: unique(\n          tables.flatMap((t) => t.indexes),\n          (index) => [index.type, ...index.columns.sort()].join(\"-\"),\n        ),\n      };\n    });\n\n    // 조인테이블 포함하여 MigrationSet 배열\n    const entitySets: MigrationSet[] = [...entitySetsWithJoinTable, ...joinTables];\n\n    const codes: GenMigrationCode[] = (\n      await Promise.all(\n        entitySets.map(async (entitySet) => {\n          const dbSet = await PostgreSQLSchemaReader.getMigrationSetFromDB(\n            compareDB,\n            entitySet.table,\n          );\n          Naite.t(`migrator:compareMigrations:entitySet:${entitySet.table}`, entitySet);\n          Naite.t(`migrator:compareMigrations:dbSet:${entitySet.table}`, dbSet);\n\n          if (dbSet === null) {\n            // 기존 테이블 없음, 새로 테이블 생성\n            return await generateCreateCode(entitySet);\n          } else {\n            // 기존 테이블 존재하는 케이스\n            return await generateAlterCode(entitySet, dbSet);\n          }\n        }),\n      )\n    ).flat();\n\n    // normal 타입이 앞으로, foreign이 뒤로\n    codes.sort((codeA, codeB) => {\n      if (codeA.type === \"foreign\" && codeB.type === \"normal\") {\n        return 1;\n      } else if (codeA.type === \"normal\" && codeB.type === \"foreign\") {\n        return -1;\n      } else {\n        return 0;\n      }\n    });\n\n    return codes;\n  }\n\n  /**\n   * Shadow DB 테스트를 진행합니다.\n   *\n   * Sonamu UI에서 사용됩니다.\n   *\n   * @returns Shadow DB 테스트 결과\n   */\n  async runShadowTest(): Promise<MigrationResult> {\n    const tdbConn = Sonamu.dbConfig.test.connection as Knex.PgConnectionConfig;\n    const shadowDatabase = `${tdbConn.database}__migration_shadow`;\n\n    // 테스트 상황에서는 트랜잭션을 초기화하고, 새 데이터베이스 커넥션을 가져와야 함\n    if (isTest()) {\n      await DB.clearTestTransaction();\n      await DB.destroy();\n    }\n\n    // 기존 Shadow DB 삭제 후 Shadow DB 생성\n    const tdb = knex(Sonamu.dbConfig.test);\n    !isTest() && console.log(chalk.magenta(`${shadowDatabase} 삭제`));\n    await tdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase}`);\n    await tdb.raw(`CREATE DATABASE ${shadowDatabase} TEMPLATE ${tdbConn.database}`);\n\n    // Shadow DB에 연결\n    const sdb = knex({\n      ...Sonamu.dbConfig.test,\n      connection: {\n        ...tdbConn,\n        database: shadowDatabase,\n        password: tdbConn.password,\n      },\n    });\n\n    // shadow DB 테스트 진행\n    try {\n      const [batchNo, applied] = await sdb.migrate.latest();\n      !isTest() &&\n        console.log(chalk.green(\"Shadow DB 테스트에 성공했습니다!\"), {\n          batchNo,\n          applied,\n        });\n\n      return [\n        {\n          connKey: \"shadow\",\n          batchNo,\n          applied,\n        },\n      ];\n    } catch (e) {\n      console.error(e);\n      throw new ServiceUnavailableException(\"Shadow DB 테스트 진행 중 에러\");\n    } finally {\n      // Shadow DB 연결 종료\n      await sdb.destroy();\n\n      // Shadow DB 삭제\n      !isTest() && console.log(chalk.magenta(`${shadowDatabase} 삭제`));\n      await tdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase}`);\n\n      // Test DB 연결 종료\n      await tdb.destroy();\n    }\n  }\n}\n"],"names":["assert","chalk","mkdir","readdir","unlink","writeFile","knex","path","group","sum","unique","Sonamu","DB","EntityManager","ServiceUnavailableException","Naite","isTest","exists","generateAlterCode","generateCreateCode","getMigrationSetFromEntity","PostgreSQLSchemaReader","Migrator","getMigrationCodes","srcMigrationsDir","join","apiRootPath","recursive","codes","filter","f","endsWith","map","name","replace","sort","a","b","t","getStatus","connKeys","Object","keys","dbConfig","key","migrationStatusError","statuses","Promise","all","connKey","knexOptions","tConn","status","migrate","err","console","warn","yellow","JSON","stringify","connection","Error","message","String","pending","fdList","list","fd","file","currentVersion","_err","destroy","connString","user","host","port","database","preparedCodes","status0conn","find","undefined","compareDBconn","genCodes","compareMigrations","conns","error","runAction","action","targets","configs","target","options","c","config","result","batchNo","applied","latest","rollback","validateDeletable","codeNames","appliedCodes","codeName","some","conn","includes","canDelete","length","delCodes","filePath","genDateTag","index","baseDate","Date","date","getTime","pad","num","size","toString","padStart","getFullYear","getMonth","getDate","getHours","getMinutes","getSeconds","generatePreparedCodes","log","green","migrationsDir","pcode","entries","formatted","dateTag","title","compareDB","entityIds","getAllIds","entitySetsWithJoinTable","entityId","get","props","joinTablesWithDup","flatMap","entitySet","joinTables","values","jt","table","tables","indexes","type","columns","entitySets","dbSet","getMigrationSetFromDB","flat","codeA","codeB","runShadowTest","tdbConn","test","shadowDatabase","clearTestTransaction","tdb","magenta","raw","sdb","password","e"],"mappings":"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"}