sonamu 0.7.1 → 0.7.3

package/src/bin/cli.ts

@@ -100,12 +100,12 @@ async function sync() {
  * pnpm dev 하면 실행되는 함수입니다.
  * 프로젝트에 대해 HMR 지원하는 개발 서버를 띄워줍니다.
  *
- * TypeScript를 바로 실행할 수 있도록 @sonamu-kit/loader를,
- * HMR을 지원하기 위해 @sonamu-kit/hot-hook을 import하며,
+ * TypeScript를 바로 실행할 수 있도록 @sonamu-kit/ts-loader를,
+ * HMR을 지원하기 위해 @sonamu-kit/hmr-hook을 import하며,
  * 소스맵 지원을 위해 --enable-source-maps 플래그를 포함하여 실행합니다.
  *
- * 이때 @sonamu-kit/loader와 @sonamu-kit/hot-hook는 sonamu가 자체적으로 가지고 있는 dependency입니다.
- * 또한 실행에 사용하는 @sonamu-kit/hot-runner도 마찬가지로 sonamu가 자체적으로 가지고 있는 dependency입니다.
+ * 이때 @sonamu-kit/ts-loader와 @sonamu-kit/hmr-hook는 sonamu가 자체적으로 가지고 있는 dependency입니다.
+ * 또한 실행에 사용하는 @sonamu-kit/hmr-runner도 마찬가지로 sonamu가 자체적으로 가지고 있는 dependency입니다.
  * 따라서 사용자 프로젝트에서는 이 세 패키지를 직접 설치할 필요가 없습니다.
  *
  * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
@@ -116,10 +116,10 @@ async function dev() {
 
   console.log(chalk.yellow.bold("🚀 Starting Sonamu dev server...\n"));
 
-  // 이 sonamu 패키지가 dependencies로 가지고 있는 @sonamu-kit/hot-runner의 bin/run.js를 사용합니다.
-  // 이 경로(/bin/run.js)는 @sonamu-kit/hot-runner의 package.json의 bin 필드에 명시되어 있는 그것과 같습니다.
+  // 이 sonamu 패키지가 dependencies로 가지고 있는 @sonamu-kit/hmr-runner의 bin/run.js를 사용합니다.
+  // 이 경로(/bin/run.js)는 @sonamu-kit/hmr-runner의 package.json의 bin 필드에 명시되어 있는 그것과 같습니다.
   const hotRunnerBinPath = createRequire(import.meta.url).resolve(
-    "@sonamu-kit/hot-runner/bin/run.js",
+    "@sonamu-kit/hmr-runner/bin/run.js",
   );
 
   const serverProcess = spawn(
@@ -127,8 +127,8 @@ async function dev() {
     [
       hotRunnerBinPath, // 이렇게 해서 hot-runner를 실행하구요
       "--clear-screen=false", // 이하 hot-runner에게 넘겨줄 인자들입니다.
-      "--node-args=--import=sonamu/loader-register", // TypeScript 서포트를 위한 로더,
-      "--node-args=--import=sonamu/hot-hook-register", // HMR을 지원하기 위한 hot-hook,
+      "--node-args=--import=sonamu/ts-loader-register", // TypeScript 서포트를 위한 로더,
+      "--node-args=--import=sonamu/hmr-hook-register", // HMR을 지원하기 위한 hook,
       "--node-args=--enable-source-maps", // 그리고 소스맵 지원을 위한 플래그입니다.
       "--on-key=r:restart:Restart server", // r 누르면 서버 재시작하게 해줘요.
       `--on-key=f:shell(rm ${path.join(apiRoot, "sonamu.lock")}):restart:Force restart`, // f 누르면 sonamu.lock 파일을 지우고 서버 재시작하게 해줘요.
@@ -144,7 +144,7 @@ async function dev() {
         ...process.env,
         NODE_ENV: "development",
         HOT: "yes", // 얘가 있어야 HMR이 활성화됩니다.
-        API_ROOT_PATH: apiRoot, // 이 경로가 hot-hook의 루트 디렉토리가 됩니다.
+        API_ROOT_PATH: apiRoot, // 이 경로가 hmr-hook의 루트 디렉토리가 됩니다.
       },
     },
   );
@@ -216,23 +216,6 @@ async function build() {
     process.exit(1);
   }
 
-  // sonamu.config.ts만 따로 빌드합니다.
-  // 이 친구는 src에 들어있지 않기 때문에 SWC_BUILD_COMMAND로 빌드되지 않습니다.
-  // 따라서 따로 빌드해줍니다.
-  try {
-    const configPath = path.join(apiRoot, "sonamu.config.ts");
-    if (await exists(configPath)) {
-      console.log(chalk.blue("Building sonamu.config.ts..."));
-      execSync(`swc ${configPath} -o ${BUILD_DIR}/sonamu.config.js`, {
-        cwd: apiRoot,
-        stdio: "inherit",
-      });
-    }
-  } catch (error) {
-    console.error(chalk.red("Building sonamu.config.ts failed."), error);
-    process.exit(1);
-  }
-
   // 마지막에는 타입 체크를 해요.
   try {
     console.log(chalk.blue("Checking types with tsc..."));
@@ -481,14 +464,14 @@ async function ui() {
       return;
     }
 
-    // UI를 별도 프로세스로 실행 (hot-hook 활성화)
+    // UI를 별도 프로세스로 실행 (hmr-hook 활성화)
     const uiProcess = spawn(
       process.execPath,
       [
         "--import",
-        "sonamu/loader-register",
+        "sonamu/ts-loader-register",
         "--import",
-        "sonamu/hot-hook-register",
+        "sonamu/hmr-hook-register",
         "--enable-source-maps",
         "--no-warnings",
         uiNodePath,

package/src/bin/{hot-hook-register.ts → hmr-hook-register.ts}

@@ -1,22 +1,22 @@
 /**
- * hot-hook 초기화하는 모듈입니다.
+ * hmr-hook 초기화하는 모듈입니다.
  *
  * 이 파일은 --import 플래그로 프로세스 시작 시 로드되어야 합니다.
  *
  * 환경변수:
  * - API_ROOT_PATH: 사용자 프로젝트의 API 루트 경로
- * - HOT: 'yes'일 때만 hot-hook 활성화
+ * - HOT: 'yes'일 때만 hmr-hook 활성화
  */
 
 if (process.env.HOT === "yes" && process.env.API_ROOT_PATH) {
-  const { hot } = await import("@sonamu-kit/hot-hook");
+  const { hot } = await import("@sonamu-kit/hmr-hook");
 
   await hot.init({
     rootDirectory: process.env.API_ROOT_PATH, // 이 친구가 프로젝트 API 경로로 잘 설정되어야 아래 바운더리가 작동합니다.
     boundaries: [`./src/**/*.ts`], // 프로젝트의 이 친구들이 바운더리가 됩니다.
   });
 
-  console.log("🔥 Hot-hook initialized");
+  console.log("🔥 HMR-hook initialized");
 }
 
 export {};

package/src/bin/{loader-register.ts → ts-loader-register.ts}

@@ -4,7 +4,7 @@ import { exists } from "../utils/fs-utils.js";
 import { findApiRootPath } from "../utils/utils.js";
 
 /**
- * @sonamu-kit/loader/loader를 등록하는 스크립트입니다.
+ * @sonamu-kit/ts-loader/loader를 등록하는 스크립트입니다.
  * 이 스크립트는 sonamu cli로 dev 실행할 때 --import로 실행됩니다.
  */
 async function setupSwcConfig() {
@@ -33,6 +33,6 @@ async function setupSwcConfig() {
 // swc 설정 파일 경로를 환경 변수로 설정
 await setupSwcConfig();
 
-register("@sonamu-kit/loader/loader", {
+register("@sonamu-kit/ts-loader/loader", {
   parentURL: import.meta.url,
 });

package/src/database/base-model.ts

@@ -1,10 +1,9 @@
-import assert from "assert";
-import inflection from "inflection";
+/** biome-ignore-all lint/suspicious/noExplicitAny: Puri의 타입은 개별 모델에서 확정되므로 BaseModel에서는 any를 허용함 */
+
 import type { Knex } from "knex";
-import { group, isObject, omit, set, unique } from "radashi";
+import { group, isObject, omit, set } from "radashi";
 import { Sonamu } from "../api";
-import { type DatabaseSchemaExtend, isCustomJoinClause, type SubsetQuery } from "../types/types";
-import type { BaseListParams } from "../utils/model";
+import type { DatabaseSchemaExtend } from "../types/types";
 import { getJoinTables, getTableNamesFromWhere } from "../utils/sql-parser";
 import { chunk } from "../utils/utils";
 import type {
@@ -56,7 +55,7 @@ export class BaseModelClass<
 
     // 트랜잭션이 없으면 새로운 PuriWrapper 반환
     const db = this.getDB(which);
-    return new PuriWrapper(db, this.getUpsertBuilder());
+    return new PuriWrapper(db, new UpsertBuilder());
   }
 
   async destroy() {
@@ -365,236 +364,6 @@ export class BaseModelClass<
       return hydrated;
     }) as T[];
   }
-
-  // Legacy SubsetQuery 실행 (Puri 도입 전 호환용)
-  async runSubsetQuery<T extends BaseListParams, U extends string>({
-    params,
-    baseTable,
-    subset,
-    subsetQuery,
-    build,
-    afterBuild,
-    debug,
-    db: _db,
-    optimizeCountQuery,
-  }: {
-    subset: U;
-    params: T;
-    subsetQuery: SubsetQuery;
-    build: (buildParams: {
-      qb: Knex.QueryBuilder;
-      db: Knex;
-      select: (string | Knex.Raw)[];
-      joins: SubsetQuery["joins"];
-      virtual: string[];
-    }) => Knex.QueryBuilder;
-    afterBuild?: (buildParams: {
-      qb: Knex.QueryBuilder;
-      db: Knex;
-      select: (string | Knex.Raw)[];
-      joins: SubsetQuery["joins"];
-      virtual: string[];
-    }) => Knex.QueryBuilder;
-    baseTable?: string;
-    debug?: boolean | "list" | "count";
-    db?: Knex;
-    optimizeCountQuery?: boolean;
-  }): Promise<{
-    // biome-ignore lint/suspicious/noExplicitAny: Puri 도입 전까지 any로 유지
-    rows: any[];
-    total?: number | undefined;
-    subsetQuery: SubsetQuery;
-    qb: Knex.QueryBuilder;
-  }> {
-    const chalk = (await import("chalk")).default;
-    const SqlParser = (await import("node-sql-parser")).default;
-    const { getTableName, getTableNamesFromWhere } = await import("../utils/sql-parser");
-
-    const db = _db ?? this.getDB(subset.startsWith("A") ? "w" : "r");
-    baseTable = baseTable ?? inflection.pluralize(inflection.underscore(this.modelName));
-    const queryMode = params.queryMode ?? (params.id !== undefined ? "list" : "both");
-
-    const { select, virtual, joins, loaders } = subsetQuery;
-    const qb = build({
-      qb: db.from(baseTable),
-      db,
-      select,
-      joins,
-      virtual,
-    });
-
-    const applyJoinClause = (qb: Knex.QueryBuilder, joins: SubsetQuery["joins"]) => {
-      joins.forEach((join) => {
-        if (join.join === "inner") {
-          qb.innerJoin(`${join.table} as ${join.as}`, this.getJoinClause(db, join));
-        } else if (join.join === "outer") {
-          qb.leftOuterJoin(`${join.table} as ${join.as}`, this.getJoinClause(db, join));
-        }
-      });
-    };
-
-    // countQuery
-    const total = await (async () => {
-      if (queryMode === "list") {
-        return undefined;
-      }
-
-      const clonedQb = qb.clone().clear("order").clear("offset").clear("limit");
-      const parser = new SqlParser.Parser();
-
-      if (optimizeCountQuery) {
-        const parsedQuery = parser.astify(clonedQb.toQuery(), {
-          database: Sonamu.config.database.database,
-        });
-        const tables = getTableNamesFromWhere(parsedQuery);
-        const needToJoin = unique(
-          tables.flatMap((table) => table.split("__").map((t) => inflection.pluralize(t))),
-        );
-        applyJoinClause(
-          clonedQb,
-          joins.filter((j) => needToJoin.includes(j.table)),
-        );
-      } else {
-        applyJoinClause(clonedQb, joins);
-      }
-
-      const processedQb = afterBuild?.({ qb: clonedQb, db, select, joins, virtual }) ?? clonedQb;
-
-      const parsedQuery = parser.astify(processedQb.toQuery(), {
-        database: Sonamu.config.database.database,
-      });
-      const q = Array.isArray(parsedQuery) ? parsedQuery[0] : parsedQuery;
-      if (q.type !== "select") {
-        throw new Error("Invalid query");
-      }
-
-      const countQuery =
-        q.distinct !== null
-          ? clonedQb
-              .clear("select")
-              .select(
-                db.raw(
-                  `COUNT(DISTINCT \`${getTableName(q.columns[0].expr)}\`.\`${q.columns[0].expr.column}\`) as total`,
-                ),
-              )
-              .first()
-          : clonedQb.clear("select").count("*", { as: "total" }).first();
-      const countRow: { total?: number } = await countQuery;
-
-      if (debug === true || debug === "count") {
-        console.debug("DEBUG: count query", chalk.blue(countQuery.toQuery().toString()));
-      }
-
-      return countRow?.total ?? 0;
-    })();
-
-    // listQuery
-    const rows = await (async () => {
-      if (queryMode === "count") {
-        return [];
-      }
-
-      if (params.num !== 0) {
-        assert(params.num);
-        qb.limit(params.num);
-        qb.offset(params.num * ((params.page ?? 1) - 1));
-      }
-
-      const clonedQb = qb.clone().select(select);
-      applyJoinClause(clonedQb, joins);
-
-      const listQuery = afterBuild?.({ qb: clonedQb, db, select, joins, virtual }) ?? clonedQb;
-
-      let rows = await listQuery;
-      if (debug === true || debug === "list") {
-        console.debug("DEBUG: list query", chalk.blue(listQuery.toQuery().toString()));
-      }
-
-      rows = await this.useLoaders(db, rows, loaders);
-      rows = this.hydrate(rows);
-      return rows;
-    })();
-
-    return { rows, total, subsetQuery, qb };
-  }
-
-  // Legacy Loader 처리 (Puri 도입 전 호환용)
-  async useLoaders(db: Knex, rows: UnknownDBRecord[], loaders: SubsetQuery["loaders"]) {
-    if (loaders.length === 0) {
-      return rows;
-    }
-
-    for (const loader of loaders) {
-      let subQ: Knex.QueryBuilder;
-      let subRows: UnknownDBRecord[];
-      let toCol: string;
-
-      const fromIds = rows.map((row) => row[loader.manyJoin.idField]);
-
-      if (loader.manyJoin.through === undefined) {
-        // HasMany
-        const idColumn = `${loader.manyJoin.toTable}.${loader.manyJoin.toCol}`;
-        subQ = db(loader.manyJoin.toTable)
-          .whereIn(idColumn as string, fromIds as string[])
-          .select([...loader.select, idColumn]);
-
-        loader.oneJoins.forEach((join) => {
-          if (join.join === "inner") {
-            subQ.innerJoin(`${join.table} as ${join.as}`, this.getJoinClause(db, join));
-          } else if (join.join === "outer") {
-            subQ.leftOuterJoin(`${join.table} as ${join.as}`, this.getJoinClause(db, join));
-          }
-        });
-        toCol = loader.manyJoin.toCol;
-      } else {
-        // ManyToMany
-        const idColumn = `${loader.manyJoin.through.table}.${loader.manyJoin.through.fromCol}`;
-        subQ = db(loader.manyJoin.through.table)
-          .join(
-            loader.manyJoin.toTable,
-            `${loader.manyJoin.through.table}.${loader.manyJoin.through.toCol}`,
-            `${loader.manyJoin.toTable}.${loader.manyJoin.toCol}`,
-          )
-          .whereIn(idColumn as string, fromIds as string[])
-          .select(unique([...loader.select, idColumn]));
-
-        loader.oneJoins.forEach((join) => {
-          if (join.join === "inner") {
-            subQ.innerJoin(`${join.table} as ${join.as}`, this.getJoinClause(db, join));
-          } else if (join.join === "outer") {
-            subQ.leftOuterJoin(`${join.table} as ${join.as}`, this.getJoinClause(db, join));
-          }
-        });
-        toCol = loader.manyJoin.through.fromCol;
-      }
-      subRows = await subQ;
-
-      if (loader.loaders) {
-        subRows = await this.useLoaders(db, subRows, loader.loaders);
-      }
-
-      const subRowGroups = group(subRows, (row) => row[toCol] as string);
-      rows = rows.map((row) => {
-        row[loader.as] = (subRowGroups[row[loader.manyJoin.idField] as string] ?? []).map((r) =>
-          omit(r, [toCol]),
-        );
-        return row;
-      });
-    }
-    return rows;
-  }
-
-  getJoinClause(db: Knex<any, unknown>, join: SubsetQuery["joins"][number]): Knex.Raw<any> {
-    if (!isCustomJoinClause(join)) {
-      return db.raw(`${join.from} = ${join.to}`);
-    } else {
-      return db.raw(join.custom);
-    }
-  }
-
-  getUpsertBuilder(): UpsertBuilder {
-    return new UpsertBuilder();
-  }
 }
 
 /**

package/src/database/base-model.types.ts

@@ -1,3 +1,5 @@
+/** biome-ignore-all lint/suspicious/noExplicitAny: Puri의 타입은 개별 모델에서 확정되므로 BaseModel에서는 any를 허용함 */
+
 /**
  * BaseModel 타입 시스템
  *

package/src/database/puri-wrapper.ts

@@ -148,7 +148,7 @@ export class PuriWrapper<TSchema extends DatabaseSchemaExtend = DatabaseSchemaEx
   }
 
   ubUpsert(tableName: TableName<TSchema>, chunkSize?: number): Promise<number[]> {
-    return this.upsertBuilder.upsert(this.knex, tableName, chunkSize);
+    return this.upsertBuilder.upsert(this.knex, tableName, { chunkSize });
   }
 
   ubInsertOnly(tableName: TableName<TSchema>, chunkSize?: number): Promise<number[]> {
@@ -160,7 +160,7 @@ export class PuriWrapper<TSchema extends DatabaseSchemaExtend = DatabaseSchemaEx
     mode: "upsert" | "insert",
     chunkSize?: number,
   ): Promise<number[]> {
-    return this.upsertBuilder.upsertOrInsert(this.knex, tableName, mode, chunkSize);
+    return this.upsertBuilder.upsertOrInsert(this.knex, tableName, mode, { chunkSize });
   }
 
   ubUpdateBatch(

package/src/database/upsert-builder.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "crypto";
 import type { Knex } from "knex";
-import { unique } from "radashi";
+import { isArray, unique } from "radashi";
 import { EntityManager } from "../entity/entity-manager";
 import { Naite } from "../naite/naite";
 import { assertDefined, chunk, nonNullable } from "../utils/utils";
@@ -17,6 +17,10 @@ export type UBRef = {
   of: string;
   use?: string;
 };
+type UpsertOptions = {
+  chunkSize?: number;
+  cleanOrphans?: string | string[]; // FK 컬럼명(들)
+};
 export function isRefField(field: unknown): field is UBRef {
   return (
     field !== undefined &&
@@ -150,18 +154,37 @@ export class UpsertBuilder {
     return result;
   }
 
-  async upsert(wdb: Knex, tableName: string, chunkSize?: number): Promise<number[]> {
-    return this.upsertOrInsert(wdb, tableName, "upsert", chunkSize);
+  async upsert(
+    wdb: Knex,
+    tableName: string,
+    optionsOrChunkSize?: UpsertOptions,
+  ): Promise<number[]> {
+    // 숫자면 { chunkSize: n } 으로 변환
+    const options =
+      typeof optionsOrChunkSize === "number"
+        ? { chunkSize: optionsOrChunkSize }
+        : optionsOrChunkSize;
+
+    return this.upsertOrInsert(wdb, tableName, "upsert", options);
   }
-  async insertOnly(wdb: Knex, tableName: string, chunkSize?: number): Promise<number[]> {
-    return this.upsertOrInsert(wdb, tableName, "insert", chunkSize);
+  async insertOnly(
+    wdb: Knex,
+    tableName: string,
+    optionsOrChunkSize?: UpsertOptions | number,
+  ): Promise<number[]> {
+    const options =
+      typeof optionsOrChunkSize === "number"
+        ? { chunkSize: optionsOrChunkSize }
+        : optionsOrChunkSize;
+
+    return this.upsertOrInsert(wdb, tableName, "insert", options);
   }
 
   async upsertOrInsert(
     wdb: Knex,
     tableName: string,
     mode: "upsert" | "insert",
-    chunkSize?: number,
+    options?: UpsertOptions,
   ): Promise<number[]> {
     if (this.hasTable(tableName) === false) {
       return [];
@@ -244,43 +267,47 @@ export class UpsertBuilder {
       });
 
       // 현재 레벨 upsert
+      const chunkSize = options?.chunkSize;
       const levelChunks = chunkSize ? chunk(resolvedRows, chunkSize) : [resolvedRows];
-      const selectFields = unique(["uuid", "id", ...extractFields]);
+      const selectFields = unique(["id", ...extractFields]);
 
       for (const dataChunk of levelChunks) {
         if (dataChunk.length === 0) continue;
 
-        let resultRows: { uuid: string; id: number; [key: string]: unknown }[];
+        // uuid를 별도로 보관하고, DB에 저장할 데이터에서 제거
+        const originalUuids = dataChunk.map((r) => r.uuid as string);
+        const dataForDb = dataChunk.map(({ uuid, ...rest }) => rest);
 
-        if (mode === "insert") {
-          // INSERT 모드
-          await wdb.insert(dataChunk).into(tableName);
+        let resultRows: { id: number; [key: string]: unknown }[];
 
-          const uuids = dataChunk.map((r) => r.uuid);
-          resultRows = await wdb(tableName)
-            .select(selectFields)
-            .whereIn("uuid", uuids as readonly string[]);
+        if (mode === "insert") {
+          // INSERT 모드 - RETURNING 사용
+          resultRows = await wdb.insert(dataForDb).into(tableName).returning(selectFields);
         } else {
-          // UPSERT 모드: onConflict로 중복 처리
+          // UPSERT 모드 - onConflict 사용
           const conflictColumns = table.uniqueIndexes[0].columns;
-          const updateColumns = Object.keys(dataChunk[0]).filter(
-            (col) => col !== "uuid" && !conflictColumns.includes(col),
+          const updateColumns = Object.keys(dataForDb[0]).filter(
+            (col) => !conflictColumns.includes(col),
           );
 
-          const query = wdb.insert(dataChunk).into(tableName).onConflict(conflictColumns);
+          // updateColumns가 비어있어도 merge()를 사용하여 모든 행이 RETURNING되도록 보장
+          const mergeColumns = updateColumns.length > 0 ? updateColumns : conflictColumns;
 
-          // updateColumns 유무에 따라 ignore/merge 선택하고 RETURNING으로 결과 받기
-          if (updateColumns.length === 0) {
-            resultRows = await query.ignore().returning(selectFields);
-          } else {
-            resultRows = await query.merge(updateColumns).returning(selectFields);
-          }
+          resultRows = await wdb
+            .insert(dataForDb)
+            .into(tableName)
+            .onConflict(conflictColumns)
+            .merge(mergeColumns)
+            .returning(selectFields);
         }
 
-        // 양쪽 모드 공통 처리
-        for (const row of resultRows) {
-          uuidMap.set(row.uuid, row);
-          allIds.push(row.id);
+        if (originalUuids.length !== resultRows.length) {
+          throw new Error(`${tableName}: register/returning 불일치`);
+        }
+
+        for (let i = 0; i < resultRows.length; i++) {
+          uuidMap.set(originalUuids[i], resultRows[i]);
+          allIds.push(resultRows[i].id);
         }
       }
     }
@@ -311,6 +338,38 @@ export class UpsertBuilder {
       });
     }
 
+    if (options?.cleanOrphans) {
+      const cleanOrphans = options.cleanOrphans;
+      const fkColumns = isArray(cleanOrphans) ? cleanOrphans : [cleanOrphans];
+
+      // 현재 register된 레코드들의 FK 값들 추출
+      const fkConditions = fkColumns.map((fkCol) => {
+        const fkValues = [...new Set(table.rows.map((row) => row[fkCol]).filter((v) => v != null))];
+        return { column: fkCol, values: fkValues };
+      });
+
+      // 모든 FK 컬럼에 값이 있는 경우에만 삭제 실행
+      if (fkConditions.every((fc) => fc.values.length > 0)) {
+        let deleteQuery = wdb(tableName);
+
+        // 각 FK 컬럼에 대한 WHERE IN 조건 추가
+        for (const { column, values } of fkConditions) {
+          deleteQuery = deleteQuery.whereIn(column, values);
+        }
+
+        // 방금 upsert한 ID는 제외
+        deleteQuery = deleteQuery.whereNotIn("id", allIds);
+
+        const deletedCount = await deleteQuery.delete();
+
+        Naite.t("puri:ub-clean-orphans", {
+          tableName,
+          cleanOrphans: fkColumns,
+          deletedCount,
+        });
+      }
+    }
+
     // 해당 테이블의 데이터 초기화
     table.rows = [];
     table.references.clear();

package/src/entity/entity.ts

@@ -524,8 +524,8 @@ export class Entity {
       // 일반 prop 처리
       if (key === "") {
         return group.map((propName) => {
-          // uuid 개별 처리
-          if (propName === "uuid") {
+          // FIXME: 이거 나중에 없애야함
+          if (propName === "말도안되는프롭명__이거왜타입처리가꼬여서이러지?") {
             return {
               nodeType: "plain" as const,
               prop: {

package/src/migration/code-generation.ts

@@ -146,15 +146,15 @@ 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(
+    return `await knex.raw(\`ALTER TABLE ${table} ADD FULLTEXT INDEX ${index.name} (${index.columns.join(
       ", ",
     )}) WITH PARSER ngram\`);`;
   }
 
   return `table.${methodMap[index.type]}([${index.columns
     .map((col) => `'${col}'`)
-    .join(",")}]${index.type === "fulltext" ? ", undefined, 'FULLTEXT'" : ""})`;
+    .join(",")}], '${index.name}'${index.type === "fulltext" ? ", 'FULLTEXT'" : ""}
+  );`;
 }
 
 /**
@@ -309,6 +309,8 @@ async function generateAlterCode_ColumnAndIndexes(
   });
   // Naite.t("migrator:generateAlterCode_ColumnAndIndexes:alterColumnsTo", alterColumnsTo);
 
+  // TODO: 인덱스명 변경된 경우 처리
+
   const lines: string[] = [
     'import { Knex } from "knex";',
     "",
@@ -536,7 +538,7 @@ function genIndexDropDefinition(index: MigrationIndex) {
 
   return `table.drop${methodMap[index.type]}([${index.columns
     .map((columnName) => `'${columnName}'`)
-    .join(",")}])`;
+    .join(",")}], '${index.name}')`;
 }
 
 /**
@@ -723,10 +725,10 @@ export async function generateAlterCode(
          */
 
   const entityIndexes = alphabetical(entitySet.indexes, (a) =>
-    [a.type, ...a.columns.sort((c1, c2) => (c1 > c2 ? 1 : -1))].join("-"),
+    [a.type, ...a.columns].join("-"),
   );
   const dbIndexes = alphabetical(dbSet.indexes, (a) =>
-    [a.type, ...a.columns.sort((c1, c2) => (c1 > c2 ? 1 : -1))].join("-"),
+    [a.type, ...a.columns].join("-"),
   );
 
   const replaceNoActionOnMySQL = (f: MigrationForeign) => {