sonamu 0.6.0 → 0.7.0

package/src/migration/code-generation.ts

@@ -1,13 +1,15 @@
-import * as _ from "lodash-es";
-import prettier from "prettier";
 import equal from "fast-deep-equal";
-import {
+import { alphabetical, diff, fork, omit } from "radashi";
+import { Naite } from "..";
+import type {
   GenMigrationCode,
   MigrationColumn,
   MigrationForeign,
   MigrationIndex,
   MigrationSet,
 } from "../types/types";
+import { formatCode } from "../utils/formatter";
+import { differenceWith, intersectionBy } from "../utils/utils";
 
 /**
  * 테이블 생성하는 케이스 - 컬럼/인덱스 생성
@@ -15,12 +17,12 @@ import {
 async function generateCreateCode_ColumnAndIndexes(
   table: string,
   columns: MigrationColumn[],
-  indexes: MigrationIndex[]
+  indexes: MigrationIndex[],
 ): Promise<GenMigrationCode> {
   // fulltext index 분리
-  const [ngramIndexes, standardIndexes] = _.partition(
+  const [ngramIndexes, standardIndexes] = fork(
     indexes,
-    (i) => i.type === "fulltext" && i.parser === "ngram"
+    (i) => i.type === "fulltext" && i.parser === "ngram",
   );
 
   // 컬럼, 인덱스 처리
@@ -47,9 +49,7 @@ async function generateCreateCode_ColumnAndIndexes(
     table,
     type: "normal",
     title: `create__${table}`,
-    formatted: await prettier.format(lines.join("\n"), {
-      parser: "typescript",
-    }),
+    formatted: formatCode(lines.join("\n"), "typescript", `src/migration/${table}.ts`),
   };
 }
 
@@ -63,38 +63,49 @@ function genColumnDefinitions(columns: MigrationColumn[]): string[] {
       return `table.increments().primary();`;
     }
 
-    // FIXME: float(M,D) deprecated -> decimal(M,D) 이용하도록 하고, float/double 처리 추가
-    if (column.type === "float" || column.type === "decimal") {
-      chains.push(
-        `${column.type}('${column.name}', ${column.precision}, ${column.scale})`
-      );
+    // 배열 타입 처리
+    if (column.type.endsWith("[]")) {
+      const elementType = column.type.slice(0, -2); // "integer[]" -> "integer"
+      const pgType = getPgArrayType(column, elementType);
+      chains.push(`specificType('${column.name}', '${pgType}')`);
+    } else if (column.type === "numberOrNumeric") {
+      // number
+      if (column.numberType === "real") {
+        chains.push(`float('${column.name}')`);
+      } else if (column.numberType === "double precision") {
+        chains.push(`double('${column.name}')`);
+      } else if ((column.numberType ?? "numeric") === "numeric") {
+        chains.push(`decimal('${column.name}', ${column.precision}, ${column.scale})`);
+      }
+    } else if (column.type === "string") {
+      // string
+      if (column.length !== undefined) {
+        chains.push(`string('${column.name}', ${column.length})`);
+      } else {
+        chains.push(`text('${column.name}')`);
+      }
+    } else if (column.type === "date") {
+      // date
+      chains.push(`timestamp('${column.name}', { useTz: true })`);
+    } else if (column.type === "json") {
+      // json
+      chains.push(`jsonb('${column.name}')`);
     } else {
       // type, length
-      let columnType = column.type;
       let extraType: string | undefined;
-      if (columnType.includes("text") && columnType !== "text") {
-        extraType = columnType;
-        columnType = "text";
-      }
       chains.push(
-        `${columnType}('${column.name}'${
+        `${column.type}('${column.name}'${
           column.length ? `, ${column.length}` : ""
-        }${extraType ? `, '${extraType}'` : ""})`
+        }${extraType ? `, '${extraType}'` : ""})`,
       );
     }
-    if (column.unsigned) {
-      chains.push("unsigned()");
-    }
 
     // nullable
     chains.push(column.nullable ? "nullable()" : "notNullable()");
 
     // defaultTo
     if (column.defaultTo !== undefined) {
-      if (
-        typeof column.defaultTo === "string" &&
-        column.defaultTo.startsWith(`"`)
-      ) {
+      if (typeof column.defaultTo === "string" && column.defaultTo.startsWith(`"`)) {
         chains.push(`defaultTo(${column.defaultTo})`);
       } else {
         chains.push(`defaultTo(knex.raw('${column.defaultTo}'))`);
@@ -105,6 +116,25 @@ function genColumnDefinitions(columns: MigrationColumn[]): string[] {
   });
 }
 
+function getPgArrayType(column: MigrationColumn, elementType: string): string {
+  if (elementType === "numberOrNumeric") {
+    if (column.numberType === "real") return "real[]";
+    if (column.numberType === "double precision") return "double precision[]";
+    return `numeric(${column.precision}, ${column.scale})[]`;
+  }
+  if (elementType === "string") {
+    return column.length ? `varchar(${column.length})[]` : "text[]";
+  }
+  if (elementType === "date") return "timestamptz[]";
+  if (elementType === "integer") return "integer[]";
+  if (elementType === "bigInteger") return "bigint[]";
+  if (elementType === "boolean") return "boolean[]";
+  if (elementType === "uuid") return "uuid[]";
+  if (elementType === "enum") return "text[]";
+
+  throw new Error(`Unknown array element type: ${elementType}`);
+}
+
 /**
  * 개별 인덱스 정의 생성
  */
@@ -118,7 +148,7 @@ function genIndexDefinition(index: MigrationIndex, table: string) {
   if (index.type === "fulltext" && index.parser === "ngram") {
     const indexName = `${table}_${index.columns.join("_")}_index`;
     return `await knex.raw(\`ALTER TABLE ${table} ADD FULLTEXT INDEX ${indexName} (${index.columns.join(
-      ", "
+      ", ",
     )}) WITH PARSER ngram\`);`;
   }
 
@@ -132,7 +162,7 @@ function genIndexDefinition(index: MigrationIndex, table: string) {
  */
 async function generateCreateCode_Foreign(
   table: string,
-  foreigns: MigrationForeign[]
+  foreigns: MigrationForeign[],
 ): Promise<GenMigrationCode[]> {
   if (foreigns.length === 0) {
     return [];
@@ -162,17 +192,13 @@ async function generateCreateCode_Foreign(
     "}",
   ];
 
-  const foreignKeysString = foreigns
-    .map((foreign) => foreign.columns.join("_"))
-    .join("_");
+  const foreignKeysString = foreigns.map((foreign) => foreign.columns.join("_")).join("_");
   return [
     {
       table,
       type: "foreign",
       title: `foreign__${table}__${foreignKeysString}`,
-      formatted: await prettier.format(lines.join("\n"), {
-        parser: "typescript",
-      }),
+      formatted: formatCode(lines.join("\n"), "typescript", `src/migration/${table}.ts`),
     },
   ];
 }
@@ -182,7 +208,7 @@ async function generateCreateCode_Foreign(
  */
 function genForeignDefinitions(
   table: string,
-  foreigns: MigrationForeign[]
+  foreigns: MigrationForeign[],
 ): { up: string[]; down: string[] } {
   return foreigns.reduce(
     (r, foreign) => {
@@ -193,7 +219,7 @@ function genForeignDefinitions(
         `table.foreign('${foreign.columns.join(",")}')
             .references('${foreign.to}')
             .onUpdate('${foreign.onUpdate}')
-            .onDelete('${foreign.onDelete}')`
+            .onDelete('${foreign.onDelete}')`,
       );
       r.down.push(`table.dropForeign([${columnsStringQuote}])`);
       return r;
@@ -201,7 +227,7 @@ function genForeignDefinitions(
     {
       up: [] as string[],
       down: [] as string[],
-    }
+    },
   );
 }
 
@@ -214,7 +240,7 @@ async function generateAlterCode_ColumnAndIndexes(
   entityIndexes: MigrationIndex[],
   dbColumns: MigrationColumn[],
   dbIndexes: MigrationIndex[],
-  dbForeigns: MigrationForeign[]
+  dbForeigns: MigrationForeign[],
 ): Promise<GenMigrationCode[]> {
   /*
     세부 비교 후 다른점 찾아서 코드 생성
@@ -236,26 +262,53 @@ async function generateAlterCode_ColumnAndIndexes(
     alterColumnsTo,
     entityColumns,
     table,
-    dbForeigns
+    dbForeigns,
   );
 
   // 인덱스의 add, drop 여부 확인
   const alterIndexesTo = getAlterIndexesTo(entityIndexes, dbIndexes);
 
   // fulltext index 분리
-  const [ngramIndexes, standardIndexes] = _.partition(
+  const [ngramIndexes, standardIndexes] = fork(
     alterIndexesTo.add,
-    (i) => i.type === "fulltext" && i.parser === "ngram"
+    (i) => i.type === "fulltext" && i.parser === "ngram",
   );
 
   // 인덱스가 삭제되는 경우, 컬럼과 같이 삭제된 케이스에는 drop에서 제외해야함!
   const indexNeedsToDrop = alterIndexesTo.drop.filter(
     (index) =>
       index.columns.every((colName) =>
-        alterColumnsTo.drop.map((col) => col.name).includes(colName)
-      ) === false
+        alterColumnsTo.drop.map((col) => col.name).includes(colName),
+      ) === false,
   );
 
+  // 빈 코드 생성 방지
+  if (
+    alterColumnLinesTo.add.up.length === 0 &&
+    alterColumnLinesTo.drop.up.length === 0 &&
+    alterColumnLinesTo.alter.up.length === 0 &&
+    standardIndexes.length === 0 &&
+    indexNeedsToDrop.length === 0
+  ) {
+    Naite.t("migrator:generateAlterCode_ColumnAndIndexes:emptyCodeGenerationError", {
+      entityColumns,
+      dbColumns,
+      entityIndexes,
+      dbIndexes,
+    });
+    // throw new Error("컬럼/인덱스 변경 코드 생성 오류");
+  }
+  Naite.t("migrator:generateAlterCode_ColumnAndIndexes:debug", {
+    "alterColumnsTo.add.length": alterColumnsTo.add.length,
+    "alterColumnsTo.drop.length": alterColumnsTo.drop.length,
+    "alterColumnsTo.alter.length": alterColumnsTo.alter.length,
+    "alterIndexesTo.add.length": alterIndexesTo.add.length,
+    "alterIndexesTo.drop.length": alterIndexesTo.drop.length,
+    "standardIndexes.length": standardIndexes.length,
+    "indexNeedsToDrop.length": indexNeedsToDrop.length,
+  });
+  // Naite.t("migrator:generateAlterCode_ColumnAndIndexes:alterColumnsTo", alterColumnsTo);
+
   const lines: string[] = [
     'import { Knex } from "knex";',
     "",
@@ -285,8 +338,8 @@ async function generateAlterCode_ColumnAndIndexes(
       .filter(
         (index) =>
           index.columns.every((colName) =>
-            alterColumnsTo.add.map((col) => col.name).includes(colName)
-          ) === false
+            alterColumnsTo.add.map((col) => col.name).includes(colName),
+          ) === false,
       )
       .map(genIndexDropDefinition),
     ...indexNeedsToDrop.map((index) => genIndexDefinition(index, table)),
@@ -294,10 +347,7 @@ async function generateAlterCode_ColumnAndIndexes(
     "}",
   ];
 
-  const formatted = await prettier.format(lines.join("\n"), {
-    parser: "typescript",
-  });
-
+  const formatted = formatCode(lines.join("\n"), "typescript", `src/migration/${table}.ts`);
   const title = [
     "alter",
     table,
@@ -325,10 +375,7 @@ async function generateAlterCode_ColumnAndIndexes(
 /**
  * 각 컬럼 이름 기준으로 add, drop, alter 여부 확인
  */
-function getAlterColumnsTo(
-  entityColumns: MigrationColumn[],
-  dbColumns: MigrationColumn[]
-) {
+function getAlterColumnsTo(entityColumns: MigrationColumn[], dbColumns: MigrationColumn[]) {
   const columnsTo = {
     add: [] as MigrationColumn[],
     drop: [] as MigrationColumn[],
@@ -337,8 +384,8 @@ function getAlterColumnsTo(
 
   // 컬럼명 기준 비교
   const extraColumns = {
-    db: _.differenceBy(dbColumns, entityColumns, (col) => col.name),
-    entity: _.differenceBy(entityColumns, dbColumns, (col) => col.name),
+    db: diff(dbColumns, entityColumns, (col) => col.name),
+    entity: diff(entityColumns, dbColumns, (col) => col.name),
   };
   if (extraColumns.entity.length > 0) {
     columnsTo.add = columnsTo.add.concat(extraColumns.entity);
@@ -348,19 +395,9 @@ function getAlterColumnsTo(
   }
 
   // 동일 컬럼명의 세부 필드 비교
-  const sameDbColumns = _.intersectionBy(
-    dbColumns,
-    entityColumns,
-    (col) => col.name
-  );
-  const sameMdColumns = _.intersectionBy(
-    entityColumns,
-    dbColumns,
-    (col) => col.name
-  );
-  columnsTo.alter = _.differenceWith(sameDbColumns, sameMdColumns, (a, b) =>
-    equal(a, b)
-  );
+  const sameDbColumns = intersectionBy(dbColumns, entityColumns, (col) => col.name);
+  const sameMdColumns = intersectionBy(entityColumns, dbColumns, (col) => col.name);
+  columnsTo.alter = differenceWith(sameDbColumns, sameMdColumns, (a, b) => equal(a, b));
 
   return columnsTo;
 }
@@ -372,9 +409,9 @@ function getAlterColumnLinesTo(
   columnsTo: ReturnType<typeof getAlterColumnsTo>,
   entityColumns: MigrationColumn[],
   table: string,
-  dbForeigns: MigrationForeign[]
+  dbForeigns: MigrationForeign[],
 ) {
-  let linesTo = {
+  const linesTo = {
     add: {
       up: [] as string[],
       down: [] as string[],
@@ -393,16 +430,14 @@ function getAlterColumnLinesTo(
     up: ["// add", ...genColumnDefinitions(columnsTo.add)],
     down: [
       "// rollback - add",
-      `table.dropColumns(${columnsTo.add
-        .map((col) => `'${col.name}'`)
-        .join(", ")})`,
+      `table.dropColumns(${columnsTo.add.map((col) => `'${col.name}'`).join(", ")})`,
     ],
   };
 
   // drop할 컬럼에 걸린 FK 찾기
   const dropColumnNames = columnsTo.drop.map((col) => col.name);
   const fkToDropBeforeColumn = dbForeigns.filter((fk) =>
-    fk.columns.some((col) => dropColumnNames.includes(col))
+    fk.columns.some((col) => dropColumnNames.includes(col)),
   );
 
   const dropFkLines = fkToDropBeforeColumn.map((fk) => {
@@ -418,46 +453,40 @@ function getAlterColumnLinesTo(
         ? ["// drop foreign keys on columns to be dropped", ...dropFkLines]
         : []),
       "// drop columns",
-      `table.dropColumns(${columnsTo.drop
-        .map((col) => `'${col.name}'`)
-        .join(", ")})`,
+      `table.dropColumns(${columnsTo.drop.map((col) => `'${col.name}'`).join(", ")})`,
     ],
     down: [
       "// rollback - drop columns",
       ...genColumnDefinitions(columnsTo.drop),
-      ...(restoreFkLines.length > 0
-        ? ["// restore foreign keys", ...restoreFkLines]
-        : []),
+      ...(restoreFkLines.length > 0 ? ["// restore foreign keys", ...restoreFkLines] : []),
     ],
   };
   linesTo.alter = columnsTo.alter.reduce(
     (r, dbColumn) => {
-      const entityColumn = entityColumns.find(
-        (col) => col.name == dbColumn.name
-      );
+      const entityColumn = entityColumns.find((col) => col.name === dbColumn.name);
       if (entityColumn === undefined) {
         return r;
       }
 
       // 컬럼 변경사항
-      const columnDiffUp = _.difference(
+      const columnDiffUp = diff(
         genColumnDefinitions([entityColumn]),
-        genColumnDefinitions([dbColumn])
+        genColumnDefinitions([dbColumn]),
       );
-      const columnDiffDown = _.difference(
+      const columnDiffDown = diff(
         genColumnDefinitions([dbColumn]),
-        genColumnDefinitions([entityColumn])
+        genColumnDefinitions([entityColumn]),
       );
       if (columnDiffUp.length > 0) {
         r.up = [
           ...r.up,
           "// alter column",
-          ...columnDiffUp.map((l) => l.replace(";", "") + ".alter();"),
+          ...columnDiffUp.map((l) => `${l.replace(";", "")}.alter();`),
         ];
         r.down = [
           ...r.down,
           "// rollback - alter column",
-          ...columnDiffDown.map((l) => l.replace(";", "") + ".alter();"),
+          ...columnDiffDown.map((l) => `${l.replace(";", "")}.alter();`),
         ];
       }
 
@@ -466,7 +495,7 @@ function getAlterColumnLinesTo(
     {
       up: [] as string[],
       down: [] as string[],
-    }
+    },
   );
 
   return linesTo;
@@ -475,22 +504,15 @@ function getAlterColumnLinesTo(
 /**
  * 인덱스의 add, drop 여부 확인
  */
-function getAlterIndexesTo(
-  entityIndexes: MigrationIndex[],
-  dbIndexes: MigrationIndex[]
-) {
+function getAlterIndexesTo(entityIndexes: MigrationIndex[], dbIndexes: MigrationIndex[]) {
   // 인덱스 비교
-  let indexesTo = {
+  const indexesTo = {
     add: [] as MigrationIndex[],
     drop: [] as MigrationIndex[],
   };
   const extraIndexes = {
-    db: _.differenceBy(dbIndexes, entityIndexes, (col) =>
-      [col.type, col.columns.join("-")].join("//")
-    ),
-    entity: _.differenceBy(entityIndexes, dbIndexes, (col) =>
-      [col.type, col.columns.join("-")].join("//")
-    ),
+    db: diff(dbIndexes, entityIndexes, (col) => [col.type, col.columns.join("-")].join("//")),
+    entity: diff(entityIndexes, dbIndexes, (col) => [col.type, col.columns.join("-")].join("//")),
   };
   if (extraIndexes.entity.length > 0) {
     indexesTo.add = indexesTo.add.concat(extraIndexes.entity);
@@ -524,7 +546,7 @@ async function generateAlterCode_Foreigns(
   table: string,
   entityForeigns: MigrationForeign[],
   dbForeigns: MigrationForeign[],
-  droppingColumns: MigrationColumn[] = []
+  droppingColumns: MigrationColumn[] = [],
 ): Promise<GenMigrationCode[]> {
   // console.log({ entityForeigns, dbForeigns });
 
@@ -537,9 +559,7 @@ async function generateAlterCode_Foreigns(
 
   const fkTo = entityForeigns.reduce(
     (result, entityF) => {
-      const matchingDbF = dbForeigns.find(
-        (dbF) => getKey(entityF) === getKey(dbF)
-      );
+      const matchingDbF = dbForeigns.find((dbF) => getKey(entityF) === getKey(dbF));
       if (!matchingDbF) {
         result.add.push(entityF);
         return result;
@@ -557,20 +577,16 @@ async function generateAlterCode_Foreigns(
       drop: [] as MigrationForeign[],
       alterSrc: [] as MigrationForeign[],
       alterDst: [] as MigrationForeign[],
-    }
+    },
   );
 
   // dbForeigns에는 있지만 entityForeigns에는 없는 경우 (삭제된 FK)
   // 단, 삭제될 컬럼의 FK는 제외 (generateAlterCode_ColumnAndIndexes에서 처리)
   dbForeigns.forEach((dbF) => {
-    const matchingEntityF = entityForeigns.find(
-      (entityF) => getKey(entityF) === getKey(dbF)
-    );
+    const matchingEntityF = entityForeigns.find((entityF) => getKey(entityF) === getKey(dbF));
     if (!matchingEntityF) {
       // 이 FK의 컬럼이 삭제될 컬럼 목록에 있는지 확인
-      const isColumnDropping = dbF.columns.some((col) =>
-        droppingColumnNames.includes(col)
-      );
+      const isColumnDropping = dbF.columns.some((col) => droppingColumnNames.includes(col));
       // 컬럼이 삭제되지 않는 경우에만 FK drop 목록에 추가
       if (!isColumnDropping) {
         fkTo.drop.push(dbF);
@@ -586,13 +602,25 @@ async function generateAlterCode_Foreigns(
   };
 
   // drop fk columns인 경우(생성될 코드 없는 경우) 패스
-  const hasLines = Object.values(linesTo).some(
-    (l) => l.up.length > 0 || l.down.length > 0
-  );
+  const hasLines = Object.values(linesTo).some((l) => l.up.length > 0 || l.down.length > 0);
   if (!hasLines) {
     return [];
   }
 
+  if (
+    linesTo.add.up.length === 0 &&
+    linesTo.drop.up.length === 0 &&
+    linesTo.alterSrc.up.length === 0 &&
+    linesTo.alterDst.up.length === 0
+  ) {
+    Naite.t("migrator:generateAlterCode_Foreigns:fkChangeCodeGenerationError", {
+      table,
+      entityForeigns,
+      dbForeigns,
+    });
+    throw new Error("FK 변경 코드 생성 오류");
+  }
+
   const lines: string[] = [
     'import { Knex } from "knex";',
     "",
@@ -615,10 +643,7 @@ async function generateAlterCode_Foreigns(
     "}",
   ];
 
-  const formatted = await prettier.format(lines.join("\n"), {
-    parser: "typescript",
-  });
-
+  const formatted = formatCode(lines.join("\n"), "typescript", `src/migration/${table}.ts`);
   const title = [
     "alter",
     table,
@@ -641,14 +666,12 @@ async function generateAlterCode_Foreigns(
  * @param entitySet
  * @returns CREATE 마이그레이션 코드
  */
-export async function generateCreateCode(
-  entitySet: MigrationSet
-): Promise<GenMigrationCode[]> {
+export async function generateCreateCode(entitySet: MigrationSet): Promise<GenMigrationCode[]> {
   return [
     await generateCreateCode_ColumnAndIndexes(
       entitySet.table,
       entitySet.columns,
-      entitySet.indexes
+      entitySet.indexes,
     ),
     ...(await generateCreateCode_Foreign(entitySet.table, entitySet.foreigns)),
   ];
@@ -662,38 +685,32 @@ export async function generateCreateCode(
  */
 export async function generateAlterCode(
   entitySet: MigrationSet,
-  dbSet: MigrationSet
+  dbSet: MigrationSet,
 ): Promise<GenMigrationCode[]> {
   const replaceColumnDefaultTo = (col: MigrationColumn) => {
     // float인 경우 기본값을 0으로 지정하는 경우 "0.00"으로 변환되는 케이스 대응
-    if (
-      col.type === "float" &&
-      col.defaultTo &&
-      String(col.defaultTo).includes('"') === false
-    ) {
-      col.defaultTo = `"${Number(col.defaultTo).toFixed(col.scale ?? 2)}"`;
-    }
-    // string인 경우 기본값이 빈 스트링인 경우 대응
-    if (col.type === "string" && col.defaultTo === "") {
-      col.defaultTo = '""';
-    }
-    // boolean인 경우 기본값 정규화 (MySQL에서는 TINYINT(1)로 저장되므로 0 또는 1로 정규화)
-    // TODO: db.ts에 typeCase 설정 확인하여 처리하도록 수정 필요
-    if (col.type === "boolean" && col.defaultTo !== undefined) {
-      if (col.defaultTo === "0" || col.defaultTo.toLowerCase() === "false") {
-        col.defaultTo = "0";
-      } else if (col.defaultTo === "1" || col.defaultTo.toLowerCase() === "true") {
-        col.defaultTo = "1";
-      }
-    }
+    // if (col.type === "float" && col.defaultTo && String(col.defaultTo).includes('"') === false) {
+    //   col.defaultTo = `"${Number(col.defaultTo).toFixed(col.scale ?? 2)}"`;
+    // }
+    // // string인 경우 기본값이 빈 스트링인 경우 대응
+    // if (col.type === "string" && col.defaultTo === "") {
+    //   col.defaultTo = '""';
+    // }
+    // // boolean인 경우 기본값 정규화 (MySQL에서는 TINYINT(1)로 저장되므로 0 또는 1로 정규화)
+    // // TODO: db.ts에 typeCase 설정 확인하여 처리하도록 수정 필요
+    // if (col.type === "boolean" && col.defaultTo !== undefined) {
+    //   if (col.defaultTo === "0" || col.defaultTo.toLowerCase() === "false") {
+    //     col.defaultTo = "0";
+    //   } else if (col.defaultTo === "1" || col.defaultTo.toLowerCase() === "true") {
+    //     col.defaultTo = "1";
+    //   }
+    // }
+
+    // FIXME: 일단 MySQL 상황에서 발생했던 이슈의 workaround 이므로 Pg에서 재확인 후 대응 추가
     return col;
   };
-  const entityColumns = _.sortBy(entitySet.columns, (a) => a.name).map(
-    replaceColumnDefaultTo
-  );
-  const dbColumns = _.sortBy(dbSet.columns, (a) => a.name).map(
-    replaceColumnDefaultTo
-  );
+  const entityColumns = alphabetical(entitySet.columns, (a) => a.name).map(replaceColumnDefaultTo);
+  const dbColumns = alphabetical(dbSet.columns, (a) => a.name).map(replaceColumnDefaultTo);
 
   /* 디버깅용 코드, 특정 컬럼에서 불일치 발생할 때 확인
         const entityColumn = entitySet.columns.find(
@@ -705,11 +722,11 @@ export async function generateAlterCode(
         console.debug({ entityColumn, dbColumn });
          */
 
-  const entityIndexes = _.sortBy(entitySet.indexes, (a) =>
-    [a.type, ...a.columns.sort((c1, c2) => (c1 > c2 ? 1 : -1))].join("-")
+  const entityIndexes = alphabetical(entitySet.indexes, (a) =>
+    [a.type, ...a.columns.sort((c1, c2) => (c1 > c2 ? 1 : -1))].join("-"),
   );
-  const dbIndexes = _.sortBy(dbSet.indexes, (a) =>
-    [a.type, ...a.columns.sort((c1, c2) => (c1 > c2 ? 1 : -1))].join("-")
+  const dbIndexes = alphabetical(dbSet.indexes, (a) =>
+    [a.type, ...a.columns.sort((c1, c2) => (c1 > c2 ? 1 : -1))].join("-"),
   );
 
   const replaceNoActionOnMySQL = (f: MigrationForeign) => {
@@ -722,27 +739,23 @@ export async function generateAlterCode(
     };
   };
 
-  const entityForeigns = _.sortBy(entitySet.foreigns, (a) =>
-    [a.to, ...a.columns].join("-")
-  ).map((f) => replaceNoActionOnMySQL(f));
-  const dbForeigns = _.sortBy(dbSet.foreigns, (a) =>
-    [a.to, ...a.columns].join("-")
+  const entityForeigns = alphabetical(entitySet.foreigns, (a) =>
+    [a.to, ...a.columns].join("-"),
   ).map((f) => replaceNoActionOnMySQL(f));
+  const dbForeigns = alphabetical(dbSet.foreigns, (a) => [a.to, ...a.columns].join("-")).map((f) =>
+    replaceNoActionOnMySQL(f),
+  );
 
   // 삭제될 컬럼 목록 계산
-  const droppingColumns = _.differenceBy(
-    dbColumns,
-    entityColumns,
-    (col) => col.name
-  );
+  const droppingColumns = diff(dbColumns, entityColumns, (col) => col.name);
 
   const alterCodes: (GenMigrationCode | GenMigrationCode[] | null)[] = [];
 
   // 1. columnsAndIndexes 처리
   const isEqualColumns = equal(entityColumns, dbColumns);
   const isEqualIndexes = equal(
-    entityIndexes.map((index) => _.omit(index, ["parser"])),
-    dbIndexes
+    entityIndexes.map((index) => omit(index, ["parser"])),
+    dbIndexes,
   );
   if (!isEqualColumns || !isEqualIndexes) {
     alterCodes.push(
@@ -752,8 +765,8 @@ export async function generateAlterCode(
         entityIndexes,
         dbColumns,
         dbIndexes,
-        dbSet.foreigns
-      )
+        dbSet.foreigns,
+      ),
     );
   }
 
@@ -764,8 +777,8 @@ export async function generateAlterCode(
         entitySet.table,
         entityForeigns,
         dbForeigns,
-        droppingColumns
-      )
+        droppingColumns,
+      ),
     );
   }