sonamu 0.0.41 → 0.1.0

package/dist/entity/migrator.js

@@ -0,0 +1,1385 @@
+"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 = 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_1 = require("fs");
+const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
+const inflection_1 = 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 lodash_able_1 = require("../utils/lodash-able");
+const entity_manager_1 = require("./entity-manager");
+const api_1 = require("../api");
+const so_exceptions_1 = require("../exceptions/so-exceptions");
+const utils_1 = require("../utils/utils");
+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) {
+                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`;
+            const srcMigrations = (0, fs_1.readdirSync)(srcMigrationsDir)
+                .filter((f) => f.endsWith(".ts"))
+                .map((f) => f.split(".")[0]);
+            const distMigrations = (0, fs_1.readdirSync)(distMigrationsDir)
+                .filter((f) => f.endsWith(".js"))
+                .map((f) => f.split(".")[0]);
+            const normal = (0, lodash_1.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 = (0, lodash_1.difference)(srcMigrations, distMigrations).map((filename) => {
+                return {
+                    name: filename,
+                    path: path_1.default.join(srcMigrationsDir, filename) + ".ts",
+                };
+            });
+            const onlyJs = (0, lodash_1.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 run the dev:serve\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 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 connections
+            const conns = (yield Promise.all(targets.map((target) => __awaiter(this, void 0, void 0, function* () {
+                const knexOptions = api_1.Sonamu.dbConfig[target];
+                if (knexOptions === undefined) {
+                    return null;
+                }
+                return {
+                    connKey: target,
+                    knex: (0, knex_1.default)(knexOptions),
+                };
+            })))).filter(utils_1.nonNullable);
+            // 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 ((0, fs_1.existsSync)(delFile)) {
+                    console.log(chalk_1.default.red(`DELETE: ${delFile}`));
+                    (0, fs_1.unlinkSync)(delFile);
+                    return delFiles.includes(".ts") ? 1 : 0;
+                }
+                return 0;
+            }));
+            return (0, lodash_1.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`;
+                (0, fs_1.writeFileSync)(filePath, pcode.formatted);
+                console.log(chalk_1.default.green(`MIGRTAION CRETATED ${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 ((0, fs_1.existsSync)(p)) {
+                    (0, fs_1.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`;
+                (0, fs_1.writeFileSync)(filePath, code.formatted);
+                console.log(chalk_1.default.green(`MIGRTAION CRETATED ${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 ((0, fs_1.existsSync)(migrationPath) === false) {
+                    (0, fs_1.mkdirSync)(migrationPath, {
+                        recursive: true,
+                    });
+                }
+                const files = (0, fs_1.readdirSync)(migrationPath).filter((filename) => filename.startsWith(".") === false);
+                r[which] = files;
+                return r;
+            }, {
+                src: [],
+                dist: [],
+            });
+            const diffOnSrc = (0, lodash_1.differenceBy)(files.src, files.dist, (filename) => filename.split(".")[0]);
+            if (diffOnSrc.length > 0) {
+                throw new Error("컴파일 되지 않은 파일이 있습니다.\n" + diffOnSrc.join("\n"));
+            }
+            const diffOnDist = (0, lodash_1.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) => {
+                    (0, fs_1.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 = (0, lodash_1.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 [
+                        this.generateCreateCode_ColumnAndIndexes(entitySet.table, entitySet.columns, entitySet.indexes),
+                        ...this.generateCreateCode_Foreign(entitySet.table, entitySet.foreigns),
+                    ];
+                }
+                // 기존 테이블 존재하는 케이스
+                const alterCodes = ["columnsAndIndexes", "foreigns"].map((key) => {
+                    // 배열 원소의 순서가 달라서 불일치가 발생하는걸 방지하기 위해 각 항목별로 정렬 처리 후 비교
+                    if (key === "columnsAndIndexes") {
+                        const entityColumns = (0, lodash_1.sortBy)(entitySet.columns, (a) => a.name);
+                        const dbColumns = (0, lodash_1.sortBy)(dbSet.columns, (a) => a.name);
+                        /* 디버깅용 코드, 특정 컬럼에서 불일치 발생할 때 확인
+                        const entityCreatedAt = entitySet.columns.find(
+                          (col) => col.name === "created_at"
+                        );
+                        const dbCreatedAt = dbSet.columns.find(
+                          (col) => col.name === "created_at"
+                        );
+                        console.debug({ entityCreatedAt, dbCreatedAt });
+                        */
+                        const entityIndexes = (0, lodash_1.sortBy)(entitySet.indexes, (a) => [
+                            a.type,
+                            ...a.columns.sort((c1, c2) => (c1 > c2 ? 1 : -1)),
+                        ].join("-"));
+                        const dbIndexes = (0, lodash_1.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 = (0, lodash_1.sortBy)(entitySet.foreigns, (a) => [a.to, ...a.columns].join("-")).map((f) => replaceNoActionOnMySQL(f));
+                        const dbForeigns = (0, lodash_1.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) => {
+                var _a;
+                const dbColType = this.resolveDBColType(dbColumn.Type, dbColumn.Field);
+                return Object.assign(Object.assign({ name: dbColumn.Field, nullable: dbColumn.Null !== "NO" }, dbColType), (0, lodash_able_1.propIf)(dbColumn.Default !== null, {
+                    defaultTo: dbColType.type === "float"
+                        ? parseFloat((_a = dbColumn.Default) !== null && _a !== void 0 ? _a : "0").toString()
+                        : dbColumn.Default,
+                }));
+            });
+            const dbIndexesGroup = (0, lodash_1.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 Object.assign({ type: "uuid" }, (0, lodash_able_1.propIf)(length !== undefined, {}));
+        }
+        switch (rawType) {
+            case "int":
+                return {
+                    type: "integer",
+                    unsigned: unsigned === "unsigned",
+                };
+            case "varchar":
+                // case "char":
+                return Object.assign({ type: "string" }, (0, lodash_able_1.propIf)(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) }, (0, lodash_able_1.propIf)(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) }, (0, lodash_able_1.propIf)(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 [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) => {
+                    // 해당 라인을 정규식으로 파싱
+                    const matched = line.match(/CONSTRAINT `(.+)` FOREIGN KEY \(`(.+)`\) REFERENCES `(.+)` \(`(.+)`\)( ON DELETE [A-Z ]+ ON UPDATE [A-Z ]+)*/);
+                    if (!matched) {
+                        throw new Error(`인식할 수 없는 FOREIGN KEY CONSTRAINT ${line}`);
+                    }
+                    const [, keyName, from, referencesTable, referencesField, _onClause] = matched;
+                    const onClause = _onClause !== null && _onClause !== void 0 ? _onClause : "";
+                    const { onDelete, onUpdate } = (() => {
+                        var _a, _b, _c, _d;
+                        // ON Clause가 둘다 있는 경우
+                        if (onClause.includes("ON DELETE") &&
+                            onClause.includes("ON UPDATE")) {
+                            const [, onDelete, onUpdate] = onClause.match(/ON DELETE ([A-Z ]+) ON UPDATE ([A-Z ]+)/);
+                            return {
+                                onDelete,
+                                onUpdate,
+                            };
+                        }
+                        // 각각 있는 경우
+                        const onDelete = (_b = (_a = onClause.match(/ON DELETE ([A-Z ]+)( ON)*/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : "NO ACTION";
+                        const onUpdate = (_d = (_c = onClause.match(/ON UPDATE ([A-Z ]+)/)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : "NO ACTION";
+                        return {
+                            onDelete,
+                            onUpdate,
+                        };
+                    })();
+                    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 }), (0, lodash_able_1.propIf)(prop.dbDefault !== undefined, {
+                    defaultTo: "" + prop.dbDefault,
+                })), ((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}.${(0, inflection_1.singularize)(table1)}_id`,
+                        to: `${prop.joinTable}.${(0, inflection_1.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: `${(0, inflection_1.underscore)((0, inflection_1.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) {
+                chains.push(`defaultTo(knex.raw('${column.defaultTo}'))`);
+            }
+            return `table.${chains.join(".")};`;
+        });
+    }
+    /*
+    MigrationIndex[] 읽어서 인덱스/유니크 정의하는 구문 생성
+  */
+    genIndexDefinitions(indexes) {
+        if (indexes.length === 0) {
+            return [];
+        }
+        const lines = (0, lodash_1.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) {
+        // 컬럼, 인덱스 처리
+        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: prettier_1.default.format(lines.join("\n"), {
+                parser: "typescript",
+            }),
+        };
+    }
+    /*
+    테이블 생성하는 케이스 - FK 생성
+  */
+    generateCreateCode_Foreign(table, foreigns) {
+        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: 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({}, (0, lodash_1.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({}, (0, lodash_1.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({}, (0, lodash_1.pick)(foreign, ["columns", "to", "onUpdate", "onDelete"]));
+            }));
+        }
+    }
+    generateAlterCode_ColumnAndIndexes(table, entityColumns, entityIndexes, dbColumns, dbIndexes) {
+        /*
+          세부 비교 후 다른점 찾아서 코드 생성
+    
+          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 > 1
+                ? alterIndexLinesTo.add.down
+                : []),
+            ...(alterIndexLinesTo.drop.down.length > 1
+                ? alterIndexLinesTo.drop.down
+                : []),
+            "})",
+            "}",
+        ];
+        const formatted = 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: (0, lodash_1.differenceBy)(dbColumns, entityColumns, (col) => col.name),
+            entity: (0, lodash_1.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 = (0, lodash_1.intersectionBy)(dbColumns, entityColumns, (col) => col.name);
+        const sameMdColumns = (0, lodash_1.intersectionBy)(entityColumns, dbColumns, (col) => col.name);
+        columnsTo.alter = (0, lodash_1.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 = (0, lodash_1.difference)(this.genColumnDefinitions([entityColumn]), this.genColumnDefinitions([dbColumn]));
+            const columnDiffDown = (0, lodash_1.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: (0, lodash_1.differenceBy)(dbIndexes, entityIndexes, (col) => [col.type, col.columns.join("-")].join("//")),
+            entity: (0, lodash_1.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${(0, inflection_1.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${(0, inflection_1.capitalize)(index.type)}([${index.columns
+                    .map((columnName) => `'${columnName}'`)
+                    .join(",")}])`),
+            ],
+            down: [
+                "// rollback - drop indexes",
+                ...this.genIndexDefinitions(indexesTo.drop),
+            ],
+        };
+        return linesTo;
+    }
+    generateAlterCode_Foreigns(table, entityForeigns, dbForeigns) {
+        // 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 = 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