sonamu 0.6.0 → 0.7.1

package/src/bin/cli.ts

@@ -1,26 +1,29 @@
 import chalk from "chalk";
 import dotenv from "dotenv";
+
 dotenv.config();
 
-import path from "path";
-import { fileURLToPath } from "url";
-import { tsicli } from "tsicli";
 import { execSync, spawn } from "child_process";
-import { mkdir, readdir, writeFile } from "fs/promises";
-import { exists } from "../utils/fs-utils";
+import { mkdir, readdir, rm, writeFile } from "fs/promises";
+import knex, { type Knex } from "knex";
+import { createRequire } from "module";
+import path from "path";
 import process from "process";
+import { tsicli } from "tsicli";
 import { Sonamu } from "../api";
-import knex, { Knex } from "knex";
+import type { SonamuDBConfig } from "../database/db";
 import { EntityManager } from "../entity/entity-manager";
 import { Migrator } from "../migration/migrator";
 import { FixtureManager } from "../testing/fixture-manager";
+import { exists } from "../utils/fs-utils";
 import { findApiRootPath } from "../utils/utils";
+import { BUILD_DIR, SWC_BUILD_COMMAND, TSC_TYPE_CHECK_COMMAND } from "./build-config";
 
 let migrator: Migrator;
 
 async function bootstrap() {
-  // dev 명령어가 아닌 경우에만 Sonamu 초기화
-  if (process.argv[2] !== "dev") {
+  const notToInit = ["dev", "build", "start"].includes(process.argv[2] ?? "");
+  if (!notToInit) {
     await Sonamu.init(false, false);
   }
 
@@ -55,16 +58,14 @@ async function bootstrap() {
       ["scaffold", "view_list", "#entityId"],
       ["scaffold", "view_form", "#entityId"],
       ["ui"],
+      ["sync"],
       ["dev"],
+      ["build"],
       ["start"],
     ],
     runners: {
-      migrate_run,
-      migrate_check,
-      migrate_rollback,
-      migrate_clear,
-      migrate_reset,
       migrate_status,
+      migrate_run,
       fixture_init,
       fixture_import,
       fixture_sync,
@@ -75,32 +76,66 @@ async function bootstrap() {
       ui,
       // scaffold_view_list,
       // scaffold_view_form,
+      sync,
       dev,
+      build,
       start,
     },
   });
 }
+
 bootstrap().finally(async () => {
-  if (migrator) {
-    await migrator.destroy();
-  }
   await FixtureManager.destroy();
 });
 
