sonamu 0.8.26 → 0.9.0

package/dist/migration/migrator.js

@@ -1,353 +1,348 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { createKnexInstance, init_knex } from "../database/knex.js";
+import { DB, init_db } from "../database/db.js";
+import { SD, init_sd } from "../dict/sd.js";
+import { ServiceUnavailableException, init_so_exceptions } from "../exceptions/so-exceptions.js";
+import { init_controller, isTest } from "../utils/controller.js";
+import { exists, init_fs_utils } from "../utils/fs-utils.js";
+import { Sonamu, init_sonamu } from "../api/sonamu.js";
+import { EntityManager, init_entity_manager } from "../entity/entity-manager.js";
+import { Naite, init_naite } from "../naite/naite.js";
+import { PostgreSQLSchemaReader, init_postgresql_schema_reader } from "./postgresql-schema-reader.js";
+import { generateAlterCode, generateCreateCode, init_code_generation } from "./code-generation.js";
+import { getMigrationSetFromEntity, init_migration_set } from "./migration-set.js";
+import { group, sum, unique } from "radashi";
 import assert from "assert";
-import chalk from "chalk";
-import { mkdir, readdir, unlink, writeFile } from "node:fs/promises";
+import { mkdir, readdir, unlink, writeFile } from "fs/promises";
 import path from "path";
