sonamu 0.2.48 → 0.2.49

package/src/testing/fixture-manager.ts

@@ -158,6 +158,10 @@ export class FixtureManagerClass {
             await transaction(tableName).truncate();
 
             const rows = await frdb(tableName);
+            if (rows.length === 0) {
+              return;
+            }
+
             console.log(chalk.blue(tableName), rows.length);
             await transaction
               .insert(
@@ -307,58 +311,72 @@ export class FixtureManagerClass {
       throw new Error("No records found");
     }
 
-    const visitedEntities = new Set<string>();
-    const records: FixtureRecord[] = [];
+    const fixtures: FixtureRecord[] = [];
     for (const row of rows) {
-      const initialRecordsLength = records.length;
-      await this.createFixtureRecord(entity, row, visitedEntities, records);
-      const currentFixtureRecord = records.find(
+      const initialRecordsLength = fixtures.length;
+      const newRecords = await this.createFixtureRecord(entity, row);
+      fixtures.push(...newRecords);
+      const currentFixtureRecord = fixtures.find(
         (r) => r.fixtureId === `${entityId}#${row.id}`
       );
 
       if (currentFixtureRecord) {
         // 현재 fixture로부터 생성된 fetchedRecords 설정
-        currentFixtureRecord.fetchedRecords = records
+        currentFixtureRecord.fetchedRecords = fixtures
           .filter((r) => r.fixtureId !== currentFixtureRecord.fixtureId)
           .slice(initialRecordsLength)
           .map((r) => r.fixtureId);
       }
     }
 
-    for await (const record of records) {
-      const entity = EntityManager.get(record.entityId);
-      const rows: FixtureRecord[] = [];
-      const row = await targetDB(entity.table).where("id", record.id).first();
+    for await (const fixture of fixtures) {
+      const entity = EntityManager.get(fixture.entityId);
+
+      // targetDB에 해당 레코드가 존재하는지 확인
+      const row = await targetDB(entity.table).where("id", fixture.id).first();
       if (row) {
-        await this.createFixtureRecord(
-          entity,
-          row,
-          new Set(),
-          rows,
-          true,
-          targetDB
-        );
-        record.target = rows[0];
+        const [record] = await this.createFixtureRecord(entity, row, {
+          singleRecord: true,
+          _db: targetDB,
+        });
+        fixture.target = record;
+        continue;
+      }
+
+      // targetDB에 해당 레코드가 존재하지 않는 경우, unique 제약을 위반하는지 확인
+      const uniqueRow = await this.checkUniqueViolation(
+        targetDB,
+        entity,
+        fixture
+      );
+      if (uniqueRow) {
+        const [record] = await this.createFixtureRecord(entity, uniqueRow, {
+          singleRecord: true,
+          _db: targetDB,
+        });
+        fixture.unique = record;
       }
     }
 
-    return records;
+    return fixtures;
   }
 
   async createFixtureRecord(
     entity: Entity,
     row: any,
-    visitedEntities: Set<string>,
-    records: FixtureRecord[],
-    singleRecord = false,
-    _db?: Knex
-  ) {
+    options?: {
+      singleRecord?: boolean;
+      _db?: Knex;
+    },
+    visitedEntities = new Set<string>()
+  ): Promise<FixtureRecord[]> {
     const fixtureId = `${entity.id}#${row.id}`;
     if (visitedEntities.has(fixtureId)) {
-      return;
+      return [];
     }
     visitedEntities.add(fixtureId);
 
+    const records: FixtureRecord[] = [];
     const record: FixtureRecord = {
       fixtureId,
       entityId: entity.id,
@@ -378,7 +396,7 @@ export class FixtureManagerClass {
         value: row[prop.name],
       };
 
-      const db = _db ?? BaseModel.getDB("w");
+      const db = options?._db ?? BaseModel.getDB("w");
       if (isManyToManyRelationProp(prop)) {
         const relatedEntity = EntityManager.get(prop.with);
         const throughTable = prop.joinTable;
@@ -412,32 +430,34 @@ export class FixtureManagerClass {
         if (relatedId) {
           record.belongsRecords.push(`${prop.with}#${relatedId}`);
         }
-        if (!singleRecord && relatedId) {
+        if (!options?.singleRecord && relatedId) {
           const relatedEntity = EntityManager.get(prop.with);
           const relatedRow = await db(relatedEntity.table)
             .where("id", relatedId)
             .first();
           if (relatedRow) {
-            await this.createFixtureRecord(
+            const newRecords = await this.createFixtureRecord(
               relatedEntity,
               relatedRow,
-              visitedEntities,
-              records,
-              singleRecord,
-              _db
+              options,
+              visitedEntities
             );
+            records.push(...newRecords);
           }
         }
       }
     }
 
     records.push(record);
+    return records;
   }
 
   async insertFixtures(
     dbName: keyof SonamuDBConfig,
-    fixtures: FixtureRecord[]
+    _fixtures: FixtureRecord[]
   ) {
+    const fixtures = _.uniqBy(_fixtures, (f) => f.fixtureId);
+
     this.buildDependencyGraph(fixtures);
     const insertionOrder = this.getInsertionOrder();
     const db = knex(Sonamu.dbConfig[dbName]);
@@ -447,7 +467,27 @@ export class FixtureManagerClass {
 
       for (const fixtureId of insertionOrder) {
         const fixture = fixtures.find((f) => f.fixtureId === fixtureId)!;
-        await this.insertFixture(trx, fixture);
+        const result = await this.insertFixture(trx, fixture);
+        if (result.id !== fixture.id) {
+          // ID가 변경된 경우, 다른 fixture에서 참조하는 경우가 찾아서 수정
+          console.log(
+            chalk.yellow(
+              `Unique constraint violation: ${fixture.entityId}#${fixture.id} -> ${fixture.entityId}#${result.id}`
+            )
+          );
+          fixtures.forEach((f) => {
+            Object.values(f.columns).forEach((column) => {
+              if (
+                column.prop.type === "relation" &&
+                column.prop.with === result.entityId &&
+                column.value === fixture.id
+              ) {
+                column.value = result.id;
+              }
+            });
+          });
+          fixture.id = result.id;
+        }
       }
 
       for (const fixtureId of insertionOrder) {
@@ -468,7 +508,7 @@ export class FixtureManagerClass {
       });
     }
 
-    return records;
+    return _.uniqBy(records, (r) => `${r.entityId}#${r.data.id}`);
   }
 
   private getInsertionOrder() {
@@ -598,6 +638,14 @@ export class FixtureManagerClass {
     const entity = EntityManager.get(fixture.entityId);
 
     try {
+      const uniqueFound = await this.checkUniqueViolation(db, entity, fixture);
+      if (uniqueFound) {
+        return {
+          entityId: fixture.entityId,
+          id: uniqueFound.id,
+        };
+      }
+
       const found = await db(entity.table).where("id", fixture.id).first();
       if (found && !fixture.override) {
         return {
@@ -688,5 +736,43 @@ export class FixtureManagerClass {
       throw new Error("Failed to find fixtureLoader in fixture.ts");
     }
   }
+
+  // 해당 픽스쳐의 값으로 유니크 제약에 위배되는 레코드가 있는지 확인
+  private async checkUniqueViolation(
+    db: Knex,
+    entity: Entity,
+    fixture: FixtureRecord
+  ) {
+    const uniqueIndexes = entity.indexes.filter((i) => i.type === "unique");
+    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) {
+          const field = column.split("_id")[0];
+
+          if (Array.isArray(fixture.columns[field].value)) {
+            qb.whereIn(column, fixture.columns[field].value);
+          } else {
+            qb.andWhere(column, fixture.columns[field].value);
+          }
+        }
+      });
+    }
+    const [uniqueFound] = await uniqueQuery;
+    return uniqueFound;
+  }
 }
 export const FixtureManager = new FixtureManagerClass();

package/src/types/types.ts

@@ -738,8 +738,9 @@ export type FixtureRecord = {
     };
   };
   fetchedRecords: string[];
-  belongsRecords: string[]; //
-  target?: FixtureRecord; // Import 대상 DB 레코드
+  belongsRecords: string[];
+  target?: FixtureRecord; // Import 대상 DB 레코드(id가 같은)
+  unique?: FixtureRecord; // Import 대상 DB 레코드(unique key가 같은)
   override?: boolean;
 };
 

package/src/utils/utils.ts

@@ -17,19 +17,21 @@ export async function importMultiple(
   filePaths: string[],
   doRefresh: boolean = false
 ): Promise<{ filePath: string; imported: any }[]> {
-  return Promise.all(
-    filePaths.map(async (filePath) => {
-      const importPath = "./" + path.relative(__dirname, filePath);
-      if (doRefresh) {
-        delete require.cache[require.resolve(importPath)];
-      }
-      const imported = await import(importPath);
-      return {
-        filePath,
-        imported,
-      };
-    })
-  );
+  const results: { filePath: string; imported: any }[] = [];
+
+  for (const filePath of filePaths) {
+    const importPath = "./" + path.relative(__dirname, filePath);
+    if (doRefresh) {
+      delete require.cache[require.resolve(importPath)];
+    }
+    const imported = await import(importPath);
+    results.push({
+      filePath,
+      imported,
+    });
+  }
+
+  return results;
 }
 export async function findAppRootPath() {
   const apiRootPath = await findApiRootPath();