sonamu 0.0.1 → 0.0.2

package/dist/smd/migrator.js

@@ -0,0 +1,1084 @@
+"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 smd_manager_1 = require("./smd-manager");
+class Migrator {
+    constructor(options) {
+        this.appRootPath = options.appRootPath;
+        this.knexfile = options.knexfile;
+        this.mode = options.mode;
+        if (this.mode === "dev") {
+            const devDB = (0, knex_1.default)(this.knexfile.development_master);
+            const testDB = (0, knex_1.default)(this.knexfile.test);
+            const fixtureLocalDB = (0, knex_1.default)(this.knexfile.fixture_local);
+            const applyDBs = [devDB, testDB, fixtureLocalDB];
+            if (this.knexfile.fixture_local.connection
+                .host !==
+                this.knexfile.fixture_remote.connection
+                    .host) {
+                const fixtureRemoteDB = (0, knex_1.default)(this.knexfile.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)(this.knexfile.production_master);
+            const testDB = (0, knex_1.default)(this.knexfile.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 = `${this.appRootPath}/api/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);
+        });
+    }
+    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"]);
+            /* 디버깅용 코드
+            console.log(codes[0].formatted);
+            process.exit();
+             */
+            // 실제 파일 생성 프롬프트
+            const answer = yield (0, prompts_1.default)({
+                type: "confirm",
+                name: "value",
+                message: "마이그레이션 코드를 생성하시겠습니까?",
+                initial: false,
+            });
+            if (answer.value === false) {
+                return;
+            }
+            // 실제 코드 생성
+            const migrationsDir = `${this.appRootPath}/api/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(this.appRootPath, "api", 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(this.appRootPath, "api", "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)(this.knexfile.test);
+            const tdbConn = this.knexfile.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({}, this.knexfile.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 = `${this.appRootPath}/api/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 = smd_manager_1.SMDManager.getAllIds();
+            // 조인테이블 포함하여 MD에서 MigrationSet 추출
+            const smdSetsWithJoinTable = smdIds
+                .filter((smdId) => {
+                const smd = smd_manager_1.SMDManager.get(smdId);
+                return smd.props.length > 0;
+            })
+                .map((smdId) => {
+                const smd = smd_manager_1.SMDManager.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.columns.join("-"));
+                        const dbIndexes = (0, lodash_1.sortBy)(dbSet.indexes, (a) => a.columns.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 smdForeigns = (0, lodash_1.sortBy)(smdSet.foreigns, (a) => a.columns.join("-"));
+                        const dbForeigns = (0, lodash_1.sortBy)(dbSet.foreigns, (a) => a.columns.join("-"));
+                        if ((0, fast_deep_equal_1.default)(smdForeigns, dbForeigns) === false) {
+                            // TODO FK alter
+                            console.log(chalk_1.default.red(`FK 다름! ${smdSet.table}`));
+                            // console.dir({ smdForeigns, dbForeigns }, { depth: null });
+                        }
+                    }
+                    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) {
+                return null;
+            }
+            const columns = dbColumns.map((dbColumn) => {
+                const dbColType = this.resolveDBColType(dbColumn.Type, dbColumn.Field);
+                return Object.assign(Object.assign({ name: dbColumn.Field, nullable: dbColumn.Null !== "NO" }, dbColType), (0, lodash_able_1.propIf)(dbColumn.Default !== null, {
+                    defaultTo: dbColType.type === "float"
+                        ? parseFloat(dbColumn.Default).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 Object.assign({ type: currentIndexes[0].Non_unique === 1 ? "index" : "unique", columns: currentIndexes.map((currentIndex) => currentIndex.Column_name) }, (0, lodash_able_1.propIf)(currentIndexes.length > 1, {
+                    name: keyName,
+                }));
+            });
+            // 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) {
+        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 "float(8,2)":
+                return Object.assign({ type: "float" }, (0, lodash_able_1.propIf)(unsigned === "unsigned", {
+                    unsigned: true,
+                }));
+            case "decimal(8,2)":
+                return Object.assign({ type: "decimal" }, (0, lodash_able_1.propIf)(unsigned === "unsigned", {
+                    unsigned: true,
+                }));
+            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:
+                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, onDelete, onUpdate,] = matched;
+                    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;
+            // 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({ 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,
+                }));
+                r.columns.push(column);
+            }
+            // 일반 컬럼 + ToOne 케이스 컬럼
+            if (!(0, types_1.isRelationProp)(prop) ||
+                (0, types_1.isBelongsToOneRelationProp)(prop) ||
+                ((0, types_1.isOneToOneRelationProp)(prop) && prop.hasJoinColumn)) {
+                const propName = !(0, types_1.isRelationProp)(prop)
+                    ? prop.name
+                    : `${prop.name}_id`;
+                // index 처리
+                if (prop.index !== undefined) {
+                    if (prop.index !== true) {
+                        prop.index.map((indexName) => {
+                            const namedOne = r.indexes.find((_index) => _index.name === indexName);
+                            if (namedOne) {
+                                namedOne.columns.push(propName);
+                            }
+                            else {
+                                r.indexes.push({
+                                    type: "index",
+                                    columns: [propName],
+                                    name: indexName,
+                                });
+                            }
+                        });
+                    }
+                    else {
+                        r.indexes.push({
+                            type: "index",
+                            columns: [propName],
+                        });
+                    }
+                }
+                // unique 처리
+                if (prop.unique !== undefined) {
+                    if (prop.unique !== true) {
+                        prop.unique.map((indexName) => {
+                            const namedOne = r.indexes.find((_index) => _index.name === indexName);
+                            if (namedOne) {
+                                namedOne.columns.push(propName);
+                            }
+                            else {
+                                r.indexes.push({
+                                    type: "unique",
+                                    columns: [propName],
+                                    name: indexName,
+                                });
+                            }
+                        });
+                    }
+                    else {
+                        r.indexes.push({
+                            type: "unique",
+                            columns: [propName],
+                        });
+                    }
+                }
+            }
+            if ((0, types_1.isManyToManyRelationProp)(prop)) {
+                // ManyToMany 케이스
+                const relMd = smd_manager_1.SMDManager.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"],
+                        },
+                    ],
+                    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: (_a = prop.nullable) !== null && _a !== void 0 ? _a : 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: [],
+        });
+        // 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();`;
+            }
+            // 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) => {
+            if (index.name === undefined) {
+                r.push(`table.${index.type}(['${index.columns[0]}'])`);
+            }
+            else {
+                r.push(`table.${index.type}([${index.columns
+                    .map((col) => `'${col}'`)
+                    .join(",")}], '${index.name}')`);
+            }
+            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",
+            ]));
+        }), ["name", "type", "nullable", "unsigned", "length", "defaultTo"]);
+        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) {
+        // console.log(chalk.cyan("MigrationColumns from DB"));
+        // showMigrationSet(dbColumns);
+        // console.log(chalk.cyan("MigrationColumns from MD"));
+        // showMigrationSet(smdColumns);
+        /*
+          세부 비교 후 다른점 찾아서 코드 생성
+    
+          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) => { var _a; return [col.type, (_a = col.name) !== null && _a !== void 0 ? _a : col.columns.join("-")].join("//"); }),
+            smd: (0, lodash_1.differenceBy)(smdIndexes, dbIndexes, (col) => { var _a; return [col.type, (_a = col.name) !== null && _a !== void 0 ? _a : 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;
+    }
+    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