sonamu 0.2.38 → 0.2.40

package/dist/smd/migrator.js

@@ -1,1164 +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 = 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/entity-manager");
-const api_1 = require("../api");
-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} 입력`);
-        }
-    }
-    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();
-            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"));
-                const result = yield this.runShadowTest();
-                console.timeEnd(chalk_1.default.blue("Migrator - runShadowTest"));
-                if (result === true) {
-                    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);
-                    })));
-                }
-                return;
-            }
-            // MD-DB간 비교하여 코드 생성 리턴
-            const codes = yield this.compareMigrations();
-            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 }) }));
-            try {
-                const [batchNo, log] = yield sdb.migrate.latest();
-                console.log(chalk_1.default.green("Shadow DB 테스트에 성공했습니다!"), {
-                    batchNo,
-                    log,
-                });
-                // 생성한 Shadow DB 삭제
-                console.log(chalk_1.default.magenta(`${shadowDatabase} 삭제`));
-                yield sdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase};`);
-                return true;
-            }
-            catch (e) {
-                console.error(chalk_1.default.red("Shadow DB 테스트 진행 중 에러"), e);
-                return false;
-            }
-            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() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // MD 순회하여 싱크
-            const smdIds = entity_manager_1.EntityManager.getAllIds();
-            // 조인테이블 포함하여 MD에서 MigrationSet 추출
-            const smdSetsWithJoinTable = smdIds
-                .filter((smdId) => {
-                const smd = entity_manager_1.EntityManager.get(smdId);
-                return smd.props.length > 0;
-            })
-                .map((smdId) => {
-                const smd = entity_manager_1.EntityManager.get(smdId);
-                return this.getMigrationSetFromMD(smd);
-            });
-            // 조인테이블만 추출
-            const joinTables = (0, lodash_1.uniqBy)(smdSetsWithJoinTable.map((smdSet) => smdSet.joinTables).flat(), (joinTable) => {
-                return joinTable.table;
-            });
-            // 조인테이블 포함하여 MigrationSet 배열
-            const smdSets = [...smdSetsWithJoinTable, ...joinTables];
-            let codes = (yield Promise.all(smdSets.map((smdSet) => __awaiter(this, void 0, void 0, function* () {
-                const dbSet = yield this.getMigrationSetFromDB(smdSet.table);
-                if (dbSet === null) {
-                    // 기존 테이블 없음, 새로 테이블 생성
-                    return [
-                        this.generateCreateCode_ColumnAndIndexes(smdSet.table, smdSet.columns, smdSet.indexes),
-                        ...this.generateCreateCode_Foreign(smdSet.table, smdSet.foreigns),
-                    ];
-                }
-                // 기존 테이블 존재하는 케이스
-                const alterCodes = ["columnsAndIndexes", "foreigns"].map((key) => {
-                    // 배열 원소의 순서가 달라서 불일치가 발생하는걸 방지하기 위해 각 항목별로 정렬 처리 후 비교
-                    if (key === "columnsAndIndexes") {
-                        const smdColumns = (0, lodash_1.sortBy)(smdSet.columns, (a) => a.name);
-                        const dbColumns = (0, lodash_1.sortBy)(dbSet.columns, (a) => a.name);
-                        /* 디버깅용 코드, 특정 컬럼에서 불일치 발생할 때 확인
-                        const smdCreatedAt = smdSet.columns.find(
-                          (col) => col.name === "created_at"
-                        );
-                        const dbCreatedAt = dbSet.columns.find(
-                          (col) => col.name === "created_at"
-                        );
-                        console.debug({ smdCreatedAt, dbCreatedAt });
-                        */
-                        const smdIndexes = (0, lodash_1.sortBy)(smdSet.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)(smdColumns, dbColumns);
-                        const isEqualIndexes = (0, fast_deep_equal_1.default)(smdIndexes, dbIndexes);
-                        if (isEqualColumns && isEqualIndexes) {
-                            return null;
-                        }
-                        else {
-                            // this.showMigrationSet("MD", smdSet);
-                            // this.showMigrationSet("DB", dbSet);
-                            return this.generateAlterCode_ColumnAndIndexes(smdSet.table, smdColumns, smdIndexes, 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 smdForeigns = (0, lodash_1.sortBy)(smdSet.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)(smdForeigns, dbForeigns) === false) {
-                            console.dir({ smdForeigns, dbForeigns }, { depth: null });
-                            return this.generateAlterCode_Foreigns(smdSet.table, smdForeigns, 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(table) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let dbColumns, dbIndexes, dbForeigns;
-            try {
-                [dbColumns, dbIndexes, dbForeigns] = yield this.readTable(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(tableName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // 테이블 정보
-            try {
-                const [cols] = yield this.targets.compare.raw(`SHOW FIELDS FROM ${tableName}`);
-                const [indexes] = yield this.targets.compare.raw(`SHOW INDEX FROM ${tableName}`);
-                const [[row]] = yield this.targets.compare.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(smd) {
-        const migrationSet = smd.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: `${smd.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"],
-                        },
-                        // 조인 테이블에 걸린 인덱스 찾아와서 연결
-                        ...smd.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: smd.table,
-            columns: [],
-            indexes: [],
-            foreigns: [],
-            joinTables: [],
-        });
-        // indexes
-        migrationSet.indexes = smd.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, smdColumns, smdIndexes, dbColumns, dbIndexes) {
-        /*
-          세부 비교 후 다른점 찾아서 코드 생성
-    
-          1. 컬럼갯수 다름: MD에 있으나, DB에 없다면 추가
-          2. 컬럼갯수 다름: MD에 없으나, DB에 있다면 삭제
-          3. 그외 컬럼(컬럼 갯수가 동일하거나, 다른 경우 동일한 컬럼끼리) => alter
-          4. 다른거 다 동일하고 index만 변경되는 경우
-    
-          ** 컬럼명을 변경하는 경우는 따로 핸들링하지 않음
-          => drop/add 형태의 마이그레이션 코드가 생성되는데, 수동으로 rename 코드로 수정하여 처리
-        */
-        // 각 컬럼 이름 기준으로 add, drop, alter 여부 확인
-        const alterColumnsTo = this.getAlterColumnsTo(smdColumns, dbColumns);
-        // 추출된 컬럼들을 기준으로 각각 라인 생성
-        const alterColumnLinesTo = this.getAlterColumnLinesTo(alterColumnsTo, smdColumns);
-        // 인덱스의 add, drop 여부 확인
-        const alterIndexesTo = this.getAlterIndexesTo(smdIndexes, 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(smdColumns, dbColumns) {
-        const columnsTo = {
-            add: [],
-            drop: [],
-            alter: [],
-        };
-        // 컬럼명 기준 비교
-        const extraColumns = {
-            db: (0, lodash_1.differenceBy)(dbColumns, smdColumns, (col) => col.name),
-            smd: (0, lodash_1.differenceBy)(smdColumns, dbColumns, (col) => col.name),
-        };
-        if (extraColumns.smd.length > 0) {
-            columnsTo.add = columnsTo.add.concat(extraColumns.smd);
-        }
-        if (extraColumns.db.length > 0) {
-            columnsTo.drop = columnsTo.drop.concat(extraColumns.db);
-        }
-        // 동일 컬럼명의 세부 필드 비교
-        const sameDbColumns = (0, lodash_1.intersectionBy)(dbColumns, smdColumns, (col) => col.name);
-        const sameMdColumns = (0, lodash_1.intersectionBy)(smdColumns, 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, smdColumns) {
-        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 smdColumn = smdColumns.find((col) => col.name == dbColumn.name);
-            if (smdColumn === undefined) {
-                return r;
-            }
-            // 컬럼 변경사항
-            const columnDiffUp = (0, lodash_1.difference)(this.genColumnDefinitions([smdColumn]), this.genColumnDefinitions([dbColumn]));
-            const columnDiffDown = (0, lodash_1.difference)(this.genColumnDefinitions([dbColumn]), this.genColumnDefinitions([smdColumn]));
-            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(smdIndexes, dbIndexes) {
-        // 인덱스 비교
-        let indexesTo = {
-            add: [],
-            drop: [],
-        };
-        const extraIndexes = {
-            db: (0, lodash_1.differenceBy)(dbIndexes, smdIndexes, (col) => [col.type, col.columns.join("-")].join("//")),
-            smd: (0, lodash_1.differenceBy)(smdIndexes, dbIndexes, (col) => [col.type, col.columns.join("-")].join("//")),
-        };
-        if (extraIndexes.smd.length > 0) {
-            indexesTo.add = indexesTo.add.concat(extraIndexes.smd);
-        }
-        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, smdForeigns, dbForeigns) {
-        // console.log({ smdForeigns, dbForeigns });
-        const getKey = (mf) => {
-            return [mf.columns.join("-"), mf.to].join("///");
-        };
-        const fkTo = smdForeigns.reduce((result, smdF) => {
-            const matchingDbF = dbForeigns.find((dbF) => getKey(smdF) === getKey(dbF));
-            if (!matchingDbF) {
-                result.add.push(smdF);
-                return result;
-            }
-            if ((0, fast_deep_equal_1.default)(smdF, matchingDbF) === false) {
-                result.alterSrc.push(matchingDbF);
-                result.alterDst.push(smdF);
-                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