-import { group, sum, unique } from "radashi";
-import { Sonamu } from "../api/index.js";
-import { DB } from "../database/db.js";
-import { createKnexInstance } from "../database/knex.js";
-import { SD } from "../dict/sd.js";
-import { EntityManager } from "../entity/entity-manager.js";
-import { ServiceUnavailableException } from "../exceptions/so-exceptions.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 {
-    async getMigrationCodes() {
-        const srcMigrationsDir = path.join(Sonamu.apiRootPath, "src", "migrations"); // 이건 환경에 관계없이 항상 src에서 찾아야 해요.
-        if (!await exists(srcMigrationsDir)) {
-            await mkdir(srcMigrationsDir, {
-                recursive: true
-            });
-        }
-        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); // 이름 내림차순 정렬(최신순)
-        Naite.t("migrator:getMigrationCodes:results", codes);
-        return codes;
-    }
-    /**
-   * 타겟별 마이그레이션 상태와 코드 생성/준비 상태를 구해옵니다.
-   * 실제로 DB에 접근도 하고 마이그레이션 코드 파일도 확인하고,
-   * 필요하다면 적용할 수 있는 코드를 생성까지 해옵니다.
-   *
-   * CLI와 Sonamu UI에서 사용됩니다.
-   *
-   * @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 = createKnexInstance(knexOptions);
-            try {
-                const status = await (async ()=>{
-                    try {
-                        return await tConn.migrate.status();
-                    } catch (err) {
-                        console.warn(chalk.yellow(`${connKey}의 마이그레이션 상태를 가져오는 데에 실패하였습니다. 데이터베이스가 올바르게 구성되지 않은 것 같습니다. 확인하시고 다시 시도해주세요.\n시도한 연결 설정:\n${JSON.stringify(knexOptions.connection, null, 2)}\n발생한 에러:\n${err}\n`));
-                        migrationStatusError = err instanceof Error ? err.message : String(err);
-                        return "error";
-                    }
-                })();
-                const pending = await (async ()=>{
-                    try {
-                        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) {
-                        migrationStatusError = _err instanceof Error ? _err.message : String(_err);
-                        return "error";
-                    }
-                })();
-                Naite.t("migrator:getStatus:status", status);
-                const connection = knexOptions.connection;
-                return {
-                    name: connKey.replace("_master", ""),
-                    connKey,
-                    connString: `pg://${connection.user ?? ""}@${connection.host}:${connection.port}/${connection.database}`,
-                    currentVersion,
-                    status: status,
-                    pending
-                };
-            } finally{
-                await tConn.destroy();
-            }
-        }));
-        Naite.t("migrator:getStatus:conns", statuses);
-        const preparedCodes = 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 [];
-            }
-            const compareDBconn = createKnexInstance(Sonamu.dbConfig[status0conn.connKey]);
-            try {
-                return await this.compareMigrations(compareDBconn);
-            } finally{
-                await compareDBconn.destroy();
-            }
-        })();
-        Naite.t("migrator:getStatus:preparedCodes", preparedCodes);
-        return {
-            conns: statuses,
-            codes,
-            preparedCodes,
-            error: migrationStatusError
-        };
-    }
-    /**
-   * 마이그레이션을 적용하거나 롤백합니다.
-   * Sonamu UI에서 마이그레이션 작업을 수행할 때 사용됩니다.
-   *
-   * CLI와 Sonamu UI에서 사용됩니다.
-   *
-   * @param action 작업 유형 (apply/rollback)
-   * @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 = unique(targets.map((target)=>({
-                connKey: target,
-                options: Sonamu.dbConfig[target]
-            })).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,
-                knex: createKnexInstance(config.options)
-            })));
-        try {
-            // action
-            const result = await (async ()=>{
-                switch(action){
-                    case "apply":
-                        return Promise.all(conns.map(async ({ connKey, knex })=>{
-                            const [batchNo, applied] = await knex.migrate.latest();
-                            return {
-                                connKey,
-                                batchNo,
-                                applied
-                            };
-                        }));
-                    case "rollback":
-                        return Promise.all(conns.map(async ({ connKey, knex })=>{
-                            const [batchNo, applied] = await knex.migrate.rollback();
-                            return {
-                                connKey,
-                                batchNo,
-                                applied
-                            };
-                        }));
-                }
-            })();
-            Naite.t("migrator:runAction:result", result);
-            return result;
-        } finally{
-            await Promise.all(conns.map(({ knex })=>{
-                return knex.destroy();
-            }));
-        }
-    }
-    /**
-   * 삭제 가능한 마이그레이션 코드 파일을 검증합니다.
-   *
-   * @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에서 사용됩니다.
-   *
-   * @param codeNames 삭제할 마이그레이션 코드 파일 이름 배열
-   * @returns 삭제된 마이그레이션 코드 파일 개수
-   */ async delCodes(codeNames) {
-        const { conns } = await this.getStatus();
-        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(", ")}`);
-        }
-        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;
-        })));
-    }
-    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());
-    }
-    /**
-   * 마이그레이션 코드 파일을 생성합니다.
-   *
-   * Sonamu UI에서 사용됩니다.
-   *
-   * @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;
-        }
-        // 실제 코드 생성
-        const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
-        for (const [index, pcode] of preparedCodes.entries()){
-            if (pcode.formatted) {
-                const dateTag = this.genDateTag(index);
-                const filePath = `${migrationsDir}/${dateTag}_${pcode.title}.ts`;
-                await writeFile(filePath, pcode.formatted);
-                !isTest() && console.log(chalk.green(`MIGRATION CREATED ${filePath}`));
-            }
-        }
-        return preparedCodes.length;
-    }
-    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.flatMap((entitySet)=>entitySet.joinTables);
-        // 중복 제거 (중복인 경우 indexes를 병합)
-        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: unique(tables.flatMap((t)=>t.indexes), (index)=>[
-                        index.type,
-                        ...index.columns
-                    ].join("-"))
-            };
-        });
-        // 조인테이블 포함하여 MigrationSet 배열
-        const entitySets = [
-            ...entitySetsWithJoinTable,
-            ...joinTables
-        ];
-        const codes = (await Promise.all(entitySets.map(async (entitySet)=>{
-            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);
-            } else {
-                // 기존 테이블 존재하는 케이스
-                return await generateAlterCode(entitySet, dbSet, compareDB);
-            }
-        }))).flat();
-        // normal 타입이 앞으로, foreign이 뒤로
-        codes.sort((codeA, codeB)=>{
-            if (codeA.type === "foreign" && codeB.type === "normal") {
-                return 1;
-            } else if (codeA.type === "normal" && codeB.type === "foreign") {
-                return -1;
-            } else {
-                return 0;
-            }
-        });
-        return codes;
-    }
-    /**
-   * Shadow DB 테스트를 진행합니다.
-   *
-   * Sonamu UI에서 사용됩니다.
-   *
-   * @returns Shadow DB 테스트 결과
-   */ async runShadowTest() {
-        const tdbConn = Sonamu.dbConfig.test.connection;
-        const shadowDatabase = `${tdbConn.database}__migration_shadow`;
-        // 테스트 상황에서는 트랜잭션을 초기화하고, 새 데이터베이스 커넥션을 가져와야 함
-        if (isTest()) {
-            await DB.clearTestTransaction();
-            // 병렬 테스트 모드에서는 worker DB 연결 유지
-            if (process.env.SONAMU_WORKER_DB !== "true") {
-                await DB.destroy();
-            }
-        }
-        // 기존 Shadow DB 삭제 후 Shadow DB 생성
-        const tdb = createKnexInstance(Sonamu.dbConfig.test);
-        try {
-            !isTest() && console.log(chalk.magenta(`${shadowDatabase} 삭제`));
-            await tdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase}`);
-            await tdb.raw(`
+import chalk from "chalk";
+
+//#region src/migration/migrator.ts
+var Migrator;
+var init_migrator = __esmMin((() => {
+	init_sonamu();
+	init_db();
+	init_knex();
+	init_sd();
+	init_entity_manager();
+	init_so_exceptions();
+	init_naite();
+	init_controller();
+	init_fs_utils();
+	init_code_generation();
+	init_migration_set();
+	init_postgresql_schema_reader();
+	Migrator = class {
+		async runMigrationsSequentially(conns, action) {
+			const results = [];
+			for (const { connKey, knex } of conns) {
+				const [batchNo, applied] = action === "apply" ? await knex.migrate.latest() : await knex.migrate.rollback();
+				results.push({
+					connKey,
+					batchNo,
+					applied
+				});
+			}
+			return results;
+		}
+		async getMigrationCodes() {
+			const srcMigrationsDir = path.join(Sonamu.apiRootPath, "src", "migrations");
+			if (!await exists(srcMigrationsDir)) {
+				await mkdir(srcMigrationsDir, { recursive: true });
+			}
+			const codes = (await readdir(srcMigrationsDir)).filter((f) => f.endsWith(".ts")).map((f) => ({
+				name: f.replace(".ts", ""),
+				path: path.join(srcMigrationsDir, f)
+			})).toSorted((a, b) => a.name < b.name ? 1 : -1);
+			Naite.t("migrator:getMigrationCodes:results", codes);
+			return codes;
+		}
+		/**
+		* 타겟별 마이그레이션 상태와 코드 생성/준비 상태를 구해옵니다.
+		* 실제로 DB에 접근도 하고 마이그레이션 코드 파일도 확인하고,
+		* 필요하다면 적용할 수 있는 코드를 생성까지 해옵니다.
+		*
+		* CLI와 Sonamu UI에서 사용됩니다.
+		*
+		* @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"));
+			let migrationStatusError;
+			const statuses = await Promise.all(connKeys.map(async (connKey) => {
+				const knexOptions = Sonamu.dbConfig[connKey];
+				const tConn = createKnexInstance(knexOptions);
+				try {
+					const status = await (async () => {
+						try {
+							return await tConn.migrate.status();
+						} catch (err) {
+							console.warn(chalk.yellow(`${connKey}의 마이그레이션 상태를 가져오는 데에 실패하였습니다. 데이터베이스가 올바르게 구성되지 않은 것 같습니다. 확인하시고 다시 시도해주세요.\n시도한 연결 설정:\n${JSON.stringify(knexOptions.connection, null, 2)}\n발생한 에러:\n${err}\n`));
+							migrationStatusError = err instanceof Error ? err.message : String(err);
+							return "error";
+						}
+					})();
+					const pending = await (async () => {
+						try {
+							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) {
+							migrationStatusError = _err instanceof Error ? _err.message : String(_err);
+							return "error";
+						}
+					})();
+					Naite.t("migrator:getStatus:status", status);
+					const connection = knexOptions.connection;
+					return {
+						name: connKey.replace("_master", ""),
+						connKey,
+						connString: `pg://${connection.user ?? ""}@${connection.host}:${connection.port}/${connection.database}`,
+						currentVersion,
+						status,
+						pending
+					};
+				} finally {
+					await tConn.destroy();
+				}
+			}));
+			Naite.t("migrator:getStatus:conns", statuses);
+			const preparedCodes = 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 [];
+				}
+				const compareDBconn = createKnexInstance(Sonamu.dbConfig[status0conn.connKey]);
+				try {
+					return await this.compareMigrations(compareDBconn);
+				} finally {
+					await compareDBconn.destroy();
+				}
+			})();
+			Naite.t("migrator:getStatus:preparedCodes", preparedCodes);
+			return {
+				conns: statuses,
+				codes,
+				preparedCodes,
+				error: migrationStatusError
+			};
+		}
+		/**
+		* 마이그레이션을 적용하거나 롤백합니다.
+		* Sonamu UI에서 마이그레이션 작업을 수행할 때 사용됩니다.
+		*
+		* CLI와 Sonamu UI에서 사용됩니다.
+		*
+		* @param action 작업 유형 (apply/rollback)
+		* @param targets 작업 대상 DB 설정 키 (keyof SonamuDBConfig)
+		* @returns 작업 결과
+		*/
+		async runAction(action, targets) {
+			Naite.t("migrator:runAction:action", action);
+			Naite.t("migrator:runAction:targets", targets);
+			const configs = unique(targets.map((target) => ({
+				connKey: target,
+				options: Sonamu.dbConfig[target]
+			})).filter((c) => c.options !== undefined), ({ options }) => `${options.connection.host}:${options.connection.port ?? 5432}/${options.connection.database}`);
+			const conns = await Promise.all(configs.map(async (config) => ({
+				connKey: config.connKey,
+				knex: createKnexInstance(config.options)
+			})));
+			try {
+				const result = await (async () => {
+					switch (action) {
+						case "apply": return this.runMigrationsSequentially(conns, "apply");
+						case "rollback": return this.runMigrationsSequentially(conns, "rollback");
+					}
+				})();
+				Naite.t("migrator:runAction:result", result);
+				return result;
+			} finally {
+				await Promise.all(conns.map(({ knex }) => {
+					return knex.destroy();
+				}));
+			}
+		}
+		/**
+		* 삭제 가능한 마이그레이션 코드 파일을 검증합니다.
+		*
+		* @param conns 마이그레이션 상태 배열
+		* @param codeNames 삭제할 마이그레이션 코드 파일 이름 배열
+		* @returns 삭제 가능 여부 및 적용된 마이그레이션 코드 파일 이름
+		*/
+		validateDeletable(conns, codeNames) {
+			const appliedCodes = codeNames.filter((codeName) => conns.some((conn) => !conn.pending.includes(codeName)));
+			return {
+				canDelete: appliedCodes.length === 0,
+				appliedCodes
+			};
+		}
+		/**
+		* 마이그레이션 코드 파일을 삭제합니다.
+		*
+		* Sonamu UI에서 사용됩니다.
+		*
+		* @param codeNames 삭제할 마이그레이션 코드 파일 이름 배열
+		* @returns 삭제된 마이그레이션 코드 파일 개수
+		*/
+		async delCodes(codeNames) {
+			const { conns } = await this.getStatus();
+			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(", ")}`);
+			}
+			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;
+			})));
+		}
+		genDateTag(index, baseDate = new Date()) {
+			const date = new Date(baseDate.getTime() + index * 1e3);
+			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());
+		}
+		/**
+		* 마이그레이션 코드 파일을 생성합니다.
+		*
+		* Sonamu UI에서 사용됩니다.
+		*
+		* @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;
+			}
+			const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
+			for (const [index, pcode] of preparedCodes.entries()) {
+				if (pcode.formatted) {
+					const dateTag = this.genDateTag(index);
+					const filePath = `${migrationsDir}/${dateTag}_${pcode.title}.ts`;
+					await writeFile(filePath, pcode.formatted);
+					!isTest() && console.log(chalk.green(`MIGRATION CREATED ${filePath}`));
+				}
+			}
+			return preparedCodes.length;
+		}
+		async compareMigrations(compareDB) {
+			const entityIds = EntityManager.getAllIds();
+			const entitySetsWithJoinTable = entityIds.filter((entityId) => EntityManager.get(entityId).props.length > 0).map((entityId) => getMigrationSetFromEntity(EntityManager.get(entityId)));
+			const joinTablesWithDup = entitySetsWithJoinTable.flatMap((entitySet) => entitySet.joinTables);
+			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: unique(tables.flatMap((t) => t.indexes), (index) => [index.type, ...index.columns].join("-"))
+				};
+			});
+			const entitySets = [...entitySetsWithJoinTable, ...joinTables];
+			const codes = (await Promise.all(entitySets.map(async (entitySet) => {
+				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);
+				} else {
+					return await generateAlterCode(entitySet, dbSet, compareDB);
+				}
+			}))).flat();
+			codes.sort((codeA, codeB) => {
+				if (codeA.type === "foreign" && codeB.type === "normal") {
+					return 1;
+				} else if (codeA.type === "normal" && codeB.type === "foreign") {
+					return -1;
+				} else {
+					return 0;
+				}
+			});
+			return codes;
+		}
+		/**
+		* Shadow DB 테스트를 진행합니다.
+		*
+		* Sonamu UI에서 사용됩니다.
+		*
+		* @returns Shadow DB 테스트 결과
+		*/
+		async runShadowTest() {
+			const tdbConn = Sonamu.dbConfig.test.connection;
+			const shadowDatabase = `${tdbConn.database}__migration_shadow`;
+			if (isTest()) {
+				await DB.clearTestTransaction();
+				if (process.env.SONAMU_WORKER_DB !== "true") {
+					await DB.destroy();
+				}
+			}
+			const tdb = createKnexInstance(Sonamu.dbConfig.test);
+			try {
+				!isTest() && console.log(chalk.magenta(`${shadowDatabase} 삭제`));
+				await tdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase}`);
+				await tdb.raw(`
         SELECT pg_terminate_backend(pg_stat_activity.pid)
         FROM pg_stat_activity
         WHERE datname = '${tdbConn.database}'
           AND pid <> pg_backend_pid();
       `);
