sonamu 0.4.13 → 0.5.0

package/src/testing/fixture-manager.ts

@@ -19,69 +19,138 @@ import { Entity } from "../entity/entity";
 import inflection from "inflection";
 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";
+import knex, { Knex } from "knex";
+import { BaseModel } from "../database/base-model";
+import { SonamuDBConfig } from "../database/db";
 
 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;
+  }
+  cachedTableNames: string[] | null = null;
+
   private relationGraph = new RelationGraph();
 
   init() {
-    DB.testInit();
+    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);
   }
 
   async cleanAndSeed(usingTables?: string[]) {
-    const tableNames = await (async () => {
+    const tableNames: string[] = await (async () => {
       if (usingTables) {
         return usingTables;
       }
+      if (this.cachedTableNames) {
+        return this.cachedTableNames;
+      }
 
-      const tables = await DB.tdb.raw<{ Name: string }>(
-        `SHOW TABLE STATUS WHERE Engine IS NOT NULL`
+      const [tables] = await this.tdb.raw(
+        `SHOW TABLE STATUS WHERE Engine IS NOT NULL AND Name != 'migrations'`
       );
-      return tables.map((tableInfo: any) => tableInfo["Name"] as string);
+      const tableNames = tables.map(
+        (tableInfo: { Name: string }) => tableInfo["Name"]
+      );
+      this.cachedTableNames = tableNames;
+      return tableNames;
     })();
 
-    await DB.tdb.raw(`SET FOREIGN_KEY_CHECKS = 0`);
-    for await (let tableName of tableNames) {
-      if (tableName == "migrations") {
-        continue;
-      }
+    // migrations 제외한 테이블 목록
+    const tableListStr = tableNames.join(", ");
 
-      const [fdbChecksumRow] = await DB.fdb.raw<{ Checksum: string }>(
-        `CHECKSUM TABLE ${tableName}`
-      );
-      const fdbChecksum = fdbChecksumRow["Checksum"];
+    // 한 번에 모든 테이블 체크섬 확인
+    const [fdbChecksumRows] = await this.fdb.raw<
+      [{ Table: string; Checksum: number }[]]
+    >(`CHECKSUM TABLE ${tableListStr}`);
+    const [tdbChecksumRows] = await this.tdb.raw<
+      [{ Table: string; Checksum: number }[]]
+    >(`CHECKSUM TABLE ${tableListStr}`);
 
-      const [tdbChecksumRow] = await DB.tdb.raw<{ Checksum: string }>(
-        `CHECKSUM TABLE ${tableName}`
-      );
-      const tdbChecksum = tdbChecksumRow["Checksum"];
+    // 체크섬 맵 생성
+    const fdbChecksums = new Map(
+      fdbChecksumRows.map((row) => [row.Table.split(".").pop()!, row.Checksum])
+    );
+    const tdbChecksums = new Map(
+      tdbChecksumRows.map((row) => [row.Table.split(".").pop()!, row.Checksum])
+    );
 
-      if (fdbChecksum !== tdbChecksum) {
-        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 DB.tdb.raw(`SET FOREIGN_KEY_CHECKS = 1`);
+    // 변경된 테이블들만 처리
+    const changedTables = tableNames.filter(
+      (tableName) => fdbChecksums.get(tableName) !== tdbChecksums.get(tableName)
+    );
+
+    // 병렬로 truncate + insert 실행
+    await this.tdb.transaction(async (trx) => {
+      await trx.raw(`SET FOREIGN_KEY_CHECKS = 0`);
+
+      await Promise.all(
+        changedTables.map(async (tableName) => {
+          await trx.raw(`SET FOREIGN_KEY_CHECKS = 0`);
+          await trx(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 trx.raw(rawQuery);
+        })
+      );
+      await trx.raw(`SET FOREIGN_KEY_CHECKS = 1`);
+    });
 
     // console.timeEnd("FIXTURE-CleanAndSeed");
   }
 
-  async getChecksum(db: KnexClient | KyselyClient, tableName: string) {
-    const [checksumRow] = await db.raw<{ Checksum: string }>(
-      `CHECKSUM TABLE ${tableName}`
-    );
+  async getChecksum(db: Knex, tableName: string) {
+    const [[checksumRow]] = await db.raw(`CHECKSUM TABLE ${tableName}`);
     return checksumRow.Checksum;
   }
 
   async sync() {
-    const frdb = DB.getClient("fixture_remote");
+    const frdb = knex(Sonamu.dbConfig.fixture_remote);
 
-    const tables = await DB.fdb.raw<{ Name: string }>(
+    const [tables] = await this.fdb.raw(
       "SHOW TABLE STATUS WHERE Engine IS NOT NULL"
     );
     const tableNames: string[] = tables.map(
@@ -91,44 +160,46 @@ export class FixtureManagerClass {
     console.log(chalk.magenta("SYNC..."));
     await Promise.all(
       tableNames.map(async (tableName) => {
-        if (tableName.startsWith(DB.migrationTable)) {
+        if (tableName.startsWith("knex_migrations")) {
           return;
         }
 
         const remoteChecksum = await this.getChecksum(frdb, tableName);
-        const localChecksum = await this.getChecksum(DB.fdb, tableName);
+        const localChecksum = await this.getChecksum(this.fdb, tableName);
 
         if (remoteChecksum !== localChecksum) {
-          await DB.fdb.trx(async (transaction) => {
+          await this.fdb.transaction(async (transaction) => {
             await transaction.raw(`SET FOREIGN_KEY_CHECKS = 0`);
-            await transaction.truncate(tableName);
+            await transaction(tableName).truncate();
 
-            const rows = await frdb.raw(`SELECT * FROM ${tableName}`);
+            const rows = await frdb(tableName);
             if (rows.length === 0) {
               return;
             }
 
             console.log(chalk.blue(tableName), rows.length);
-            await transaction.raw(
-              `INSERT INTO ${tableName} (${Object.keys(rows[0] as any)
-                .map((k) => `\`${k}\``)
-                .join(",")}) VALUES ?`,
-              [
-                rows.map((row: any) =>
-                  Object.values(row).map((v) => {
-                    if (v === null) {
-                      return null;
-                    } else if (typeof v === "boolean") {
-                      return v ? 1 : 0;
-                    } else if (typeof v === "object") {
-                      return JSON.stringify(v);
-                    } else {
-                      return v;
-                    }
-                  })
-                ),
-              ]
-            );
+            await transaction
+              .insert(
+                rows.map((row: any) => {
+                  return Object.fromEntries(
+                    Object.entries(row).map(([key, value]) => {
+                      if (value === null) {
+                        return [key, null];
+                      } else if (typeof value === "boolean") {
+                        return [key, value ? 1 : 0];
+                      } else if (
+                        typeof value === "object" &&
+                        !(value instanceof Date)
+                      ) {
+                        return [key, JSON.stringify(value)];
+                      } else {
+                        return [key, value];
+                      }
+                    })
+                  );
+                })
+              )
+              .into(tableName);
             console.log("OK");
             await transaction.raw(`SET FOREIGN_KEY_CHECKS = 1`);
           });
@@ -140,7 +211,11 @@ export class FixtureManagerClass {
     await frdb.destroy();
   }
 
+  private visitedRecords = new Set<string>();
   async importFixture(entityId: string, ids: number[]) {
+    // 방문 기록 초기화 (새로운 import 작업 시작)
+    this.visitedRecords.clear();
+
     const queries = _.uniq(
       (
         await Promise.all(
@@ -151,9 +226,9 @@ export class FixtureManagerClass {
       ).flat()
     );
 
-    const wdb = DB.toClient(DB.getDB("w"));
+    const wdb = BaseModel.getDB("w");
     for (let query of queries) {
-      const [rsh] = await wdb.raw<{ info: any }>(query);
+      const [rsh] = await wdb.raw(query);
       console.log({
         query,
         info: rsh.info,
@@ -166,21 +241,29 @@ export class FixtureManagerClass {
     field: string,
     id: number
   ): Promise<string[]> {
+    const recordKey = `${entityId}#${field}#${id}`;
+
+    // 순환 참조 방지: 이미 방문한 레코드는 스킵
+    if (this.visitedRecords.has(recordKey)) {
+      return [];
+    }
+    this.visitedRecords.add(recordKey);
+
     console.log({ entityId, field, id });
     const entity = EntityManager.get(entityId);
-    const wdb = DB.toClient(DB.getDB("w"));
+    const wdb = BaseModel.getDB("w");
 
     // 여기서 실DB의 row 가져옴
-    const [row] = await wdb.raw<any>(
-      `SELECT * FROM ${entity.table} WHERE ${field} = ${id} LIMIT 1`
-    );
+    const [row] = await wdb(entity.table).where(field, id).limit(1);
     if (row === undefined) {
       throw new Error(`${entityId}#${id} row를 찾을 수 없습니다.`);
     }
 
     // 픽스쳐DB, 실DB
-    const fixtureDatabase = DB.connectionInfo.fixture_remote.database;
-    const realDatabase = DB.connectionInfo.production_master.database;
+    const fixtureDatabase = (Sonamu.dbConfig.fixture_remote.connection as any)
+      .database;
+    const realDatabase = (Sonamu.dbConfig.production_master.connection as any)
+      .database;
 
     const selfQuery = `INSERT IGNORE INTO \`${fixtureDatabase}\`.\`${entity.table}\` (SELECT * FROM \`${realDatabase}\`.\`${entity.table}\` WHERE \`id\` = ${id})`;
 
@@ -203,7 +286,16 @@ export class FixtureManagerClass {
         let field: string;
         let id: number;
         if (isOneToOneRelationProp(relation) && !relation.hasJoinColumn) {
-          field = `${relation.name}_id`;
+          const relatedEntity = EntityManager.get(relation.with);
+          const relatedIdColumnName = relatedEntity.props.find(
+            (p) => isRelationProp(p) && p.with === entity.id
+          )?.name;
+          if (!relatedIdColumnName) {
+            throw new Error(
+              `${relatedEntity.id}의 ${entity.id} 관계 프롭을 찾을 수 없습니다.`
+            );
+          }
+          field = `${relatedIdColumnName}_id`;
           id = row["id"];
         } else {
           field = "id";
@@ -226,9 +318,16 @@ export class FixtureManagerClass {
     return [..._.uniq(relQueries.reverse().flat()), selfQuery];
   }
 
-  async destory() {
-    await DB.testDestroy();
-    await DB.destroy();
+  async destroy() {
+    if (this._tdb) {
+      await this._tdb.destroy();
+      this._tdb = null;
+    }
+    if (this._fdb) {
+      await this._fdb.destroy();
+      this._fdb = null;
+    }
+    await BaseModel.destroy();
   }
 
   async getFixtures(
@@ -236,8 +335,8 @@ export class FixtureManagerClass {
     targetDBName: keyof SonamuDBConfig,
     searchOptions: FixtureSearchOptions
   ) {
-    const sourceDB = DB.getClient(sourceDBName);
-    const targetDB = DB.getClient(targetDBName);
+    const sourceDB = knex(Sonamu.dbConfig[sourceDBName]);
+    const targetDB = knex(Sonamu.dbConfig[targetDBName]);
     const { entityId, field, value, searchType } = searchOptions;
 
     const entity = EntityManager.get(entityId);
@@ -246,14 +345,14 @@ export class FixtureManagerClass {
         ? `${field}_id`
         : field;
 
-    let query = sourceDB.from(entity.table).selectAll();
+    let query = sourceDB(entity.table);
     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.execute();
+    const rows = await query;
     if (rows.length === 0) {
       throw new Error("No records found");
     }
@@ -280,12 +379,7 @@ export class FixtureManagerClass {
       const entity = EntityManager.get(fixture.entityId);
 
       // ID를 이용하여 targetDB에 레코드가 존재하는지 확인
-      const [row] = await targetDB
-        .from(entity.table)
-        .selectAll()
-        .where(["id", "=", fixture.id])
-        .first()
-        .execute();
+      const row = await targetDB(entity.table).where("id", fixture.id).first();
       if (row) {
         const [record] = await this.createFixtureRecord(entity, row, {
           singleRecord: true,
@@ -318,7 +412,7 @@ export class FixtureManagerClass {
     row: any,
     options?: {
       singleRecord?: boolean;
-      _db?: KnexClient | KyselyClient;
+      _db?: Knex;
     }
   ): Promise<FixtureRecord[]> {
     const records: FixtureRecord[] = [];
@@ -350,27 +444,21 @@ export class FixtureManagerClass {
           value: row[prop.name],
         };
 
-        const db = options?._db ?? DB.toClient(DB.getDB("w"));
+        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
-            .from(throughTable)
-            .select(toColumn)
-            .where([fromColumn, "=", row.id])
-            .execute();
-          const relatedIds = _relatedIds.map((r) => parseInt(r[toColumn]));
-
+          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
-            .from(relatedEntity.table)
-            .select("id")
-            .where([prop.joinColumn, "=", row.id])
+          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) {
@@ -379,13 +467,9 @@ export class FixtureManagerClass {
             (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();
-
+            const relatedRow = await db(relatedEntity.table)
+              .where("id", row.id)
+              .first();
             record.columns[prop.name].value = relatedRow?.id;
           }
         } else if (isRelationProp(prop)) {
@@ -396,12 +480,9 @@ export class FixtureManagerClass {
           }
           if (!options?.singleRecord && relatedId) {
             const relatedEntity = EntityManager.get(prop.with);
-            const [relatedRow] = await db
-              .from(relatedEntity.table)
-              .selectAll()
-              .where(["id", "=", relatedId])
-              .first()
-              .execute();
+            const relatedRow = await db(relatedEntity.table)
+              .where("id", relatedId)
+              .first();
             if (relatedRow) {
               await create(relatedEntity, relatedRow);
             }
@@ -425,9 +506,9 @@ export class FixtureManagerClass {
 
     this.relationGraph.buildGraph(fixtures);
     const insertionOrder = this.relationGraph.getInsertionOrder();
-    const db = DB.getClient(dbName);
+    const db = knex(Sonamu.dbConfig[dbName]);
 
-    await db.trx(async (trx) => {
+    await db.transaction(async (trx) => {
       await trx.raw(`SET FOREIGN_KEY_CHECKS = 0`);
 
       for (const fixtureId of insertionOrder) {
@@ -466,12 +547,7 @@ export class FixtureManagerClass {
 
     for await (const r of fixtures) {
       const entity = EntityManager.get(r.entityId);
-      const [record] = await db
-        .from(entity.table)
-        .selectAll()
-        .where(["id", "=", r.id])
-        .first()
-        .execute();
+      const record = await db(entity.table).where("id", r.id).first();
       records.push({
         entityId: r.entityId,
         data: record,
@@ -505,10 +581,7 @@ export class FixtureManagerClass {
     return insertData;
   }
 
-  private async insertFixture(
-    db: KnexClient | KyselyClient,
-    fixture: FixtureRecord
-  ) {
+  private async insertFixture(db: Knex, fixture: FixtureRecord) {
     const insertData = this.prepareInsertData(fixture);
     const entity = EntityManager.get(fixture.entityId);
 
@@ -521,12 +594,7 @@ export class FixtureManagerClass {
         };
       }
 
-      const [found] = await db
-        .from(entity.table)
-        .select("id")
-        .where(["id", "=", fixture.id])
-        .first()
-        .execute();
+      const found = await db(entity.table).where("id", fixture.id).first();
       if (found && !fixture.override) {
         return {
           entityId: fixture.entityId,
@@ -534,8 +602,8 @@ export class FixtureManagerClass {
         };
       }
 
-      await db.upsert(entity.table, [insertData]);
-
+      const q = db.insert(insertData).into(entity.table);
+      await q.onDuplicateUpdate.apply(q, Object.keys(insertData));
       return {
         entityId: fixture.entityId,
         id: fixture.id,
@@ -547,7 +615,7 @@ export class FixtureManagerClass {
   }
 
   private async handleManyToManyRelations(
-    db: KnexClient | KyselyClient,
+    db: Knex,
     fixture: FixtureRecord,
     fixtures: FixtureRecord[]
   ) {
@@ -572,29 +640,20 @@ export class FixtureManagerClass {
             );
           }
 
-          const [found] = await db
-            .from(joinTable)
-            .select("id")
-            .where([
-              [`${inflection.singularize(entity.table)}_id`, "=", fixture.id],
-              [
-                `${inflection.singularize(relatedEntity.table)}_id`,
-                "=",
-                relatedId,
-              ],
-            ])
-            .first()
-            .execute();
+          const [found] = await db(joinTable)
+            .where({
+              [`${inflection.singularize(entity.table)}_id`]: fixture.id,
+              [`${inflection.singularize(relatedEntity.table)}_id`]: relatedId,
+            })
+            .limit(1);
           if (found) {
             continue;
           }
 
-          const newIds = await db.insert(joinTable, [
-            {
-              [`${inflection.singularize(entity.table)}_id`]: fixture.id,
-              [`${inflection.singularize(relatedEntity.table)}_id`]: relatedId,
-            },
-          ]);
+          const newIds = await db(joinTable).insert({
+            [`${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}`
@@ -628,7 +687,7 @@ export class FixtureManagerClass {
 
   // 해당 픽스쳐의 값으로 유니크 제약에 위배되는 레코드가 있는지 확인
   private async checkUniqueViolation(
-    db: KnexClient | KyselyClient,
+    db: Knex,
     entity: Entity,
     fixture: FixtureRecord
   ) {
@@ -642,34 +701,30 @@ export class FixtureManagerClass {
       return null;
     }
 
-    let uniqueQuery = db.from(entity.table).selectAll();
-    const whereClauses = uniqueIndexes
-      .map((index) => {
-        // 컬럼 중 하나라도 null이면 유니크 제약을 위반하지 않기 때문에 해당 인덱스는 무시
-        const containsNull = index.columns.some((column) => {
+    let uniqueQuery = db(entity.table);
+    for (const index of uniqueIndexes) {
+      // 컬럼 중 하나라도 null이면 유니크 제약을 위반하지 않기 때문에 해당 인덱스는 무시
+      const containsNull = index.columns.some((column) => {
+        const field = column.split("_id")[0];
+        return fixture.columns[field].value === null;
+      });
+      if (containsNull) {
+        continue;
+      }
+
+      uniqueQuery = uniqueQuery.orWhere((qb) => {
+        for (const column of index.columns) {
           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)) {
-            return [c, "in", fixture.columns[field].value];
+            qb.whereIn(column, fixture.columns[field].value);
           } else {
-            return [c, "=", fixture.columns[field].value];
+            qb.andWhere(column, fixture.columns[field].value);
           }
-        });
-      })
-      .filter(Boolean) as WhereClause[];
-
-    for (const clauses of whereClauses) {
-      uniqueQuery = uniqueQuery.orWhere(clauses);
+        }
+      });
     }
-
-    const [uniqueFound] = await uniqueQuery.execute();
+    const [uniqueFound] = await uniqueQuery;
     return uniqueFound;
   }
 }