+/**
+ * pnpm sync 하면 실행되는 함수입니다.
+ * 프로젝트를 싱크합니다.
+ */
+async function sync() {
+  await Sonamu.syncer.sync();
+}
+
+/**
+ * pnpm dev 하면 실행되는 함수입니다.
+ * 프로젝트에 대해 HMR 지원하는 개발 서버를 띄워줍니다.
+ *
+ * TypeScript를 바로 실행할 수 있도록 @sonamu-kit/loader를,
+ * HMR을 지원하기 위해 @sonamu-kit/hot-hook을 import하며,
+ * 소스맵 지원을 위해 --enable-source-maps 플래그를 포함하여 실행합니다.
+ *
+ * 이때 @sonamu-kit/loader와 @sonamu-kit/hot-hook는 sonamu가 자체적으로 가지고 있는 dependency입니다.
+ * 또한 실행에 사용하는 @sonamu-kit/hot-runner도 마찬가지로 sonamu가 자체적으로 가지고 있는 dependency입니다.
+ * 따라서 사용자 프로젝트에서는 이 세 패키지를 직접 설치할 필요가 없습니다.
+ *
+ * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
+ */
 async function dev() {
   const apiRoot = findApiRootPath();
-  const entryPoint = 'src/index.ts';   
+  const entryPoint = "src/index.ts";
 
-  console.log(chalk.yellow.bold('🚀 Starting Sonamu dev server...\n'));
+  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 필드에 명시되어 있는 그것과 같습니다.
+  const hotRunnerBinPath = createRequire(import.meta.url).resolve(
+    "@sonamu-kit/hot-runner/bin/run.js",
+  );
 
   const serverProcess = spawn(
-    "hot-runner",
+    process.execPath, // node
     [
-      "--clear-screen=false",
-      "--node-args=--import=@sonamu-kit/loader",
-      "--node-args=--import=sonamu/hot-hook-register",
-      "--node-args=--enable-source-maps",
-      entryPoint,
+      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=--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 파일을 지우고 서버 재시작하게 해줘요.
+
+      "--on-key=enter:shell(echo hi):Key binding test", // enter를 key로 쓸 수 있음을 보이기 위한 테스트입니다.
+      "--on-key=ctrl+f ctrl+f:shell(git pull && pnpm install && pnpm --filter sonamu build && echo 'Sonamu is now up-to-date!'):restart:Pull & install & build & restart", // modifier와의 조합, 그리고 두 개의 chord를 사용할 수 있음을 보이기 위한 테스트입니다.
+      entryPoint, // 마지막으로 실제 실행할 스크립트의 경로를 넘겨줍니다.
     ],
     {
       cwd: apiRoot,
@@ -108,23 +143,23 @@ async function dev() {
       env: {
         ...process.env,
         NODE_ENV: "development",
-        HOT: "yes",
-        API_ROOT_PATH: apiRoot,
+        HOT: "yes", // 얘가 있어야 HMR이 활성화됩니다.
+        API_ROOT_PATH: apiRoot, // 이 경로가 hot-hook의 루트 디렉토리가 됩니다.
       },
-    }
+    },
   );
 
   // 종료 처리
   const cleanup = () => {
-    console.log(chalk.yellow('\n\n👋 Shutting down...'));
-    serverProcess.kill('SIGTERM');
+    console.log(chalk.yellow("\n\n👋 Shutting down..."));
+    serverProcess.kill("SIGTERM");
     process.exit(0);
   };
 
-  process.on('SIGINT', cleanup);
-  process.on('SIGTERM', cleanup);
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
 
-  serverProcess.on('exit', (code) => {
+  serverProcess.on("exit", (code) => {
     if (code !== 0) {
       console.error(chalk.red(`❌ Server exited with code ${code}`));
       process.exit(code || 1);
@@ -132,25 +167,112 @@ async function dev() {
   });
 }
 
+/**
+ * pnpm build 하면 실행되는 함수입니다.
+ * 프로젝트를 빌드합니다.
+ *
+ * 빌드에 필요한 .swcrc는 프로젝트 루트에서 찾고, 없으면 sonamu가 관리하는 .swcrc.project-default를 사용합니다.
+ * sonamu.config.ts는 src에 들어있지 않기 때문에 SWC_BUILD_COMMAND로 빌드되지 않습니다.
+ * 따라서 따로 빌드해줍니다.
+ *
+ * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
+ */
+async function build() {
+  const apiRoot = findApiRootPath();
+
+  // 출력 디렉토리를 제거합니다.
+  try {
+    console.log(chalk.blue("Removing build directory..."));
+    if (await exists(BUILD_DIR)) {
+      await rm(BUILD_DIR, { recursive: true, force: true });
+    }
+  } catch (error) {
+    console.error(chalk.red("Remove build directory failed."), error);
+    process.exit(1);
+  }
+
+  // .swcrc 파일을 지정합니다.
+  let swcFilePath = ".swcrc";
+  try {
+    if (await exists(swcFilePath)) {
+      // 사용자 프로젝트에 .swcrc가 있으면 우선으로 사용합니다.
+      console.log(chalk.blue("Using .swcrc from project root..."));
+    } else {
+      // 아니라면 sonamu가 관리하는 .swcrc.project-default를 가져다 씁니다.
+      console.log(chalk.blue("Using default .swcrc from sonamu package..."));
+      swcFilePath = path.join(import.meta.dirname, "..", "..", ".swcrc.project-default");
+    }
+  } catch (error) {
+    console.error(chalk.red("Setting up swc config file failed."), error);
+    process.exit(1);
+  }
+
+  // 소스 디렉토리를 빌드합니다.
+  try {
+    console.log(chalk.blue("Building with swc..."));
+    execSync(SWC_BUILD_COMMAND(swcFilePath), { cwd: apiRoot, stdio: "inherit" });
+  } catch (error) {
+    console.error(chalk.red("Build failed."), error);
+    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..."));
+    execSync(TSC_TYPE_CHECK_COMMAND, {
+      cwd: apiRoot,
+      stdio: "inherit",
+    });
+  } catch (error) {
+    console.error(chalk.red("Type check failed."), error);
+    process.exit(1);
+  }
+}
+
+/**
+ * pnpm start 하면 실행되는 함수입니다.
+ * 빌드된 프로젝트를 실행합니다.
+ *
+ * 빌드된 결과물(dist 디렉토리의 index.js 엔트리포인트)이 없다면 실행을 중단합니다.
+ * 소스맵 지원과 dotenv 지원을 포함하여 실행합니다.
+ *
+ * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
+ */
 async function start() {
-  const entryPoint = 'dist/index.js';  
+  const apiRoot = findApiRootPath();
+  const entryPoint = "dist/index.js";
 
   if (!(await exists(entryPoint))) {
-    console.log(
-      chalk.red(`${entryPoint} not found. Please build your project first.`)
-    );
+    console.log(chalk.red(`${entryPoint} not found. Please build your project first.`));
     console.log(chalk.blue("Run: yarn sonamu build"));
     return;
   }
 
   const { spawn } = await import("child_process");
   const serverProcess = spawn(
-    "node",
+    process.execPath,
     ["--enable-source-maps", "-r", "dotenv/config", entryPoint],
     {
-      cwd: Sonamu.apiRootPath,
+      cwd: apiRoot,
       stdio: "inherit",
-    }
+    },
   );
 
   process.on("SIGINT", () => {
@@ -161,9 +283,7 @@ async function start() {
 
 async function setupMigrator() {
   // migrator
-  migrator = new Migrator({
-    mode: "dev",
-  });
+  migrator = new Migrator();
 }
 
 async function setupFixtureManager() {
@@ -173,13 +293,10 @@ async function setupFixtureManager() {
 async function migrate_run() {
   await setupMigrator();
 
-  await migrator.run();
-}
-
-async function migrate_check() {
-  await setupMigrator();
-
-  await migrator.check();
+  await migrator.runAction(
+    "apply",
+    Object.keys(Sonamu.dbConfig) as (keyof SonamuDBConfig)[] /*싹 다!*/,
+  );
 }
 
 async function migrate_status() {
@@ -190,24 +307,6 @@ async function migrate_status() {
   console.log(status);
 }
 
-async function migrate_rollback() {
-  await setupMigrator();
-
-  await migrator.rollback();
-}
-
-async function migrate_clear() {
-  await setupMigrator();
-
-  await migrator.clearPendingList();
-}
-
-async function migrate_reset() {
-  await setupMigrator();
-
-  await migrator.resetAll();
-}
-
 async function fixture_init() {
   const srcConfig = Sonamu.dbConfig.development_master;
   const targets = [
@@ -215,23 +314,14 @@ async function fixture_init() {
       label: "(REMOTE) Fixture DB",
       config: Sonamu.dbConfig.fixture_remote,
     },
-    {
-      label: "(LOCAL) Fixture DB",
-      config: Sonamu.dbConfig.fixture_local,
-      toSkip: (() => {
-        const remoteConn = Sonamu.dbConfig.fixture_remote
-          .connection as Knex.ConnectionConfig;
-        const localConn = Sonamu.dbConfig.fixture_local
-          .connection as Knex.ConnectionConfig;
-        return (
-          remoteConn.host === localConn.host &&
-          remoteConn.database === localConn.database
-        );
-      })(),
-    },
     {
       label: "(LOCAL) Testing DB",
       config: Sonamu.dbConfig.test,
+      toSkip: (() => {
+        const remoteConn = Sonamu.dbConfig.fixture_remote.connection as Knex.ConnectionConfig;
+        const localConn = Sonamu.dbConfig.test.connection as Knex.ConnectionConfig;
+        return remoteConn.host === localConn.host && remoteConn.database === localConn.database;
+      })(),
     },
   ] as {
     label: string;
@@ -245,16 +335,16 @@ async function fixture_init() {
   const srcConn = srcConfig.connection as Knex.ConnectionConfig;
   const migrationsDump = `/tmp/sonamu-fixture-init-migrations-${Date.now()}.sql`;
   execSync(
-    `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction -d --no-create-db --triggers ${srcConn.database} > ${dumpFilename}`
+    `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction -d --no-create-db --triggers ${srcConn.database} > ${dumpFilename}`,
   );
   const _db = knex(srcConfig);
   const [[migrations]] = await _db.raw(
     "SELECT COUNT(*) as count FROM information_schema.tables WHERE table_schema = ? AND table_name = 'knex_migrations'",
-    [srcConn.database]
+    [srcConn.database],
   );
   if (migrations.count > 0) {
     execSync(
-      `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction --no-create-db --triggers ${srcConn.database} knex_migrations knex_migrations_lock > ${migrationsDump}`
+      `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction --no-create-db --triggers ${srcConn.database} knex_migrations knex_migrations_lock > ${migrationsDump}`,
     );
   }
 
@@ -276,9 +366,7 @@ async function fixture_init() {
     });
     const [[row]] = await db.raw(`SHOW DATABASES LIKE "${conn.database}"`);
     if (row) {
-      console.log(
-        chalk.yellow(`${label}: Database "${conn.database}" Already exists`)
-      );
+      console.log(chalk.yellow(`${label}: Database "${conn.database}" Already exists`));
       await db.destroy();
       continue;
     }
@@ -321,11 +409,9 @@ async function stub_practice(name: string) {
     }
 
     const filteredSeqs = fileNames
-      .filter(
-        (fileName) => fileName.startsWith("p") && fileName.endsWith(".ts")
-      )
+      .filter((fileName) => fileName.startsWith("p") && fileName.endsWith(".ts"))
       .map((fileName) => {
-        const [, seqNo] = fileName.match(/^p([0-9]+)\-/) ?? ["0", "0"];
+        const [, seqNo] = fileName.match(/^p([0-9]+)-/) ?? ["0", "0"];
         return parseInt(seqNo);
       })
       .sort((a, b) => b - a);
@@ -358,14 +444,14 @@ async function stub_practice(name: string) {
 
   const runCode = `yarn node -r dotenv/config --enable-source-maps dist/practices/${fileName.replace(
     ".ts",
-    ".js"
+    ".js",
   )}`;
   console.log(`${chalk.blue(runCode)} copied to clipboard.`);
   execSync(`echo "${runCode}" | pbcopy`);
 }
 
 async function stub_entity(entityId: string) {
-  await Sonamu.syncer.createEntity({ entityId });
+  await Sonamu.syncer.createEntity({ entityId, title: entityId });
 }
 
 async function scaffold_model(entityId: string) {
@@ -382,18 +468,15 @@ async function scaffold_model_test(entityId: string) {
 
 async function ui() {
   try {
-    // @sonamu-kit/ui의 run-ui.ts 스크립트 경로 찾기
-    const uiModulePath = await import.meta.resolve("@sonamu-kit/ui");
-    const uiNodePath = path.join(
-      path.dirname(fileURLToPath(uiModulePath)),
-      "run-ui.js"
-    );
+    // 사용자 프로젝트의 패키지들 중에서 @sonamu-kit/ui를 찾습니다.
+    // 이를 위해서 createRequire를 사용하여 프로젝트 경로 기준으로 resolve합니다.
+    const projectRequire = createRequire(path.join(Sonamu.apiRootPath, "package.json"));
+    const uiPackagePath = projectRequire.resolve("@sonamu-kit/ui"); // 없으면 여기서 터져요(MODULE_NOT_FOUND)
+    const uiNodePath = path.join(path.dirname(uiPackagePath), "run-ui.js");
 
     if (!(await exists(uiNodePath))) {
       console.log(
-        chalk.red(
-          `UI runner script not found at ${uiNodePath}. Please rebuild @sonamu-kit/ui.`
-        )
+        chalk.red(`UI runner script not found at ${uiNodePath}. Please rebuild @sonamu-kit/ui.`),
       );
       return;
     }
@@ -402,8 +485,10 @@ async function ui() {
     const uiProcess = spawn(
       process.execPath,
       [
-        "--import", "@sonamu-kit/loader",
-        "--import", "sonamu/hot-hook-register",
+        "--import",
+        "sonamu/loader-register",
+        "--import",
+        "sonamu/hot-hook-register",
         "--enable-source-maps",
         "--no-warnings",
         uiNodePath,
@@ -413,12 +498,11 @@ async function ui() {
         env: {
           ...process.env,
           HOT: "yes",
-          PROJECT_NAME:
-            Sonamu.config.projectName ?? path.basename(Sonamu.apiRootPath),
+          PROJECT_NAME: Sonamu.config.projectName ?? path.basename(Sonamu.apiRootPath),
           API_ROOT_PATH: Sonamu.apiRootPath,
           UI_PORT: (Sonamu.config.ui?.port ?? 57000).toString(),
         },
-      }
+      },
     );
 
     // 종료 처리
@@ -439,9 +523,7 @@ async function ui() {
     });
   } catch (e: unknown) {
     if (e instanceof Error && e.message.includes("isn't declared")) {
-      console.log(
-        `You need to install ${chalk.blue(`@sonamu-kit/ui`)} first.`
-      );
+      console.log(`You need to install ${chalk.blue(`@sonamu-kit/ui`)} first.`);
       return;
     }
     throw e;

package/src/bin/loader-register.ts

@@ -0,0 +1,38 @@
+import { register } from "node:module";
+import * as path from "node:path";
+import { exists } from "../utils/fs-utils.js";
+import { findApiRootPath } from "../utils/utils.js";
+
+/**
+ * @sonamu-kit/loader/loader를 등록하는 스크립트입니다.
+ * 이 스크립트는 sonamu cli로 dev 실행할 때 --import로 실행됩니다.
+ */
+async function setupSwcConfig() {
+  try {
+    const apiRoot = findApiRootPath();
+
+    // 프로젝트 루트에서 .swcrc 찾기
+    const projectSwcrcPath = path.join(apiRoot, ".swcrc");
+    if (await exists(projectSwcrcPath)) {
+      // 사용자 프로젝트에 .swcrc가 있으면 우선으로 사용합니다.
+      process.env.SWCRC_PATH = projectSwcrcPath;
+      return;
+    }
+
+    // 아니라면 sonamu가 관리하는 .swcrc.project-default를 가져다 씁니다.
+    const sonamuSwcrcPath = path.join(import.meta.dirname, "..", "..", ".swcrc.project-default");
+    if (await exists(sonamuSwcrcPath)) {
+      process.env.SWCRC_PATH = sonamuSwcrcPath;
+      return;
+    }
+  } catch {
+    // 환경 변수 설정 실패는 무시 (loader가 기본 설정 사용)
+  }
+}
+
+// swc 설정 파일 경로를 환경 변수로 설정
+await setupSwcConfig();
+
+register("@sonamu-kit/loader/loader", {
+  parentURL: import.meta.url,
+});

package/src/database/_batch_update.ts

@@ -3,11 +3,12 @@
   https://github.com/knex/knex/issues/5716
 */
 
-import { Knex } from "knex";
+import type { Knex } from "knex";
 
+type ColumnValue = string | number | boolean | null;
 export type RowWithId<Id extends string> = {
-  [key in Id]: any;
-} & Record<string, any>;
+  [key in Id]: ColumnValue;
+} & Record<string, ColumnValue>;
 
 /**
  * Batch update rows in a table. Technically its a patch since it only updates the specified columns. Any omitted columns will not be affected
@@ -24,17 +25,14 @@ export async function batchUpdate<Id extends string>(
   ids: Id[],
   rows: RowWithId<Id>[],
   chunkSize = 50,
-  trx: Knex.Transaction | null = null
+  trx: Knex.Transaction | null = null,
 ) {
   const chunks: RowWithId<Id>[][] = [];
   for (let i = 0; i < rows.length; i += chunkSize) {
     chunks.push(rows.slice(i, i + chunkSize));
   }
 
-  const executeUpdate = async (
-    chunk: RowWithId<Id>[],
-    transaction: Knex.Transaction
-  ) => {
+  const executeUpdate = async (chunk: RowWithId<Id>[], transaction: Knex.Transaction) => {
     const sql = generateBatchUpdateSQL(knex, tableName, chunk, ids);
     return knex.raw(sql).transacting(transaction);
   };
@@ -59,7 +57,7 @@ export async function batchUpdate<Id extends string>(
  * [ { a: 1, b: 2 }, { a: 3, c: 4 } ] => Set([ "a", "b", "c" ])
  * @param data
  */
-function generateKeySetFromData(data: Record<string, any>[]) {
+function generateKeySetFromData(data: Record<string, ColumnValue>[]) {
   const keySet: Set<string> = new Set();
   for (const row of data) {
     for (const key of Object.keys(row)) {
@@ -72,50 +70,67 @@ function generateKeySetFromData(data: Record<string, any>[]) {
 function generateBatchUpdateSQL<Id extends string>(
   db: Knex,
   tableName: string,
-  data: Record<string, any>[],
-  identifiers: Id[]
+  data: Record<string, ColumnValue>[],
+  identifiers: Id[],
 ) {
   const keySet = generateKeySetFromData(data);
-  const bindings = [];
+  const allBindings: (string | number | boolean | null)[] = [];
 
   const invalidIdentifiers = identifiers.filter((id) => !keySet.has(id));
   if (invalidIdentifiers.length > 0) {
     throw new Error(
-      `Invalid identifiers: ${invalidIdentifiers.join(", ")}. Identifiers must exist in the data`
+      `Invalid identifiers: ${invalidIdentifiers.join(", ")}. Identifiers must exist in the data`,
     );
   }
 
-  const cases = [];
+  const cases: string[] = [];
+
   for (const key of keySet) {
     if (identifiers.includes(key as Id)) continue;
 
-    const rows = [];
+    const caseBindings: (string | number | boolean | null)[] = [];
+    const whenClauses: string[] = [];
+
     for (const row of data) {
-      if (Object.hasOwnProperty.call(row, key)) {
-        const whereClause = identifiers
-          .map((id) => `\`${id}\` = ?`)
-          .join(" AND ");
-        rows.push(`WHEN (${whereClause}) THEN ?`);
-        bindings.push(...identifiers.map((i) => row[i]), row[key]);
+      if (Object.hasOwn(row, key)) {
+        const whereParts = identifiers.map(() => `?? = ?`).join(" AND ");
+        whenClauses.push(`WHEN (${whereParts}) THEN ?`);
+
+        // identifier 이름과 값들을 추가
+        for (const id of identifiers) {
+          caseBindings.push(id, row[id]);
+        }
+        // THEN 값 추가
+        caseBindings.push(row[key]);
       }
     }
 
-    const whenThen = rows.join(" ");
-    cases.push(`\`${key}\` = CASE ${whenThen} ELSE \`${key}\` END`);
+    const whenThen = whenClauses.join(" ");
+    cases.push(`?? = CASE ${whenThen} ELSE ?? END`);
+
+    // 컬럼명 2개 추가 (SET의 컬럼명, ELSE의 컬럼명)
+    allBindings.push(key);
+    allBindings.push(...caseBindings);
+    allBindings.push(key);
   }
 
   const whereInClauses = identifiers
-    .map((col) => `${col} IN (${data.map(() => "?").join(", ")})`)
+    .map((_col) => `?? IN (${data.map(() => "?").join(", ")})`)
     .join(" AND ");
 
-  const whereInBindings = identifiers.flatMap((col) =>
-    data.map((row) => row[col])
-  );
+  const whereInBindings: (string | number | boolean | null)[] = [];
+  for (const col of identifiers) {
+    whereInBindings.push(col);
+    for (const row of data) {
+      whereInBindings.push(row[col]);
+    }
+  }
 
-  const sql = db.raw(
-    `UPDATE \`${tableName}\` SET ${cases.join(", ")} WHERE ${whereInClauses}`,
-    [...bindings, ...whereInBindings]
-  );
+  const sql = db.raw(`UPDATE ?? SET ${cases.join(", ")} WHERE ${whereInClauses}`, [
+    tableName,
+    ...allBindings,
+    ...whereInBindings,
+  ]);
 
   return sql.toQuery();
 }