-            await tdb.raw(`CREATE DATABASE ${shadowDatabase} TEMPLATE ${tdbConn.database}`);
-            // Shadow DB에 연결
-            const sdb = createKnexInstance({
-                ...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(SD("sonamu.error.shadowDbTestFailed"));
-            } finally{
-                await sdb.destroy();
-            }
-        } finally{
-            // Shadow DB 삭제
-            !isTest() && console.log(chalk.magenta(`${shadowDatabase} 삭제`));
-            try {
-                await tdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase}`);
-            } catch (e) {
-                console.error("Shadow DB 정리 실패:", e); // 이게 없으면 조용히 누수
-            } finally{
-                await tdb.destroy();
-            }
-        }
-    }
-}
+				await tdb.raw(`CREATE DATABASE ${shadowDatabase} TEMPLATE ${tdbConn.database}`);
+				const sdb = createKnexInstance({
+					...Sonamu.dbConfig.test,
+					connection: {
+						...tdbConn,
+						database: shadowDatabase,
+						password: tdbConn.password
+					}
+				});
+				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(SD("sonamu.error.shadowDbTestFailed"));
+				} finally {
+					await sdb.destroy();
+				}
+			} finally {
+				!isTest() && console.log(chalk.magenta(`${shadowDatabase} 삭제`));
+				try {
+					await tdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase}`);
+				} catch (e) {
+					console.error("Shadow DB 정리 실패:", e);
+				} finally {
+					await tdb.destroy();
+				}
+			}
+		}
+	};
+}));
 
