sonamu 0.8.26 → 0.9.0

package/dist/testing/data-explorer.js

@@ -1,91 +1,82 @@
-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(`
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { init_types, isBelongsToOneRelationProp, isOneToOneRelationProp, isRelationProp } from "../types/types.js";
+
+//#region src/testing/data-explorer.ts
+var DataExplorer;
+var init_data_explorer = __esmMin((() => {
+	init_types();
+	DataExplorer = class {
+		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(":");
+						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}`);
+			}
+		}
+		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");
+			}
+			const result = await this.db.raw(`
       WITH numbered_rows AS (
         SELECT *, ROW_NUMBER() OVER (ORDER BY id) as rn
         FROM ??
@@ -94,181 +85,162 @@ export class DataExplorer {
       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);
-            }
-        }
-    }
-}
+				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("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;
+			const mainRecords = await this.explore(entityName, options);
+			const result = {
+				main: {
+					entityId: entityName,
+					records: mainRecords
+				},
+				related: new Map()
+			};
+			if (!includeRelations || maxDepth <= 0) {
+				return result;
+			}
+			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);
+			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;
+				if (visited.has(targetEntityName)) {
+					continue;
+				}
+				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);
+			}
+			const allEntities = this.entityManager.getAllEntities();
+			for (const otherEntity of allEntities) {
+				const otherEntityName = otherEntity.id;
+				if (visited.has(otherEntityName) || otherEntityName === entityName) {
+					continue;
+				}
+				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;
+					const foreignKeyName = `${prop.name}_id`;
+					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":"AAIA,SAASA,0BAA0B,EAAEC,sBAAsB,EAAEC,cAAc,QAAQ,oBAAiB;AAqCpG,4CAA4C;AAC5C,OAAO,MAAMC;;;IACHC,MAAqB;IAE7B,YACE,AAAQC,EAAQ,EAChB,AAAQC,aAAmC,EAC3CC,YAA2B,CAC3B;aAHQF,KAAAA;aACAC,gBAAAA;QAGR,IAAI,CAACF,KAAK,GAAGG;IACf;IAEA,MAAMC,QACJC,UAAkB,EAClBC,OAA4B,EACQ;QACpC,MAAMC,SAAS,IAAI,CAACL,aAAa,CAACM,GAAG,CAACH;QACtC,IAAI,CAACE,QAAQ;YACX,MAAM,IAAIE,MAAM,CAAC,kBAAkB,EAAEJ,YAAY;QACnD;QAEA,QAAQ;QACR,IAAIC,QAAQI,QAAQ,IAAI,IAAI,CAACV,KAAK,EAAE;YAClC,MAAMW,WAAW,IAAI,CAACC,gBAAgB,CAACP,YAAYC;YACnD,OAAO,IAAI,CAACN,KAAK,CAACa,QAAQ,CAAC;gBACzBC,KAAKH;gBACLI,KAAKT,QAAQU,QAAQ,IAAI;gBACzBC,SAAS,IAAM,IAAI,CAACC,eAAe,CAACX,QAAQD;YAC9C;QACF;QAEA,OAAO,IAAI,CAACY,eAAe,CAACX,QAAQD;IACtC;IAEA,MAAcY,gBACZX,MAAc,EACdD,OAA4B,EACQ;QACpC,MAAMa,QAAQ,IAAI,CAAClB,EAAE,CAACM,OAAOa,KAAK;QAElC,OAAQd,QAAQe,QAAQ;YACtB,KAAK;gBACH,OAAO,MAAM,IAAI,CAACC,UAAU,CAACH,OAAOb,QAAQiB,KAAK,IAAI;YAEvD,KAAK;gBAAU;oBACb,MAAMC,eAAe,IAAI,CAACC,mBAAmB,CAAClB,QAAQ;oBACtD,IAAIiB,cAAc;wBAChBL,MAAMO,OAAO,CAACF,cAAc;oBAC9B;oBACA,OAAO,MAAML,MAAMI,KAAK,CAACjB,QAAQiB,KAAK,IAAI;gBAC5C;YAEA,KAAK;gBACH,OAAO,MAAM,IAAI,CAACI,YAAY,CAACR,OAAOb,QAAQiB,KAAK,IAAI;YAEzD,KAAK;gBACH,IAAIjB,QAAQsB,GAAG,IAAItB,QAAQsB,GAAG,CAACC,MAAM,GAAG,GAAG;oBACzCV,MAAMW,OAAO,CAAC,MAAMxB,QAAQsB,GAAG;gBACjC;gBACA,OAAO,MAAMT;YAEf,KAAK;gBACH,IAAIb,QAAQyB,KAAK,EAAE;oBACjBZ,MAAMY,KAAK,CAACzB,QAAQyB,KAAK;gBAC3B;gBACA,IAAIzB,QAAQoB,OAAO,EAAE;oBACnB,MAAM,CAACM,KAAKC,MAAM,KAAK,CAAC,GAAG3B,QAAQoB,OAAO,CAACQ,KAAK,CAAC;oBACjD,qCAAqC;oBACrC,IAAIF,QAAQ,MAAM;wBAChBb,MAAMgB,UAAU,CAAC,CAAC,oBAAoB,EAAEF,KAAK,EAAE;4BAACD;yBAAI;oBACtD,OAAO;wBACLb,MAAMO,OAAO,CAACM,KAAKC;oBACrB;gBACF;gBACA,OAAO,MAAMd,MAAMI,KAAK,CAACjB,QAAQiB,KAAK,IAAI;YAE5C,KAAK;gBACH,IAAI,CAACjB,QAAQ8B,QAAQ,EAAE;oBACrB,MAAM,IAAI3B,MAAM;gBAClB;gBACA,OAAO,IAAI,CAAC4B,YAAY,CAAC/B,QAAQ8B,QAAQ;YAE3C;gBACE,MAAM,IAAI3B,MAAM,CAAC,kBAAkB,EAAEH,QAAQe,QAAQ,EAAE;QAC3D;IACF;IAEA,oCAAoC;IACpC,MAAcC,WACZH,KAAwB,EACxBI,KAAa,EACuB;QACpC,MAAM,CAAC,EAAEe,KAAK,EAAE,CAAC,GAAG,MAAMnB,MAAMoB,KAAK,GAAGD,KAAK,CAAC;QAC9C,MAAME,QAAQC,OAAOH;QAErB,IAAIE,SAASjB,OAAO;YAClB,OAAO,MAAMJ,MAAMI,KAAK,CAACA;QAC3B;QAEA,WAAW;QACX,MAAMmB,WAAWC,KAAKC,KAAK,CAACJ,QAAQjB;QAEpC,UAAU;QACV,MAAMsB,YAAY1B,MAAM2B,QAAQ,GAAGC,KAAK,CAAC,sBAAsB,CAAC,EAAE;QAClE,IAAI,CAACF,WAAW;YACd,MAAM,IAAIpC,MAAM;QAClB;QAEA,oCAAoC;QACpC,MAAMuC,SAAS,MAAM,IAAI,CAAC/C,EAAE,CAACgD,GAAG,CAC9B,CAAC;;;;;;;;IAQH,CAAC,EACC;YAACJ;YAAWH;YAAUnB;SAAM;QAG9B,OAAOyB,OAAOE,IAAI;IACpB;IAEA,MAAcvB,aACZR,KAAwB,EACxBI,KAAa,EACuB;QACpC,OAAO,MAAMJ,MAAMgB,UAAU,CAAC,YAAYZ,KAAK,CAACA;IAClD;IAEQE,oBAAoBlB,MAAc,EAAE4C,UAAkB,EAAiB;QAC7E,MAAMC,OAAO7C,OAAO8C,KAAK,CAACC,IAAI,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAKL;QACjD,OAAOC,MAAMI,QAAQ;IACvB;IAEA,MAAcnB,aAAaD,QAAgB,EAAsC;QAC/E,MAAMqB,KAAK,MAAM,MAAM,CAAC;QACxB,MAAMC,UAAU,MAAMD,GAAGE,QAAQ,CAACvB,UAAU;QAE5C,IAAIA,SAASwB,QAAQ,CAAC,UAAU;YAC9B,MAAMC,SAASC,KAAKC,KAAK,CAACL;YAC1B,IAAI,CAACM,MAAMC,OAAO,CAACJ,SAAS;gBAC1B,MAAM,IAAIpD,MAAM;YAClB;YACA,OAAOoD;QACT,OAAO,IAAIzB,SAASwB,QAAQ,CAAC,SAAS;YACpC,MAAMM,QAAQR,QAAQxB,KAAK,CAAC,MAAMiC,MAAM,CAAC,CAACC,OAASA,KAAKC,IAAI;YAC5D,IAAIH,MAAMrC,MAAM,KAAK,GAAG,OAAO,EAAE;YAEjC,MAAMyC,UAAUJ,KAAK,CAAC,EAAE,CAAChC,KAAK,CAAC,KAAKqC,GAAG,CAAC,CAACC,IAAMA,EAAEH,IAAI;YACrD,OAAOH,MAAMO,KAAK,CAAC,GAAGF,GAAG,CAAC,CAACH;gBACzB,MAAMM,SAASN,KAAKlC,KAAK,CAAC;gBAC1B,OAAOoC,QAAQK,MAAM,CACnB,CAACC,KAA8BC,QAAgBC;oBAC7CF,GAAG,CAACC,OAAO,GAAGH,MAAM,CAACI,EAAE,EAAET;oBACzB,OAAOO;gBACT,GACA,CAAC;YAEL;QACF;QAEA,MAAM,IAAInE,MAAM,CAAC,yBAAyB,EAAE2B,UAAU;IACxD;IAEA,MAAM2C,gBACJ1E,UAAkB,EAClB2E,YAAoB,EACpB1E,OAAsC,EACF;QACpC,MAAMC,SAAS,IAAI,CAACL,aAAa,CAACM,GAAG,CAACH;QACtC,MAAM+C,OAAO7C,OAAO8C,KAAK,CAACC,IAAI,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAKwB;QAEjD,IAAI,CAAC5B,QAAQ,CAACtD,eAAesD,OAAO;YAClC,MAAM,IAAI3C,MAAM,CAAC,6BAA6B,EAAEJ,WAAW,CAAC,EAAE2E,cAAc;QAC9E;QAEA,MAAMC,aAAa7B,KAAK8B,IAAI,EAAED;QAC9B,MAAM5D,WAAW4D,YAAY5D,YAAYf,SAASe,YAAY;QAC9D,MAAM8D,SACJF,YAAYE,UAAU,OAAOF,WAAWE,MAAM,KAAK,WAC9CF,WAAWE,MAAM,GAClB,CAAC;QAEP,OAAO,IAAI,CAAC/E,OAAO,CAACgD,KAAKgC,IAAI,EAAE;YAC7B/D;YACAE,OAAOjB,SAASiB,SAAU,CAAA,OAAO4D,OAAO5D,KAAK,KAAK,WAAW4D,OAAO5D,KAAK,GAAG,EAAC;YAC7E,GAAI,OAAO4D,WAAW,WAAWA,SAAS,CAAC,CAAC;YAC5C,GAAG7E,OAAO;QACZ;IACF;IAEA;;GAEC,GACD,MAAM+E,iBACJhF,UAAkB,EAClBiF,aAAuB,EACvBhF,OAAsC,EACc;QACpD,MAAMiF,UAAU,MAAMC,QAAQC,GAAG,CAC/BH,cAAcf,GAAG,CAAC,OAAOnB;YACvB,MAAMsC,OAAO,MAAM,IAAI,CAACX,eAAe,CAAC1E,YAAY+C,MAAM9C;YAC1D,OAAO;gBAAC8C;gBAAMsC;aAAK;QACrB;QAGF,OAAOC,OAAOC,WAAW,CAACL;IAC5B;IAEQ3E,iBAAiBP,UAAkB,EAAEC,OAA4B,EAAU;QACjF,MAAMuF,QAAQ;YACZ,CAAC,aAAa,EAAExF,YAAY;YAC5BC,QAAQe,QAAQ;YAChBf,QAAQiB,KAAK,EAAEuB,cAAc;SAC9B;QAED,IAAIxC,QAAQyB,KAAK,EAAE;YACjB8D,MAAMC,IAAI,CAAChC,KAAKiC,SAAS,CAACzF,QAAQyB,KAAK;QACzC;QACA,IAAIzB,QAAQoB,OAAO,EAAE;YACnBmE,MAAMC,IAAI,CAACxF,QAAQoB,OAAO;QAC5B;QACA,IAAIpB,QAAQsB,GAAG,EAAE;YACfiE,MAAMC,IAAI,CAACxF,QAAQsB,GAAG,CAACoE,IAAI,CAAC;QAC9B;QAEA,OAAOH,MAAMG,IAAI,CAAC;IACpB;IAEA;;;GAGC,GACD,MAAMC,qBACJ5F,UAAkB,EAClBC,OAAoC,EACC;QACrC,MAAM4F,mBAAmB5F,QAAQ4F,gBAAgB,IAAI;QACrD,MAAMC,WAAW7F,QAAQ6F,QAAQ,IAAI;QAErC,eAAe;QACf,MAAMC,cAAc,MAAM,IAAI,CAAChG,OAAO,CAACC,YAAYC;QAEnD,MAAM0C,SAAqC;YACzCqD,MAAM;gBACJC,UAAUjG;gBACVkG,SAASH;YACX;YACAI,SAAS,IAAIC;QACf;QAEA,wBAAwB;QACxB,IAAI,CAACP,oBAAoBC,YAAY,GAAG;YACtC,OAAOnD;QACT;QAEA,2BAA2B;QAC3B,MAAM0D,UAAU,IAAIC,IAAY;YAACtG;SAAW;QAE5C,kBAAkB;QAClB,MAAM,IAAI,CAACuG,kBAAkB,CAACvG,YAAY+F,aAAapD,OAAOwD,OAAO,EAAEE,SAASP;QAEhF,OAAOnD;IACT;IAEA;;GAEC,GACD,MAAc4D,mBACZvG,UAAkB,EAClBkG,OAAkC,EAClCM,UAAkD,EAClDH,OAAoB,EACpBI,cAAsB,EACP;QACf,IAAIA,kBAAkB,KAAKP,QAAQ1E,MAAM,KAAK,GAAG;YAC/C;QACF;QAEA,MAAMtB,SAAS,IAAI,CAACL,aAAa,CAACM,GAAG,CAACH;QACtC,MAAM0G,YAAYR,QAAQhC,GAAG,CAAC,CAACyC,IAAMA,EAAEC,EAAE,EAAE9C,MAAM,CAAC,CAAC8C,KAAOA,MAAM;QAEhE,kDAAkD;QAClD,MAAMC,uBAAuB3G,OAAO8C,KAAK,CAACc,MAAM,CAC9C,CAACf,OACCtD,eAAesD,SACdxD,CAAAA,2BAA2BwD,SAAUvD,uBAAuBuD,SAASA,KAAK+D,aAAa;QAG5F,KAAK,MAAM/D,QAAQ8D,qBAAsB;YACvC,IAAI,CAACpH,eAAesD,OAAO;YAE3B,MAAMgE,mBAAmBhE,KAAKgC,IAAI;YAElC,+BAA+B;YAC/B,IAAIsB,QAAQW,GAAG,CAACD,mBAAmB;gBACjC;YACF;YAEA,cAAc;YACd,MAAME,iBAAiB,GAAGlE,KAAKI,IAAI,CAAC,GAAG,CAAC;YACxC,MAAM+D,gBAAgBhB,QACnBhC,GAAG,CAAC,CAACiD,SAAWA,MAAM,CAACF,eAAe,EACtCnD,MAAM,CAAC,CAAC8C,KAAOA,MAAM;YAExB,IAAIM,cAAc1F,MAAM,KAAK,GAAG;gBAC9B;YACF;YAEA,QAAQ;YACR,MAAM4F,YAAY;mBAAI,IAAId,IAAIY;aAAe;YAE7C,YAAY;YACZ,MAAMG,oBAAoB,MAAM,IAAI,CAACtH,OAAO,CAACgH,kBAAkB;gBAC7D/F,UAAU;gBACVO,KAAK6F;YACP;YAEA,SAAS;YACTZ,WAAWc,GAAG,CAACP,kBAAkBM;YACjChB,QAAQkB,GAAG,CAACR;YAEZ,0BAA0B;YAC1B,MAAM,IAAI,CAACR,kBAAkB,CAC3BQ,kBACAM,mBACAb,YACAH,SACAI,iBAAiB;QAErB;QAEA,mDAAmD;QACnD,8CAA8C;QAC9C,MAAMe,cAAc,IAAI,CAAC3H,aAAa,CAAC4H,cAAc;QAErD,KAAK,MAAMC,eAAeF,YAAa;YACrC,MAAMG,kBAAkBD,YAAYd,EAAE;YAEtC,sBAAsB;YACtB,IAAIP,QAAQW,GAAG,CAACW,oBAAoBA,oBAAoB3H,YAAY;gBAClE;YACF;YAEA,mCAAmC;YACnC,MAAM4H,oBAAoBF,YAAY1E,KAAK,CAACc,MAAM,CAChD,CAACf,OACCtD,eAAesD,SACfA,KAAKgC,IAAI,KAAK/E,cACbT,CAAAA,2BAA2BwD,SACzBvD,uBAAuBuD,SAASA,KAAK+D,aAAa;YAGzD,KAAK,MAAM/D,QAAQ6E,kBAAmB;gBACpC,IAAI,CAACnI,eAAesD,OAAO;gBAE3B,qCAAqC;gBACrC,MAAMkE,iBAAiB,GAAGlE,KAAKI,IAAI,CAAC,GAAG,CAAC;gBAExC,mCAAmC;gBACnC,MAAMrC,QAAQ,IAAI,CAAClB,EAAE,CAAC8H,YAAY3G,KAAK,EAAEU,OAAO,CAACwF,gBAAgBP;gBACjE,MAAMmB,kBAAkB,MAAM/G;gBAE9B,IAAI+G,gBAAgBrG,MAAM,KAAK,GAAG;oBAChC;gBACF;gBAEA,SAAS;gBACTgF,WAAWc,GAAG,CAACK,iBAAiBE;gBAChCxB,QAAQkB,GAAG,CAACI;gBAEZ,0BAA0B;gBAC1B,MAAM,IAAI,CAACpB,kBAAkB,CAC3BoB,iBACAE,iBACArB,YACAH,SACAI,iBAAiB;YAErB;QACF;IACF;AACF"}
+//#endregion
+init_data_explorer();
+export { DataExplorer, init_data_explorer };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"data-explorer.js","names":["db: Knex","entityManager: typeof EntityManager","result: ExploreWithRelationsResult"],"sources":["../../src/testing/data-explorer.ts"],"sourcesContent":["import { type Knex } from \"knex\";\n\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"],"mappings":"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"}