sonamu 0.7.53 → 0.8.0

package/dist/testing/data-explorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-explorer.d.ts","sourceRoot":"","sources":["../../src/testing/data-explorer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AACjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAG9D,MAAM,MAAM,oBAAoB,GAAG,QAAQ,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE7F,+CAA+C;AAC/C,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC;AAEnG,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4BAA4B;IAC5B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,8BAA8B;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,mBAAmB,GAAG;IAC9D,+BAA+B;IAC/B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,2BAA2B;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,oBAAoB;IACpB,IAAI,EAAE;QACJ,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;KACpC,CAAC;IACF,0CAA0C;IAC1C,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;CACjD,CAAC;AAGF,qBAAa,YAAY;IAIrB,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,aAAa;IAJvB,OAAO,CAAC,KAAK,CAAC,CAAe;gBAGnB,EAAE,EAAE,IAAI,EACR,aAAa,EAAE,OAAO,aAAa,EAC3C,YAAY,CAAC,EAAE,YAAY;IAKvB,OAAO,CACX,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;YAmBvB,eAAe;YAsDf,UAAU;YAqCV,YAAY;IAO1B,OAAO,CAAC,mBAAmB;YAKb,YAAY;IA8BpB,eAAe,CACnB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,OAAO,CAAC,mBAAmB,CAAC,GACrC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAuBrC;;OAEG;IACG,gBAAgB,CACpB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EAAE,EACvB,OAAO,CAAC,EAAE,OAAO,CAAC,mBAAmB,CAAC,GACrC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;IAWrD,OAAO,CAAC,gBAAgB;IAoBxB;;;OAGG;IACG,oBAAoB,CACxB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,0BAA0B,CAAC;IA6BtC;;OAEG;YACW,kBAAkB;CAkHjC"}

package/dist/testing/data-explorer.js

