sonamu 0.7.53 → 0.8.0

package/dist/testing/fixture-generator.js

@@ -0,0 +1,954 @@
+import chalk from "chalk";
+import { isBelongsToOneRelationProp, isOneToOneRelationProp, isRelationProp } from "../types/types.js";
+import { DataExplorer } from "./data-explorer.js";
+import { fakerMappings } from "./faker-mappings.js";
+import { FixtureManager } from "./fixture-manager.js";
+export class FixtureGenerator {
+    sourceDb;
+    targetDbName;
+    entityManager;
+    dataExplorer;
+    locale;
+    mappings;
+    llmCache = new Map();
+    options;
+    constructor(sourceDb, // FixtureManager.insertFixtures가 dbName 문자열을 받기 때문에 직접 사용하지 않습니다
+    // 미래 확장성을 위해 API 시그니처에는 포함시켰습니다
+    _targetDb, targetDbName, entityManager, options){
+        this.sourceDb = sourceDb;
+        this.targetDbName = targetDbName;
+        this.entityManager = entityManager;
+        this.dataExplorer = new DataExplorer(sourceDb, entityManager);
+        this.locale = options?.locale || "ko";
+        this.mappings = fakerMappings;
+        this.options = {
+            locale: options?.locale || "ko",
+            useLLM: options?.useLLM || false,
+            enableLLMCache: options?.enableLLMCache !== false,
+            llmModel: options?.llmModel || "claude-sonnet-4-5"
+        };
+    }
+    /**
+   * Fixture 생성 (단일)
+   * @returns 생성된 fixture 데이터 (메모리 상)
+   */ async generate(entityName, overrides = {}, context = this.createContext()) {
+        const entity = this.entityManager.get(entityName);
+        const tempId = `${entityName}#temp#${Date.now()}`; // 임시 ID
+        // 각 prop별 값 생성
+        const fixture = {};
+        for (const prop of entity.props){
+            // Virtual prop은 스킵
+            if ("virtual" in prop && prop.virtual) {
+                continue;
+            }
+            // override가 있으면 사용
+            if (prop.name in overrides) {
+                fixture[prop.name] = overrides[prop.name];
+                continue;
+            }
+            // cone에서 생성 전략 확인
+            const cone = prop.cone;
+            // 1. Relation prop 처리
+            if (isRelationProp(prop)) {
+                const relationValue = await this.generateRelationValue(entity, prop, context);
+                // BelongsToOne, OneToOne(hasJoinColumn)의 경우 foreign key 컬럼명으로 저장
+                if (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop) && prop.hasJoinColumn) {
+                    fixture[`${prop.name}_id`] = relationValue;
+                } else {
+                    fixture[prop.name] = relationValue;
+                }
+                continue;
+            }
+            // 2. fixtureGenerator 사용
+            if (cone?.fixtureGenerator) {
+                fixture[prop.name] = await this.executeGenerator(cone.fixtureGenerator, prop, entity);
+                continue;
+            }
+            // 2.5. fixtureHint + LLM 사용
+            if (cone?.fixtureHint && this.options.useLLM) {
+                try {
+                    fixture[prop.name] = await this.generateWithLLM(cone.fixtureHint, prop, entity);
+                    continue;
+                } catch (error) {
+                    console.warn(`[FixtureGenerator] LLM generation failed for ${entity.id}.${prop.name}, falling back to default`, error instanceof Error ? error.message : error);
+                // fallback: fixtureDefault 또는 기본값으로 계속
+                }
+            }
+            // 3. fixtureDefault 사용
+            if (cone?.fixtureDefault !== undefined) {
+                fixture[prop.name] = cone.fixtureDefault;
+                continue;
+            }
+            // 4. 타입별 기본 생성
+            fixture[prop.name] = await this.generateDefaultValue(prop, entity);
+        }
+        // 5. password 필드 암호화
+        if ("password" in fixture && fixture.password && typeof fixture.password === "string") {
+            const bcrypt = await import("bcrypt");
+            fixture.password = await bcrypt.hash(fixture.password, 10);
+        }
+        context.fixtures.set(tempId, fixture);
+        return fixture;
+    }
+    /**
+   * Relation 값 생성 + 자동 Import
+   */ async generateRelationValue(entity, prop, context) {
+        if (!isRelationProp(prop)) {
+            throw new Error(`FixtureGenerator: ${entity.id}.${prop.name} is not a relation prop`);
+        }
+        // BelongsToOne, OneToOne(hasJoinColumn)만 처리
+        if (!isBelongsToOneRelationProp(prop) && !(isOneToOneRelationProp(prop) && prop.hasJoinColumn)) {
+            return null;
+        }
+        const cone = prop.cone;
+        const dataSource = cone?.dataSource;
+        // DataExplorer로 참조 데이터 조회 (sourceDb)
+        // 관계 체인을 따라가기 위해 exploreWithRelations 사용
+        if (dataSource) {
+            const cacheKey = `${prop.with}:${JSON.stringify(dataSource)}`;
+            if (!context.referenceCache.has(cacheKey)) {
+                const exploreResult = await this.dataExplorer.exploreWithRelations(prop.with, {
+                    strategy: dataSource.strategy,
+                    limit: dataSource.config?.limit || 10,
+                    includeRelations: true,
+                    maxDepth: 3,
+                    ...dataSource.config
+                });
+                context.referenceCache.set(cacheKey, exploreResult.main.records);
+                // 조회한 데이터와 관계된 모든 엔티티를 targetDb에 import
+                await this.importExploreResult(exploreResult, context);
+            }
+            const candidates = context.referenceCache.get(cacheKey);
+            if (candidates && candidates.length > 0) {
+                // 랜덤하게 하나 선택
+                const selected = candidates[Math.floor(Math.random() * candidates.length)];
+                return selected.id;
+            }
+        }
+        // dataSource가 없을 때 자동으로 fixture DB에서 조회 시도
+        // 관계 체인을 따라가기 위해 exploreWithRelations 사용
+        const autoKey = `${prop.with}:auto`;
+        if (!context.referenceCache.has(autoKey)) {
+            // fixture DB(sourceDb)에서 자동 조회 (관계 포함)
+            const autoExploreResult = await this.dataExplorer.exploreWithRelations(prop.with, {
+                strategy: "random",
+                limit: 10,
+                includeRelations: true,
+                maxDepth: 3
+            });
+            context.referenceCache.set(autoKey, autoExploreResult.main.records);
+            // 조회한 데이터와 관계된 모든 엔티티를 targetDb에 import
+            if (autoExploreResult.main.records.length > 0) {
+                await this.importExploreResult(autoExploreResult, context);
+            }
+        }
+        const autoCandidates = context.referenceCache.get(autoKey);
+        if (autoCandidates && autoCandidates.length > 0) {
+            // 랜덤하게 하나 선택
+            const selected = autoCandidates[Math.floor(Math.random() * autoCandidates.length)];
+            return selected.id;
+        }
+        // 참조 데이터가 없으면 null 반환 (nullable인 경우)
+        if (prop.nullable) {
+            return null;
+        }
+        // nullable이 아니고 데이터도 없으면 에러
+        throw new Error(`FixtureGenerator: ${entity.id}.${prop.name}에 필요한 ${prop.with} 데이터가 없습니다. ` + `먼저 ${prop.with}를 생성하거나 cone.dataSource를 설정하세요.`);
+    }
+    /**
+   * ExploreWithRelations 결과를 targetDb에 import
+   *
+   * 관계 체인을 따라간 결과(main + related)를 모두 import합니다.
+   * 의존성 순서는 FixtureManager.insertFixtures가 자동으로 처리합니다.
+   */ async importExploreResult(exploreResult, context) {
+        const allFixtureRecords = [];
+        // 1. Related entities import (Company, Department 등)
+        for (const [entityId, records] of exploreResult.related.entries()){
+            const entity = this.entityManager.get(entityId);
+            const recordsToImport = [];
+            console.log(chalk.cyan(`Importing related entity: ${entityId} (${records.length} records)`));
+            for (const record of records){
+                const recordKey = `${entityId}#${record.id}`;
+                if (!context.importedRecords.has(recordKey)) {
+                    recordsToImport.push(record);
+                    context.importedRecords.add(recordKey);
+                }
+            }
+            if (recordsToImport.length > 0) {
+                for (const record of recordsToImport){
+                    console.log(chalk.gray(`  - Processing ${entityId} record:`, JSON.stringify(record).slice(0, 100)));
+                    const fixtureRecords = await FixtureManager.createFixtureRecord(entity, record, {
+                        _db: this.sourceDb,
+                        singleRecord: true
+                    });
+                    allFixtureRecords.push(...fixtureRecords);
+                }
+            }
+        }
+        // 2. Main entity import (Employee 등)
+        const mainEntity = this.entityManager.get(exploreResult.main.entityId);
+        const mainRecordsToImport = [];
+        console.log(chalk.cyan(`Importing main entity: ${exploreResult.main.entityId} (${exploreResult.main.records.length} records)`));
+        for (const record of exploreResult.main.records){
+            const recordKey = `${exploreResult.main.entityId}#${record.id}`;
+            if (!context.importedRecords.has(recordKey)) {
+                mainRecordsToImport.push(record);
+                context.importedRecords.add(recordKey);
+            }
+        }
+        if (mainRecordsToImport.length > 0) {
+            for (const record of mainRecordsToImport){
+                console.log(chalk.gray(`  - Processing ${exploreResult.main.entityId} record:`, JSON.stringify(record).slice(0, 100)));
+                const fixtureRecords = await FixtureManager.createFixtureRecord(mainEntity, record, {
+                    _db: this.sourceDb,
+                    singleRecord: true
+                });
+                allFixtureRecords.push(...fixtureRecords);
+            }
+        }
+        // 3. 모든 fixture를 한 번에 삽입 (의존성 순서 자동 처리)
+        if (allFixtureRecords.length > 0) {
+            await FixtureManager.insertFixtures(this.targetDbName, allFixtureRecords);
+            console.log(chalk.green(`Auto-imported ${exploreResult.main.entityId} with relations: ` + `${exploreResult.main.records.length} main + ${exploreResult.related.size} related entities`));
+        }
+    }
+    /**
+   * fixtureGenerator 실행 (Faker.js만 지원)
+   *
+   * faker.* 형식의 표현식을 안전하게 파싱하여 실행합니다.
+   * 예: "faker.internet.email()" → faker.internet.email()
+   * 예: "faker.lorem.words(3)" → faker.lorem.words(3)
+   */ async executeGenerator(generator, prop, entity) {
+        // Faker.js 표현식만 지원
+        if (generator.startsWith("faker.")) {
+            // username이나 name 필드는 한국어 faker 사용
+            const isNameField = prop.name === "username" || prop.name === "name";
+            const fakerModule = await import("@faker-js/faker");
+            const faker = isNameField ? fakerModule.fakerKO : fakerModule.faker;
+            const expr = generator.slice(6); // "faker." 제거
+            try {
+                // 함수 경로와 인자 파싱
+                const match = expr.match(/^([\w.]+)(?:\((.*?)\))?$/);
+                if (!match) {
+                    throw new Error(`FixtureGenerator: Invalid faker expression for ${prop.name}: ${generator}`);
+                }
+                const [, path, argsStr] = match;
+                const parts = path.split(".");
+                // faker 객체에서 함수 찾기
+                let fn = faker;
+                for (const part of parts){
+                    if (typeof fn === "object" && fn !== null && part in fn) {
+                        fn = fn[part];
+                    } else {
+                        throw new Error(`FixtureGenerator: Invalid faker path for ${prop.name}: faker.${path}`);
+                    }
+                }
+                // 함수가 아니면 에러
+                if (typeof fn !== "function") {
+                    throw new Error(`FixtureGenerator: faker.${path} is not a function (for ${prop.name})`);
+                }
+                // 인자 파싱 (JSON 형식만 지원)
+                let args = [];
+                if (argsStr?.trim()) {
+                    try {
+                        // JSON 배열로 파싱 시도
+                        const parsed = JSON.parse(`[${argsStr}]`);
+                        args = Array.isArray(parsed) ? parsed : [
+                            parsed
+                        ];
+                    } catch  {
+                        // 숫자나 문자열 단일 인자 처리
+                        const trimmed = argsStr.trim();
+                        if (!Number.isNaN(Number(trimmed))) {
+                            args = [
+                                Number(trimmed)
+                            ];
+                        } else if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+                            args = [
+                                trimmed.slice(1, -1)
+                            ];
+                        } else {
+                            throw new Error(`FixtureGenerator: Cannot parse arguments for ${prop.name}: ${argsStr}`);
+                        }
+                    }
+                }
+                return fn(...args);
+            } catch (error) {
+                console.log(chalk.yellow(`Failed to execute generator "${generator}" for ${prop.name}, falling back to default:`), error);
+                return this.generateDefaultValue(prop, entity);
+            }
+        }
+        // faker 이외의 표현식은 지원하지 않음
+        console.log(chalk.yellow(`Unsupported generator expression for ${prop.name}: ${generator}. Only faker.* expressions are supported. Using default value.`));
+        return this.generateDefaultValue(prop, entity);
+    }
+    /**
+   * 필드의 타입과 이름을 분석하여 적절한 기본값을 생성합니다.
+   *
+   * 우선순위:
+   * 1. 필드명 패턴 매칭 (salary, budget 등 의미있는 데이터)
+   * 2. 특수 케이스 (Department name 등 도메인 지식)
+   * 3. 배열 타입 (JSON 배열)
+   * 4. Enum 타입
+   * 5. 타입별 기본값
+   */ async generateDefaultValue(prop, entity) {
+        const fakerModule = await import("@faker-js/faker");
+        const faker = fakerModule.faker;
+        const fakerKO = fakerModule.fakerKO;
+        const fakerJA = fakerModule.fakerJA;
+        const localeFaker = this.locale === "ko" ? fakerKO : this.locale === "ja" ? fakerJA : faker;
+        /**
+     * 1. 필드명에서 의미를 추론하여 현실적인 데이터를 생성합니다.
+     * 예: salary → 30M~150M (한국 연봉 범위)
+     *     budget → 10M~500M (프로젝트 예산 범위)
+     */ const localeMappings = this.mappings[this.locale] || this.mappings.en;
+        const normalizedName = prop.name.toLowerCase().replace(/_/g, "");
+        for (const [pattern, config] of Object.entries(localeMappings.field_patterns)){
+            if (normalizedName.includes(pattern.toLowerCase())) {
+                try {
+                    return await this.executeFakerExpression(config.faker, prop);
+                } catch (error) {
+                    console.log(chalk.yellow(`Failed to execute field pattern "${pattern}" for ${prop.name}, falling back:`), error);
+                    break;
+                }
+            }
+        }
+        /**
+     * 2. Department name은 한국어 부서명 목록에서 선택합니다.
+     * 고유성을 위해 70% 확률로 prefix/suffix를 추가합니다.
+     */ if (entity?.id === "Department" && prop.name === "name") {
+            const departments = [
+                "개발팀",
+                "기획팀",
+                "마케팅팀",
+                "영업팀",
+                "인사팀",
+                "총무팀",
+                "재무팀",
+                "회계팀",
+                "법무팀",
+                "디자인팀",
+                "IT팀",
+                "고객지원팀",
+                "품질관리팀",
+                "연구개발팀",
+                "생산팀",
+                "구매팀",
+                "물류팀"
+            ];
+            const prefixes = [
+                "신규",
+                "통합",
+                "전략",
+                "글로벌",
+                "디지털",
+                "핵심"
+            ];
+            const suffixes = [
+                "1팀",
+                "2팀",
+                "3팀",
+                "A팀",
+                "B팀",
+                "본부",
+                "센터",
+                "그룹"
+            ];
+            const dept = faker.helpers.arrayElement(departments);
+            const random = Math.random();
+            if (random > 0.7) {
+                const prefix = faker.helpers.arrayElement(prefixes);
+                return `${prefix} ${dept}`;
+            }
+            if (random > 0.4) {
+                const suffix = faker.helpers.arrayElement(suffixes);
+                return `${dept} ${suffix}`;
+            }
+            return dept;
+        }
+        /**
+     * 3. JSON 타입이면서 배열인 경우 (SonamuFile[], string[] 등)
+     * 필드명 패턴을 보고 적절한 배열 데이터를 생성합니다.
+     */ if (prop.type === "json" && "id" in prop && prop.id) {
+            if (prop.id.endsWith("[]")) {
+                return this.generateArrayValue(prop, entity, faker, localeFaker);
+            }
+        }
+        /** 4. Enum 타입은 정의된 값 중 하나를 랜덤 선택합니다 */ if (prop.type === "enum") {
+            let enumValues = [];
+            if ("enum" in prop && Array.isArray(prop.enum) && prop.enum.length > 0) {
+                enumValues = prop.enum;
+            } else if ("id" in prop && prop.id && entity?.enumLabels?.[prop.id]) {
+                enumValues = Object.keys(entity.enumLabels[prop.id]);
+            }
+            if (enumValues.length > 0) {
+                return faker.helpers.arrayElement(enumValues);
+            }
+            return prop.nullable ? null : "UNKNOWN";
+        }
+        if (prop.type === "enum[]") {
+            let enumValues = [];
+            if ("enum" in prop && Array.isArray(prop.enum) && prop.enum.length > 0) {
+                enumValues = prop.enum;
+            } else if ("id" in prop && prop.id && entity?.enumLabels?.[prop.id]) {
+                enumValues = Object.keys(entity.enumLabels[prop.id]);
+            }
+            if (enumValues.length > 0) {
+                return [
+                    faker.helpers.arrayElement(enumValues)
+                ];
+            }
+            return [];
+        }
+        /**
+     * 5. Vector 타입은 현재 지원하지 않으므로 null을 반환합니다.
+     * 향후 AI embedding 생성 기능 추가 시 구현 예정입니다.
+     */ if (prop.type === "vector" || prop.type === "vector[]" || prop.type === "tsvector") {
+            return null;
+        }
+        /** 6. 타입별 기본 Faker 표현식을 실행합니다 */ const typeDefault = localeMappings.type_defaults[prop.type];
+        if (typeDefault) {
+            try {
+                return await this.executeFakerExpression(typeDefault.faker, prop);
+            } catch (error) {
+                console.log(chalk.yellow(`Failed to execute type default for ${prop.type}, using fallback:`, error));
+            }
+        }
+        /** 7. 매핑되지 않은 타입은 기본 Faker 함수로 처리합니다 */ switch(prop.type){
+            case "string":
+            case "string[]":
+                return faker.lorem.words(3);
+            case "integer":
+                return faker.number.int({
+                    min: 1,
+                    max: 1000
+                });
+            case "integer[]":
+                return [
+                    faker.number.int({
+                        min: 1,
+                        max: 1000
+                    })
+                ];
+            case "bigInteger":
+                return faker.number.bigInt({
+                    min: 1n,
+                    max: 1000n
+                });
+            case "bigInteger[]":
+                return [
+                    faker.number.bigInt({
+                        min: 1n,
+                        max: 1000n
+                    })
+                ];
+            case "number":
+            case "numeric":
+                return faker.number.float({
+                    min: 0,
+                    max: 1000
+                });
+            case "number[]":
+            case "numeric[]":
+                return [
+                    faker.number.float({
+                        min: 0,
+                        max: 1000
+                    })
+                ];
+            case "boolean":
+                return faker.datatype.boolean();
+            case "boolean[]":
+                return [
+                    faker.datatype.boolean()
+                ];
+            case "date":
+            case "date[]":
+                return faker.date.past();
+            case "json":
+                return {};
+            case "uuid":
+            case "uuid[]":
+                return faker.string.uuid();
+            default:
+                return null;
+        }
+    }
+    /**
+   * 배열 타입의 값을 생성합니다.
+   *
+   * 타입 ID와 필드명 패턴을 분석하여 적절한 배열 데이터를 생성합니다.
+   * 예: image_urls → [{url, name, mime_type}, ...]
+   *     tag_ids → [1, 23, 45]
+   */ generateArrayValue(prop, _entity, faker, _localeFaker) {
+        const count = faker.number.int({
+            min: 1,
+            max: 3
+        });
+        /** SonamuFile[]은 Sonamu 내장 타입으로 구조가 정해져 있습니다 */ if ("id" in prop && prop.id === "SonamuFile[]") {
+            return Array.from({
+                length: count
+            }, ()=>({
+                    url: faker.image.url(),
+                    name: faker.system.fileName(),
+                    mime_type: faker.helpers.arrayElement([
+                        "image/jpeg",
+                        "image/png",
+                        "image/gif",
+                        "application/pdf"
+                    ])
+                }));
+        }
+        /** 필드명에서 배열의 용도를 추론합니다 */ const normalizedName = prop.name.toLowerCase().replace(/_/g, "");
+        if (normalizedName.includes("url") || normalizedName.includes("image")) {
+            return Array.from({
+                length: count
+            }, ()=>faker.internet.url());
+        }
+        if (normalizedName.includes("id") && normalizedName.endsWith("s")) {
+            return Array.from({
+                length: count
+            }, ()=>faker.number.int({
+                    min: 1,
+                    max: 100
+                }));
+        }
+        if (normalizedName.includes("tag") || normalizedName.includes("name")) {
+            return Array.from({
+                length: count
+            }, ()=>faker.lorem.word());
+        }
+        /** 패턴 매칭되지 않으면 빈 배열을 반환합니다 */ return [];
+    }
+    /**
+   * JSON 매핑의 Faker 표현식을 파싱하여 실행합니다.
+   *
+   * 표현식 예시:
+   * - "faker.internet.email()" → 인자 없음
+   * - "faker.number.int({ min: 1, max: 100 })" → JSON 인자
+   * - "{}" → 리터럴 값 (JSON.parse)
+   *
+   * fakerKO, fakerJA도 지원하여 다국어 데이터를 생성합니다.
+   */ async executeFakerExpression(expression, prop) {
+        const fakerModule = await import("@faker-js/faker");
+        const faker = fakerModule.faker;
+        const fakerKO = fakerModule.fakerKO;
+        const fakerJA = fakerModule.fakerJA;
+        /** Faker 표현식이 아닌 리터럴 값은 JSON으로 파싱합니다 */ if (!expression.startsWith("faker")) {
+            try {
+                return JSON.parse(expression);
+            } catch  {
+                return expression;
+            }
+        }
+        /** 표현식에서 Faker 객체와 경로를 추출합니다 */ const match = expression.match(/^(faker|fakerKO|fakerJA)\.(.*?)$/);
+        if (!match) {
+            throw new Error(`Invalid faker expression: ${expression}`);
+        }
+        const [, fakerName, expr] = match;
+        const selectedFaker = fakerName === "fakerKO" ? fakerKO : fakerName === "fakerJA" ? fakerJA : faker;
+        const funcMatch = expr.match(/^([\w.]+)(?:\((.*?)\))?$/);
+        if (!funcMatch) {
+            throw new Error(`Invalid faker expression for ${prop.name}: ${expression}`);
+        }
+        const [, path, argsStr] = funcMatch;
+        const parts = path.split(".");
+        /** 점 표기법(dot notation)으로 Faker 함수를 찾아갑니다 */ let fn = selectedFaker;
+        for (const part of parts){
+            if (typeof fn === "object" && fn !== null && part in fn) {
+                fn = fn[part];
+            } else {
+                throw new Error(`Invalid faker path for ${prop.name}: ${fakerName}.${path}`);
+            }
+        }
+        if (typeof fn !== "function") {
+            throw new Error(`${fakerName}.${path} is not a function (for ${prop.name})`);
+        }
+        /** 함수 인자를 JSON으로 파싱합니다 */ let args = [];
+        if (argsStr?.trim()) {
+            try {
+                const parsed = JSON.parse(`[${argsStr}]`);
+                args = Array.isArray(parsed) ? parsed : [
+                    parsed
+                ];
+            } catch  {
+                /** JSON 파싱 실패 시 단순 숫자/문자열로 시도합니다 */ const trimmed = argsStr.trim();
+                if (!Number.isNaN(Number(trimmed))) {
+                    args = [
+                        Number(trimmed)
+                    ];
+                } else if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+                    args = [
+                        trimmed.slice(1, -1)
+                    ];
+                } else {
+                    throw new Error(`Cannot parse arguments for ${prop.name}: ${argsStr}`);
+                }
+            }
+        }
+        return fn(...args);
+    }
+    /**
+   * fixtureHint를 LLM에게 전달하여 현실적인 테스트 데이터를 생성합니다.
+   *
+   * faker.js로는 생성하기 어려운 복잡한 텍스트(자기소개, 설명문 등)를
+   * LLM을 활용하여 생성합니다. 동일한 hint에 대한 중복 호출을 방지하기 위해
+   * 캐싱을 기본으로 지원합니다 (LLM API 비용 절감).
+   *
+   * ai 패키지는 dynamic import로 불러오므로, useLLM이 false인 경우
+   * 의존성이 설치되지 않아도 fixture 생성이 정상 동작합니다.
+   */ async generateWithLLM(fixtureHint, prop, entity) {
+        const cacheKey = `${entity.id}:${prop.name}:${fixtureHint}`;
+        if (this.options.enableLLMCache && this.llmCache.has(cacheKey)) {
+            return this.llmCache.get(cacheKey);
+        }
+        const apiKey = this.getApiKey();
+        const { createAnthropic } = await import("@ai-sdk/anthropic");
+        const { generateText } = await import("ai");
+        const { text } = await generateText({
+            model: createAnthropic({
+                apiKey
+            })(this.options.llmModel || "claude-sonnet-4-5"),
+            prompt: this.buildLLMPrompt(fixtureHint, prop, entity)
+        });
+        const value = this.parseLLMResponse(text, prop.type);
+        if (this.options.enableLLMCache) {
+            this.llmCache.set(cacheKey, value);
+        }
+        return value;
+    }
+    buildLLMPrompt(hint, prop, entity) {
+        const locale = this.options.locale || "ko";
+        const language = locale === "ko" ? "Korean" : locale === "ja" ? "Japanese" : "English";
+        let prompt = `Generate test data for ${entity.id}.${prop.name} (type: ${prop.type})
+
+Requirement: ${hint}
+
+Rules:
+- Return ONLY the value, no explanation or markdown
+- Use ${language} language if applicable
+- Format: ${this.getExpectedFormat(prop.type)}`;
+        // enum 타입인 경우 가능한 값 목록 추가
+        if (prop.type === "enum" || prop.type === "enum[]") {
+            let enumValues = [];
+            if ("enum" in prop && Array.isArray(prop.enum) && prop.enum.length > 0) {
+                enumValues = prop.enum;
+            } else if ("id" in prop && prop.id && entity?.enumLabels?.[prop.id]) {
+                enumValues = Object.keys(entity.enumLabels[prop.id]);
+            }
+            if (enumValues.length > 0) {
+                prompt += `\n- IMPORTANT: Choose ONLY from these allowed values: ${enumValues.join(", ")}`;
+            }
+        }
+        prompt += `\n\nExample: ${this.getExampleForType(prop.type, locale)}`;
+        return prompt;
+    }
+    parseLLMResponse(text, propType) {
+        const cleaned = text.trim();
+        // 배열 타입 처리
+        if (propType.endsWith("[]")) {
+            try {
+                const parsed = JSON.parse(cleaned);
+                const baseType = propType.slice(0, -2); // "integer[]" -> "integer"
+                if (Array.isArray(parsed)) {
+                    return parsed.map((item)=>{
+                        // null/undefined는 타입별 기본값으로
+                        if (item === null || item === undefined) {
+                            return this.getDefaultValueForType(baseType);
+                        }
+                        // 객체는 JSON.stringify 후 파싱 (json 타입인 경우)
+                        if (typeof item === "object") {
+                            return baseType === "json" ? item : this.parseScalarValue(JSON.stringify(item), baseType);
+                        }
+                        // primitive 값은 문자열로 변환 후 파싱
+                        return this.parseScalarValue(String(item), baseType);
+                    });
+                }
+                // 단일 값이 온 경우 배열로 감싸기
+                if (parsed === null || parsed === undefined) {
+                    return [
+                        this.getDefaultValueForType(baseType)
+                    ];
+                }
+                return [
+                    this.parseScalarValue(String(parsed), baseType)
+                ];
+            } catch  {
+                return [];
+            }
+        }
+        return this.parseScalarValue(cleaned, propType);
+    }
+    getDefaultValueForType(propType) {
+        switch(propType){
+            case "integer":
+                return 0;
+            case "bigInteger":
+                return 0n;
+            case "float":
+            case "number":
+            case "numeric":
+                return 0;
+            case "boolean":
+                return false;
+            case "date":
+                return new Date();
+            case "json":
+                return {};
+            case "uuid":
+                return "00000000-0000-0000-0000-000000000000";
+            default:
+                return "";
+        }
+    }
+    parseScalarValue(text, propType) {
+        const cleaned = text.trim();
+        switch(propType){
+            case "integer":
+                {
+                    const num = parseInt(cleaned, 10);
+                    return Number.isNaN(num) ? 0 : num;
+                }
+            case "bigInteger":
+                {
+                    try {
+                        return BigInt(cleaned);
+                    } catch  {
+                        return 0n;
+                    }
+                }
+            case "float":
+            case "number":
+            case "numeric":
+                {
+                    const num = parseFloat(cleaned);
+                    return Number.isNaN(num) ? 0 : num;
+                }
+            case "boolean":
+                return cleaned.toLowerCase() === "true";
+            case "date":
+                {
+                    const date = new Date(cleaned);
+                    return Number.isNaN(date.getTime()) ? new Date() : date;
+                }
+            case "json":
+                try {
+                    return JSON.parse(cleaned);
+                } catch  {
+                    return cleaned;
+                }
+            case "uuid":
+            case "enum":
+                return cleaned;
+            default:
+                return cleaned;
+        }
+    }
+    /**
+   * Sonamu.secret을 우선으로 하고, 없으면 환경변수에서 API 키를 읽습니다.
+   *
+   * Sonamu.secret은 프로젝트별 설정(sonamu.config.ts)이므로 더 높은 우선순위를 가지며,
+   * 환경변수는 개발 환경이나 CI/CD에서 fallback으로 사용됩니다.
+   */ getApiKey() {
+        let apiKey;
+        try {
+            const { Sonamu } = require("../api");
+            apiKey = Sonamu.secret?.anthropic_api_key;
+        } catch  {
+        // Sonamu가 초기화되지 않은 경우 (테스트 환경 등)
+        }
+        if (!apiKey) {
+            apiKey = process.env.ANTHROPIC_API_KEY;
+        }
+        if (!apiKey) {
+            throw new Error("ANTHROPIC_API_KEY not found. Set it in environment variables or Sonamu.secret.anthropic_api_key");
+        }
+        return apiKey;
+    }
+    getExpectedFormat(propType) {
+        // 배열 타입 처리
+        if (propType.endsWith("[]")) {
+            const baseType = propType.slice(0, -2);
+            const baseFormat = this.getScalarFormat(baseType);
+            return `JSON array of ${baseFormat} (e.g., [${this.getExampleForType(baseType, "en")}, ...])`;
+        }
+        return this.getScalarFormat(propType);
+    }
+    getScalarFormat(propType) {
+        switch(propType){
+            case "integer":
+            case "bigInteger":
+                return "integer numbers";
+            case "float":
+            case "number":
+            case "numeric":
+                return "decimal numbers";
+            case "boolean":
+                return "booleans (true or false)";
+            case "date":
+                return "ISO 8601 date strings";
+            case "json":
+                return "valid JSON object or array";
+            case "uuid":
+                return "UUID strings";
+            case "enum":
+                return "one of the allowed enum values";
+            default:
+                return "plain text strings";
+        }
+    }
+    getExampleForType(propType, locale) {
+        // 배열 타입 처리
+        if (propType.endsWith("[]")) {
+            const baseType = propType.slice(0, -2);
+            const baseExample = this.getScalarExample(baseType, locale);
+            return `[${baseExample}]`;
+        }
+        return this.getScalarExample(propType, locale);
+    }
+    getScalarExample(propType, locale) {
+        const isKorean = locale === "ko";
+        switch(propType){
+            case "integer":
+            case "bigInteger":
+                return "42";
+            case "float":
+            case "number":
+            case "numeric":
+                return "3.14";
+            case "boolean":
+                return "true";
+            case "date":
+                return "2024-01-01";
+            case "json":
+                return '{"key": "value"}';
+            case "uuid":
+                return "550e8400-e29b-41d4-a716-446655440000";
+            case "enum":
+                return "ENUM_VALUE";
+            default:
+                return isKorean ? "안녕하세요" : "Hello";
+        }
+    }
+    /**
+   * LLM 캐시 통계를 반환합니다.
+   */ getLLMCacheStats() {
+        return {
+            size: this.llmCache.size,
+            enabled: this.options.enableLLMCache
+        };
+    }
+    /**
+   * LLM 캐시를 초기화합니다.
+   */ clearLLMCache() {
+        this.llmCache.clear();
+    }
+    /**
+   * 컨텍스트 생성
+   */ createContext() {
+        return {
+            fixtures: new Map(),
+            referenceCache: new Map(),
+            importedRecords: new Set()
+        };
+    }
+    /**
+   * 배치 생성 및 자동 저장
+   *
+   * 1. 각 spec별로 fixture 생성 (메모리)
+   * 2. FixtureRecord로 변환
+   * 3. FixtureManager.insertFixtures()로 targetDb에 저장
+   *
+   * @returns 저장된 fixture 데이터 (실제 DB ID 포함)
+   */ async generateBatch(specs) {
+        const context = this.createContext();
+        const generatedFixtures = [];
+        // 1. 각 spec별로 fixture 생성
+        for (const spec of specs){
+            for(let i = 0; i < spec.count; i++){
+                const fixture = await this.generate(spec.entity, spec.overrides || {}, context);
+                generatedFixtures.push({
+                    entity: spec.entity,
+                    data: fixture
+                });
+            }
+        }
+        // 2. FixtureRecord로 변환
+        const fixtureRecords = [];
+        for (const { entity: entityName, data } of generatedFixtures){
+            const entity = this.entityManager.get(entityName);
+            // 임시 ID 생성 (targetDb에 INSERT 후 실제 ID를 받음)
+            const tempId = Math.floor(Math.random() * 1000000);
+            const records = await FixtureManager.createFixtureRecord(entity, {
+                ...data,
+                id: tempId
+            }, {
+                singleRecord: true
+            });
+            fixtureRecords.push(...records);
+        }
+        // 3. targetDb에 삽입 (FixtureManager가 의존성 정렬 처리)
+        const results = await FixtureManager.insertFixtures(this.targetDbName, fixtureRecords);
+        console.log(chalk.green(`Generated and saved ${results.length} fixtures to ${this.targetDbName}`));
+        return results;
+    }
+    /**
+   * 실제 DB(sourceDb)에서 데이터를 조회하여 fixture DB(targetDb)에 import합니다.
+   *
+   * 1. DataExplorer로 sourceDb에서 데이터 조회 (관련 데이터 포함)
+   * 2. FixtureRecord로 변환
+   * 3. targetDb에 삽입
+   *
+   * @param entityName - 조회할 entity 이름
+   * @param options - 조회 옵션 (strategy, limit, includeRelations 등)
+   * @returns 저장된 fixture 데이터 (실제 DB ID 포함)
+   *
+   * @example
+   * // 프로덕션 DB에서 User 10명 + 관련 Employee, Department 가져오기
+   * await generator.importFromSource("User", {
+   *   strategy: "sample",
+   *   limit: 10,
+   *   includeRelations: true,
+   *   maxDepth: 2
+   * });
+   */ async importFromSource(entityName, options) {
+        console.log(chalk.blue(`Importing ${entityName} from source DB with options: ${JSON.stringify({
+            strategy: options.strategy,
+            limit: options.limit,
+            includeRelations: options.includeRelations,
+            maxDepth: options.maxDepth
+        })}`));
+        // 1. DataExplorer로 sourceDb에서 데이터 조회 (관련 데이터 포함)
+        const exploreResult = await this.dataExplorer.exploreWithRelations(entityName, options);
+        console.log(chalk.cyan(`Found ${exploreResult.main.records.length} ${entityName} records and ${exploreResult.related.size} related entities`));
+        // 2. FixtureRecord로 변환
+        const fixtureRecords = [];
+        // 메인 entity의 records를 FixtureRecord로 변환
+        const mainEntity = this.entityManager.get(entityName);
+        for (const record of exploreResult.main.records){
+            const records = await FixtureManager.createFixtureRecord(mainEntity, record, {
+                _db: this.sourceDb,
+                singleRecord: true
+            });
+            fixtureRecords.push(...records);
+        }
+        // 관련 entity의 records를 FixtureRecord로 변환
+        for (const [relatedEntityName, relatedRecords] of exploreResult.related.entries()){
+            const relatedEntity = this.entityManager.get(relatedEntityName);
+            for (const record of relatedRecords){
+                const records = await FixtureManager.createFixtureRecord(relatedEntity, record, {
+                    _db: this.sourceDb,
+                    singleRecord: true
+                });
+                fixtureRecords.push(...records);
+            }
+            console.log(chalk.gray(`  - ${relatedEntityName}: ${relatedRecords.length} records`));
+        }
+        // 3. targetDb에 삽입 (FixtureManager가 의존성 정렬 처리)
+        const results = await FixtureManager.insertFixtures(this.targetDbName, fixtureRecords);
+        console.log(chalk.green(`Successfully imported ${results.length} records to ${this.targetDbName} (${exploreResult.main.records.length} ${entityName} + ${results.length - exploreResult.main.records.length} related)`));
+        return results;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/testing/fixture-generator.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport type { Knex } from \"knex\";\nimport type { Entity } from \"../entity/entity\";\nimport type { EntityManager } from \"../entity/entity-manager\";\nimport type { EntityProp, FixtureImportResult, FixtureRecord } from \"../types/types\";\nimport { isBelongsToOneRelationProp, isOneToOneRelationProp, isRelationProp } from \"../types/types\";\nimport {\n  DataExplorer,\n  type ExploreWithRelationsOptions,\n  type ExploreWithRelationsResult,\n} from \"./data-explorer\";\nimport { type FakerMappings, fakerMappings } from \"./faker-mappings\";\nimport { FixtureManager } from \"./fixture-manager\";\n\nexport type Locale = \"ko\" | \"en\" | \"ja\";\n\nexport type FixtureGeneratorOptions = {\n  locale?: Locale;\n  useLLM?: boolean;\n  enableLLMCache?: boolean;\n  llmModel?: string;\n};\n\nexport type GeneratorContext = {\n  /** 생성 중인 fixture들 (메모리 상) */\n  fixtures: Map<string, Record<string, unknown>>;\n\n  /** 참조 데이터 캐시 (DataExplorer 결과) */\n  referenceCache: Map<string, Record<string, unknown>[]>;\n\n  /** 이미 import된 레코드를 추적하여 중복 import를 방지합니다 */\n  importedRecords: Set<string>; // \"User#123\"\n};\n\nexport class FixtureGenerator {\n  private dataExplorer: DataExplorer;\n  private locale: Locale;\n  private mappings: FakerMappings;\n  private llmCache: Map<string, unknown> = new Map();\n  private options: FixtureGeneratorOptions;\n\n  constructor(\n    private sourceDb: Knex,\n    // FixtureManager.insertFixtures가 dbName 문자열을 받기 때문에 직접 사용하지 않습니다\n    // 미래 확장성을 위해 API 시그니처에는 포함시켰습니다\n    _targetDb: Knex,\n    private targetDbName: \"fixture\" | \"test\" | \"production_master\",\n    private entityManager: typeof EntityManager,\n    options?: FixtureGeneratorOptions,\n  ) {\n    this.dataExplorer = new DataExplorer(sourceDb, entityManager);\n    this.locale = options?.locale || \"ko\";\n    this.mappings = fakerMappings;\n    this.options = {\n      locale: options?.locale || \"ko\",\n      useLLM: options?.useLLM || false,\n      enableLLMCache: options?.enableLLMCache !== false,\n      llmModel: options?.llmModel || \"claude-sonnet-4-5\",\n    };\n  }\n\n  /**\n   * Fixture 생성 (단일)\n   * @returns 생성된 fixture 데이터 (메모리 상)\n   */\n  async generate(\n    entityName: string,\n    overrides: Record<string, unknown> = {},\n    context: GeneratorContext = this.createContext(),\n  ): Promise<Record<string, unknown>> {\n    const entity = this.entityManager.get(entityName);\n    const tempId = `${entityName}#temp#${Date.now()}`; // 임시 ID\n\n    // 각 prop별 값 생성\n    const fixture: Record<string, unknown> = {};\n\n    for (const prop of entity.props) {\n      // Virtual prop은 스킵\n      if (\"virtual\" in prop && prop.virtual) {\n        continue;\n      }\n\n      // override가 있으면 사용\n      if (prop.name in overrides) {\n        fixture[prop.name] = overrides[prop.name];\n        continue;\n      }\n\n      // cone에서 생성 전략 확인\n      const cone = prop.cone;\n\n      // 1. Relation prop 처리\n      if (isRelationProp(prop)) {\n        const relationValue = await this.generateRelationValue(entity, prop, context);\n        // BelongsToOne, OneToOne(hasJoinColumn)의 경우 foreign key 컬럼명으로 저장\n        if (\n          isBelongsToOneRelationProp(prop) ||\n          (isOneToOneRelationProp(prop) && prop.hasJoinColumn)\n        ) {\n          fixture[`${prop.name}_id`] = relationValue;\n        } else {\n          fixture[prop.name] = relationValue;\n        }\n        continue;\n      }\n\n      // 2. fixtureGenerator 사용\n      if (cone?.fixtureGenerator) {\n        fixture[prop.name] = await this.executeGenerator(\n          cone.fixtureGenerator as string,\n          prop,\n          entity,\n        );\n        continue;\n      }\n\n      // 2.5. fixtureHint + LLM 사용\n      if (cone?.fixtureHint && this.options.useLLM) {\n        try {\n          fixture[prop.name] = await this.generateWithLLM(cone.fixtureHint, prop, entity);\n          continue;\n        } catch (error) {\n          console.warn(\n            `[FixtureGenerator] LLM generation failed for ${entity.id}.${prop.name}, falling back to default`,\n            error instanceof Error ? error.message : error,\n          );\n          // fallback: fixtureDefault 또는 기본값으로 계속\n        }\n      }\n\n      // 3. fixtureDefault 사용\n      if (cone?.fixtureDefault !== undefined) {\n        fixture[prop.name] = cone.fixtureDefault;\n        continue;\n      }\n\n      // 4. 타입별 기본 생성\n      fixture[prop.name] = await this.generateDefaultValue(prop, entity);\n    }\n\n    // 5. password 필드 암호화\n    if (\"password\" in fixture && fixture.password && typeof fixture.password === \"string\") {\n      const bcrypt = await import(\"bcrypt\");\n      fixture.password = await bcrypt.hash(fixture.password, 10);\n    }\n\n    context.fixtures.set(tempId, fixture);\n    return fixture;\n  }\n\n  /**\n   * Relation 값 생성 + 자동 Import\n   */\n  private async generateRelationValue(\n    entity: Entity,\n    prop: EntityProp,\n    context: GeneratorContext,\n  ): Promise<number | null> {\n    if (!isRelationProp(prop)) {\n      throw new Error(`FixtureGenerator: ${entity.id}.${prop.name} is not a relation prop`);\n    }\n\n    // BelongsToOne, OneToOne(hasJoinColumn)만 처리\n    if (\n      !isBelongsToOneRelationProp(prop) &&\n      !(isOneToOneRelationProp(prop) && prop.hasJoinColumn)\n    ) {\n      return null;\n    }\n\n    const cone = prop.cone;\n    const dataSource = cone?.dataSource;\n\n    // DataExplorer로 참조 데이터 조회 (sourceDb)\n    // 관계 체인을 따라가기 위해 exploreWithRelations 사용\n    if (dataSource) {\n      const cacheKey = `${prop.with}:${JSON.stringify(dataSource)}`;\n\n      if (!context.referenceCache.has(cacheKey)) {\n        const exploreResult = await this.dataExplorer.exploreWithRelations(prop.with, {\n          strategy: dataSource.strategy,\n          limit:\n            ((dataSource.config as Record<string, unknown> | undefined)?.limit as\n              | number\n              | undefined) || 10,\n          includeRelations: true,\n          maxDepth: 3,\n          ...(dataSource.config as Record<string, unknown> | undefined),\n        });\n        context.referenceCache.set(cacheKey, exploreResult.main.records);\n\n        // 조회한 데이터와 관계된 모든 엔티티를 targetDb에 import\n        await this.importExploreResult(exploreResult, context);\n      }\n\n      const candidates = context.referenceCache.get(cacheKey);\n      if (candidates && candidates.length > 0) {\n        // 랜덤하게 하나 선택\n        const selected = candidates[Math.floor(Math.random() * candidates.length)];\n        return selected.id as number;\n      }\n    }\n\n    // dataSource가 없을 때 자동으로 fixture DB에서 조회 시도\n    // 관계 체인을 따라가기 위해 exploreWithRelations 사용\n    const autoKey = `${prop.with}:auto`;\n    if (!context.referenceCache.has(autoKey)) {\n      // fixture DB(sourceDb)에서 자동 조회 (관계 포함)\n      const autoExploreResult = await this.dataExplorer.exploreWithRelations(prop.with, {\n        strategy: \"random\",\n        limit: 10,\n        includeRelations: true,\n        maxDepth: 3,\n      });\n      context.referenceCache.set(autoKey, autoExploreResult.main.records);\n\n      // 조회한 데이터와 관계된 모든 엔티티를 targetDb에 import\n      if (autoExploreResult.main.records.length > 0) {\n        await this.importExploreResult(autoExploreResult, context);\n      }\n    }\n\n    const autoCandidates = context.referenceCache.get(autoKey);\n    if (autoCandidates && autoCandidates.length > 0) {\n      // 랜덤하게 하나 선택\n      const selected = autoCandidates[Math.floor(Math.random() * autoCandidates.length)];\n      return selected.id as number;\n    }\n\n    // 참조 데이터가 없으면 null 반환 (nullable인 경우)\n    if (prop.nullable) {\n      return null;\n    }\n\n    // nullable이 아니고 데이터도 없으면 에러\n    throw new Error(\n      `FixtureGenerator: ${entity.id}.${prop.name}에 필요한 ${prop.with} 데이터가 없습니다. ` +\n        `먼저 ${prop.with}를 생성하거나 cone.dataSource를 설정하세요.`,\n    );\n  }\n\n  /**\n   * ExploreWithRelations 결과를 targetDb에 import\n   *\n   * 관계 체인을 따라간 결과(main + related)를 모두 import합니다.\n   * 의존성 순서는 FixtureManager.insertFixtures가 자동으로 처리합니다.\n   */\n  private async importExploreResult(\n    exploreResult: ExploreWithRelationsResult,\n    context: GeneratorContext,\n  ): Promise<void> {\n    const allFixtureRecords: FixtureRecord[] = [];\n\n    // 1. Related entities import (Company, Department 등)\n    for (const [entityId, records] of exploreResult.related.entries()) {\n      const entity = this.entityManager.get(entityId);\n      const recordsToImport: Record<string, unknown>[] = [];\n\n      console.log(chalk.cyan(`Importing related entity: ${entityId} (${records.length} records)`));\n\n      for (const record of records) {\n        const recordKey = `${entityId}#${record.id}`;\n        if (!context.importedRecords.has(recordKey)) {\n          recordsToImport.push(record);\n          context.importedRecords.add(recordKey);\n        }\n      }\n\n      if (recordsToImport.length > 0) {\n        for (const record of recordsToImport) {\n          console.log(\n            chalk.gray(`  - Processing ${entityId} record:`, JSON.stringify(record).slice(0, 100)),\n          );\n          const fixtureRecords = await FixtureManager.createFixtureRecord(\n            entity,\n            record as { id: number | string; [key: string]: string | number | boolean | null },\n            { _db: this.sourceDb, singleRecord: true },\n          );\n          allFixtureRecords.push(...fixtureRecords);\n        }\n      }\n    }\n\n    // 2. Main entity import (Employee 등)\n    const mainEntity = this.entityManager.get(exploreResult.main.entityId);\n    const mainRecordsToImport: Record<string, unknown>[] = [];\n\n    console.log(\n      chalk.cyan(\n        `Importing main entity: ${exploreResult.main.entityId} (${exploreResult.main.records.length} records)`,\n      ),\n    );\n\n    for (const record of exploreResult.main.records) {\n      const recordKey = `${exploreResult.main.entityId}#${record.id}`;\n      if (!context.importedRecords.has(recordKey)) {\n        mainRecordsToImport.push(record);\n        context.importedRecords.add(recordKey);\n      }\n    }\n\n    if (mainRecordsToImport.length > 0) {\n      for (const record of mainRecordsToImport) {\n        console.log(\n          chalk.gray(\n            `  - Processing ${exploreResult.main.entityId} record:`,\n            JSON.stringify(record).slice(0, 100),\n          ),\n        );\n        const fixtureRecords = await FixtureManager.createFixtureRecord(\n          mainEntity,\n          record as { id: number | string; [key: string]: string | number | boolean | null },\n          { _db: this.sourceDb, singleRecord: true },\n        );\n        allFixtureRecords.push(...fixtureRecords);\n      }\n    }\n\n    // 3. 모든 fixture를 한 번에 삽입 (의존성 순서 자동 처리)\n    if (allFixtureRecords.length > 0) {\n      await FixtureManager.insertFixtures(this.targetDbName, allFixtureRecords);\n\n      console.log(\n        chalk.green(\n          `Auto-imported ${exploreResult.main.entityId} with relations: ` +\n            `${exploreResult.main.records.length} main + ${exploreResult.related.size} related entities`,\n        ),\n      );\n    }\n  }\n\n  /**\n   * fixtureGenerator 실행 (Faker.js만 지원)\n   *\n   * faker.* 형식의 표현식을 안전하게 파싱하여 실행합니다.\n   * 예: \"faker.internet.email()\" → faker.internet.email()\n   * 예: \"faker.lorem.words(3)\" → faker.lorem.words(3)\n   */\n  private async executeGenerator(\n    generator: string,\n    prop: EntityProp,\n    entity: Entity,\n  ): Promise<unknown> {\n    // Faker.js 표현식만 지원\n    if (generator.startsWith(\"faker.\")) {\n      // username이나 name 필드는 한국어 faker 사용\n      const isNameField = prop.name === \"username\" || prop.name === \"name\";\n      const fakerModule = await import(\"@faker-js/faker\");\n      const faker = isNameField ? fakerModule.fakerKO : fakerModule.faker;\n      const expr = generator.slice(6); // \"faker.\" 제거\n\n      try {\n        // 함수 경로와 인자 파싱\n        const match = expr.match(/^([\\w.]+)(?:\\((.*?)\\))?$/);\n        if (!match) {\n          throw new Error(\n            `FixtureGenerator: Invalid faker expression for ${prop.name}: ${generator}`,\n          );\n        }\n\n        const [, path, argsStr] = match;\n        const parts = path.split(\".\");\n\n        // faker 객체에서 함수 찾기\n        let fn: unknown = faker;\n        for (const part of parts) {\n          if (typeof fn === \"object\" && fn !== null && part in fn) {\n            fn = (fn as Record<string, unknown>)[part];\n          } else {\n            throw new Error(`FixtureGenerator: Invalid faker path for ${prop.name}: faker.${path}`);\n          }\n        }\n\n        // 함수가 아니면 에러\n        if (typeof fn !== \"function\") {\n          throw new Error(`FixtureGenerator: faker.${path} is not a function (for ${prop.name})`);\n        }\n\n        // 인자 파싱 (JSON 형식만 지원)\n        let args: unknown[] = [];\n        if (argsStr?.trim()) {\n          try {\n            // JSON 배열로 파싱 시도\n            const parsed = JSON.parse(`[${argsStr}]`) as unknown;\n            args = Array.isArray(parsed) ? parsed : [parsed];\n          } catch {\n            // 숫자나 문자열 단일 인자 처리\n            const trimmed = argsStr.trim();\n            if (!Number.isNaN(Number(trimmed))) {\n              args = [Number(trimmed)];\n            } else if (\n              (trimmed.startsWith('\"') && trimmed.endsWith('\"')) ||\n              (trimmed.startsWith(\"'\") && trimmed.endsWith(\"'\"))\n            ) {\n              args = [trimmed.slice(1, -1)];\n            } else {\n              throw new Error(\n                `FixtureGenerator: Cannot parse arguments for ${prop.name}: ${argsStr}`,\n              );\n            }\n          }\n        }\n\n        return fn(...args);\n      } catch (error) {\n        console.log(\n          chalk.yellow(\n            `Failed to execute generator \"${generator}\" for ${prop.name}, falling back to default:`,\n          ),\n          error,\n        );\n        return this.generateDefaultValue(prop, entity);\n      }\n    }\n\n    // faker 이외의 표현식은 지원하지 않음\n    console.log(\n      chalk.yellow(\n        `Unsupported generator expression for ${prop.name}: ${generator}. Only faker.* expressions are supported. Using default value.`,\n      ),\n    );\n    return this.generateDefaultValue(prop, entity);\n  }\n\n  /**\n   * 필드의 타입과 이름을 분석하여 적절한 기본값을 생성합니다.\n   *\n   * 우선순위:\n   * 1. 필드명 패턴 매칭 (salary, budget 등 의미있는 데이터)\n   * 2. 특수 케이스 (Department name 등 도메인 지식)\n   * 3. 배열 타입 (JSON 배열)\n   * 4. Enum 타입\n   * 5. 타입별 기본값\n   */\n  private async generateDefaultValue(prop: EntityProp, entity?: Entity): Promise<unknown> {\n    const fakerModule = await import(\"@faker-js/faker\");\n    const faker = fakerModule.faker;\n    const fakerKO = fakerModule.fakerKO;\n    const fakerJA = fakerModule.fakerJA;\n\n    const localeFaker = this.locale === \"ko\" ? fakerKO : this.locale === \"ja\" ? fakerJA : faker;\n\n    /**\n     * 1. 필드명에서 의미를 추론하여 현실적인 데이터를 생성합니다.\n     * 예: salary → 30M~150M (한국 연봉 범위)\n     *     budget → 10M~500M (프로젝트 예산 범위)\n     */\n    const localeMappings = this.mappings[this.locale] || this.mappings.en;\n    const normalizedName = prop.name.toLowerCase().replace(/_/g, \"\");\n\n    for (const [pattern, config] of Object.entries(localeMappings.field_patterns)) {\n      if (normalizedName.includes(pattern.toLowerCase())) {\n        try {\n          return await this.executeFakerExpression(config.faker, prop);\n        } catch (error) {\n          console.log(\n            chalk.yellow(\n              `Failed to execute field pattern \"${pattern}\" for ${prop.name}, falling back:`,\n            ),\n            error,\n          );\n          break;\n        }\n      }\n    }\n\n    /**\n     * 2. Department name은 한국어 부서명 목록에서 선택합니다.\n     * 고유성을 위해 70% 확률로 prefix/suffix를 추가합니다.\n     */\n    if (entity?.id === \"Department\" && prop.name === \"name\") {\n      const departments = [\n        \"개발팀\",\n        \"기획팀\",\n        \"마케팅팀\",\n        \"영업팀\",\n        \"인사팀\",\n        \"총무팀\",\n        \"재무팀\",\n        \"회계팀\",\n        \"법무팀\",\n        \"디자인팀\",\n        \"IT팀\",\n        \"고객지원팀\",\n        \"품질관리팀\",\n        \"연구개발팀\",\n        \"생산팀\",\n        \"구매팀\",\n        \"물류팀\",\n      ];\n      const prefixes = [\"신규\", \"통합\", \"전략\", \"글로벌\", \"디지털\", \"핵심\"];\n      const suffixes = [\"1팀\", \"2팀\", \"3팀\", \"A팀\", \"B팀\", \"본부\", \"센터\", \"그룹\"];\n\n      const dept = faker.helpers.arrayElement(departments);\n\n      const random = Math.random();\n      if (random > 0.7) {\n        const prefix = faker.helpers.arrayElement(prefixes);\n        return `${prefix} ${dept}`;\n      }\n      if (random > 0.4) {\n        const suffix = faker.helpers.arrayElement(suffixes);\n        return `${dept} ${suffix}`;\n      }\n      return dept;\n    }\n\n    /**\n     * 3. JSON 타입이면서 배열인 경우 (SonamuFile[], string[] 등)\n     * 필드명 패턴을 보고 적절한 배열 데이터를 생성합니다.\n     */\n    if (prop.type === \"json\" && \"id\" in prop && prop.id) {\n      if (prop.id.endsWith(\"[]\")) {\n        return this.generateArrayValue(prop, entity, faker, localeFaker);\n      }\n    }\n\n    /** 4. Enum 타입은 정의된 값 중 하나를 랜덤 선택합니다 */\n    if (prop.type === \"enum\") {\n      let enumValues: string[] = [];\n\n      if (\"enum\" in prop && Array.isArray(prop.enum) && prop.enum.length > 0) {\n        enumValues = prop.enum;\n      } else if (\"id\" in prop && prop.id && entity?.enumLabels?.[prop.id]) {\n        enumValues = Object.keys(entity.enumLabels[prop.id]);\n      }\n\n      if (enumValues.length > 0) {\n        return faker.helpers.arrayElement(enumValues);\n      }\n      return prop.nullable ? null : \"UNKNOWN\";\n    }\n\n    if (prop.type === \"enum[]\") {\n      let enumValues: string[] = [];\n\n      if (\"enum\" in prop && Array.isArray(prop.enum) && prop.enum.length > 0) {\n        enumValues = prop.enum;\n      } else if (\"id\" in prop && prop.id && entity?.enumLabels?.[prop.id]) {\n        enumValues = Object.keys(entity.enumLabels[prop.id]);\n      }\n\n      if (enumValues.length > 0) {\n        return [faker.helpers.arrayElement(enumValues)];\n      }\n      return [];\n    }\n\n    /**\n     * 5. Vector 타입은 현재 지원하지 않으므로 null을 반환합니다.\n     * 향후 AI embedding 생성 기능 추가 시 구현 예정입니다.\n     */\n    if (prop.type === \"vector\" || prop.type === \"vector[]\" || prop.type === \"tsvector\") {\n      return null;\n    }\n\n    /** 6. 타입별 기본 Faker 표현식을 실행합니다 */\n    const typeDefault = localeMappings.type_defaults[prop.type];\n    if (typeDefault) {\n      try {\n        return await this.executeFakerExpression(typeDefault.faker, prop);\n      } catch (error) {\n        console.log(\n          chalk.yellow(`Failed to execute type default for ${prop.type}, using fallback:`, error),\n        );\n      }\n    }\n\n    /** 7. 매핑되지 않은 타입은 기본 Faker 함수로 처리합니다 */\n    switch (prop.type) {\n      case \"string\":\n      case \"string[]\":\n        return faker.lorem.words(3);\n      case \"integer\":\n        return faker.number.int({ min: 1, max: 1000 });\n      case \"integer[]\":\n        return [faker.number.int({ min: 1, max: 1000 })];\n      case \"bigInteger\":\n        return faker.number.bigInt({ min: 1n, max: 1000n });\n      case \"bigInteger[]\":\n        return [faker.number.bigInt({ min: 1n, max: 1000n })];\n      case \"number\":\n      case \"numeric\":\n        return faker.number.float({ min: 0, max: 1000 });\n      case \"number[]\":\n      case \"numeric[]\":\n        return [faker.number.float({ min: 0, max: 1000 })];\n      case \"boolean\":\n        return faker.datatype.boolean();\n      case \"boolean[]\":\n        return [faker.datatype.boolean()];\n      case \"date\":\n      case \"date[]\":\n        return faker.date.past();\n      case \"json\":\n        return {};\n      case \"uuid\":\n      case \"uuid[]\":\n        return faker.string.uuid();\n      default:\n        return null;\n    }\n  }\n\n  /**\n   * 배열 타입의 값을 생성합니다.\n   *\n   * 타입 ID와 필드명 패턴을 분석하여 적절한 배열 데이터를 생성합니다.\n   * 예: image_urls → [{url, name, mime_type}, ...]\n   *     tag_ids → [1, 23, 45]\n   */\n  private generateArrayValue(\n    prop: EntityProp,\n    _entity: Entity | undefined,\n    faker: typeof import(\"@faker-js/faker\").faker,\n    _localeFaker: typeof import(\"@faker-js/faker\").faker,\n  ): unknown[] {\n    const count = faker.number.int({ min: 1, max: 3 });\n\n    /** SonamuFile[]은 Sonamu 내장 타입으로 구조가 정해져 있습니다 */\n    if (\"id\" in prop && prop.id === \"SonamuFile[]\") {\n      return Array.from({ length: count }, () => ({\n        url: faker.image.url(),\n        name: faker.system.fileName(),\n        mime_type: faker.helpers.arrayElement([\n          \"image/jpeg\",\n          \"image/png\",\n          \"image/gif\",\n          \"application/pdf\",\n        ]),\n      }));\n    }\n\n    /** 필드명에서 배열의 용도를 추론합니다 */\n    const normalizedName = prop.name.toLowerCase().replace(/_/g, \"\");\n\n    if (normalizedName.includes(\"url\") || normalizedName.includes(\"image\")) {\n      return Array.from({ length: count }, () => faker.internet.url());\n    }\n\n    if (normalizedName.includes(\"id\") && normalizedName.endsWith(\"s\")) {\n      return Array.from({ length: count }, () => faker.number.int({ min: 1, max: 100 }));\n    }\n\n    if (normalizedName.includes(\"tag\") || normalizedName.includes(\"name\")) {\n      return Array.from({ length: count }, () => faker.lorem.word());\n    }\n\n    /** 패턴 매칭되지 않으면 빈 배열을 반환합니다 */\n    return [];\n  }\n\n  /**\n   * JSON 매핑의 Faker 표현식을 파싱하여 실행합니다.\n   *\n   * 표현식 예시:\n   * - \"faker.internet.email()\" → 인자 없음\n   * - \"faker.number.int({ min: 1, max: 100 })\" → JSON 인자\n   * - \"{}\" → 리터럴 값 (JSON.parse)\n   *\n   * fakerKO, fakerJA도 지원하여 다국어 데이터를 생성합니다.\n   */\n  private async executeFakerExpression(expression: string, prop: EntityProp): Promise<unknown> {\n    const fakerModule = await import(\"@faker-js/faker\");\n    const faker = fakerModule.faker;\n    const fakerKO = fakerModule.fakerKO;\n    const fakerJA = fakerModule.fakerJA;\n\n    /** Faker 표현식이 아닌 리터럴 값은 JSON으로 파싱합니다 */\n    if (!expression.startsWith(\"faker\")) {\n      try {\n        return JSON.parse(expression);\n      } catch {\n        return expression;\n      }\n    }\n\n    /** 표현식에서 Faker 객체와 경로를 추출합니다 */\n    const match = expression.match(/^(faker|fakerKO|fakerJA)\\.(.*?)$/);\n    if (!match) {\n      throw new Error(`Invalid faker expression: ${expression}`);\n    }\n\n    const [, fakerName, expr] = match;\n    const selectedFaker =\n      fakerName === \"fakerKO\" ? fakerKO : fakerName === \"fakerJA\" ? fakerJA : faker;\n\n    const funcMatch = expr.match(/^([\\w.]+)(?:\\((.*?)\\))?$/);\n    if (!funcMatch) {\n      throw new Error(`Invalid faker expression for ${prop.name}: ${expression}`);\n    }\n\n    const [, path, argsStr] = funcMatch;\n    const parts = path.split(\".\");\n\n    /** 점 표기법(dot notation)으로 Faker 함수를 찾아갑니다 */\n    let fn: unknown = selectedFaker;\n    for (const part of parts) {\n      if (typeof fn === \"object\" && fn !== null && part in fn) {\n        fn = (fn as Record<string, unknown>)[part];\n      } else {\n        throw new Error(`Invalid faker path for ${prop.name}: ${fakerName}.${path}`);\n      }\n    }\n\n    if (typeof fn !== \"function\") {\n      throw new Error(`${fakerName}.${path} is not a function (for ${prop.name})`);\n    }\n\n    /** 함수 인자를 JSON으로 파싱합니다 */\n    let args: unknown[] = [];\n    if (argsStr?.trim()) {\n      try {\n        const parsed = JSON.parse(`[${argsStr}]`) as unknown;\n        args = Array.isArray(parsed) ? parsed : [parsed];\n      } catch {\n        /** JSON 파싱 실패 시 단순 숫자/문자열로 시도합니다 */\n        const trimmed = argsStr.trim();\n        if (!Number.isNaN(Number(trimmed))) {\n          args = [Number(trimmed)];\n        } else if (\n          (trimmed.startsWith('\"') && trimmed.endsWith('\"')) ||\n          (trimmed.startsWith(\"'\") && trimmed.endsWith(\"'\"))\n        ) {\n          args = [trimmed.slice(1, -1)];\n        } else {\n          throw new Error(`Cannot parse arguments for ${prop.name}: ${argsStr}`);\n        }\n      }\n    }\n\n    return fn(...args);\n  }\n\n  /**\n   * fixtureHint를 LLM에게 전달하여 현실적인 테스트 데이터를 생성합니다.\n   *\n   * faker.js로는 생성하기 어려운 복잡한 텍스트(자기소개, 설명문 등)를\n   * LLM을 활용하여 생성합니다. 동일한 hint에 대한 중복 호출을 방지하기 위해\n   * 캐싱을 기본으로 지원합니다 (LLM API 비용 절감).\n   *\n   * ai 패키지는 dynamic import로 불러오므로, useLLM이 false인 경우\n   * 의존성이 설치되지 않아도 fixture 생성이 정상 동작합니다.\n   */\n  private async generateWithLLM(\n    fixtureHint: string,\n    prop: EntityProp,\n    entity: Entity,\n  ): Promise<unknown> {\n    const cacheKey = `${entity.id}:${prop.name}:${fixtureHint}`;\n    if (this.options.enableLLMCache && this.llmCache.has(cacheKey)) {\n      return this.llmCache.get(cacheKey);\n    }\n\n    const apiKey = this.getApiKey();\n    const { createAnthropic } = await import(\"@ai-sdk/anthropic\");\n    const { generateText } = await import(\"ai\");\n\n    const { text } = await generateText({\n      model: createAnthropic({ apiKey })(this.options.llmModel || \"claude-sonnet-4-5\"),\n      prompt: this.buildLLMPrompt(fixtureHint, prop, entity),\n    });\n\n    const value = this.parseLLMResponse(text, prop.type);\n    if (this.options.enableLLMCache) {\n      this.llmCache.set(cacheKey, value);\n    }\n\n    return value;\n  }\n\n  private buildLLMPrompt(hint: string, prop: EntityProp, entity: Entity): string {\n    const locale = this.options.locale || \"ko\";\n    const language = locale === \"ko\" ? \"Korean\" : locale === \"ja\" ? \"Japanese\" : \"English\";\n\n    let prompt = `Generate test data for ${entity.id}.${prop.name} (type: ${prop.type})\n\nRequirement: ${hint}\n\nRules:\n- Return ONLY the value, no explanation or markdown\n- Use ${language} language if applicable\n- Format: ${this.getExpectedFormat(prop.type)}`;\n\n    // enum 타입인 경우 가능한 값 목록 추가\n    if (prop.type === \"enum\" || prop.type === \"enum[]\") {\n      let enumValues: string[] = [];\n\n      if (\"enum\" in prop && Array.isArray(prop.enum) && prop.enum.length > 0) {\n        enumValues = prop.enum;\n      } else if (\"id\" in prop && prop.id && entity?.enumLabels?.[prop.id]) {\n        enumValues = Object.keys(entity.enumLabels[prop.id]);\n      }\n\n      if (enumValues.length > 0) {\n        prompt += `\\n- IMPORTANT: Choose ONLY from these allowed values: ${enumValues.join(\", \")}`;\n      }\n    }\n\n    prompt += `\\n\\nExample: ${this.getExampleForType(prop.type, locale)}`;\n\n    return prompt;\n  }\n\n  private parseLLMResponse(text: string, propType: string): unknown {\n    const cleaned = text.trim();\n\n    // 배열 타입 처리\n    if (propType.endsWith(\"[]\")) {\n      try {\n        const parsed = JSON.parse(cleaned);\n        const baseType = propType.slice(0, -2); // \"integer[]\" -> \"integer\"\n\n        if (Array.isArray(parsed)) {\n          return parsed.map((item) => {\n            // null/undefined는 타입별 기본값으로\n            if (item === null || item === undefined) {\n              return this.getDefaultValueForType(baseType);\n            }\n            // 객체는 JSON.stringify 후 파싱 (json 타입인 경우)\n            if (typeof item === \"object\") {\n              return baseType === \"json\"\n                ? item\n                : this.parseScalarValue(JSON.stringify(item), baseType);\n            }\n            // primitive 값은 문자열로 변환 후 파싱\n            return this.parseScalarValue(String(item), baseType);\n          });\n        }\n\n        // 단일 값이 온 경우 배열로 감싸기\n        if (parsed === null || parsed === undefined) {\n          return [this.getDefaultValueForType(baseType)];\n        }\n        return [this.parseScalarValue(String(parsed), baseType)];\n      } catch {\n        return [];\n      }\n    }\n\n    return this.parseScalarValue(cleaned, propType);\n  }\n\n  private getDefaultValueForType(propType: string): unknown {\n    switch (propType) {\n      case \"integer\":\n        return 0;\n      case \"bigInteger\":\n        return 0n;\n      case \"float\":\n      case \"number\":\n      case \"numeric\":\n        return 0;\n      case \"boolean\":\n        return false;\n      case \"date\":\n        return new Date();\n      case \"json\":\n        return {};\n      case \"uuid\":\n        return \"00000000-0000-0000-0000-000000000000\";\n      default:\n        return \"\";\n    }\n  }\n\n  private parseScalarValue(text: string, propType: string): unknown {\n    const cleaned = text.trim();\n\n    switch (propType) {\n      case \"integer\": {\n        const num = parseInt(cleaned, 10);\n        return Number.isNaN(num) ? 0 : num;\n      }\n      case \"bigInteger\": {\n        try {\n          return BigInt(cleaned);\n        } catch {\n          return 0n;\n        }\n      }\n      case \"float\":\n      case \"number\":\n      case \"numeric\": {\n        const num = parseFloat(cleaned);\n        return Number.isNaN(num) ? 0 : num;\n      }\n      case \"boolean\":\n        return cleaned.toLowerCase() === \"true\";\n      case \"date\": {\n        const date = new Date(cleaned);\n        return Number.isNaN(date.getTime()) ? new Date() : date;\n      }\n      case \"json\":\n        try {\n          return JSON.parse(cleaned);\n        } catch {\n          return cleaned;\n        }\n      case \"uuid\":\n      case \"enum\":\n        return cleaned;\n      default:\n        return cleaned;\n    }\n  }\n\n  /**\n   * Sonamu.secret을 우선으로 하고, 없으면 환경변수에서 API 키를 읽습니다.\n   *\n   * Sonamu.secret은 프로젝트별 설정(sonamu.config.ts)이므로 더 높은 우선순위를 가지며,\n   * 환경변수는 개발 환경이나 CI/CD에서 fallback으로 사용됩니다.\n   */\n  private getApiKey(): string {\n    let apiKey: string | undefined;\n\n    try {\n      const { Sonamu } = require(\"../api\");\n      apiKey = Sonamu.secret?.anthropic_api_key;\n    } catch {\n      // Sonamu가 초기화되지 않은 경우 (테스트 환경 등)\n    }\n\n    if (!apiKey) {\n      apiKey = process.env.ANTHROPIC_API_KEY;\n    }\n\n    if (!apiKey) {\n      throw new Error(\n        \"ANTHROPIC_API_KEY not found. Set it in environment variables or Sonamu.secret.anthropic_api_key\",\n      );\n    }\n\n    return apiKey;\n  }\n\n  private getExpectedFormat(propType: string): string {\n    // 배열 타입 처리\n    if (propType.endsWith(\"[]\")) {\n      const baseType = propType.slice(0, -2);\n      const baseFormat = this.getScalarFormat(baseType);\n      return `JSON array of ${baseFormat} (e.g., [${this.getExampleForType(baseType, \"en\")}, ...])`;\n    }\n\n    return this.getScalarFormat(propType);\n  }\n\n  private getScalarFormat(propType: string): string {\n    switch (propType) {\n      case \"integer\":\n      case \"bigInteger\":\n        return \"integer numbers\";\n      case \"float\":\n      case \"number\":\n      case \"numeric\":\n        return \"decimal numbers\";\n      case \"boolean\":\n        return \"booleans (true or false)\";\n      case \"date\":\n        return \"ISO 8601 date strings\";\n      case \"json\":\n        return \"valid JSON object or array\";\n      case \"uuid\":\n        return \"UUID strings\";\n      case \"enum\":\n        return \"one of the allowed enum values\";\n      default:\n        return \"plain text strings\";\n    }\n  }\n\n  private getExampleForType(propType: string, locale: Locale): string {\n    // 배열 타입 처리\n    if (propType.endsWith(\"[]\")) {\n      const baseType = propType.slice(0, -2);\n      const baseExample = this.getScalarExample(baseType, locale);\n      return `[${baseExample}]`;\n    }\n\n    return this.getScalarExample(propType, locale);\n  }\n\n  private getScalarExample(propType: string, locale: Locale): string {\n    const isKorean = locale === \"ko\";\n\n    switch (propType) {\n      case \"integer\":\n      case \"bigInteger\":\n        return \"42\";\n      case \"float\":\n      case \"number\":\n      case \"numeric\":\n        return \"3.14\";\n      case \"boolean\":\n        return \"true\";\n      case \"date\":\n        return \"2024-01-01\";\n      case \"json\":\n        return '{\"key\": \"value\"}';\n      case \"uuid\":\n        return \"550e8400-e29b-41d4-a716-446655440000\";\n      case \"enum\":\n        return \"ENUM_VALUE\";\n      default:\n        return isKorean ? \"안녕하세요\" : \"Hello\";\n    }\n  }\n\n  /**\n   * LLM 캐시 통계를 반환합니다.\n   */\n  getLLMCacheStats() {\n    return {\n      size: this.llmCache.size,\n      enabled: this.options.enableLLMCache,\n    };\n  }\n\n  /**\n   * LLM 캐시를 초기화합니다.\n   */\n  clearLLMCache() {\n    this.llmCache.clear();\n  }\n\n  /**\n   * 컨텍스트 생성\n   */\n  private createContext(): GeneratorContext {\n    return {\n      fixtures: new Map(),\n      referenceCache: new Map(),\n      importedRecords: new Set(),\n    };\n  }\n\n  /**\n   * 배치 생성 및 자동 저장\n   *\n   * 1. 각 spec별로 fixture 생성 (메모리)\n   * 2. FixtureRecord로 변환\n   * 3. FixtureManager.insertFixtures()로 targetDb에 저장\n   *\n   * @returns 저장된 fixture 데이터 (실제 DB ID 포함)\n   */\n  async generateBatch(\n    specs: Array<{ entity: string; count: number; overrides?: Record<string, unknown> }>,\n  ): Promise<FixtureImportResult[]> {\n    const context = this.createContext();\n    const generatedFixtures: Array<{ entity: string; data: Record<string, unknown> }> = [];\n\n    // 1. 각 spec별로 fixture 생성\n    for (const spec of specs) {\n      for (let i = 0; i < spec.count; i++) {\n        const fixture = await this.generate(spec.entity, spec.overrides || {}, context);\n        generatedFixtures.push({\n          entity: spec.entity,\n          data: fixture,\n        });\n      }\n    }\n\n    // 2. FixtureRecord로 변환\n    const fixtureRecords: FixtureRecord[] = [];\n    for (const { entity: entityName, data } of generatedFixtures) {\n      const entity = this.entityManager.get(entityName);\n\n      // 임시 ID 생성 (targetDb에 INSERT 후 실제 ID를 받음)\n      const tempId = Math.floor(Math.random() * 1000000);\n      const records = await FixtureManager.createFixtureRecord(\n        entity,\n        { ...data, id: tempId } as { id: number; [key: string]: string | number | boolean | null },\n        { singleRecord: true },\n      );\n      fixtureRecords.push(...records);\n    }\n\n    // 3. targetDb에 삽입 (FixtureManager가 의존성 정렬 처리)\n    const results = await FixtureManager.insertFixtures(this.targetDbName, fixtureRecords);\n\n    console.log(\n      chalk.green(`Generated and saved ${results.length} fixtures to ${this.targetDbName}`),\n    );\n    return results;\n  }\n\n  /**\n   * 실제 DB(sourceDb)에서 데이터를 조회하여 fixture DB(targetDb)에 import합니다.\n   *\n   * 1. DataExplorer로 sourceDb에서 데이터 조회 (관련 데이터 포함)\n   * 2. FixtureRecord로 변환\n   * 3. targetDb에 삽입\n   *\n   * @param entityName - 조회할 entity 이름\n   * @param options - 조회 옵션 (strategy, limit, includeRelations 등)\n   * @returns 저장된 fixture 데이터 (실제 DB ID 포함)\n   *\n   * @example\n   * // 프로덕션 DB에서 User 10명 + 관련 Employee, Department 가져오기\n   * await generator.importFromSource(\"User\", {\n   *   strategy: \"sample\",\n   *   limit: 10,\n   *   includeRelations: true,\n   *   maxDepth: 2\n   * });\n   */\n  async importFromSource(\n    entityName: string,\n    options: ExploreWithRelationsOptions,\n  ): Promise<FixtureImportResult[]> {\n    console.log(\n      chalk.blue(\n        `Importing ${entityName} from source DB with options: ${JSON.stringify({ strategy: options.strategy, limit: options.limit, includeRelations: options.includeRelations, maxDepth: options.maxDepth })}`,\n      ),\n    );\n\n    // 1. DataExplorer로 sourceDb에서 데이터 조회 (관련 데이터 포함)\n    const exploreResult = await this.dataExplorer.exploreWithRelations(entityName, options);\n\n    console.log(\n      chalk.cyan(\n        `Found ${exploreResult.main.records.length} ${entityName} records and ${exploreResult.related.size} related entities`,\n      ),\n    );\n\n    // 2. FixtureRecord로 변환\n    const fixtureRecords: FixtureRecord[] = [];\n\n    // 메인 entity의 records를 FixtureRecord로 변환\n    const mainEntity = this.entityManager.get(entityName);\n    for (const record of exploreResult.main.records) {\n      const records = await FixtureManager.createFixtureRecord(\n        mainEntity,\n        record as { id: number | string; [key: string]: string | number | boolean | null },\n        { _db: this.sourceDb, singleRecord: true },\n      );\n      fixtureRecords.push(...records);\n    }\n\n    // 관련 entity의 records를 FixtureRecord로 변환\n    for (const [relatedEntityName, relatedRecords] of exploreResult.related.entries()) {\n      const relatedEntity = this.entityManager.get(relatedEntityName);\n      for (const record of relatedRecords) {\n        const records = await FixtureManager.createFixtureRecord(\n          relatedEntity,\n          record as { id: number | string; [key: string]: string | number | boolean | null },\n          { _db: this.sourceDb, singleRecord: true },\n        );\n        fixtureRecords.push(...records);\n      }\n\n      console.log(chalk.gray(`  - ${relatedEntityName}: ${relatedRecords.length} records`));\n    }\n\n    // 3. targetDb에 삽입 (FixtureManager가 의존성 정렬 처리)\n    const results = await FixtureManager.insertFixtures(this.targetDbName, fixtureRecords);\n\n    console.log(\n      chalk.green(\n        `Successfully imported ${results.length} records to ${this.targetDbName} (${exploreResult.main.records.length} ${entityName} + ${results.length - exploreResult.main.records.length} related)`,\n      ),\n    );\n\n    return results;\n  }\n}\n"],"names":["chalk","isBelongsToOneRelationProp","isOneToOneRelationProp","isRelationProp","DataExplorer","fakerMappings","FixtureManager","FixtureGenerator","dataExplorer","locale","mappings","llmCache","Map","options","sourceDb","_targetDb","targetDbName","entityManager","useLLM","enableLLMCache","llmModel","generate","entityName","overrides","context","createContext","entity","get","tempId","Date","now","fixture","prop","props","virtual","name","cone","relationValue","generateRelationValue","hasJoinColumn","fixtureGenerator","executeGenerator","fixtureHint","generateWithLLM","error","console","warn","id","Error","message","fixtureDefault","undefined","generateDefaultValue","password","bcrypt","hash","fixtures","set","dataSource","cacheKey","with","JSON","stringify","referenceCache","has","exploreResult","exploreWithRelations","strategy","limit","config","includeRelations","maxDepth","main","records","importExploreResult","candidates","length","selected","Math","floor","random","autoKey","autoExploreResult","autoCandidates","nullable","allFixtureRecords","entityId","related","entries","recordsToImport","log","cyan","record","recordKey","importedRecords","push","add","gray","slice","fixtureRecords","createFixtureRecord","_db","singleRecord","mainEntity","mainRecordsToImport","insertFixtures","green","size","generator","startsWith","isNameField","fakerModule","faker","fakerKO","expr","match","path","argsStr","parts","split","fn","part","args","trim","parsed","parse","Array","isArray","trimmed","Number","isNaN","endsWith","yellow","fakerJA","localeFaker","localeMappings","en","normalizedName","toLowerCase","replace","pattern","Object","field_patterns","includes","executeFakerExpression","departments","prefixes","suffixes","dept","helpers","arrayElement","prefix","suffix","type","generateArrayValue","enumValues","enum","enumLabels","keys","typeDefault","type_defaults","lorem","words","number","int","min","max","bigInt","float","datatype","boolean","date","past","string","uuid","_entity","_localeFaker","count","from","url","image","system","fileName","mime_type","internet","word","expression","fakerName","selectedFaker","funcMatch","apiKey","getApiKey","createAnthropic","generateText","text","model","prompt","buildLLMPrompt","value","parseLLMResponse","hint","language","getExpectedFormat","join","getExampleForType","propType","cleaned","baseType","map","item","getDefaultValueForType","parseScalarValue","String","num","parseInt","BigInt","parseFloat","getTime","Sonamu","require","secret","anthropic_api_key","process","env","ANTHROPIC_API_KEY","baseFormat","getScalarFormat","baseExample","getScalarExample","isKorean","getLLMCacheStats","enabled","clearLLMCache","clear","Set","generateBatch","specs","generatedFixtures","spec","i","data","results","importFromSource","blue","relatedEntityName","relatedRecords","relatedEntity"],"mappings":"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"}