sonamu 0.2.38 → 0.2.40

package/dist/entity/migrator.js

@@ -1,1434 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Migrator = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const knex_1 = __importDefault(require("knex"));
-const prettier_1 = __importDefault(require("prettier"));
-const chalk_1 = __importDefault(require("chalk"));
-const luxon_1 = require("luxon");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
-const inflection_1 = __importDefault(require("inflection"));
-const prompts_1 = __importDefault(require("prompts"));
-const child_process_1 = require("child_process");
-const path_1 = __importDefault(require("path"));
-const types_1 = require("../types/types");
-const entity_manager_1 = require("./entity-manager");
-const api_1 = require("../api");
-const so_exceptions_1 = require("../exceptions/so-exceptions");
-class Migrator {
-    constructor(options) {
-        this.mode = options.mode;
-        const { dbConfig } = api_1.Sonamu;
-        if (this.mode === "dev") {
-            const devDB = (0, knex_1.default)(dbConfig.development_master);
-            const testDB = (0, knex_1.default)(dbConfig.test);
-            const fixtureLocalDB = (0, knex_1.default)(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 = (0, knex_1.default)(dbConfig.fixture_remote);
-                applyDBs.push(fixtureRemoteDB);
-            }
-            this.targets = {
-                compare: devDB,
-                pending: devDB,
-                shadow: testDB,
-                apply: applyDBs,
-            };
-        }
-        else if (this.mode === "deploy") {
-            const productionDB = (0, knex_1.default)(api_1.Sonamu.dbConfig.production_master);
-            const testDB = (0, knex_1.default)(api_1.Sonamu.dbConfig.test);
-            this.targets = {
-                pending: productionDB,
-                shadow: testDB,
-                apply: [productionDB],
-            };
-        }
-        else {
-            throw new Error(`잘못된 모드 ${this.mode} 입력`);
-        }
-    }
-    getMigrationCodes() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const srcMigrationsDir = `${api_1.Sonamu.apiRootPath}/src/migrations`;
-            const distMigrationsDir = `${api_1.Sonamu.apiRootPath}/dist/migrations`;
-            if (fs_extra_1.default.existsSync(srcMigrationsDir) === false) {
-                fs_extra_1.default.mkdirSync(srcMigrationsDir, {
-                    recursive: true,
-                });
-            }
-            if (fs_extra_1.default.existsSync(distMigrationsDir) === false) {
-                fs_extra_1.default.mkdirSync(distMigrationsDir, {
-                    recursive: true,
-                });
-            }
-            const srcMigrations = fs_extra_1.default
-                .readdirSync(srcMigrationsDir)
-                .filter((f) => f.endsWith(".ts"))
-                .map((f) => f.split(".")[0]);
-            const distMigrations = fs_extra_1.default
-                .readdirSync(distMigrationsDir)
-                .filter((f) => f.endsWith(".js"))
-                .map((f) => f.split(".")[0]);
-            const normal = lodash_1.default.intersection(srcMigrations, distMigrations)
-                .map((filename) => {
-                return {
-                    name: filename,
-                    path: path_1.default.join(srcMigrationsDir, filename) + ".ts",
-                };
-            })
-                .sort((a, b) => (a > b ? 1 : -1));
-            const onlyTs = lodash_1.default.difference(srcMigrations, distMigrations).map((filename) => {
-                return {
-                    name: filename,
-                    path: path_1.default.join(srcMigrationsDir, filename) + ".ts",
-                };
-            });
-            const onlyJs = lodash_1.default.difference(distMigrations, srcMigrations).map((filename) => {
-                return {
-                    name: filename,
-                    path: path_1.default.join(distMigrationsDir, filename) + ".js",
-                };
-            });
-            return {
-                normal,
-                onlyTs,
-                onlyJs,
-            };
-        });
-    }
-    getStatus() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { normal, onlyTs, onlyJs } = yield this.getMigrationCodes();
-            if (onlyTs.length > 0) {
-                console.debug({ onlyTs });
-                throw new so_exceptions_1.ServiceUnavailableException(`There is an un-compiled TS migration files.\nPlease compile them first.\n\n${onlyTs
-                    .map((f) => f.name)
-                    .join("\n")}`);
-            }
-            if (onlyJs.length > 0) {
-                console.debug({ onlyJs });
-                yield Promise.all(onlyJs.map((f) => __awaiter(this, void 0, void 0, function* () {
-                    (0, child_process_1.execSync)(`rm -f ${f.path.replace("/src/", "/dist/").replace(".ts", ".js")}`);
-                })));
-            }
-            const connKeys = Object.keys(api_1.Sonamu.dbConfig).filter((key) => key.endsWith("_slave") === false);
-            const statuses = yield Promise.all(connKeys.map((connKey) => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b;
-                const knexOptions = api_1.Sonamu.dbConfig[connKey];
-                const tConn = (0, knex_1.default)(knexOptions);
-                const status = yield (() => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        return yield tConn.migrate.status();
-                    }
-                    catch (err) {
-                        return "error";
-                    }
-                }))();
-                const pending = yield (() => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        const [, fdList] = yield tConn.migrate.list();
-                        return fdList.map((fd) => fd.file.replace(".js", ""));
-                    }
-                    catch (err) {
-                        return [];
-                    }
-                }))();
-                const currentVersion = yield (() => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        return tConn.migrate.currentVersion();
-                    }
-                    catch (err) {
-                        return "error";
-                    }
-                }))();
-                const connection = knexOptions.connection;
-                yield tConn.destroy();
-                return {
-                    name: connKey.replace("_master", ""),
-                    connKey,
-                    connString: `${knexOptions.client}://${(_a = connection.user) !== null && _a !== void 0 ? _a : ""}@${connection.host}:${(_b = connection.port) !== null && _b !== void 0 ? _b : 3306}/${connection.database}`,
-                    currentVersion,
-                    status,
-                    pending,
-                };
-            })));
-            const preparedCodes = yield (() => __awaiter(this, void 0, void 0, function* () {
-                const status0conn = statuses.find((status) => status.status === 0);
-                if (status0conn === undefined) {
-                    return [];
-                }
-                const compareDBconn = (0, knex_1.default)(api_1.Sonamu.dbConfig[status0conn.connKey]);
-                const genCodes = yield this.compareMigrations(compareDBconn);
-                yield compareDBconn.destroy();
-                return genCodes;
-            }))();
-            return {
-                conns: statuses,
-                codes: normal,
-                preparedCodes,
-            };
-            /*
-              TS/JS 코드 컴파일 상태 확인
-              1. 원본 파일 없는 JS파일이 존재하는 경우: 삭제
-              2. 컴파일 되지 않은 TS파일이 존재하는 경우: throw 쳐서 데브 서버 오픈 요청
-        
-              DB 마이그레이션 상태 확인
-              1. 전체 DB설정에 대해서 현재 마이그레이션 상태 확인
-                - connKey: string
-                - status: number
-                - currentVersion: string
-                - list: { file: string; directory: string }[]
-        
-            */
-        });
-    }
-    runAction(action, targets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // get uniq knex configs
-            const configs = lodash_1.default.uniqBy(targets
-                .map((target) => ({
-                connKey: target,
-                options: api_1.Sonamu.dbConfig[target],
-            }))
-                .filter((c) => c.options !== undefined), ({ options }) => {
-                var _a;
-                return `${options.connection.host}:${(_a = options.connection.port) !== null && _a !== void 0 ? _a : 3306}/${options.connection.database}`;
-            });
-            // get connections
-            const conns = yield Promise.all(configs.map((config) => __awaiter(this, void 0, void 0, function* () {
-                return ({
-                    connKey: config.connKey,
-                    knex: (0, knex_1.default)(config.options),
-                });
-            })));
-            // action
-            const result = yield (() => __awaiter(this, void 0, void 0, function* () {
-                switch (action) {
-                    case "latest":
-                        return Promise.all(conns.map(({ connKey, knex }) => __awaiter(this, void 0, void 0, function* () {
-                            const [batchNo, applied] = yield knex.migrate.latest();
-                            return {
-                                connKey,
-                                batchNo,
-                                applied,
-                            };
-                        })));
-                    case "rollback":
-                        return Promise.all(conns.map(({ connKey, knex }) => __awaiter(this, void 0, void 0, function* () {
-                            const [batchNo, applied] = yield knex.migrate.rollback();
-                            return {
-                                connKey,
-                                batchNo,
-                                applied,
-                            };
-                        })));
-                }
-            }))();
-            // destroy
-            yield Promise.all(conns.map(({ knex }) => {
-                return knex.destroy();
-            }));
-            return result;
-        });
-    }
-    delCodes(codeNames) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { conns } = yield this.getStatus();
-            if (conns.some((conn) => {
-                return codeNames.some((codeName) => conn.pending.includes(codeName) === false);
-            })) {
-                throw new Error("You cannot delete a migration file if there is already applied.");
-            }
-            const delFiles = codeNames
-                .map((codeName) => [
-                `${api_1.Sonamu.apiRootPath}/src/migrations/${codeName}.ts`,
-                `${api_1.Sonamu.apiRootPath}/dist/migrations/${codeName}.js`,
-            ])
-                .flat();
-            const res = yield Promise.all(delFiles.map((delFile) => {
-                if (fs_extra_1.default.existsSync(delFile)) {
-                    console.log(chalk_1.default.red(`DELETE: ${delFile}`));
-                    fs_extra_1.default.unlinkSync(delFile);
-                    return delFiles.includes(".ts") ? 1 : 0;
-                }
-                return 0;
-            }));
-            return lodash_1.default.sum(res);
-        });
-    }
-    generatePreparedCodes() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { preparedCodes } = yield this.getStatus();
-            if (preparedCodes.length === 0) {
-                console.log(chalk_1.default.green("\n현재 모두 싱크된 상태입니다."));
-                return 0;
-            }
-            // 실제 코드 생성
-            const migrationsDir = `${api_1.Sonamu.apiRootPath}/src/migrations`;
-            preparedCodes
-                .filter((pcode) => pcode.formatted)
-                .map((pcode, index) => {
-                const dateTag = luxon_1.DateTime.local()
-                    .plus({ seconds: index })
-                    .toFormat("yyyyMMddHHmmss");
-                const filePath = `${migrationsDir}/${dateTag}_${pcode.title}.ts`;
-                fs_extra_1.default.writeFileSync(filePath, pcode.formatted);
-                console.log(chalk_1.default.green(`MIGRTAION CREATED ${filePath}`));
-            });
-            return preparedCodes.length;
-        });
-    }
-    clearPendingList() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [, pendingList] = (yield this.targets.pending.migrate.list());
-            const migrationsDir = `${api_1.Sonamu.apiRootPath}/src/migrations`;
-            const delList = pendingList.map((df) => {
-                return path_1.default.join(migrationsDir, df.file).replace(".js", ".ts");
-            });
-            for (let p of delList) {
-                if (fs_extra_1.default.existsSync(p)) {
-                    fs_extra_1.default.unlinkSync(p);
-                }
-            }
-            yield this.cleanUpDist(true);
-        });
-    }
-    check() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const codes = yield this.compareMigrations(this.targets.compare);
-            if (codes.length === 0) {
-                console.log(chalk_1.default.green("\n현재 모두 싱크된 상태입니다."));
-                return;
-            }
-            // 현재 생성된 코드 표기
-            console.table(codes, ["type", "title"]);
-            console.log(codes[0]);
-        });
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // pending 마이그레이션 확인
-            const [, pendingList] = yield this.targets.pending.migrate.list();
-            if (pendingList.length > 0) {
-                console.log(chalk_1.default.red("pending 된 마이그레이션이 존재합니다."), pendingList.map((pending) => pending.file));
-                // pending이 있는 경우 Shadow DB 테스트 진행 여부 컨펌
-                const answer = yield (0, prompts_1.default)({
-                    type: "confirm",
-                    name: "value",
-                    message: "Shadow DB 테스트를 진행하시겠습니까?",
-                    initial: true,
-                });
-                if (answer.value === false) {
-                    return;
-                }
-                console.time(chalk_1.default.blue("Migrator - runShadowTest"));
-                yield this.runShadowTest();
-                console.timeEnd(chalk_1.default.blue("Migrator - runShadowTest"));
-                yield Promise.all(this.targets.apply.map((applyDb) => __awaiter(this, void 0, void 0, function* () {
-                    const label = chalk_1.default.green(`APPLIED ${applyDb.client.connectionSettings.host} ${applyDb.client.database()}`);
-                    console.time(label);
-                    const [,] = yield applyDb.migrate.latest();
-                    console.timeEnd(label);
-                })));
-            }
-            // MD-DB간 비교하여 코드 생성 리턴
-            const codes = yield this.compareMigrations(this.targets.compare);
-            if (codes.length === 0) {
-                console.log(chalk_1.default.green("\n현재 모두 싱크된 상태입니다."));
-                return;
-            }
-            // 현재 생성된 코드 표기
-            console.table(codes, ["type", "title"]);
-            /* DEBUG: 디버깅용 코드
-            codes.map((code) => console.log(code.formatted));
-            process.exit();
-             */
-            // 실제 파일 생성 프롬프트
-            const answer = yield (0, prompts_1.default)({
-                type: "confirm",
-                name: "value",
-                message: "마이그레이션 코드를 생성하시겠습니까?",
-                initial: false,
-            });
-            if (answer.value === false) {
-                return;
-            }
-            // 실제 코드 생성
-            const migrationsDir = `${api_1.Sonamu.apiRootPath}/src/migrations`;
-            codes
-                .filter((code) => code.formatted)
-                .map((code, index) => {
-                const dateTag = luxon_1.DateTime.local()
-                    .plus({ seconds: index })
-                    .toFormat("yyyyMMddHHmmss");
-                const filePath = `${migrationsDir}/${dateTag}_${code.title}.ts`;
-                fs_extra_1.default.writeFileSync(filePath, code.formatted);
-                console.log(chalk_1.default.green(`MIGRTAION CREATED ${filePath}`));
-            });
-        });
-    }
-    rollback() {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.time(chalk_1.default.red("rollback:"));
-            const rollbackAllResult = yield Promise.all(this.targets.apply.map((db) => __awaiter(this, void 0, void 0, function* () {
-                yield db.migrate.forceFreeMigrationsLock();
-                return db.migrate.rollback(undefined, false);
-            })));
-            console.dir({ rollbackAllResult }, { depth: null });
-            console.timeEnd(chalk_1.default.red("rollback:"));
-        });
-    }
-    cleanUpDist(force = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const files = ["src", "dist"].reduce((r, which) => {
-                const migrationPath = path_1.default.join(api_1.Sonamu.apiRootPath, which, "migrations");
-                if (fs_extra_1.default.existsSync(migrationPath) === false) {
-                    fs_extra_1.default.mkdirSync(migrationPath, {
-                        recursive: true,
-                    });
-                }
-                const files = fs_extra_1.default
-                    .readdirSync(migrationPath)
-                    .filter((filename) => filename.startsWith(".") === false);
-                r[which] = files;
-                return r;
-            }, {
-                src: [],
-                dist: [],
-            });
-            const diffOnSrc = lodash_1.default.differenceBy(files.src, files.dist, (filename) => filename.split(".")[0]);
-            if (diffOnSrc.length > 0) {
-                throw new Error("컴파일 되지 않은 파일이 있습니다.\n" + diffOnSrc.join("\n"));
-            }
-            const diffOnDist = lodash_1.default.differenceBy(files.dist, files.src, (filename) => filename.split(".")[0]);
-            if (diffOnDist.length > 0) {
-                console.log(chalk_1.default.red("원본 ts파일을 찾을 수 없는 js파일이 있습니다."));
-                console.log(diffOnDist);
-                if (!force) {
-                    const answer = yield (0, prompts_1.default)({
-                        type: "confirm",
-                        name: "value",
-                        message: "삭제를 진행하시겠습니까?",
-                        initial: true,
-                    });
-                    if (answer.value === false) {
-                        return;
-                    }
-                }
-                const filesToRm = diffOnDist.map((filename) => {
-                    return path_1.default.join(api_1.Sonamu.apiRootPath, "dist", "migrations", filename);
-                });
-                filesToRm.map((filePath) => {
-                    fs_extra_1.default.unlinkSync(filePath);
-                });
-                console.log(chalk_1.default.green(`${filesToRm.length}건 삭제되었습니다!`));
-            }
-        });
-    }
-    runShadowTest() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // ShadowDB 생성 후 테스트 진행
-            const tdb = (0, knex_1.default)(api_1.Sonamu.dbConfig.test);
-            const tdbConn = api_1.Sonamu.dbConfig.test.connection;
-            const shadowDatabase = tdbConn.database + "__migration_shadow";
-            const tmpSqlPath = `/tmp/${shadowDatabase}.sql`;
-            // 테스트DB 덤프 후 Database명 치환
-            console.log(chalk_1.default.magenta(`${tdbConn.database}의 데이터 ${tmpSqlPath}로 덤프`));
-            (0, child_process_1.execSync)(`mysqldump -h${tdbConn.host} -u${tdbConn.user} -p'${tdbConn.password}' ${tdbConn.database} --single-transaction --no-create-db --triggers > ${tmpSqlPath};`);
-            (0, child_process_1.execSync)(`sed -i'' -e 's/\`${tdbConn.database}\`/\`${shadowDatabase}\`/g' ${tmpSqlPath};`);
-            // 기존 ShadowDB 리셋
-            console.log(chalk_1.default.magenta(`${shadowDatabase} 리셋`));
-            yield tdb.raw(`DROP DATABASE IF EXISTS \`${shadowDatabase}\`;`);
-            yield tdb.raw(`CREATE DATABASE \`${shadowDatabase}\`;`);
-            // ShadowDB 테이블 + 데이터 생성
-            console.log(chalk_1.default.magenta(`${shadowDatabase} 데이터베이스 생성`));
-            (0, child_process_1.execSync)(`mysql -h${tdbConn.host} -u${tdbConn.user} -p'${tdbConn.password}' ${shadowDatabase} < ${tmpSqlPath};`);
-            // tdb 연결 종료
-            yield tdb.destroy();
-            // shadow db 테스트 진행
-            const sdb = (0, knex_1.default)(Object.assign(Object.assign({}, api_1.Sonamu.dbConfig.test), { connection: Object.assign(Object.assign({}, tdbConn), { database: shadowDatabase, password: tdbConn.password }) }));
-            try {
-                const [batchNo, applied] = yield sdb.migrate.latest();
-                console.log(chalk_1.default.green("Shadow DB 테스트에 성공했습니다!"), {
-                    batchNo,
-                    applied,
-                });
-                // 생성한 Shadow DB 삭제
-                console.log(chalk_1.default.magenta(`${shadowDatabase} 삭제`));
-                yield sdb.raw(`DROP DATABASE IF EXISTS \`${shadowDatabase}\`;`);
-                return [
-                    {
-                        connKey: "shadow",
-                        batchNo,
-                        applied,
-                    },
-                ];
-            }
-            catch (e) {
-                console.error(e);
-                throw new so_exceptions_1.ServiceUnavailableException("Shadow DB 테스트 진행 중 에러");
-            }
-            finally {
-                yield sdb.destroy();
-            }
-        });
-    }
-    resetAll() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const answer = yield (0, prompts_1.default)({
-                type: "confirm",
-                name: "value",
-                message: "모든 DB를 롤백하고 전체 마이그레이션 파일을 삭제하시겠습니까?",
-                initial: false,
-            });
-            if (answer.value === false) {
-                return;
-            }
-            console.time(chalk_1.default.red("rollback-all:"));
-            const rollbackAllResult = yield Promise.all(this.targets.apply.map((db) => __awaiter(this, void 0, void 0, function* () {
-                yield db.migrate.forceFreeMigrationsLock();
-                return db.migrate.rollback(undefined, true);
-            })));
-            console.log({ rollbackAllResult });
-            console.timeEnd(chalk_1.default.red("rollback-all:"));
-            const migrationsDir = `${api_1.Sonamu.apiRootPath}/src/migrations`;
-            console.time(chalk_1.default.red("delete migration files"));
-            (0, child_process_1.execSync)(`rm -f ${migrationsDir}/*`);
-            (0, child_process_1.execSync)(`rm -f ${migrationsDir.replace("/src/", "/dist/")}/*`);
-            console.timeEnd(chalk_1.default.red("delete migration files"));
-        });
-    }
-    compareMigrations(compareDB) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // MD 순회하여 싱크
-            const entityIds = entity_manager_1.EntityManager.getAllIds();
-            // 조인테이블 포함하여 MD에서 MigrationSet 추출
-            const entitySetsWithJoinTable = entityIds
-                .filter((entityId) => {
-                const entity = entity_manager_1.EntityManager.get(entityId);
-                return entity.props.length > 0;
-            })
-                .map((entityId) => {
-                const entity = entity_manager_1.EntityManager.get(entityId);
-                return this.getMigrationSetFromMD(entity);
-            });
-            // 조인테이블만 추출
-            const joinTables = lodash_1.default.uniqBy(entitySetsWithJoinTable.map((entitySet) => entitySet.joinTables).flat(), (joinTable) => {
-                return joinTable.table;
-            });
-            // 조인테이블 포함하여 MigrationSet 배열
-            const entitySets = [
-                ...entitySetsWithJoinTable,
-                ...joinTables,
-            ];
-            let codes = (yield Promise.all(entitySets.map((entitySet) => __awaiter(this, void 0, void 0, function* () {
-                const dbSet = yield this.getMigrationSetFromDB(compareDB, entitySet.table);
-                if (dbSet === null) {
-                    // 기존 테이블 없음, 새로 테이블 생성
-                    return [
-                        yield this.generateCreateCode_ColumnAndIndexes(entitySet.table, entitySet.columns, entitySet.indexes),
-                        ...(yield this.generateCreateCode_Foreign(entitySet.table, entitySet.foreigns)),
-                    ];
-                }
-                // 기존 테이블 존재하는 케이스
-                const alterCodes = yield Promise.all(["columnsAndIndexes", "foreigns"].map((key) => {
-                    // 배열 원소의 순서가 달라서 불일치가 발생하는걸 방지하기 위해 각 항목별로 정렬 처리 후 비교
-                    if (key === "columnsAndIndexes") {
-                        const replaceColumnDefaultTo = (col) => {
-                            var _a;
-                            // float인 경우 기본값을 0으로 지정하는 경우 "0.00"으로 변환되는 케이스 대응
-                            if (col.type === "float" &&
-                                col.defaultTo &&
-                                String(col.defaultTo).includes('"') === false) {
-                                col.defaultTo = `"${Number(col.defaultTo).toFixed((_a = col.scale) !== null && _a !== void 0 ? _a : 2)}"`;
-                            }
-                            // string인 경우 기본값이 빈 스트링인 경우 대응
-                            if (col.type === "string" && col.defaultTo === "") {
-                                col.defaultTo = '""';
-                            }
-                            return col;
-                        };
-                        const entityColumns = lodash_1.default.sortBy(entitySet.columns, (a) => a.name).map(replaceColumnDefaultTo);
-                        const dbColumns = lodash_1.default.sortBy(dbSet.columns, (a) => a.name).map(replaceColumnDefaultTo);
-                        /* 디버깅용 코드, 특정 컬럼에서 불일치 발생할 때 확인
-                    const entityColumn = entitySet.columns.find(
-                      (col) => col.name === "price_krw"
-                    );
-                    const dbColumn = dbSet.columns.find(
-                      (col) => col.name === "price_krw"
-                    );
-                    console.debug({ entityColumn, dbColumn });
-                     */
-                        const entityIndexes = lodash_1.default.sortBy(entitySet.indexes, (a) => [
-                            a.type,
-                            ...a.columns.sort((c1, c2) => (c1 > c2 ? 1 : -1)),
-                        ].join("-"));
-                        const dbIndexes = lodash_1.default.sortBy(dbSet.indexes, (a) => [
-                            a.type,
-                            ...a.columns.sort((c1, c2) => (c1 > c2 ? 1 : -1)),
-                        ].join("-"));
-                        const isEqualColumns = (0, fast_deep_equal_1.default)(entityColumns, dbColumns);
-                        const isEqualIndexes = (0, fast_deep_equal_1.default)(entityIndexes, dbIndexes);
-                        if (isEqualColumns && isEqualIndexes) {
-                            return null;
-                        }
-                        else {
-                            // this.showMigrationSet("MD", entitySet);
-                            // this.showMigrationSet("DB", dbSet);
-                            return this.generateAlterCode_ColumnAndIndexes(entitySet.table, entityColumns, entityIndexes, dbColumns, dbIndexes);
-                        }
-                    }
-                    else {
-                        const replaceNoActionOnMySQL = (f) => {
-                            // MySQL에서 RESTRICT와 NO ACTION은 동일함
-                            const { onDelete, onUpdate } = f;
-                            return Object.assign(Object.assign({}, f), { onUpdate: onUpdate === "RESTRICT" ? "NO ACTION" : onUpdate, onDelete: onDelete === "RESTRICT" ? "NO ACTION" : onDelete });
-                        };
-                        const entityForeigns = lodash_1.default.sortBy(entitySet.foreigns, (a) => [a.to, ...a.columns].join("-")).map((f) => replaceNoActionOnMySQL(f));
-                        const dbForeigns = lodash_1.default.sortBy(dbSet.foreigns, (a) => [a.to, ...a.columns].join("-")).map((f) => replaceNoActionOnMySQL(f));
-                        if ((0, fast_deep_equal_1.default)(entityForeigns, dbForeigns) === false) {
-                            // console.dir({ entityForeigns, dbForeigns }, { depth: null });
-                            return this.generateAlterCode_Foreigns(entitySet.table, entityForeigns, dbForeigns);
-                        }
-                    }
-                    return null;
-                }));
-                if (alterCodes.every((alterCode) => alterCode === null)) {
-                    return null;
-                }
-                else {
-                    return alterCodes.filter((alterCode) => alterCode !== null).flat();
-                }
-            }))))
-                .flat()
-                .filter((code) => code !== null);
-            /*
-              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;
-        });
-    }
-    /*
-      기존 테이블 정보 읽어서 MigrationSet 형식으로 리턴
-    */
-    getMigrationSetFromDB(compareDB, table) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let dbColumns, dbIndexes, dbForeigns;
-            try {
-                [dbColumns, dbIndexes, dbForeigns] = yield this.readTable(compareDB, table);
-            }
-            catch (e) {
-                if ((0, types_1.isKnexError)(e) && e.code === "ER_NO_SUCH_TABLE") {
-                    return null;
-                }
-                console.error(e);
-                return null;
-            }
-            const columns = dbColumns.map((dbColumn) => {
-                const dbColType = this.resolveDBColType(dbColumn.Type, dbColumn.Field);
-                return Object.assign(Object.assign({ name: dbColumn.Field, nullable: dbColumn.Null !== "NO" }, dbColType), (() => {
-                    if (dbColumn.Default !== null) {
-                        return {
-                            defaultTo: dbColumn.Default,
-                        };
-                    }
-                    return {};
-                })());
-            });
-            const dbIndexesGroup = lodash_1.default.groupBy(dbIndexes.filter((dbIndex) => dbIndex.Key_name !== "PRIMARY" &&
-                !dbForeigns.find((dbForeign) => dbForeign.keyName === dbIndex.Key_name)), (dbIndex) => dbIndex.Key_name);
-            // indexes 처리
-            const indexes = Object.keys(dbIndexesGroup).map((keyName) => {
-                const currentIndexes = dbIndexesGroup[keyName];
-                return {
-                    type: currentIndexes[0].Non_unique === 1 ? "index" : "unique",
-                    columns: currentIndexes.map((currentIndex) => currentIndex.Column_name),
-                };
-            });
-            // console.log(table);
-            // console.table(dbIndexes);
-            // console.table(dbForeigns);
-            // foreigns 처리
-            const foreigns = dbForeigns.map((dbForeign) => {
-                return {
-                    columns: [dbForeign.from],
-                    to: `${dbForeign.referencesTable}.${dbForeign.referencesField}`,
-                    onUpdate: dbForeign.onUpdate,
-                    onDelete: dbForeign.onDelete,
-                };
-            });
-            return {
-                table,
-                columns,
-                indexes,
-                foreigns,
-            };
-        });
-    }
-    resolveDBColType(colType, colField) {
-        var _a, _b;
-        let [rawType, unsigned] = colType.split(" ");
-        const matched = rawType.match(/\(([0-9]+)\)/);
-        let length;
-        if (matched !== null && matched[1]) {
-            rawType = rawType.replace(/\(([0-9]+)\)/, "");
-            length = parseInt(matched[1]);
-        }
-        if (rawType === "char" && colField === "uuid") {
-            return {
-                type: "uuid",
-            };
-        }
-        switch (rawType) {
-            case "int":
-                return {
-                    type: "integer",
-                    unsigned: unsigned === "unsigned",
-                };
-            case "varchar":
-                // case "char":
-                return Object.assign({ type: "string" }, (length !== undefined && {
-                    length,
-                }));
-            case "text":
-            case "mediumtext":
-            case "longtext":
-            case "timestamp":
-            case "json":
-            case "date":
-            case "time":
-                return {
-                    type: rawType,
-                };
-            case "datetime":
-                return {
-                    type: "dateTime",
-                };
-            case "tinyint":
-                return {
-                    type: "boolean",
-                };
-            default:
-                // decimal 처리
-                if (rawType.startsWith("decimal")) {
-                    const [, precision, scale] = (_a = rawType.match(/decimal\(([0-9]+),([0-9]+)\)/)) !== null && _a !== void 0 ? _a : [];
-                    return Object.assign({ type: "decimal", precision: parseInt(precision), scale: parseInt(scale) }, (unsigned === "unsigned" && {
-                        unsigned: true,
-                    }));
-                }
-                else if (rawType.startsWith("float")) {
-                    const [, precision, scale] = (_b = rawType.match(/float\(([0-9]+),([0-9]+)\)/)) !== null && _b !== void 0 ? _b : [];
-                    return Object.assign({ type: "float", precision: parseInt(precision), scale: parseInt(scale) }, (unsigned === "unsigned" && {
-                        unsigned: true,
-                    }));
-                }
-                throw new Error(`resolve 불가능한 DB컬럼 타입 ${colType} ${rawType}`);
-        }
-    }
-    /*
-      기존 테이블 읽어서 cols, indexes 반환
-    */
-    readTable(compareDB, tableName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // 테이블 정보
-            try {
-                const [_cols] = (yield compareDB.raw(`SHOW FIELDS FROM ${tableName}`));
-                const cols = _cols.map((col) => (Object.assign(Object.assign({}, col), (col.Default !== null && {
-                    Default: col.Default.replace(/[0-9]+/g, "").length > 0 &&
-                        col.Extra !== "DEFAULT_GENERATED"
-                        ? `"${col.Default}"`
-                        : col.Default,
-                }))));
-                const [indexes] = yield compareDB.raw(`SHOW INDEX FROM ${tableName}`);
-                const [[row]] = yield compareDB.raw(`SHOW CREATE TABLE ${tableName}`);
-                const ddl = row["Create Table"];
-                const matched = ddl.match(/CONSTRAINT .+/g);
-                const foreignKeys = (matched !== null && matched !== void 0 ? matched : []).map((line) => {
-                    var _a, _b, _c;
-                    // 해당 라인을 정규식으로 파싱
-                    const matched = line.match(/CONSTRAINT `(.+)` FOREIGN KEY \(`(.+)`\) REFERENCES `(.+)` \(`(.+)`\)( ON [A-Z ]+)*/);
-                    if (!matched) {
-                        throw new Error(`인식할 수 없는 FOREIGN KEY CONSTRAINT ${line}`);
-                    }
-                    const [, keyName, from, referencesTable, referencesField, onClause] = matched;
-                    // console.debug({ tableName, line, onClause });
-                    const [onUpdateFull, _onUpdate] = (_a = (onClause !== null && onClause !== void 0 ? onClause : "").match(/ON UPDATE ([A-Z ]+)$/)) !== null && _a !== void 0 ? _a : [];
-                    const onUpdate = _onUpdate !== null && _onUpdate !== void 0 ? _onUpdate : "NO ACTION";
-                    const onDelete = (_c = (_b = (onClause !== null && onClause !== void 0 ? onClause : "")
-                        .replace(onUpdateFull !== null && onUpdateFull !== void 0 ? onUpdateFull : "", "")
-                        .match(/ON DELETE ([A-Z ]+) /)) === null || _b === void 0 ? void 0 : _b[1]) !== null && _c !== void 0 ? _c : "NO ACTION";
-                    return {
-                        keyName,
-                        from,
-                        referencesTable,
-                        referencesField,
-                        onDelete,
-                        onUpdate,
-                    };
-                });
-                return [cols, indexes, foreignKeys];
-            }
-            catch (e) {
-                throw e;
-            }
-        });
-    }
-    /*
-      MD 내용 읽어서 MigrationSetAndJoinTable 추출
-    */
-    getMigrationSetFromMD(entity) {
-        const migrationSet = entity.props.reduce((r, prop) => {
-            var _a, _b, _c;
-            // virtual 필드 제외
-            if ((0, types_1.isVirtualProp)(prop)) {
-                return r;
-            }
-            // HasMany 케이스는 아무 처리도 하지 않음
-            if ((0, types_1.isHasManyRelationProp)(prop)) {
-                return r;
-            }
-            // 일반 컬럼
-            if (!(0, types_1.isRelationProp)(prop)) {
-                // type resolve
-                let type;
-                if ((0, types_1.isTextProp)(prop)) {
-                    type = prop.textType;
-                }
-                else if ((0, types_1.isEnumProp)(prop)) {
-                    type = "string";
-                }
-                else {
-                    type = prop.type;
-                }
-                const column = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ name: prop.name, type }, ((0, types_1.isIntegerProp)(prop) && { unsigned: prop.unsigned === true })), (((0, types_1.isStringProp)(prop) || (0, types_1.isEnumProp)(prop)) && {
-                    length: prop.length,
-                })), { nullable: prop.nullable === true }), (() => {
-                    if (prop.dbDefault !== undefined) {
-                        return {
-                            defaultTo: prop.dbDefault,
-                        };
-                    }
-                    return {};
-                })()), (((0, types_1.isDecimalProp)(prop) || (0, types_1.isFloatProp)(prop)) && {
-                    precision: (_a = prop.precision) !== null && _a !== void 0 ? _a : 8,
-                    scale: (_b = prop.scale) !== null && _b !== void 0 ? _b : 2,
-                }));
-                r.columns.push(column);
-            }
-            if ((0, types_1.isManyToManyRelationProp)(prop)) {
-                // ManyToMany 케이스
-                const relMd = entity_manager_1.EntityManager.get(prop.with);
-                const [table1, table2] = prop.joinTable.split("__");
-                const join = {
-                    from: `${entity.table}.id`,
-                    through: {
-                        from: `${prop.joinTable}.${inflection_1.default.singularize(table1)}_id`,
-                        to: `${prop.joinTable}.${inflection_1.default.singularize(table2)}_id`,
-                        onUpdate: prop.onUpdate,
-                        onDelete: prop.onDelete,
-                    },
-                    to: `${relMd.table}.id`,
-                };
-                const through = join.through;
-                const fields = [through.from, through.to];
-                r.joinTables.push({
-                    table: through.from.split(".")[0],
-                    indexes: [
-                        {
-                            type: "unique",
-                            columns: ["uuid"],
-                        },
-                        // 조인 테이블에 걸린 인덱스 찾아와서 연결
-                        ...entity.indexes
-                            .filter((index) => index.columns.find((col) => col.includes(prop.joinTable + ".")))
-                            .map((index) => (Object.assign(Object.assign({}, index), { columns: index.columns.map((col) => col.replace(prop.joinTable + ".", "")) }))),
-                    ],
-                    columns: [
-                        {
-                            name: "id",
-                            type: "integer",
-                            nullable: false,
-                            unsigned: true,
-                        },
-                        ...fields.map((field) => {
-                            return {
-                                name: field.split(".")[1],
-                                type: "integer",
-                                nullable: false,
-                                unsigned: true,
-                            };
-                        }),
-                        {
-                            name: "uuid",
-                            nullable: true,
-                            type: "uuid",
-                        },
-                    ],
-                    foreigns: fields.map((field) => {
-                        return {
-                            columns: [field.split(".")[1]],
-                            to: through.to.includes(field) ? join.to : join.from,
-                            onUpdate: through.onUpdate,
-                            onDelete: through.onDelete,
-                        };
-                    }),
-                });
-                return r;
-            }
-            else if ((0, types_1.isBelongsToOneRelationProp)(prop) ||
-                ((0, types_1.isOneToOneRelationProp)(prop) && prop.hasJoinColumn)) {
-                // -OneRelation 케이스
-                const idColumnName = prop.name + "_id";
-                r.columns.push({
-                    name: idColumnName,
-                    type: "integer",
-                    unsigned: true,
-                    nullable: (_c = prop.nullable) !== null && _c !== void 0 ? _c : false,
-                });
-                r.foreigns.push({
-                    columns: [idColumnName],
-                    to: `${inflection_1.default.underscore(inflection_1.default.pluralize(prop.with)).toLowerCase()}.id`,
-                    onUpdate: prop.onUpdate,
-                    onDelete: prop.onDelete,
-                });
-            }
-            return r;
-        }, {
-            table: entity.table,
-            columns: [],
-            indexes: [],
-            foreigns: [],
-            joinTables: [],
-        });
-        // indexes
-        migrationSet.indexes = entity.indexes.filter((index) => index.columns.find((col) => col.includes(".") === false));
-        // uuid
-        migrationSet.columns = migrationSet.columns.concat({
-            name: "uuid",
-            nullable: true,
-            type: "uuid",
-        });
-        migrationSet.indexes = migrationSet.indexes.concat({
-            type: "unique",
-            columns: ["uuid"],
-        });
-        return migrationSet;
-    }
-    /*
-    MigrationColumn[] 읽어서 컬럼 정의하는 구문 생성
-  */
-    genColumnDefinitions(columns) {
-        return columns.map((column) => {
-            const chains = [];
-            if (column.name === "id") {
-                return `table.increments().primary();`;
-            }
-            if (column.type === "float" || column.type === "decimal") {
-                chains.push(`${column.type}('${column.name}', ${column.precision}, ${column.scale})`);
-            }
-            else {
-                // type, length
-                let columnType = column.type;
-                let extraType;
-                if (columnType.includes("text") && columnType !== "text") {
-                    extraType = columnType;
-                    columnType = "text";
-                }
-                chains.push(`${column.type}('${column.name}'${column.length ? `, ${column.length}` : ""}${extraType ? `, '${extraType}'` : ""})`);
-            }
-            if (column.unsigned) {
-                chains.push("unsigned()");
-            }
-            // nullable
-            chains.push(column.nullable ? "nullable()" : "notNullable()");
-            // defaultTo
-            if (column.defaultTo !== undefined) {
-                if (typeof column.defaultTo === "string" &&
-                    column.defaultTo.startsWith(`"`)) {
-                    chains.push(`defaultTo(${column.defaultTo})`);
-                }
-                else {
-                    chains.push(`defaultTo(knex.raw('${column.defaultTo}'))`);
-                }
-            }
-            return `table.${chains.join(".")};`;
-        });
-    }
-    /*
-    MigrationIndex[] 읽어서 인덱스/유니크 정의하는 구문 생성
-  */
-    genIndexDefinitions(indexes) {
-        if (indexes.length === 0) {
-            return [];
-        }
-        const lines = lodash_1.default.uniq(indexes.reduce((r, index) => {
-            r.push(`table.${index.type}([${index.columns
-                .map((col) => `'${col}'`)
-                .join(",")}])`);
-            return r;
-        }, []));
-        return lines;
-    }
-    /*
-      MigrationForeign[] 읽어서 외부키 constraint 정의하는 구문 생성
-    */
-    genForeignDefinitions(table, foreigns) {
-        return foreigns.reduce((r, foreign) => {
-            const columnsStringQuote = foreign.columns
-                .map((col) => `'${col.replace(`${table}.`, "")}'`)
-                .join(",");
-            r.up.push(`table.foreign('${foreign.columns.join(",")}')
-            .references('${foreign.to}')
-            .onUpdate('${foreign.onUpdate}')
-            .onDelete('${foreign.onDelete}')`);
-            r.down.push(`table.dropForeign([${columnsStringQuote}])`);
-            return r;
-        }, {
-            up: [],
-            down: [],
-        });
-    }
-    /*
-      테이블 생성하는 케이스 - 컬럼/인덱스 생성
-    */
-    generateCreateCode_ColumnAndIndexes(table, columns, indexes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // 컬럼, 인덱스 처리
-            const lines = [
-                'import { Knex } from "knex";',
-                "",
-                "export async function up(knex: Knex): Promise<void> {",
-                `return knex.schema.createTable("${table}", (table) => {`,
-                "// columns",
-                ...this.genColumnDefinitions(columns),
-                "",
-                "// indexes",
-                ...this.genIndexDefinitions(indexes),
-                "});",
-                "}",
-                "",
-                "export async function down(knex: Knex): Promise<void> {",
-                ` return knex.schema.dropTable("${table}");`,
-                "}",
-            ];
-            return {
-                table,
-                type: "normal",
-                title: `create__${table}`,
-                formatted: yield prettier_1.default.format(lines.join("\n"), {
-                    parser: "typescript",
-                }),
-            };
-        });
-    }
-    /*
-    테이블 생성하는 케이스 - FK 생성
-  */
-    generateCreateCode_Foreign(table, foreigns) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (foreigns.length === 0) {
-                return [];
-            }
-            const { up, down } = this.genForeignDefinitions(table, foreigns);
-            if (up.length === 0 && down.length === 0) {
-                console.log("fk 가 뭔가 다릅니다");
-                return [];
-            }
-            const lines = [
-                'import { Knex } from "knex";',
-                "",
-                "export async function up(knex: Knex): Promise<void> {",
-                `return knex.schema.alterTable("${table}", (table) => {`,
-                "// create fk",
-                ...up,
-                "});",
-                "}",
-                "",
-                "export async function down(knex: Knex): Promise<void> {",
-                `return knex.schema.alterTable("${table}", (table) => {`,
-                "// drop fk",
-                ...down,
-                "});",
-                "}",
-            ];
-            const foreignKeysString = foreigns
-                .map((foreign) => foreign.columns.join("_"))
-                .join("_");
-            return [
-                {
-                    table,
-                    type: "foreign",
-                    title: `foreign__${table}__${foreignKeysString}`,
-                    formatted: yield prettier_1.default.format(lines.join("\n"), {
-                        parser: "typescript",
-                    }),
-                },
-            ];
-        });
-    }
-    /*
-      마이그레이션 컬럼 배열 비교용 코드
-    */
-    showMigrationSet(which, migrationSet) {
-        const { columns, indexes, foreigns } = migrationSet;
-        const styledChalk = which === "MD" ? chalk_1.default.bgGreen.black : chalk_1.default.bgBlue.black;
-        console.log(styledChalk(`${which} ${migrationSet.table} Columns\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t`));
-        console.table(columns.map((column) => {
-            return Object.assign({}, lodash_1.default.pick(column, [
-                "name",
-                "type",
-                "nullable",
-                "unsigned",
-                "length",
-                "defaultTo",
-                "precision",
-                "scale",
-            ]));
-        }), [
-            "name",
-            "type",
-            "nullable",
-            "unsigned",
-            "length",
-            "defaultTo",
-            "precision",
-            "scale",
-        ]);
-        if (indexes.length > 0) {
-            console.log(styledChalk(`${which} ${migrationSet.table} Indexes\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t`));
-            console.table(indexes.map((index) => {
-                return Object.assign({}, lodash_1.default.pick(index, ["type", "columns", "name"]));
-            }));
-        }
-        if (foreigns.length > 0) {
-            console.log(chalk_1.default.bgMagenta.black(`${which} ${migrationSet.table} Foreigns\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t`));
-            console.table(foreigns.map((foreign) => {
-                return Object.assign({}, lodash_1.default.pick(foreign, ["columns", "to", "onUpdate", "onDelete"]));
-            }));
-        }
-    }
-    generateAlterCode_ColumnAndIndexes(table, entityColumns, entityIndexes, dbColumns, dbIndexes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            /*
-              세부 비교 후 다른점 찾아서 코드 생성
-        
-              1. 컬럼갯수 다름: MD에 있으나, DB에 없다면 추가
-              2. 컬럼갯수 다름: MD에 없으나, DB에 있다면 삭제
-              3. 그외 컬럼(컬럼 갯수가 동일하거나, 다른 경우 동일한 컬럼끼리) => alter
-              4. 다른거 다 동일하고 index만 변경되는 경우
-        
-              ** 컬럼명을 변경하는 경우는 따로 핸들링하지 않음
-              => drop/add 형태의 마이그레이션 코드가 생성되는데, 수동으로 rename 코드로 수정하여 처리
-            */
-            // 각 컬럼 이름 기준으로 add, drop, alter 여부 확인
-            const alterColumnsTo = this.getAlterColumnsTo(entityColumns, dbColumns);
-            // 추출된 컬럼들을 기준으로 각각 라인 생성
-            const alterColumnLinesTo = this.getAlterColumnLinesTo(alterColumnsTo, entityColumns);
-            // 인덱스의 add, drop 여부 확인
-            const alterIndexesTo = this.getAlterIndexesTo(entityIndexes, dbIndexes);
-            // 추출된 인덱스들을 기준으로 각각 라인 생성
-            const alterIndexLinesTo = this.getAlterIndexLinesTo(alterIndexesTo, alterColumnsTo);
-            const lines = [
-                'import { Knex } from "knex";',
-                "",
-                "export async function up(knex: Knex): Promise<void> {",
-                `return knex.schema.alterTable("${table}", (table) => {`,
-                ...(alterColumnsTo.add.length > 0 ? alterColumnLinesTo.add.up : []),
-                ...(alterColumnsTo.drop.length > 0 ? alterColumnLinesTo.drop.up : []),
-                ...(alterColumnsTo.alter.length > 0 ? alterColumnLinesTo.alter.up : []),
-                ...(alterIndexesTo.add.length > 0 ? alterIndexLinesTo.add.up : []),
-                ...(alterIndexesTo.drop.length > 0 ? alterIndexLinesTo.drop.up : []),
-                "})",
-                "}",
-                "",
-                "export async function down(knex: Knex): Promise<void> {",
-                `return knex.schema.alterTable("${table}", (table) => {`,
-                ...(alterColumnsTo.add.length > 0 ? alterColumnLinesTo.add.down : []),
-                ...(alterColumnsTo.drop.length > 0 ? alterColumnLinesTo.drop.down : []),
-                ...(alterColumnsTo.alter.length > 0 ? alterColumnLinesTo.alter.down : []),
-                ...(alterIndexLinesTo.add.down.length > 0
-                    ? alterIndexLinesTo.add.down
-                    : []),
-                ...(alterIndexLinesTo.drop.down.length > 0
-                    ? alterIndexLinesTo.drop.down
-                    : []),
-                "})",
-                "}",
-            ];
-            const formatted = yield prettier_1.default.format(lines.join("\n"), {
-                parser: "typescript",
-            });
-            const title = [
-                "alter",
-                table,
-                ...["add", "drop", "alter"]
-                    .map((action) => {
-                    const len = alterColumnsTo[action].length;
-                    if (len > 0) {
-                        return action + len;
-                    }
-                    return null;
-                })
-                    .filter((part) => part !== null),
-            ].join("_");
-            return [
-                {
-                    table,
-                    title,
-                    formatted,
-                    type: "normal",
-                },
-            ];
-        });
-    }
-    getAlterColumnsTo(entityColumns, dbColumns) {
-        const columnsTo = {
-            add: [],
-            drop: [],
-            alter: [],
-        };
-        // 컬럼명 기준 비교
-        const extraColumns = {
-            db: lodash_1.default.differenceBy(dbColumns, entityColumns, (col) => col.name),
-            entity: lodash_1.default.differenceBy(entityColumns, dbColumns, (col) => col.name),
-        };
-        if (extraColumns.entity.length > 0) {
-            columnsTo.add = columnsTo.add.concat(extraColumns.entity);
-        }
-        if (extraColumns.db.length > 0) {
-            columnsTo.drop = columnsTo.drop.concat(extraColumns.db);
-        }
-        // 동일 컬럼명의 세부 필드 비교
-        const sameDbColumns = lodash_1.default.intersectionBy(dbColumns, entityColumns, (col) => col.name);
-        const sameMdColumns = lodash_1.default.intersectionBy(entityColumns, dbColumns, (col) => col.name);
-        columnsTo.alter = lodash_1.default.differenceWith(sameDbColumns, sameMdColumns, (a, b) => (0, fast_deep_equal_1.default)(a, b));
-        return columnsTo;
-    }
-    getAlterColumnLinesTo(columnsTo, entityColumns) {
-        let linesTo = {
-            add: {
-                up: [],
-                down: [],
-            },
-            drop: {
-                up: [],
-                down: [],
-            },
-            alter: {
-                up: [],
-                down: [],
-            },
-        };
-        linesTo.add = {
-            up: ["// add", ...this.genColumnDefinitions(columnsTo.add)],
-            down: [
-                "// rollback - add",
-                `table.dropColumns(${columnsTo.add
-                    .map((col) => `'${col.name}'`)
-                    .join(", ")})`,
-            ],
-        };
-        linesTo.drop = {
-            up: [
-                "// drop",
-                `table.dropColumns(${columnsTo.drop
-                    .map((col) => `'${col.name}'`)
-                    .join(", ")})`,
-            ],
-            down: [
-                "// rollback - drop",
-                ...this.genColumnDefinitions(columnsTo.drop),
-            ],
-        };
-        linesTo.alter = columnsTo.alter.reduce((r, dbColumn) => {
-            const entityColumn = entityColumns.find((col) => col.name == dbColumn.name);
-            if (entityColumn === undefined) {
-                return r;
-            }
-            // 컬럼 변경사항
-            const columnDiffUp = lodash_1.default.difference(this.genColumnDefinitions([entityColumn]), this.genColumnDefinitions([dbColumn]));
-            const columnDiffDown = lodash_1.default.difference(this.genColumnDefinitions([dbColumn]), this.genColumnDefinitions([entityColumn]));
-            if (columnDiffUp.length > 0) {
-                r.up = [
-                    ...r.up,
-                    "// alter column",
-                    ...columnDiffUp.map((l) => l.replace(";", "") + ".alter();"),
-                ];
-                r.down = [
-                    ...r.down,
-                    "// rollback - alter column",
-                    ...columnDiffDown.map((l) => l.replace(";", "") + ".alter();"),
-                ];
-            }
-            return r;
-        }, {
-            up: [],
-            down: [],
-        });
-        return linesTo;
-    }
-    getAlterIndexesTo(entityIndexes, dbIndexes) {
-        // 인덱스 비교
-        let indexesTo = {
-            add: [],
-            drop: [],
-        };
-        const extraIndexes = {
-            db: lodash_1.default.differenceBy(dbIndexes, entityIndexes, (col) => [col.type, col.columns.join("-")].join("//")),
-            entity: lodash_1.default.differenceBy(entityIndexes, dbIndexes, (col) => [col.type, col.columns.join("-")].join("//")),
-        };
-        if (extraIndexes.entity.length > 0) {
-            indexesTo.add = indexesTo.add.concat(extraIndexes.entity);
-        }
-        if (extraIndexes.db.length > 0) {
-            indexesTo.drop = indexesTo.drop.concat(extraIndexes.db);
-        }
-        return indexesTo;
-    }
-    getAlterIndexLinesTo(indexesTo, columnsTo) {
-        let linesTo = {
-            add: {
-                up: [],
-                down: [],
-            },
-            drop: {
-                up: [],
-                down: [],
-            },
-        };
-        // 인덱스가 추가되는 경우, 컬럼과 같이 추가된 케이스에는 drop에서 제외해야함!
-        linesTo.add = {
-            up: ["// add indexes", ...this.genIndexDefinitions(indexesTo.add)],
-            down: [
-                "// rollback - add indexes",
-                ...indexesTo.add
-                    .filter((index) => index.columns.every((colName) => columnsTo.add.map((col) => col.name).includes(colName)) === false)
-                    .map((index) => `table.drop${inflection_1.default.capitalize(index.type)}([${index.columns
-                    .map((columnName) => `'${columnName}'`)
-                    .join(",")}])`),
-            ],
-        };
-        // 인덱스가 삭제되는 경우, 컬럼과 같이 삭제된 케이스에는 drop에서 제외해야함!
-        linesTo.drop = {
-            up: [
-                ...indexesTo.drop
-                    .filter((index) => index.columns.every((colName) => columnsTo.drop.map((col) => col.name).includes(colName)) === false)
-                    .map((index) => `table.drop${inflection_1.default.capitalize(index.type)}([${index.columns
-                    .map((columnName) => `'${columnName}'`)
-                    .join(",")}])`),
-            ],
-            down: [
-                "// rollback - drop indexes",
-                ...this.genIndexDefinitions(indexesTo.drop),
-            ],
-        };
-        return linesTo;
-    }
-    generateAlterCode_Foreigns(table, entityForeigns, dbForeigns) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // console.log({ entityForeigns, dbForeigns });
-            const getKey = (mf) => {
-                return [mf.columns.join("-"), mf.to].join("///");
-            };
-            const fkTo = entityForeigns.reduce((result, entityF) => {
-                const matchingDbF = dbForeigns.find((dbF) => getKey(entityF) === getKey(dbF));
-                if (!matchingDbF) {
-                    result.add.push(entityF);
-                    return result;
-                }
-                if ((0, fast_deep_equal_1.default)(entityF, matchingDbF) === false) {
-                    result.alterSrc.push(matchingDbF);
-                    result.alterDst.push(entityF);
-                    return result;
-                }
-                return result;
-            }, {
-                add: [],
-                alterSrc: [],
-                alterDst: [],
-            });
-            const linesTo = {
-                add: this.genForeignDefinitions(table, fkTo.add),
-                alterSrc: this.genForeignDefinitions(table, fkTo.alterSrc),
-                alterDst: this.genForeignDefinitions(table, fkTo.alterDst),
-            };
-            const lines = [
-                'import { Knex } from "knex";',
-                "",
-                "export async function up(knex: Knex): Promise<void> {",
-                `return knex.schema.alterTable("${table}", (table) => {`,
-                ...linesTo.add.up,
-                ...linesTo.alterSrc.down,
-                ...linesTo.alterDst.up,
-                "})",
-                "}",
-                "",
-                "export async function down(knex: Knex): Promise<void> {",
-                `return knex.schema.alterTable("${table}", (table) => {`,
-                ...linesTo.add.down,
-                ...linesTo.alterDst.down,
-                ...linesTo.alterSrc.up,
-                "})",
-                "}",
-            ];
-            const formatted = yield prettier_1.default.format(lines.join("\n"), {
-                parser: "typescript",
-            });
-            const title = [
-                "alter",
-                table,
-                "foreigns",
-                // TODO 바뀌는 부분
-            ].join("_");
-            return [
-                {
-                    table,
-                    title,
-                    formatted,
-                    type: "normal",
-                },
-            ];
-        });
-    }
-    destroy() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all(this.targets.apply.map((db) => {
-                return db.destroy();
-            }));
-        });
-    }
-}
-exports.Migrator = Migrator;
-//# sourceMappingURL=migrator.js.map