sonamu 0.2.47 → 0.2.49

package/src/testing/fixture-manager.ts

@@ -5,9 +5,22 @@ import { Sonamu } from "../api";
 import { BaseModel } from "../database/base-model";
 import { EntityManager } from "../entity/entity-manager";
 import {
+  EntityProp,
+  FixtureImportResult,
+  FixtureRecord,
+  FixtureSearchOptions,
+  ManyToManyRelationProp,
   isBelongsToOneRelationProp,
+  isHasManyRelationProp,
+  isManyToManyRelationProp,
   isOneToOneRelationProp,
+  isRelationProp,
+  isVirtualProp,
 } from "../types/types";
+import { Entity } from "../entity/entity";
+import inflection from "inflection";
+import { SonamuDBConfig } from "../database/db";
+import { readFileSync, writeFileSync } from "fs";
 
 export class FixtureManagerClass {
   private _tdb: Knex | null = null;
@@ -32,6 +45,15 @@ export class FixtureManagerClass {
     return this._fdb;
   }
 
+  private dependencyGraph: Map<
+    string,
+    {
+      fixtureId: string;
+      entityId: string;
+      dependencies: Set<string>;
+    }
+  > = new Map();
+
   init() {
     if (this._tdb !== null) {
       return;
@@ -136,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(
@@ -257,5 +283,496 @@ export class FixtureManagerClass {
     }
     await BaseModel.destroy();
   }
+
+  async getFixtures(
+    sourceDBName: keyof SonamuDBConfig,
+    targetDBName: keyof SonamuDBConfig,
+    searchOptions: FixtureSearchOptions
+  ) {
+    const sourceDB = knex(Sonamu.dbConfig[sourceDBName]);
+    const targetDB = knex(Sonamu.dbConfig[targetDBName]);
+    const { entityId, field, value, searchType } = searchOptions;
+
+    const entity = EntityManager.get(entityId);
+    const column =
+      entity.props.find((prop) => prop.name === field)?.type === "relation"
+        ? `${field}_id`
+        : field;
+
+    let query = sourceDB(entity.table);
+    if (searchType === "equals") {
+      query = query.where(column, value);
+    } else if (searchType === "like") {
+      query = query.where(column, "like", `%${value}%`);
+    }
+
+    const rows = await query;
+    if (rows.length === 0) {
+      throw new Error("No records found");
+    }
+
+    const fixtures: FixtureRecord[] = [];
+    for (const row of rows) {
+      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 = fixtures
+          .filter((r) => r.fixtureId !== currentFixtureRecord.fixtureId)
+          .slice(initialRecordsLength)
+          .map((r) => r.fixtureId);
+      }
+    }
+
+    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) {
+        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 fixtures;
+  }
+
+  async createFixtureRecord(
+    entity: Entity,
+    row: any,
+    options?: {
+      singleRecord?: boolean;
+      _db?: Knex;
+    },
+    visitedEntities = new Set<string>()
+  ): Promise<FixtureRecord[]> {
+    const fixtureId = `${entity.id}#${row.id}`;
+    if (visitedEntities.has(fixtureId)) {
+      return [];
+    }
+    visitedEntities.add(fixtureId);
+
+    const records: FixtureRecord[] = [];
+    const record: FixtureRecord = {
+      fixtureId,
+      entityId: entity.id,
+      id: row.id,
+      columns: {},
+      fetchedRecords: [],
+      belongsRecords: [],
+    };
+
+    for (const prop of entity.props) {
+      if (isVirtualProp(prop)) {
+        continue;
+      }
+
+      record.columns[prop.name] = {
+        prop: prop,
+        value: row[prop.name],
+      };
+
+      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;
+        }
+      } 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(relatedEntity.table)
+            .where("id", relatedId)
+            .first();
+          if (relatedRow) {
+            const newRecords = await this.createFixtureRecord(
+              relatedEntity,
+              relatedRow,
+              options,
+              visitedEntities
+            );
+            records.push(...newRecords);
+          }
+        }
+      }
+    }
+
+    records.push(record);
+    return records;
+  }
+
+  async insertFixtures(
+    dbName: keyof SonamuDBConfig,
+    _fixtures: FixtureRecord[]
+  ) {
+    const fixtures = _.uniqBy(_fixtures, (f) => f.fixtureId);
+
+    this.buildDependencyGraph(fixtures);
+    const insertionOrder = this.getInsertionOrder();
+    const db = knex(Sonamu.dbConfig[dbName]);
+
+    await db.transaction(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);
+        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) {
+        const fixture = fixtures.find((f) => f.fixtureId === fixtureId)!;
+        await this.handleManyToManyRelations(trx, fixture, fixtures);
+      }
+      await trx.raw(`SET FOREIGN_KEY_CHECKS = 1`);
+    });
+
+    const records: FixtureImportResult[] = [];
+
+    for await (const r of fixtures) {
+      const entity = EntityManager.get(r.entityId);
+      const record = await db(entity.table).where("id", r.id).first();
+      records.push({
+        entityId: r.entityId,
+        data: record,
+      });
+    }
+
+    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)) {
+      if (isVirtualProp(column.prop)) {
+        continue;
+      }
+
+      const prop = column.prop as EntityProp;
+      if (!isRelationProp(prop)) {
+        if (prop.type === "json") {
+          insertData[propName] = JSON.stringify(column.value);
+        } else {
+          insertData[propName] = column.value;
+        }
+      } else if (
+        isBelongsToOneRelationProp(prop) ||
+        (isOneToOneRelationProp(prop) && prop.hasJoinColumn)
+      ) {
+        insertData[`${propName}_id`] = column.value;
+      }
+    }
+    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) {
+    const insertData = this.prepareInsertData(fixture);
+    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 {
+          entityId: fixture.entityId,
+          id: found.id,
+        };
+      }
+
+      const q = db.insert(insertData).into(entity.table);
+      await q.onDuplicateUpdate.apply(q, Object.keys(insertData));
+      return {
+        entityId: fixture.entityId,
+        id: fixture.id,
+      };
+    } catch (err) {
+      console.log(err);
+      throw err;
+    }
+  }
+
+  private async handleManyToManyRelations(
+    db: Knex,
+    fixture: FixtureRecord,
+    fixtures: FixtureRecord[]
+  ) {
+    for (const [, column] of Object.entries(fixture.columns)) {
+      const prop = column.prop as EntityProp;
+      if (isManyToManyRelationProp(prop)) {
+        const joinTable = (prop as ManyToManyRelationProp).joinTable;
+        const relatedIds = column.value as number[];
+
+        for (const relatedId of relatedIds) {
+          if (
+            !fixtures.find((f) => f.fixtureId === `${prop.with}#${relatedId}`)
+          ) {
+            continue;
+          }
+
+          const entity = EntityManager.get(fixture.entityId);
+          const relatedEntity = EntityManager.get(prop.with);
+          if (!entity || !relatedEntity) {
+            throw new Error(
+              `Entity not found: ${fixture.entityId}, ${prop.with}`
+            );
+          }
+
+          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(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}`
+            )
+          );
+        }
+      }
+    }
+  }
+
+  async addFixtureLoader(code: string) {
+    const path = Sonamu.apiRootPath + "/src/testing/fixture.ts";
+    let content = readFileSync(path).toString();
+
+    const fixtureLoaderStart = content.indexOf("const fixtureLoader = {");
+    const fixtureLoaderEnd = content.indexOf("};", fixtureLoaderStart);
+
+    if (fixtureLoaderStart !== -1 && fixtureLoaderEnd !== -1) {
+      const newContent =
+        content.slice(0, fixtureLoaderEnd) +
+        "  " +
+        code +
+        "\n" +
+        content.slice(fixtureLoaderEnd);
+
+      writeFileSync(path, newContent);
+    } else {
+      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

@@ -719,3 +719,34 @@ export const PathAndCode = z.object({
   code: z.string(),
 });
 export type PathAndCode = z.infer<typeof PathAndCode>;
+
+export type FixtureSearchOptions = {
+  entityId: string;
+  field: string;
+  value: string;
+  searchType: "equals" | "like";
+};
+
+export type FixtureRecord = {
+  fixtureId: string;
+  entityId: string;
+  id: number;
+  columns: {
+    [key: string]: {
+      prop: EntityProp;
+      value: any;
+    };
+  };
+  fetchedRecords: string[];
+  belongsRecords: string[];
+  target?: FixtureRecord; // Import 대상 DB 레코드(id가 같은)
+  unique?: FixtureRecord; // Import 대상 DB 레코드(unique key가 같은)
+  override?: boolean;
+};
+
+export type FixtureImportResult = {
+  entityId: string;
+  data: {
+    [key: string]: any;
+  };
+};

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();