-//# 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 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 { createKnexInstance } from \"../database/knex\";\nimport { SD } from \"../dict/sd\";\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 = createKnexInstance(knexOptions);\n\n        try {\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          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        } finally {\n          await tConn.destroy();\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 = createKnexInstance(Sonamu.dbConfig[status0conn.connKey]);\n      try {\n        return await this.compareMigrations(compareDBconn);\n      } finally {\n        await compareDBconn.destroy();\n      }\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: createKnexInstance(config.options),\n      })),\n    );\n\n    try {\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      Naite.t(\"migrator:runAction:result\", result);\n\n      return result;\n    } finally {\n      await Promise.all(\n        conns.map(({ knex }) => {\n          return knex.destroy();\n        }),\n      );\n    }\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(`MIGRATION 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].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, compareDB);\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      // 병렬 테스트 모드에서는 worker DB 연결 유지\n      if (process.env.SONAMU_WORKER_DB !== \"true\") {\n        await DB.destroy();\n      }\n    }\n\n    // 기존 Shadow DB 삭제 후 Shadow DB 생성\n    const tdb = createKnexInstance(Sonamu.dbConfig.test);\n    try {\n      !isTest() && console.log(chalk.magenta(`${shadowDatabase} 삭제`));\n      await tdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase}`);\n      await tdb.raw(`\n        SELECT pg_terminate_backend(pg_stat_activity.pid)\n        FROM pg_stat_activity\n        WHERE datname = '${tdbConn.database}'\n          AND pid <> pg_backend_pid();\n      `);\n      await tdb.raw(`CREATE DATABASE ${shadowDatabase} TEMPLATE ${tdbConn.database}`);\n\n      // Shadow DB에 연결\n      const sdb = createKnexInstance({\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(SD(\"sonamu.error.shadowDbTestFailed\"));\n      } finally {\n        await sdb.destroy();\n      }\n    } finally {\n      // Shadow DB 삭제\n      !isTest() && console.log(chalk.magenta(`${shadowDatabase} 삭제`));\n      try {\n        await tdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase}`);\n      } catch (e) {\n        console.error(\"Shadow DB 정리 실패:\", e); // 이게 없으면 조용히 누수\n      } finally {\n        await tdb.destroy();\n      }\n    }\n  }\n}\n"],"names":["assert","chalk","mkdir","readdir","unlink","writeFile","path","group","sum","unique","Sonamu","DB","createKnexInstance","SD","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","connString","user","host","port","database","destroy","preparedCodes","status0conn","find","undefined","compareDBconn","compareMigrations","conns","error","runAction","action","targets","configs","target","options","c","config","knex","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","process","env","SONAMU_WORKER_DB","tdb","magenta","raw","sdb","password","e"],"mappings":"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"}
+//#endregion
+init_migrator();
+export { Migrator, init_migrator };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"migrator.js","names":["results: MigrationResult","migrationStatusError: string | undefined","status: number | \"error\"","pending: string[]","currentVersion: string | \"error\"","preparedCodes: GenMigrationCode[]","entitySets: MigrationSet[]","codes: GenMigrationCode[]"],"sources":["../../src/migration/migrator.ts"],"sourcesContent":["import assert from \"assert\";\nimport { mkdir, readdir, unlink, writeFile } from \"fs/promises\";\nimport path from \"path\";\n\nimport chalk from \"chalk\";\nimport { type Knex } from \"knex\";\nimport { group, sum, unique } from \"radashi\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { DB } from \"../database/db\";\nimport { type SonamuDBConfig } from \"../database/db\";\nimport { createKnexInstance } from \"../database/knex\";\nimport { SD } from \"../dict/sd\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { ServiceUnavailableException } from \"../exceptions/so-exceptions\";\nimport { Naite } from \"../naite/naite\";\nimport { type GenMigrationCode, type 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, type MigrationCode, type MigrationStatus } from \"./types\";\n\nexport type MigrationResult = {\n  connKey: string;\n  batchNo: number;\n  applied: string[];\n}[];\n\nexport class Migrator {\n  private async runMigrationsSequentially(\n    conns: { connKey: keyof SonamuDBConfig; knex: Knex }[],\n    action: \"apply\" | \"rollback\",\n  ): Promise<MigrationResult> {\n    const results: MigrationResult = [];\n\n    for (const { connKey, knex } of conns) {\n      const [batchNo, applied] =\n        action === \"apply\" ? await knex.migrate.latest() : await knex.migrate.rollback();\n\n      results.push({\n        connKey,\n        batchNo,\n        applied,\n      });\n    }\n\n    return results;\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      .toSorted((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\"),\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 = createKnexInstance(knexOptions);\n\n        try {\n          const status: number | \"error\" = 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: string | \"error\" = 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          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,\n            pending,\n          };\n        } finally {\n          await tConn.destroy();\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 = createKnexInstance(Sonamu.dbConfig[status0conn.connKey]);\n      try {\n        return await this.compareMigrations(compareDBconn);\n      } finally {\n        await compareDBconn.destroy();\n      }\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],\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: createKnexInstance(config.options),\n      })),\n    );\n\n    try {\n      // action\n      const result = await (async () => {\n        switch (action) {\n          case \"apply\":\n            return this.runMigrationsSequentially(conns, \"apply\");\n          case \"rollback\":\n            return this.runMigrationsSequentially(conns, \"rollback\");\n        }\n      })();\n\n      Naite.t(\"migrator:runAction:result\", result);\n\n      return result;\n    } finally {\n      await Promise.all(\n        conns.map(({ knex }) => {\n          return knex.destroy();\n        }),\n      );\n    }\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)),\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(`MIGRATION 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].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, compareDB);\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      // 병렬 테스트 모드에서는 worker DB 연결 유지\n      if (process.env.SONAMU_WORKER_DB !== \"true\") {\n        await DB.destroy();\n      }\n    }\n\n    // 기존 Shadow DB 삭제 후 Shadow DB 생성\n    const tdb = createKnexInstance(Sonamu.dbConfig.test);\n    try {\n      !isTest() && console.log(chalk.magenta(`${shadowDatabase} 삭제`));\n      await tdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase}`);\n      await tdb.raw(`\n        SELECT pg_terminate_backend(pg_stat_activity.pid)\n        FROM pg_stat_activity\n        WHERE datname = '${tdbConn.database}'\n          AND pid <> pg_backend_pid();\n      `);\n      await tdb.raw(`CREATE DATABASE ${shadowDatabase} TEMPLATE ${tdbConn.database}`);\n\n      // Shadow DB에 연결\n      const sdb = createKnexInstance({\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(SD(\"sonamu.error.shadowDbTestFailed\"));\n      } finally {\n        await sdb.destroy();\n      }\n    } finally {\n      // Shadow DB 삭제\n      !isTest() && console.log(chalk.magenta(`${shadowDatabase} 삭제`));\n      try {\n        await tdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase}`);\n      } catch (e) {\n        console.error(\"Shadow DB 정리 실패:\", e); // 이게 없으면 조용히 누수\n      } finally {\n        await tdb.destroy();\n      }\n    }\n  }\n}\n"],"mappings":"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"}