@@ -0,0 +1,274 @@
+import { isBelongsToOneRelationProp, isOneToOneRelationProp, isRelationProp } from "../types/types.js";
+// 기존 DB 데이터를 탐색하여 fixture 생성 시 참조할 수 있는 시스템
+export class DataExplorer {
+    db;
+    entityManager;
+    cache;
+    constructor(db, entityManager, cacheManager){
+        this.db = db;
+        this.entityManager = entityManager;
+        this.cache = cacheManager;
+    }
+    async explore(entityName, options) {
+        const entity = this.entityManager.get(entityName);
+        if (!entity) {
+            throw new Error(`Entity not found: ${entityName}`);
+        }
+        // 캐싱 지원
+        if (options.useCache && this.cache) {
+            const cacheKey = this.generateCacheKey(entityName, options);
+            return this.cache.getOrSet({
+                key: cacheKey,
+                ttl: options.cacheTtl || 300,
+                factory: ()=>this.exploreInternal(entity, options)
+            });
+        }
+        return this.exploreInternal(entity, options);
+    }
+    async exploreInternal(entity, options) {
+        const query = this.db(entity.table);
+        switch(options.strategy){
+            case "sample":
+                return await this.sampleData(query, options.limit || 10);
+            case "recent":
+                {
+                    const createdAtCol = this.findTimestampColumn(entity, "created_at");
+                    if (createdAtCol) {
+                        query.orderBy(createdAtCol, "desc");
+                    }
+                    return await query.limit(options.limit || 10);
+                }
+            case "random":
+                return await this.randomSample(query, options.limit || 10);
+            case "ids":
+                if (options.ids && options.ids.length > 0) {
+                    query.whereIn("id", options.ids);
+                }
+                return await query;
+            case "query":
+                if (options.where) {
+                    query.where(options.where);
+                }
+                if (options.orderBy) {
+                    const [col, dir = "asc"] = options.orderBy.split(":");
+                    // id 컬럼은 숫자로 캐스팅하여 정렬합니다 (문자열 정렬 방지)
+                    if (col === "id") {
+                        query.orderByRaw(`CAST(?? AS INTEGER) ${dir}`, [
+                            col
+                        ]);
+                    } else {
+                        query.orderBy(col, dir);
+                    }
+                }
+                return await query.limit(options.limit || 10);
+            case "file":
+                if (!options.filePath) {
+                    throw new Error("filePath is required for file strategy");
+                }
+                return this.loadFromFile(options.filePath);
+            default:
+                throw new Error(`Unknown strategy: ${options.strategy}`);
+        }
+    }
+    // 균등 샘플링 (PostgreSQL ROW_NUMBER 사용)
+    async sampleData(query, limit) {
+        const [{ count }] = await query.clone().count("* as count");
+        const total = Number(count);
+        if (total <= limit) {
+            return await query.limit(limit);
+        }
+        // 균등 간격 계산
+        const interval = Math.floor(total / limit);
+        // 테이블명 추출
+        const tableName = query.toString().match(/from\s+"?(\w+)"?/i)?.[1];
+        if (!tableName) {
+            throw new Error("Could not extract table name from query");
+        }
+        // ROW_NUMBER()로 한 번에 균등 샘플링 (단일 쿼리)
+        const result = await this.db.raw(`
+      WITH numbered_rows AS (
+        SELECT *, ROW_NUMBER() OVER (ORDER BY id) as rn
+        FROM ??
+      )
+      SELECT * FROM numbered_rows
+      WHERE MOD(rn - 1, ?) = 0
+      LIMIT ?
+    `, [
+            tableName,
+            interval,
+            limit
+        ]);
+        return result.rows;
+    }
+    async randomSample(query, limit) {
+        return await query.orderByRaw("RANDOM()").limit(limit);
+    }
+    findTimestampColumn(entity, columnName) {
+        const prop = entity.props.find((p)=>p.name === columnName);
+        return prop?.name || null;
+    }
+    async loadFromFile(filePath) {
+        const fs = await import("node:fs/promises");
+        const content = await fs.readFile(filePath, "utf-8");
+        if (filePath.endsWith(".json")) {
+            const parsed = JSON.parse(content);
+            if (!Array.isArray(parsed)) {
+                throw new Error("JSON file must contain an array");
+            }
+            return parsed;
+        } else if (filePath.endsWith(".csv")) {
+            const lines = content.split("\n").filter((line)=>line.trim());
+            if (lines.length === 0) return [];
+            const headers = lines[0].split(",").map((h)=>h.trim());
+            return lines.slice(1).map((line)=>{
+                const values = line.split(",");
+                return headers.reduce((obj, header, i)=>{
+                    obj[header] = values[i]?.trim();
+                    return obj;
+                }, {});
+            });
+        }
+        throw new Error(`Unsupported file format: ${filePath}`);
+    }
+    async exploreRelation(entityName, relationProp, options) {
+        const entity = this.entityManager.get(entityName);
+        const prop = entity.props.find((p)=>p.name === relationProp);
+        if (!prop || !isRelationProp(prop)) {
+            throw new Error(`Relation property not found: ${entityName}.${relationProp}`);
+        }
+        const dataSource = prop.cone?.dataSource;
+        const strategy = dataSource?.strategy || options?.strategy || "sample";
+        const config = dataSource?.config && typeof dataSource.config === "object" ? dataSource.config : {};
+        return this.explore(prop.with, {
+            strategy,
+            limit: options?.limit || (typeof config.limit === "number" ? config.limit : 10),
+            ...typeof config === "object" ? config : {},
+            ...options
+        });
+    }
+    /**
+   * 여러 relation을 병렬로 조회합니다 (N+1 문제 해결)
+   */ async exploreRelations(entityName, relationProps, options) {
+        const results = await Promise.all(relationProps.map(async (prop)=>{
+            const data = await this.exploreRelation(entityName, prop, options);
+            return [
+                prop,
+                data
+            ];
+        }));
+        return Object.fromEntries(results);
+    }
+    generateCacheKey(entityName, options) {
+        const parts = [
+            `DataExplorer:${entityName}`,
+            options.strategy,
+            options.limit?.toString() || "default"
+        ];
+        if (options.where) {
+            parts.push(JSON.stringify(options.where));
+        }
+        if (options.orderBy) {
+            parts.push(options.orderBy);
+        }
+        if (options.ids) {
+            parts.push(options.ids.join(","));
+        }
+        return parts.join(":");
+    }
+    /**
+   * Entity와 관련된 데이터를 재귀적으로 탐색합니다.
+   * BelongsToOne, OneToOne(hasJoinColumn) relation을 따라가며 참조 데이터를 수집합니다.
+   */ async exploreWithRelations(entityName, options) {
+        const includeRelations = options.includeRelations ?? true;
+        const maxDepth = options.maxDepth ?? 2;
+        // 메인 entity 조회
+        const mainRecords = await this.explore(entityName, options);
+        const result = {
+            main: {
+                entityId: entityName,
+                records: mainRecords
+            },
+            related: new Map()
+        };
+        // 관련 데이터 수집하지 않으면 바로 리턴
+        if (!includeRelations || maxDepth <= 0) {
+            return result;
+        }
+        // 이미 조회한 entity 추적 (중복 방지)
+        const visited = new Set([
+            entityName
+        ]);
+        // 재귀적으로 관련 데이터 수집
+        await this.collectRelatedData(entityName, mainRecords, result.related, visited, maxDepth);
+        return result;
+    }
+    /**
+   * 관련 데이터를 재귀적으로 수집합니다 (private helper)
+   */ async collectRelatedData(entityName, records, relatedMap, visited, remainingDepth) {
+        if (remainingDepth <= 0 || records.length === 0) {
+            return;
+        }
+        const entity = this.entityManager.get(entityName);
+        const recordIds = records.map((r)=>r.id).filter((id)=>id != null);
+        // 1. Forward references: 이 entity가 참조하는 다른 entity
+        const forwardRelationProps = entity.props.filter((prop)=>isRelationProp(prop) && (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop) && prop.hasJoinColumn));
+        for (const prop of forwardRelationProps){
+            if (!isRelationProp(prop)) continue;
+            const targetEntityName = prop.with;
+            // 이미 조회한 entity는 스킵 (순환 참조 방지)
+            if (visited.has(targetEntityName)) {
+                continue;
+            }
+            // 참조하는 ID들 수집
+            const foreignKeyName = `${prop.name}_id`;
+            const referencedIds = records.map((record)=>record[foreignKeyName]).filter((id)=>id != null);
+            if (referencedIds.length === 0) {
+                continue;
+            }
+            // 중복 제거
+            const uniqueIds = [
+                ...new Set(referencedIds)
+            ];
+            // 참조 데이터 조회
+            const referencedRecords = await this.explore(targetEntityName, {
+                strategy: "ids",
+                ids: uniqueIds
+            });
+            // 결과에 추가
+            relatedMap.set(targetEntityName, referencedRecords);
+            visited.add(targetEntityName);
+            // 재귀: 참조된 데이터의 관련 데이터도 수집
+            await this.collectRelatedData(targetEntityName, referencedRecords, relatedMap, visited, remainingDepth - 1);
+        }
+        // 2. Backward references: 이 entity를 참조하는 다른 entity
+        // 모든 entity를 순회하며 현재 entity를 참조하는 relation 찾기
+        const allEntities = this.entityManager.getAllEntities();
+        for (const otherEntity of allEntities){
+            const otherEntityName = otherEntity.id;
+            // 이미 조회했거나 자기 자신이면 스킵
+            if (visited.has(otherEntityName) || otherEntityName === entityName) {
+                continue;
+            }
+            // 현재 entity를 참조하는 relation prop 찾기
+            const backwardRelations = otherEntity.props.filter((prop)=>isRelationProp(prop) && prop.with === entityName && (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop) && prop.hasJoinColumn));
+            for (const prop of backwardRelations){
+                if (!isRelationProp(prop)) continue;
+                // otherEntity가 현재 entity를 참조하는 FK 컬럼
+                const foreignKeyName = `${prop.name}_id`;
+                // 현재 레코드들을 참조하는 otherEntity 레코드 조회
+                const query = this.db(otherEntity.table).whereIn(foreignKeyName, recordIds);
+                const backwardRecords = await query;
+                if (backwardRecords.length === 0) {
+                    continue;
+                }
+                // 결과에 추가
+                relatedMap.set(otherEntityName, backwardRecords);
+                visited.add(otherEntityName);
+                // 재귀: 역참조 데이터의 관련 데이터도 수집
+                await this.collectRelatedData(otherEntityName, backwardRecords, relatedMap, visited, remainingDepth - 1);
+            }
+        }
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/testing/data-explorer.ts"],"sourcesContent":["import type { Knex } from \"knex\";\nimport type { CacheManager } from \"../cache/types\";\nimport type { Entity } from \"../entity/entity\";\nimport type { EntityManager } from \"../entity/entity-manager\";\nimport { isBelongsToOneRelationProp, isOneToOneRelationProp, isRelationProp } from \"../types/types\";\n\nexport type DataExplorerStrategy = \"sample\" | \"ids\" | \"query\" | \"file\" | \"recent\" | \"random\";\n\n/** WHERE 조건 타입 (객체 또는 Knex QueryBuilder 함수) */\nexport type WhereCondition = Record<string, unknown> | ((queryBuilder: Knex.QueryBuilder) => void);\n\nexport type DataExplorerOptions = {\n  strategy: DataExplorerStrategy;\n  limit?: number;\n  where?: WhereCondition;\n  orderBy?: string;\n  ids?: number[];\n  filePath?: string;\n  /** 캐싱 사용 여부 (기본값: false) */\n  useCache?: boolean;\n  /** 캐시 TTL (초 단위, 기본값: 300) */\n  cacheTtl?: number;\n};\n\nexport type ExploreWithRelationsOptions = DataExplorerOptions & {\n  /** 관련 데이터 포함 여부 (기본값: true) */\n  includeRelations?: boolean;\n  /** 재귀 탐색 최대 깊이 (기본값: 2) */\n  maxDepth?: number;\n};\n\nexport type ExploreWithRelationsResult = {\n  /** 메인 entity 데이터 */\n  main: {\n    entityId: string;\n    records: Record<string, unknown>[];\n  };\n  /** 관련 entity 데이터 (entityId -> records) */\n  related: Map<string, Record<string, unknown>[]>;\n};\n\n// 기존 DB 데이터를 탐색하여 fixture 생성 시 참조할 수 있는 시스템\nexport class DataExplorer {\n  private cache?: CacheManager;\n\n  constructor(\n    private db: Knex,\n    private entityManager: typeof EntityManager,\n    cacheManager?: CacheManager,\n  ) {\n    this.cache = cacheManager;\n  }\n\n  async explore(\n    entityName: string,\n    options: DataExplorerOptions,\n  ): Promise<Record<string, unknown>[]> {\n    const entity = this.entityManager.get(entityName);\n    if (!entity) {\n      throw new Error(`Entity not found: ${entityName}`);\n    }\n\n    // 캐싱 지원\n    if (options.useCache && this.cache) {\n      const cacheKey = this.generateCacheKey(entityName, options);\n      return this.cache.getOrSet({\n        key: cacheKey,\n        ttl: options.cacheTtl || 300,\n        factory: () => this.exploreInternal(entity, options),\n      });\n    }\n\n    return this.exploreInternal(entity, options);\n  }\n\n  private async exploreInternal(\n    entity: Entity,\n    options: DataExplorerOptions,\n  ): Promise<Record<string, unknown>[]> {\n    const query = this.db(entity.table);\n\n    switch (options.strategy) {\n      case \"sample\":\n        return await this.sampleData(query, options.limit || 10);\n\n      case \"recent\": {\n        const createdAtCol = this.findTimestampColumn(entity, \"created_at\");\n        if (createdAtCol) {\n          query.orderBy(createdAtCol, \"desc\");\n        }\n        return await query.limit(options.limit || 10);\n      }\n\n      case \"random\":\n        return await this.randomSample(query, options.limit || 10);\n\n      case \"ids\":\n        if (options.ids && options.ids.length > 0) {\n          query.whereIn(\"id\", options.ids);\n        }\n        return await query;\n\n      case \"query\":\n        if (options.where) {\n          query.where(options.where);\n        }\n        if (options.orderBy) {\n          const [col, dir = \"asc\"] = options.orderBy.split(\":\");\n          // id 컬럼은 숫자로 캐스팅하여 정렬합니다 (문자열 정렬 방지)\n          if (col === \"id\") {\n            query.orderByRaw(`CAST(?? AS INTEGER) ${dir}`, [col]);\n          } else {\n            query.orderBy(col, dir as \"asc\" | \"desc\");\n          }\n        }\n        return await query.limit(options.limit || 10);\n\n      case \"file\":\n        if (!options.filePath) {\n          throw new Error(\"filePath is required for file strategy\");\n        }\n        return this.loadFromFile(options.filePath);\n\n      default:\n        throw new Error(`Unknown strategy: ${options.strategy}`);\n    }\n  }\n\n  // 균등 샘플링 (PostgreSQL ROW_NUMBER 사용)\n  private async sampleData(\n    query: Knex.QueryBuilder,\n    limit: number,\n  ): Promise<Record<string, unknown>[]> {\n    const [{ count }] = await query.clone().count(\"* as count\");\n    const total = Number(count);\n\n    if (total <= limit) {\n      return await query.limit(limit);\n    }\n\n    // 균등 간격 계산\n    const interval = Math.floor(total / limit);\n\n    // 테이블명 추출\n    const tableName = query.toString().match(/from\\s+\"?(\\w+)\"?/i)?.[1];\n    if (!tableName) {\n      throw new Error(\"Could not extract table name from query\");\n    }\n\n    // ROW_NUMBER()로 한 번에 균등 샘플링 (단일 쿼리)\n    const result = await this.db.raw(\n      `\n      WITH numbered_rows AS (\n        SELECT *, ROW_NUMBER() OVER (ORDER BY id) as rn\n        FROM ??\n      )\n      SELECT * FROM numbered_rows\n      WHERE MOD(rn - 1, ?) = 0\n      LIMIT ?\n    `,\n      [tableName, interval, limit],\n    );\n\n    return result.rows;\n  }\n\n  private async randomSample(\n    query: Knex.QueryBuilder,\n    limit: number,\n  ): Promise<Record<string, unknown>[]> {\n    return await query.orderByRaw(\"RANDOM()\").limit(limit);\n  }\n\n  private findTimestampColumn(entity: Entity, columnName: string): string | null {\n    const prop = entity.props.find((p) => p.name === columnName);\n    return prop?.name || null;\n  }\n\n  private async loadFromFile(filePath: string): Promise<Record<string, unknown>[]> {\n    const fs = await import(\"fs/promises\");\n    const content = await fs.readFile(filePath, \"utf-8\");\n\n    if (filePath.endsWith(\".json\")) {\n      const parsed = JSON.parse(content);\n      if (!Array.isArray(parsed)) {\n        throw new Error(\"JSON file must contain an array\");\n      }\n      return parsed as Record<string, unknown>[];\n    } else if (filePath.endsWith(\".csv\")) {\n      const lines = content.split(\"\\n\").filter((line) => line.trim());\n      if (lines.length === 0) return [];\n\n      const headers = lines[0].split(\",\").map((h) => h.trim());\n      return lines.slice(1).map((line) => {\n        const values = line.split(\",\");\n        return headers.reduce(\n          (obj: Record<string, unknown>, header: string, i: number) => {\n            obj[header] = values[i]?.trim();\n            return obj;\n          },\n          {} as Record<string, unknown>,\n        );\n      });\n    }\n\n    throw new Error(`Unsupported file format: ${filePath}`);\n  }\n\n  async exploreRelation(\n    entityName: string,\n    relationProp: string,\n    options?: Partial<DataExplorerOptions>,\n  ): Promise<Record<string, unknown>[]> {\n    const entity = this.entityManager.get(entityName);\n    const prop = entity.props.find((p) => p.name === relationProp);\n\n    if (!prop || !isRelationProp(prop)) {\n      throw new Error(`Relation property not found: ${entityName}.${relationProp}`);\n    }\n\n    const dataSource = prop.cone?.dataSource;\n    const strategy = dataSource?.strategy || options?.strategy || \"sample\";\n    const config =\n      dataSource?.config && typeof dataSource.config === \"object\"\n        ? (dataSource.config as Record<string, unknown>)\n        : {};\n\n    return this.explore(prop.with, {\n      strategy,\n      limit: options?.limit || (typeof config.limit === \"number\" ? config.limit : 10),\n      ...(typeof config === \"object\" ? config : {}),\n      ...options,\n    });\n  }\n\n  /**\n   * 여러 relation을 병렬로 조회합니다 (N+1 문제 해결)\n   */\n  async exploreRelations(\n    entityName: string,\n    relationProps: string[],\n    options?: Partial<DataExplorerOptions>,\n  ): Promise<Record<string, Record<string, unknown>[]>> {\n    const results = await Promise.all(\n      relationProps.map(async (prop) => {\n        const data = await this.exploreRelation(entityName, prop, options);\n        return [prop, data] as const;\n      }),\n    );\n\n    return Object.fromEntries(results);\n  }\n\n  private generateCacheKey(entityName: string, options: DataExplorerOptions): string {\n    const parts = [\n      `DataExplorer:${entityName}`,\n      options.strategy,\n      options.limit?.toString() || \"default\",\n    ];\n\n    if (options.where) {\n      parts.push(JSON.stringify(options.where));\n    }\n    if (options.orderBy) {\n      parts.push(options.orderBy);\n    }\n    if (options.ids) {\n      parts.push(options.ids.join(\",\"));\n    }\n\n    return parts.join(\":\");\n  }\n\n  /**\n   * Entity와 관련된 데이터를 재귀적으로 탐색합니다.\n   * BelongsToOne, OneToOne(hasJoinColumn) relation을 따라가며 참조 데이터를 수집합니다.\n   */\n  async exploreWithRelations(\n    entityName: string,\n    options: ExploreWithRelationsOptions,\n  ): Promise<ExploreWithRelationsResult> {\n    const includeRelations = options.includeRelations ?? true;\n    const maxDepth = options.maxDepth ?? 2;\n\n    // 메인 entity 조회\n    const mainRecords = await this.explore(entityName, options);\n\n    const result: ExploreWithRelationsResult = {\n      main: {\n        entityId: entityName,\n        records: mainRecords,\n      },\n      related: new Map(),\n    };\n\n    // 관련 데이터 수집하지 않으면 바로 리턴\n    if (!includeRelations || maxDepth <= 0) {\n      return result;\n    }\n\n    // 이미 조회한 entity 추적 (중복 방지)\n    const visited = new Set<string>([entityName]);\n\n    // 재귀적으로 관련 데이터 수집\n    await this.collectRelatedData(entityName, mainRecords, result.related, visited, maxDepth);\n\n    return result;\n  }\n\n  /**\n   * 관련 데이터를 재귀적으로 수집합니다 (private helper)\n   */\n  private async collectRelatedData(\n    entityName: string,\n    records: Record<string, unknown>[],\n    relatedMap: Map<string, Record<string, unknown>[]>,\n    visited: Set<string>,\n    remainingDepth: number,\n  ): Promise<void> {\n    if (remainingDepth <= 0 || records.length === 0) {\n      return;\n    }\n\n    const entity = this.entityManager.get(entityName);\n    const recordIds = records.map((r) => r.id).filter((id) => id != null);\n\n    // 1. Forward references: 이 entity가 참조하는 다른 entity\n    const forwardRelationProps = entity.props.filter(\n      (prop) =>\n        isRelationProp(prop) &&\n        (isBelongsToOneRelationProp(prop) || (isOneToOneRelationProp(prop) && prop.hasJoinColumn)),\n    );\n\n    for (const prop of forwardRelationProps) {\n      if (!isRelationProp(prop)) continue;\n\n      const targetEntityName = prop.with;\n\n      // 이미 조회한 entity는 스킵 (순환 참조 방지)\n      if (visited.has(targetEntityName)) {\n        continue;\n      }\n\n      // 참조하는 ID들 수집\n      const foreignKeyName = `${prop.name}_id`;\n      const referencedIds = records\n        .map((record) => record[foreignKeyName])\n        .filter((id) => id != null) as number[];\n\n      if (referencedIds.length === 0) {\n        continue;\n      }\n\n      // 중복 제거\n      const uniqueIds = [...new Set(referencedIds)];\n\n      // 참조 데이터 조회\n      const referencedRecords = await this.explore(targetEntityName, {\n        strategy: \"ids\",\n        ids: uniqueIds,\n      });\n\n      // 결과에 추가\n      relatedMap.set(targetEntityName, referencedRecords);\n      visited.add(targetEntityName);\n\n      // 재귀: 참조된 데이터의 관련 데이터도 수집\n      await this.collectRelatedData(\n        targetEntityName,\n        referencedRecords,\n        relatedMap,\n        visited,\n        remainingDepth - 1,\n      );\n    }\n\n    // 2. Backward references: 이 entity를 참조하는 다른 entity\n    // 모든 entity를 순회하며 현재 entity를 참조하는 relation 찾기\n    const allEntities = this.entityManager.getAllEntities();\n\n    for (const otherEntity of allEntities) {\n      const otherEntityName = otherEntity.id;\n\n      // 이미 조회했거나 자기 자신이면 스킵\n      if (visited.has(otherEntityName) || otherEntityName === entityName) {\n        continue;\n      }\n\n      // 현재 entity를 참조하는 relation prop 찾기\n      const backwardRelations = otherEntity.props.filter(\n        (prop) =>\n          isRelationProp(prop) &&\n          prop.with === entityName &&\n          (isBelongsToOneRelationProp(prop) ||\n            (isOneToOneRelationProp(prop) && prop.hasJoinColumn)),\n      );\n\n      for (const prop of backwardRelations) {\n        if (!isRelationProp(prop)) continue;\n\n        // otherEntity가 현재 entity를 참조하는 FK 컬럼\n        const foreignKeyName = `${prop.name}_id`;\n\n        // 현재 레코드들을 참조하는 otherEntity 레코드 조회\n        const query = this.db(otherEntity.table).whereIn(foreignKeyName, recordIds);\n        const backwardRecords = await query;\n\n        if (backwardRecords.length === 0) {\n          continue;\n        }\n\n        // 결과에 추가\n        relatedMap.set(otherEntityName, backwardRecords);\n        visited.add(otherEntityName);\n\n        // 재귀: 역참조 데이터의 관련 데이터도 수집\n        await this.collectRelatedData(\n          otherEntityName,\n          backwardRecords,\n          relatedMap,\n          visited,\n          remainingDepth - 1,\n        );\n      }\n    }\n  }\n}\n"],"names":["isBelongsToOneRelationProp","isOneToOneRelationProp","isRelationProp","DataExplorer","cache","db","entityManager","cacheManager","explore","entityName","options","entity","get","Error","useCache","cacheKey","generateCacheKey","getOrSet","key","ttl","cacheTtl","factory","exploreInternal","query","table","strategy","sampleData","limit","createdAtCol","findTimestampColumn","orderBy","randomSample","ids","length","whereIn","where","col","dir","split","orderByRaw","filePath","loadFromFile","count","clone","total","Number","interval","Math","floor","tableName","toString","match","result","raw","rows","columnName","prop","props","find","p","name","fs","content","readFile","endsWith","parsed","JSON","parse","Array","isArray","lines","filter","line","trim","headers","map","h","slice","values","reduce","obj","header","i","exploreRelation","relationProp","dataSource","cone","config","with","exploreRelations","relationProps","results","Promise","all","data","Object","fromEntries","parts","push","stringify","join","exploreWithRelations","includeRelations","maxDepth","mainRecords","main","entityId","records","related","Map","visited","Set","collectRelatedData","relatedMap","remainingDepth","recordIds","r","id","forwardRelationProps","hasJoinColumn","targetEntityName","has","foreignKeyName","referencedIds","record","uniqueIds","referencedRecords","set","add","allEntities","getAllEntities","otherEntity","otherEntityName","backwardRelations","backwardRecords"],"mappings":"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"}

package/dist/testing/faker-mappings.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Fixture 생성 시 사용할 Faker 매핑 테이블입니다.
+ *
+ * 필드명이나 타입에 따라 적절한 Faker 함수를 선택하여,
+ * 현실적이고 의미있는 테스트 데이터를 생성하기 위함입니다.
+ *
+ * 예: salary 필드는 0~1000이 아닌 30M~150M 범위로 생성
+ */
+export type FakerMappingConfig = {
+    faker: string;
+    comment?: string;
+};
+export type FakerMappings = {
+    [locale: string]: {
+        field_patterns: Record<string, FakerMappingConfig>;
+        type_defaults: Record<string, FakerMappingConfig>;
+    };
+};
+export declare const fakerMappings: FakerMappings;
+//# sourceMappingURL=faker-mappings.d.ts.map

package/dist/testing/faker-mappings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"faker-mappings.d.ts","sourceRoot":"","sources":["../../src/testing/faker-mappings.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,MAAM,EAAE,MAAM,GAAG;QAChB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;QACnD,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;KACnD,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,aA6Z3B,CAAC"}