sonamu 0.3.1 → 0.4.2

package/src/testing/fixture-manager.ts

@@ -1,8 +1,6 @@
 import chalk from "chalk";
-import knex, { Knex } from "knex";
 import _ from "lodash";
 import { Sonamu } from "../api";
-import { BaseModel } from "../database/base-model";
 import { EntityManager } from "../entity/entity-manager";
 import {
   EntityProp,
@@ -19,65 +17,18 @@ import {
 } from "../types/types";
 import { Entity } from "../entity/entity";
 import inflection from "inflection";
-import { SonamuDBConfig } from "../database/db";
 import { readFileSync, writeFileSync } from "fs";
+import { RelationGraph } from "./_relation-graph";
+import { SonamuDBConfig, WhereClause } from "../database/types";
+import { DB } from "../database/db";
+import { KyselyClient } from "../database/drivers/kysely/client";
+import { KnexClient } from "../database/drivers/knex/client";
 
 export class FixtureManagerClass {
-  private _tdb: Knex | null = null;
-  set tdb(tdb: Knex) {
-    this._tdb = tdb;
-  }
-  get tdb(): Knex {
-    if (this._tdb === null) {
-      throw new Error("FixtureManager has not been initialized");
-    }
-    return this._tdb;
-  }
-
-  private _fdb: Knex | null = null;
-  set fdb(fdb: Knex) {
-    this._fdb = fdb;
-  }
-  get fdb(): Knex {
-    if (this._fdb === null) {
-      throw new Error("FixtureManager has not been initialized");
-    }
-    return this._fdb;
-  }
-
-  private dependencyGraph: Map<
-    string,
-    {
-      fixtureId: string;
-      entityId: string;
-      dependencies: Set<string>;
-    }
-  > = new Map();
+  private relationGraph = new RelationGraph();
 
   init() {
-    if (this._tdb !== null) {
-      return;
-    }
-    if (Sonamu.dbConfig.test && Sonamu.dbConfig.production_master) {
-      const tConn = Sonamu.dbConfig.test.connection as Knex.ConnectionConfig & {
-        port?: number;
-      };
-      const pConn = Sonamu.dbConfig.production_master
-        .connection as Knex.ConnectionConfig & { port?: number };
-      if (
-        `${tConn.host ?? "localhost"}:${tConn.port ?? 3306}/${
-          tConn.database
-        }` ===
-        `${pConn.host ?? "localhost"}:${pConn.port ?? 3306}/${pConn.database}`
-      ) {
-        throw new Error(
-          `테스트DB와 프로덕션DB에 동일한 데이터베이스가 사용되었습니다.`
-        );
-      }
-    }
-
-    this.tdb = knex(Sonamu.dbConfig.test);
-    this.fdb = knex(Sonamu.dbConfig.fixture_local);
+    DB.testInit();
   }
 
   async cleanAndSeed(usingTables?: string[]) {
@@ -86,56 +37,51 @@ export class FixtureManagerClass {
         return usingTables;
       }
 
-      const [tables] = await this.tdb.raw(
-        "SHOW TABLE STATUS WHERE Engine IS NOT NULL"
+      const tables = await DB.tdb.raw<{ Name: string }>(
+        `SHOW TABLE STATUS WHERE Engine IS NOT NULL`
       );
       return tables.map((tableInfo: any) => tableInfo["Name"] as string);
     })();
 
-    await this.tdb.raw(`SET FOREIGN_KEY_CHECKS = 0`);
+    await DB.tdb.raw(`SET FOREIGN_KEY_CHECKS = 0`);
     for await (let tableName of tableNames) {
       if (tableName == "migrations") {
         continue;
       }
 
-      const [[fdbChecksumRow]] = await this.fdb.raw(
+      const [fdbChecksumRow] = await DB.fdb.raw<{ Checksum: string }>(
         `CHECKSUM TABLE ${tableName}`
       );
       const fdbChecksum = fdbChecksumRow["Checksum"];
 
-      const [[tdbChecksumRow]] = await this.tdb.raw(
+      const [tdbChecksumRow] = await DB.tdb.raw<{ Checksum: string }>(
         `CHECKSUM TABLE ${tableName}`
       );
       const tdbChecksum = tdbChecksumRow["Checksum"];
 
       if (fdbChecksum !== tdbChecksum) {
-        await this.tdb(tableName).truncate();
-        const rawQuery = `INSERT INTO ${
-          (Sonamu.dbConfig.test.connection as Knex.ConnectionConfig).database
-        }.${tableName}
-            SELECT * FROM ${
-              (
-                Sonamu.dbConfig.fixture_local
-                  .connection as Knex.ConnectionConfig
-              ).database
-            }.${tableName}`;
-        await this.tdb.raw(rawQuery);
+        await DB.tdb.truncate(tableName);
+        const rawQuery = `INSERT INTO ${DB.connectionInfo.test.database}.${tableName}
+            SELECT * FROM ${DB.connectionInfo.fixture_local.database}.${tableName}`;
+        await DB.tdb.raw(rawQuery);
       }
     }
-    await this.tdb.raw(`SET FOREIGN_KEY_CHECKS = 1`);
+    await DB.tdb.raw(`SET FOREIGN_KEY_CHECKS = 1`);
 
     // console.timeEnd("FIXTURE-CleanAndSeed");
   }
 
-  async getChecksum(db: Knex, tableName: string) {
-    const [[checksumRow]] = await db.raw(`CHECKSUM TABLE ${tableName}`);
+  async getChecksum(db: KnexClient | KyselyClient, tableName: string) {
+    const [checksumRow] = await db.raw<{ Checksum: string }>(
+      `CHECKSUM TABLE ${tableName}`
+    );
     return checksumRow.Checksum;
   }
 
   async sync() {
-    const frdb = knex(Sonamu.dbConfig.fixture_remote);
+    const frdb = DB.getClient("fixture_remote");
 
-    const [tables] = await this.fdb.raw(
+    const tables = await DB.fdb.raw<{ Name: string }>(
       "SHOW TABLE STATUS WHERE Engine IS NOT NULL"
     );
     const tableNames: string[] = tables.map(
@@ -145,36 +91,30 @@ export class FixtureManagerClass {
     console.log(chalk.magenta("SYNC..."));
     await Promise.all(
       tableNames.map(async (tableName) => {
-        if (tableName.startsWith("knex_migrations")) {
+        if (tableName.startsWith(DB.migrationTable)) {
           return;
         }
 
         const remoteChecksum = await this.getChecksum(frdb, tableName);
-        const localChecksum = await this.getChecksum(this.fdb, tableName);
+        const localChecksum = await this.getChecksum(DB.fdb, tableName);
 
         if (remoteChecksum !== localChecksum) {
-          await this.fdb.transaction(async (transaction) => {
+          await DB.fdb.trx(async (transaction) => {
             await transaction.raw(`SET FOREIGN_KEY_CHECKS = 0`);
-            await transaction(tableName).truncate();
+            await transaction.truncate(tableName);
 
-            const rows = await frdb(tableName);
+            const rows = await frdb.raw(`SELECT * FROM ${tableName}`);
             if (rows.length === 0) {
               return;
             }
 
             console.log(chalk.blue(tableName), rows.length);
-            await transaction
-              .insert(
-                rows.map((row) => {
-                  Object.keys(row).map((key) => {
-                    if (Array.isArray(row[key])) {
-                      row[key] = JSON.stringify(row[key]);
-                    }
-                  });
-                  return row;
-                })
-              )
-              .into(tableName);
+            await transaction.raw(
+              `INSERT INTO ${tableName} (${Object.keys(rows[0] as any).join(
+                ","
+              )}) VALUES ?`,
+              [rows.map((row: any) => Object.values(row))]
+            );
             console.log("OK");
             await transaction.raw(`SET FOREIGN_KEY_CHECKS = 1`);
           });
@@ -197,9 +137,9 @@ export class FixtureManagerClass {
       ).flat()
     );
 
-    const wdb = BaseModel.getDB("w");
+    const wdb = DB.toClient(DB.getDB("w"));
     for (let query of queries) {
-      const [rsh] = await wdb.raw(query);
+      const [rsh] = await wdb.raw<{ info: any }>(query);
       console.log({
         query,
         info: rsh.info,
@@ -214,19 +154,19 @@ export class FixtureManagerClass {
   ): Promise<string[]> {
     console.log({ entityId, field, id });
     const entity = EntityManager.get(entityId);
-    const wdb = BaseModel.getDB("w");
+    const wdb = DB.toClient(DB.getDB("w"));
 
     // 여기서 실DB의 row 가져옴
-    const [row] = await wdb(entity.table).where(field, id).limit(1);
+    const [row] = await wdb.raw<any>(
+      `SELECT * FROM ${entity.table} WHERE ${field} = ${id} LIMIT 1`
+    );
     if (row === undefined) {
       throw new Error(`${entityId}#${id} row를 찾을 수 없습니다.`);
     }
 
     // 픽스쳐DB, 실DB
-    const fixtureDatabase = (Sonamu.dbConfig.fixture_remote.connection as any)
-      .database;
-    const realDatabase = (Sonamu.dbConfig.production_master.connection as any)
-      .database;
+    const fixtureDatabase = DB.connectionInfo.fixture_remote.database;
+    const realDatabase = DB.connectionInfo.production_master.database;
 
     const selfQuery = `INSERT IGNORE INTO \`${fixtureDatabase}\`.\`${entity.table}\` (SELECT * FROM \`${realDatabase}\`.\`${entity.table}\` WHERE \`id\` = ${id})`;
 
@@ -273,15 +213,8 @@ export class FixtureManagerClass {
   }
 
   async destory() {
-    if (this._tdb) {
-      await this._tdb.destroy();
-      this._tdb = null;
-    }
-    if (this._fdb) {
-      await this._fdb.destroy();
-      this._fdb = null;
-    }
-    await BaseModel.destroy();
+    await DB.testDestroy();
+    await DB.destroy();
   }
 
   async getFixtures(
@@ -289,8 +222,8 @@ export class FixtureManagerClass {
     targetDBName: keyof SonamuDBConfig,
     searchOptions: FixtureSearchOptions
   ) {
-    const sourceDB = knex(Sonamu.dbConfig[sourceDBName]);
-    const targetDB = knex(Sonamu.dbConfig[targetDBName]);
+    const sourceDB = DB.getClient(sourceDBName);
+    const targetDB = DB.getClient(targetDBName);
     const { entityId, field, value, searchType } = searchOptions;
 
     const entity = EntityManager.get(entityId);
@@ -299,14 +232,14 @@ export class FixtureManagerClass {
         ? `${field}_id`
         : field;
 
-    let query = sourceDB(entity.table);
+    let query = sourceDB.from(entity.table).selectAll();
     if (searchType === "equals") {
-      query = query.where(column, value);
+      query = query.where([column, "=", value]);
     } else if (searchType === "like") {
-      query = query.where(column, "like", `%${value}%`);
+      query = query.where([column, "like", `%${value}%`]);
     }
 
-    const rows = await query;
+    const rows = await query.execute();
     if (rows.length === 0) {
       throw new Error("No records found");
     }
@@ -332,8 +265,13 @@ export class FixtureManagerClass {
     for await (const fixture of fixtures) {
       const entity = EntityManager.get(fixture.entityId);
 
-      // targetDB에 해당 레코드가 존재하는지 확인
-      const row = await targetDB(entity.table).where("id", fixture.id).first();
+      // ID를 이용하여 targetDB에 레코드가 존재하는지 확인
+      const [row] = await targetDB
+        .from(entity.table)
+        .selectAll()
+        .where(["id", "=", fixture.id])
+        .first()
+        .execute();
       if (row) {
         const [record] = await this.createFixtureRecord(entity, row, {
           singleRecord: true,
@@ -343,7 +281,7 @@ export class FixtureManagerClass {
         continue;
       }
 
-      // targetDB에 해당 레코드가 존재하지 않는 경우, unique 제약을 위반하는지 확인
+      // ID를 이용하여 targetDB에서 조회되지 않는 경우, unique 제약을 위반하는지 확인
       const uniqueRow = await this.checkUniqueViolation(
         targetDB,
         entity,
@@ -358,7 +296,7 @@ export class FixtureManagerClass {
       }
     }
 
-    return fixtures;
+    return _.uniqBy(fixtures, (f) => f.fixtureId);
   }
 
   async createFixtureRecord(
@@ -366,89 +304,102 @@ export class FixtureManagerClass {
     row: any,
     options?: {
       singleRecord?: boolean;
-      _db?: Knex;
-    },
-    visitedEntities = new Set<string>()
-  ): Promise<FixtureRecord[]> {
-    const fixtureId = `${entity.id}#${row.id}`;
-    if (visitedEntities.has(fixtureId)) {
-      return [];
+      _db?: KnexClient | KyselyClient;
     }
-    visitedEntities.add(fixtureId);
-
+  ): Promise<FixtureRecord[]> {
     const records: FixtureRecord[] = [];
-    const record: FixtureRecord = {
-      fixtureId,
-      entityId: entity.id,
-      id: row.id,
-      columns: {},
-      fetchedRecords: [],
-      belongsRecords: [],
-    };
+    const visitedEntities = new Set<string>();
 
-    for (const prop of entity.props) {
-      if (isVirtualProp(prop)) {
-        continue;
+    const create = async (entity: Entity, row: any) => {
+      const fixtureId = `${entity.id}#${row.id}`;
+      if (visitedEntities.has(fixtureId)) {
+        return;
       }
-
-      record.columns[prop.name] = {
-        prop: prop,
-        value: row[prop.name],
+      visitedEntities.add(fixtureId);
+
+      const record: FixtureRecord = {
+        fixtureId,
+        entityId: entity.id,
+        id: row.id,
+        columns: {},
+        fetchedRecords: [],
+        belongsRecords: [],
       };
 
-      const db = options?._db ?? BaseModel.getDB("w");
-      if (isManyToManyRelationProp(prop)) {
-        const relatedEntity = EntityManager.get(prop.with);
-        const throughTable = prop.joinTable;
-        const fromColumn = `${inflection.singularize(entity.table)}_id`;
-        const toColumn = `${inflection.singularize(relatedEntity.table)}_id`;
-
-        const relatedIds = await db(throughTable)
-          .where(fromColumn, row.id)
-          .pluck(toColumn);
-        record.columns[prop.name].value = relatedIds;
-      } else if (isHasManyRelationProp(prop)) {
-        const relatedEntity = EntityManager.get(prop.with);
-        const relatedIds = await db(relatedEntity.table)
-          .where(prop.joinColumn, row.id)
-          .pluck("id");
-        record.columns[prop.name].value = relatedIds;
-      } else if (isOneToOneRelationProp(prop) && !prop.hasJoinColumn) {
-        const relatedEntity = EntityManager.get(prop.with);
-        const relatedProp = relatedEntity.props.find(
-          (p) => p.type === "relation" && p.with === entity.id
-        );
-        if (relatedProp) {
-          const relatedRow = await db(relatedEntity.table)
-            .where("id", row.id)
-            .first();
-          record.columns[prop.name].value = relatedRow?.id;
+      for (const prop of entity.props) {
+        if (isVirtualProp(prop)) {
+          continue;
         }
-      } else if (isRelationProp(prop)) {
-        const relatedId = row[`${prop.name}_id`];
-        record.columns[prop.name].value = relatedId;
-        if (relatedId) {
-          record.belongsRecords.push(`${prop.with}#${relatedId}`);
-        }
-        if (!options?.singleRecord && relatedId) {
+
+        record.columns[prop.name] = {
+          prop: prop,
+          value: row[prop.name],
+        };
+
+        const db = options?._db ?? DB.toClient(DB.getDB("w"));
+        if (isManyToManyRelationProp(prop)) {
           const relatedEntity = EntityManager.get(prop.with);
-          const relatedRow = await db(relatedEntity.table)
-            .where("id", relatedId)
-            .first();
-          if (relatedRow) {
-            const newRecords = await this.createFixtureRecord(
-              relatedEntity,
-              relatedRow,
-              options,
-              visitedEntities
-            );
-            records.push(...newRecords);
+          const throughTable = prop.joinTable;
+          const fromColumn = `${inflection.singularize(entity.table)}_id`;
+          const toColumn = `${inflection.singularize(relatedEntity.table)}_id`;
+
+          const _relatedIds = await db
+            .from(throughTable)
+            .select(toColumn)
+            .where([fromColumn, "=", row.id])
+            .execute();
+          const relatedIds = _relatedIds.map((r) => parseInt(r[toColumn]));
+
+          record.columns[prop.name].value = relatedIds;
+        } else if (isHasManyRelationProp(prop)) {
+          const relatedEntity = EntityManager.get(prop.with);
+          const relatedIds = await db
+            .from(relatedEntity.table)
+            .select("id")
+            .where([prop.joinColumn, "=", row.id])
+            .pluck("id");
+          record.columns[prop.name].value = relatedIds;
+        } else if (isOneToOneRelationProp(prop) && !prop.hasJoinColumn) {
+          const relatedEntity = EntityManager.get(prop.with);
+          const relatedProp = relatedEntity.props.find(
+            (p) => isRelationProp(p) && p.with === entity.id
+          );
+          if (relatedProp) {
+            const [relatedRow] = await db
+              .from(relatedEntity.table)
+              .select("id")
+              .where([relatedProp.name, "=", row.id])
+              .first()
+              .execute();
+
+            record.columns[prop.name].value = relatedRow?.id;
+          }
+        } else if (isRelationProp(prop)) {
+          const relatedId = row[`${prop.name}_id`];
+          record.columns[prop.name].value = relatedId;
+          if (relatedId) {
+            record.belongsRecords.push(`${prop.with}#${relatedId}`);
+          }
+          if (!options?.singleRecord && relatedId) {
+            const relatedEntity = EntityManager.get(prop.with);
+            const [relatedRow] = await db
+              .from(relatedEntity.table)
+              .selectAll()
+              .where(["id", "=", relatedId])
+              .first()
+              .execute();
+            if (relatedRow) {
+              await create(relatedEntity, relatedRow);
+            }
           }
         }
       }
-    }
 
-    records.push(record);
+      records.push(record);
+    };
+
+    await create(entity, row);
+
     return records;
   }
 
@@ -458,16 +409,16 @@ export class FixtureManagerClass {
   ) {
     const fixtures = _.uniqBy(_fixtures, (f) => f.fixtureId);
 
-    this.buildDependencyGraph(fixtures);
-    const insertionOrder = this.getInsertionOrder();
-    const db = knex(Sonamu.dbConfig[dbName]);
+    this.relationGraph.buildGraph(fixtures);
+    const insertionOrder = this.relationGraph.getInsertionOrder();
+    const db = DB.getClient(dbName);
 
-    await db.transaction(async (trx) => {
+    await db.trx(async (trx) => {
       await trx.raw(`SET FOREIGN_KEY_CHECKS = 0`);
 
       for (const fixtureId of insertionOrder) {
         const fixture = fixtures.find((f) => f.fixtureId === fixtureId)!;
-        const result = await this.insertFixture(trx, fixture);
+        const result = await this.insertFixture(trx as any, fixture);
         if (result.id !== fixture.id) {
           // ID가 변경된 경우, 다른 fixture에서 참조하는 경우가 찾아서 수정
           console.log(
@@ -492,7 +443,7 @@ export class FixtureManagerClass {
 
       for (const fixtureId of insertionOrder) {
         const fixture = fixtures.find((f) => f.fixtureId === fixtureId)!;
-        await this.handleManyToManyRelations(trx, fixture, fixtures);
+        await this.handleManyToManyRelations(trx as any, fixture, fixtures);
       }
       await trx.raw(`SET FOREIGN_KEY_CHECKS = 1`);
     });
@@ -501,7 +452,12 @@ export class FixtureManagerClass {
 
     for await (const r of fixtures) {
       const entity = EntityManager.get(r.entityId);
-      const record = await db(entity.table).where("id", r.id).first();
+      const [record] = await db
+        .from(entity.table)
+        .selectAll()
+        .where(["id", "=", r.id])
+        .first()
+        .execute();
       records.push({
         entityId: r.entityId,
         data: record,
@@ -511,58 +467,6 @@ export class FixtureManagerClass {
     return _.uniqBy(records, (r) => `${r.entityId}#${r.data.id}`);
   }
 
-  private getInsertionOrder() {
-    const visited = new Set<string>();
-    const order: string[] = [];
-    const tempVisited = new Set<string>();
-
-    const visit = (fixtureId: string) => {
-      if (visited.has(fixtureId)) return;
-      if (tempVisited.has(fixtureId)) {
-        console.warn(`Circular dependency detected involving: ${fixtureId}`);
-        return;
-      }
-
-      tempVisited.add(fixtureId);
-
-      const node = this.dependencyGraph.get(fixtureId)!;
-      const entity = EntityManager.get(node.entityId);
-
-      for (const depId of node.dependencies) {
-        const depNode = this.dependencyGraph.get(depId)!;
-
-        // BelongsToOne 관계이면서 nullable이 아닌 경우 먼저 방문
-        const relationProp = entity.props.find(
-          (prop) =>
-            isRelationProp(prop) &&
-            (isBelongsToOneRelationProp(prop) ||
-              (isOneToOneRelationProp(prop) && prop.hasJoinColumn)) &&
-            prop.with === depNode.entityId
-        );
-        if (relationProp && !relationProp.nullable) {
-          visit(depId);
-        }
-      }
-
-      tempVisited.delete(fixtureId);
-      visited.add(fixtureId);
-      order.push(fixtureId);
-    };
-
-    for (const fixtureId of this.dependencyGraph.keys()) {
-      visit(fixtureId);
-    }
-
-    // circular dependency로 인해 방문되지 않은 fixtureId 추가
-    for (const fixtureId of this.dependencyGraph.keys()) {
-      if (!visited.has(fixtureId)) {
-        order.push(fixtureId);
-      }
-    }
-
-    return order;
-  }
-
   private prepareInsertData(fixture: FixtureRecord) {
     const insertData: any = {};
     for (const [propName, column] of Object.entries(fixture.columns)) {
@@ -587,53 +491,10 @@ export class FixtureManagerClass {
     return insertData;
   }
 
-  private buildDependencyGraph(fixtures: FixtureRecord[]) {
-    this.dependencyGraph.clear();
-
-    // 1. 노드 추가
-    for (const fixture of fixtures) {
-      this.dependencyGraph.set(fixture.fixtureId, {
-        fixtureId: fixture.fixtureId,
-        entityId: fixture.entityId,
-        dependencies: new Set(),
-      });
-    }
-
-    // 2. 의존성 추가
-    for (const fixture of fixtures) {
-      const node = this.dependencyGraph.get(fixture.fixtureId)!;
-
-      for (const [, column] of Object.entries(fixture.columns)) {
-        const prop = column.prop as EntityProp;
-
-        if (isRelationProp(prop)) {
-          if (
-            isBelongsToOneRelationProp(prop) ||
-            (isOneToOneRelationProp(prop) && prop.hasJoinColumn)
-          ) {
-            const relatedFixtureId = `${prop.with}#${column.value}`;
-            if (this.dependencyGraph.has(relatedFixtureId)) {
-              node.dependencies.add(relatedFixtureId);
-            }
-          } else if (isManyToManyRelationProp(prop)) {
-            // ManyToMany 관계의 경우 양방향 의존성 추가
-            const relatedIds = column.value as number[];
-            for (const relatedId of relatedIds) {
-              const relatedFixtureId = `${prop.with}#${relatedId}`;
-              if (this.dependencyGraph.has(relatedFixtureId)) {
-                node.dependencies.add(relatedFixtureId);
-                this.dependencyGraph
-                  .get(relatedFixtureId)!
-                  .dependencies.add(fixture.fixtureId);
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-
-  private async insertFixture(db: Knex, fixture: FixtureRecord) {
+  private async insertFixture(
+    db: KnexClient | KyselyClient,
+    fixture: FixtureRecord
+  ) {
     const insertData = this.prepareInsertData(fixture);
     const entity = EntityManager.get(fixture.entityId);
 
@@ -646,7 +507,12 @@ export class FixtureManagerClass {
         };
       }
 
-      const found = await db(entity.table).where("id", fixture.id).first();
+      const [found] = await db
+        .from(entity.table)
+        .select("id")
+        .where(["id", "=", fixture.id])
+        .first()
+        .execute();
       if (found && !fixture.override) {
         return {
           entityId: fixture.entityId,
@@ -654,8 +520,8 @@ export class FixtureManagerClass {
         };
       }
 
-      const q = db.insert(insertData).into(entity.table);
-      await q.onDuplicateUpdate.apply(q, Object.keys(insertData));
+      await db.upsert(entity.table, [insertData]);
+
       return {
         entityId: fixture.entityId,
         id: fixture.id,
@@ -667,7 +533,7 @@ export class FixtureManagerClass {
   }
 
   private async handleManyToManyRelations(
-    db: Knex,
+    db: KnexClient | KyselyClient,
     fixture: FixtureRecord,
     fixtures: FixtureRecord[]
   ) {
@@ -692,20 +558,29 @@ export class FixtureManagerClass {
             );
           }
 
-          const [found] = await db(joinTable)
-            .where({
-              [`${inflection.singularize(entity.table)}_id`]: fixture.id,
-              [`${inflection.singularize(relatedEntity.table)}_id`]: relatedId,
-            })
-            .limit(1);
+          const [found] = await db
+            .from(joinTable)
+            .select("id")
+            .where([
+              [`${inflection.singularize(entity.table)}_id`, "=", fixture.id],
+              [
+                `${inflection.singularize(relatedEntity.table)}_id`,
+                "=",
+                relatedId,
+              ],
+            ])
+            .first()
+            .execute();
           if (found) {
             continue;
           }
 
-          const newIds = await db(joinTable).insert({
-            [`${inflection.singularize(entity.table)}_id`]: fixture.id,
-            [`${inflection.singularize(relatedEntity.table)}_id`]: relatedId,
-          });
+          const newIds = await db.insert(joinTable, [
+            {
+              [`${inflection.singularize(entity.table)}_id`]: fixture.id,
+              [`${inflection.singularize(relatedEntity.table)}_id`]: relatedId,
+            },
+          ]);
           console.log(
             chalk.green(
               `Inserted into ${joinTable}: ${entity.table}(${fixture.id}) - ${relatedEntity.table}(${relatedId}) ID: ${newIds}`
@@ -739,39 +614,48 @@ export class FixtureManagerClass {
 
   // 해당 픽스쳐의 값으로 유니크 제약에 위배되는 레코드가 있는지 확인
   private async checkUniqueViolation(
-    db: Knex,
+    db: KnexClient | KyselyClient,
     entity: Entity,
     fixture: FixtureRecord
   ) {
-    const uniqueIndexes = entity.indexes.filter((i) => i.type === "unique");
+    const _uniqueIndexes = entity.indexes.filter((i) => i.type === "unique");
+
+    // ManyToMany 관계 테이블의 유니크 제약은 제외
+    const uniqueIndexes = _uniqueIndexes.filter((index) =>
+      index.columns.every((column) => !column.startsWith(`${entity.table}__`))
+    );
     if (uniqueIndexes.length === 0) {
       return null;
     }
 
-    let uniqueQuery = db(entity.table);
-    for (const index of uniqueIndexes) {
-      // 컬럼 중 하나라도 null이면 유니크 제약을 위반하지 않기 때문에 해당 인덱스는 무시
-      if (
-        index.columns.some(
-          (column) => fixture.columns[column.split("_id")[0]].value === null
-        )
-      ) {
-        continue;
-      }
-
-      uniqueQuery = uniqueQuery.orWhere((qb) => {
-        for (const column of index.columns) {
+    let uniqueQuery = db.from(entity.table).selectAll();
+    const whereClauses = uniqueIndexes
+      .map((index) => {
+        // 컬럼 중 하나라도 null이면 유니크 제약을 위반하지 않기 때문에 해당 인덱스는 무시
+        const containsNull = index.columns.some((column) => {
           const field = column.split("_id")[0];
+          return fixture.columns[field].value === null;
+        });
+        if (containsNull) {
+          return;
+        }
 
+        return index.columns.map((c) => {
+          const field = c.split("_id")[0];
           if (Array.isArray(fixture.columns[field].value)) {
-            qb.whereIn(column, fixture.columns[field].value);
+            return [c, "in", fixture.columns[field].value];
           } else {
-            qb.andWhere(column, fixture.columns[field].value);
+            return [c, "=", fixture.columns[field].value];
           }
-        }
-      });
+        });
+      })
+      .filter(Boolean) as WhereClause[];
+
+    for (const clauses of whereClauses) {
+      uniqueQuery = uniqueQuery.orWhere(clauses);
     }
-    const [uniqueFound] = await uniqueQuery;
+
+    const [uniqueFound] = await uniqueQuery.execute();
     return uniqueFound;
   }
 }