sonamu 0.2.46 → 0.2.48

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;
@@ -257,5 +279,414 @@ 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 visitedEntities = new Set<string>();
+    const records: FixtureRecord[] = [];
+    for (const row of rows) {
+      const initialRecordsLength = records.length;
+      await this.createFixtureRecord(entity, row, visitedEntities, records);
+      const currentFixtureRecord = records.find(
+        (r) => r.fixtureId === `${entityId}#${row.id}`
+      );
+
+      if (currentFixtureRecord) {
+        // 현재 fixture로부터 생성된 fetchedRecords 설정
+        currentFixtureRecord.fetchedRecords = records
+          .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();
+      if (row) {
+        await this.createFixtureRecord(
+          entity,
+          row,
+          new Set(),
+          rows,
+          true,
+          targetDB
+        );
+        record.target = rows[0];
+      }
+    }
+
+    return records;
+  }
+
+  async createFixtureRecord(
+    entity: Entity,
+    row: any,
+    visitedEntities: Set<string>,
+    records: FixtureRecord[],
+    singleRecord = false,
+    _db?: Knex
+  ) {
+    const fixtureId = `${entity.id}#${row.id}`;
+    if (visitedEntities.has(fixtureId)) {
+      return;
+    }
+    visitedEntities.add(fixtureId);
+
+    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 = _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 (!singleRecord && relatedId) {
+          const relatedEntity = EntityManager.get(prop.with);
+          const relatedRow = await db(relatedEntity.table)
+            .where("id", relatedId)
+            .first();
+          if (relatedRow) {
+            await this.createFixtureRecord(
+              relatedEntity,
+              relatedRow,
+              visitedEntities,
+              records,
+              singleRecord,
+              _db
+            );
+          }
+        }
+      }
+    }
+
+    records.push(record);
+  }
+
+  async insertFixtures(
+    dbName: keyof SonamuDBConfig,
+    fixtures: FixtureRecord[]
+  ) {
+    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)!;
+        await this.insertFixture(trx, fixture);
+      }
+
+      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 records;
+  }
+
+  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 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");
+    }
+  }
 }
 export const FixtureManager = new FixtureManagerClass();

package/src/types/types.ts

@@ -617,6 +617,10 @@ export const TemplateOptions = z.object({
     parentId: z.string().optional(),
     title: z.string(),
     table: z.string().optional(),
+    props: z.array(z.object({})).optional(),
+    indexes: z.array(z.object({})).optional(),
+    subsets: z.object({}).optional(),
+    enums: z.object({}).optional(),
   }),
   init_types: z.object({
     entityId: z.string(),
@@ -715,3 +719,33 @@ 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 레코드
+  override?: boolean;
+};
+
+export type FixtureImportResult = {
+  entityId: string;
+  data: {
+    [key: string]: any;
+  };
+};