sonamu 0.8.26 → 0.9.0

package/dist/bin/fixture.js

@@ -1,268 +1,275 @@
+import { createKnexInstance, init_knex } from "../database/knex.js";
+import { DB, init_db } from "../database/db.js";
+import { Sonamu, init_sonamu } from "../api/sonamu.js";
+import { EntityManager, init_entity_manager } from "../entity/entity-manager.js";
+import { DataExplorer, init_data_explorer } from "../testing/data-explorer.js";
+import { FixtureGenerator, init_fixture_generator } from "../testing/fixture-generator.js";
 import chalk from "chalk";
 import prompts from "prompts";
-import { Sonamu } from "../api/index.js";
-import { DB } from "../database/db.js";
-import { createKnexInstance } from "../database/knex.js";
-import { EntityManager } from "../entity/entity-manager.js";
-import { DataExplorer } from "../testing/data-explorer.js";
-import { FixtureGenerator } from "../testing/fixture-generator.js";
+
+//#region src/bin/fixture.ts
+init_sonamu();
+init_db();
+init_knex();
+init_entity_manager();
+init_data_explorer();
+init_fixture_generator();
 /**
- * fixture gen 명령어 - cone 메타데이터를 활용하여 자동으로 fixture를 생성합니다.
- */ export async function fixtureGenCommand(options) {
-    try {
-        if (!EntityManager.isAutoloaded) {
-            await EntityManager.autoload();
-        }
-        let entityNames;
-        if (options.all) {
-            entityNames = EntityManager.getAllIds();
-            if (options.exclude) {
-                const excludeList = options.exclude.split(",").map((s)=>s.trim());
-                entityNames = entityNames.filter((name)=>!excludeList.includes(name));
-            }
-        } else if (options.include) {
-            entityNames = options.include.split(",").map((s)=>s.trim());
-        } else {
-            const result = await prompts({
-                type: "multiselect",
-                name: "entities",
-                message: "Fixture를 생성할 Entity를 선택하세요:",
-                choices: EntityManager.getAllIds().map((id)=>({
-                        title: id,
-                        value: id
-                    })),
-                min: 1
-            });
-            if (!result.entities || result.entities.length === 0) {
-                console.log(chalk.yellow("취소되었습니다."));
-                return;
-            }
-            entityNames = result.entities;
-        }
-        let count = options.count ? Number.parseInt(options.count, 10) : 5;
-        if (!options.count) {
-            const result = await prompts({
-                type: "number",
-                name: "count",
-                message: "각 Entity별 생성 개수:",
-                initial: 5,
-                min: 1
-            });
-            if (!result.count) {
-                console.log(chalk.yellow("취소되었습니다."));
-                return;
-            }
-            count = result.count;
-        }
-        let saveTarget = options["save-to"] || "db";
-        if (!options["save-to"]) {
-            const result = await prompts({
-                type: "select",
-                name: "saveTarget",
-                message: "저장 방식:",
-                choices: [
-                    {
-                        title: "Fixture DB에 저장",
-                        value: "db"
-                    },
-                    {
-                        title: "파일로 저장 (자동 파일명)",
-                        value: "file"
-                    },
-                    {
-                        title: "파일로 저장 (파일명 지정)",
-                        value: "file:custom"
-                    },
-                    {
-                        title: "저장 안 함 (출력만)",
-                        value: "none"
-                    }
-                ]
-            });
-            saveTarget = result.saveTarget;
-            if (saveTarget === "file:custom") {
-                const filenameResult = await prompts({
-                    type: "text",
-                    name: "filename",
-                    message: "파일명:",
-                    initial: "fixtures.json"
-                });
-                if (!filenameResult.filename) {
-                    console.log(chalk.yellow("취소되었습니다."));
-                    return;
-                }
-                saveTarget = `file:${filenameResult.filename}`;
-            }
-        }
-        // LLM 사용 여부 결정
-        let useLLM = options["use-llm"] ?? false;
-        if (!options["use-llm"]) {
-            const llmResult = await prompts({
-                type: "confirm",
-                name: "useLLM",
-                message: "LLM으로 더 현실적인 데이터를 생성할까요? (fixtureHint 기반, ANTHROPIC_API_KEY 필요)",
-                initial: false
-            });
-            useLLM = llmResult.useLLM ?? false;
-        }
-        const enableLLMCache = !options["no-cache"];
-        // fixture gen: fixture DB 내에서 참조 관계를 해결하고 저장합니다
-        const fixtureDb = createKnexInstance(Sonamu.dbConfig.fixture);
-        const generator = new FixtureGenerator(fixtureDb, fixtureDb, "fixture", EntityManager, {
-            useLLM,
-            enableLLMCache
-        });
-        if (useLLM) {
-            console.log(chalk.cyan(`\nLLM 모드로 ${entityNames.join(", ")} 생성 중... (캐싱: ${enableLLMCache ? "ON" : "OFF"})`));
-        } else {
-            console.log(chalk.cyan(`\n${entityNames.join(", ")} 생성 중...`));
-        }
-        const specs = entityNames.map((entityName)=>({
-                entity: entityName,
-                count,
-                overrides: {}
-            }));
-        const results = await generator.generateBatch(specs);
-        if (useLLM) {
-            const stats = generator.getLLMCacheStats();
-            console.log(chalk.cyan(`[LLM Cache] 캐시 크기: ${stats.size}`));
-        }
-        console.log(chalk.green(`\n✅ ${results.length}개 fixture 생성 완료`));
-        if (saveTarget === "none") {
-            console.log(JSON.stringify(results, null, 2));
-        } else if (saveTarget === "db") {
-            // generateBatch가 이미 DB에 저장했으므로 별도 저장이 불필요합니다.
-            console.log(chalk.green("Fixture DB에 저장되었습니다."));
-        } else if (saveTarget.startsWith("file")) {
-            const fs = await import("node:fs/promises");
-            const path = await import("node:path");
-            const fixturesDir = path.join(process.cwd(), "test", "fixtures");
-            try {
-                await fs.access(fixturesDir);
-            } catch  {
-                await fs.mkdir(fixturesDir, {
-                    recursive: true
-                });
-            }
-            for (const entityName of entityNames){
-                const entityResults = results.filter((r)=>r.entityId === entityName);
-                if (entityResults.length === 0) {
-                    continue;
-                }
-                let filename;
-                if (saveTarget === "file") {
-                    const entity = EntityManager.get(entityName);
-                    filename = `${entity.table}.json`;
-                } else {
-                    filename = saveTarget.replace("file:", "");
-                }
-                const filepath = path.join(fixturesDir, filename);
-                await fs.writeFile(filepath, JSON.stringify(entityResults.map((r)=>r.data), null, 2));
-                console.log(chalk.green(`✅ ${filepath} 저장 완료`));
-            }
-        }
-    } catch (error) {
-        console.error(chalk.red("Fixture 생성 중 오류가 발생했습니다.\n" + "원인: Entity 정의나 DB 연결을 확인해주세요.\n" + "자세한 내용:"), error);
-        throw error;
-    }
+* fixture gen 명령어 - cone 메타데이터를 활용하여 자동으로 fixture를 생성합니다.
+*/
+async function fixtureGenCommand(options) {
+	try {
+		if (!EntityManager.isAutoloaded) {
+			await EntityManager.autoload();
+		}
+		let entityNames;
+		if (options.all) {
+			entityNames = EntityManager.getAllIds();
+			if (options.exclude) {
+				const excludeList = options.exclude.split(",").map((s) => s.trim());
+				entityNames = entityNames.filter((name) => !excludeList.includes(name));
+			}
+		} else if (options.include) {
+			entityNames = options.include.split(",").map((s) => s.trim());
+		} else {
+			const result = await prompts({
+				type: "multiselect",
+				name: "entities",
+				message: "Fixture를 생성할 Entity를 선택하세요:",
+				choices: EntityManager.getAllIds().map((id) => ({
+					title: id,
+					value: id
+				})),
+				min: 1
+			});
+			if (!result.entities || result.entities.length === 0) {
+				console.log(chalk.yellow("취소되었습니다."));
+				return;
+			}
+			entityNames = result.entities;
+		}
+		let count = options.count ? Number.parseInt(options.count, 10) : 5;
+		if (!options.count) {
+			const result = await prompts({
+				type: "number",
+				name: "count",
+				message: "각 Entity별 생성 개수:",
+				initial: 5,
+				min: 1
+			});
+			if (!result.count) {
+				console.log(chalk.yellow("취소되었습니다."));
+				return;
+			}
+			count = result.count;
+		}
+		let saveTarget = options["save-to"] || "db";
+		if (!options["save-to"]) {
+			const result = await prompts({
+				type: "select",
+				name: "saveTarget",
+				message: "저장 방식:",
+				choices: [
+					{
+						title: "Fixture DB에 저장",
+						value: "db"
+					},
+					{
+						title: "파일로 저장 (자동 파일명)",
+						value: "file"
+					},
+					{
+						title: "파일로 저장 (파일명 지정)",
+						value: "file:custom"
+					},
+					{
+						title: "저장 안 함 (출력만)",
+						value: "none"
+					}
+				]
+			});
+			saveTarget = result.saveTarget;
+			if (saveTarget === "file:custom") {
+				const filenameResult = await prompts({
+					type: "text",
+					name: "filename",
+					message: "파일명:",
+					initial: "fixtures.json"
+				});
+				if (!filenameResult.filename) {
+					console.log(chalk.yellow("취소되었습니다."));
+					return;
+				}
+				saveTarget = `file:${filenameResult.filename}`;
+			}
+		}
+		let useLLM = options["use-llm"] ?? false;
+		if (!options["use-llm"]) {
+			const llmResult = await prompts({
+				type: "confirm",
+				name: "useLLM",
+				message: "LLM으로 더 현실적인 데이터를 생성할까요? (fixtureHint 기반, ANTHROPIC_API_KEY 필요)",
+				initial: false
+			});
+			useLLM = llmResult.useLLM ?? false;
+		}
+		const enableLLMCache = !options["no-cache"];
+		const fixtureDb = createKnexInstance(Sonamu.dbConfig.fixture);
+		const generator = new FixtureGenerator(fixtureDb, fixtureDb, "fixture", EntityManager, {
+			useLLM,
+			enableLLMCache
+		});
+		if (useLLM) {
+			console.log(chalk.cyan(`\nLLM 모드로 ${entityNames.join(", ")} 생성 중... (캐싱: ${enableLLMCache ? "ON" : "OFF"})`));
+		} else {
+			console.log(chalk.cyan(`\n${entityNames.join(", ")} 생성 중...`));
+		}
+		const specs = entityNames.map((entityName) => ({
+			entity: entityName,
+			count,
+			overrides: {}
+		}));
+		const results = await generator.generateBatch(specs);
+		if (useLLM) {
+			const stats = generator.getLLMCacheStats();
+			console.log(chalk.cyan(`[LLM Cache] 캐시 크기: ${stats.size}`));
+		}
+		console.log(chalk.green(`\n✅ ${results.length}개 fixture 생성 완료`));
+		if (saveTarget === "none") {
+			console.log(JSON.stringify(results, null, 2));
+		} else if (saveTarget === "db") {
+			console.log(chalk.green("Fixture DB에 저장되었습니다."));
+		} else if (saveTarget.startsWith("file")) {
+			const fs = await import("node:fs/promises");
+			const path = await import("node:path");
+			const fixturesDir = path.join(process.cwd(), "test", "fixtures");
+			try {
+				await fs.access(fixturesDir);
+			} catch {
+				await fs.mkdir(fixturesDir, { recursive: true });
+			}
+			for (const entityName of entityNames) {
+				const entityResults = results.filter((r) => r.entityId === entityName);
+				if (entityResults.length === 0) {
+					continue;
+				}
+				let filename;
+				if (saveTarget === "file") {
+					const entity = EntityManager.get(entityName);
+					filename = `${entity.table}.json`;
+				} else {
+					filename = saveTarget.replace("file:", "");
+				}
+				const filepath = path.join(fixturesDir, filename);
+				await fs.writeFile(filepath, JSON.stringify(entityResults.map((r) => r.data), null, 2));
+				console.log(chalk.green(`✅ ${filepath} 저장 완료`));
+			}
+		}
+	} catch (error) {
+		console.error(chalk.red("Fixture 생성 중 오류가 발생했습니다.\n" + "원인: Entity 정의나 DB 연결을 확인해주세요.\n" + "자세한 내용:"), error);
+		throw error;
+	}
 }
 /**
- * fixture fetch 명령어 - 실제 운영 DB에서 데이터를 가져와 fixture로 저장합니다.
- * 관계된 데이터도 함께 가져오므로 현실적인 테스트 데이터를 확보할 수 있습니다.
- */ export async function fixtureFetchCommand(options) {
-    try {
-        if (!EntityManager.isAutoloaded) {
-            await EntityManager.autoload();
-        }
-        let entityNames;
-        if (options.all) {
-            entityNames = EntityManager.getAllIds();
-            if (options.exclude) {
-                const excludeList = options.exclude.split(",").map((s)=>s.trim());
-                entityNames = entityNames.filter((name)=>!excludeList.includes(name));
-            }
-        } else if (options.include) {
-            entityNames = options.include.split(",").map((s)=>s.trim());
-        } else {
-            const result = await prompts({
-                type: "multiselect",
-                name: "entities",
-                message: "Import할 Entity를 선택하세요:",
-                choices: EntityManager.getAllIds().map((id)=>({
-                        title: id,
-                        value: id
-                    })),
-                min: 1
-            });
-            if (!result.entities || result.entities.length === 0) {
-                console.log(chalk.yellow("취소되었습니다."));
-                return;
-            }
-            entityNames = result.entities;
-        }
-        const strategy = options.strategy ?? "recent";
-        const limit = options.limit ? Number.parseInt(options.limit, 10) : 10;
-        // fixture fetch: production 데이터를 fixture DB로 import합니다
-        const sourceDb = DB.getDB("r"); // production_master (또는 development_master)
-        const fixtureDb = createKnexInstance(Sonamu.dbConfig.fixture);
-        const generator = new FixtureGenerator(sourceDb, fixtureDb, "fixture", EntityManager);
-        console.log(chalk.cyan(`\n${entityNames.join(", ")} import 중...`));
-        for (const entityName of entityNames){
-            const results = await generator.importFromSource(entityName, {
-                strategy,
-                limit,
-                includeRelations: true,
-                maxDepth: 2
-            });
-            console.log(chalk.green(`✅ ${entityName}: ${results.length}개 import 완료`));
-        }
-    } catch (error) {
-        console.error(chalk.red("실제 DB에서 데이터를 가져오는 중 오류가 발생했습니다.\n" + "원인: 소스 DB 연결 설정(sonamu.config.ts)이나 Entity 관계 정의를 확인해주세요.\n" + "자세한 내용:"), error);
-        throw error;
-    }
+* fixture fetch 명령어 - 실제 운영 DB에서 데이터를 가져와 fixture로 저장합니다.
+* 관계된 데이터도 함께 가져오므로 현실적인 테스트 데이터를 확보할 수 있습니다.
+*/
+async function fixtureFetchCommand(options) {
+	try {
+		if (!EntityManager.isAutoloaded) {
+			await EntityManager.autoload();
+		}
+		let entityNames;
+		if (options.all) {
+			entityNames = EntityManager.getAllIds();
+			if (options.exclude) {
+				const excludeList = options.exclude.split(",").map((s) => s.trim());
+				entityNames = entityNames.filter((name) => !excludeList.includes(name));
+			}
+		} else if (options.include) {
+			entityNames = options.include.split(",").map((s) => s.trim());
+		} else {
+			const result = await prompts({
+				type: "multiselect",
+				name: "entities",
+				message: "Import할 Entity를 선택하세요:",
+				choices: EntityManager.getAllIds().map((id) => ({
+					title: id,
+					value: id
+				})),
+				min: 1
+			});
+			if (!result.entities || result.entities.length === 0) {
+				console.log(chalk.yellow("취소되었습니다."));
+				return;
+			}
+			entityNames = result.entities;
+		}
+		const strategy = options.strategy ?? "recent";
+		const limit = options.limit ? Number.parseInt(options.limit, 10) : 10;
+		const sourceDb = DB.getDB("r");
+		const fixtureDb = createKnexInstance(Sonamu.dbConfig.fixture);
+		const generator = new FixtureGenerator(sourceDb, fixtureDb, "fixture", EntityManager);
+		console.log(chalk.cyan(`\n${entityNames.join(", ")} import 중...`));
+		for (const entityName of entityNames) {
+			const results = await generator.importFromSource(entityName, {
+				strategy,
+				limit,
+				includeRelations: true,
+				maxDepth: 2
+			});
+			console.log(chalk.green(`✅ ${entityName}: ${results.length}개 import 완료`));
+		}
+	} catch (error) {
+		console.error(chalk.red("실제 DB에서 데이터를 가져오는 중 오류가 발생했습니다.\n" + "원인: 소스 DB 연결 설정(sonamu.config.ts)이나 Entity 관계 정의를 확인해주세요.\n" + "자세한 내용:"), error);
+		throw error;
+	}
 }
 /**
- * fixture explore 명령어 - DB의 실제 데이터를 조회하여 확인합니다.
- * 저장하지 않고 조회만 하므로 데이터를 빠르게 확인할 때 유용합니다.
- */ export async function fixtureExploreCommand(options) {
-    try {
-        if (!EntityManager.isAutoloaded) {
-            await EntityManager.autoload();
-        }
-        let entityName = options.include;
-        if (!entityName) {
-            const result = await prompts({
-                type: "select",
-                name: "entity",
-                message: "탐색할 Entity:",
-                choices: EntityManager.getAllIds().map((id)=>({
-                        title: id,
-                        value: id
-                    }))
-            });
-            if (!result.entity) {
-                console.log(chalk.yellow("취소되었습니다."));
-                return;
-            }
-            entityName = result.entity;
-        }
-        if (!entityName) {
-            throw new Error("Entity name is required");
-        }
-        const strategy = options.strategy ?? "sample";
-        const limit = options.limit ? Number.parseInt(options.limit, 10) : 10;
-        const db = DB.getDB("r");
-        const explorer = new DataExplorer(db, EntityManager);
-        const data = await explorer.explore(entityName, {
-            strategy,
-            limit
-        });
-        console.log(chalk.cyan(`\n${entityName} ${data.length}개 조회 완료:`));
-        console.table(data);
-    } catch (error) {
-        console.error(chalk.red("데이터 조회 중 오류가 발생했습니다.\n" + "원인: DB 연결이나 Entity 정의를 확인해주세요.\n" + "자세한 내용:"), error);
-        throw error;
-    }
+* fixture explore 명령어 - DB의 실제 데이터를 조회하여 확인합니다.
+* 저장하지 않고 조회만 하므로 데이터를 빠르게 확인할 때 유용합니다.
+*/
+async function fixtureExploreCommand(options) {
+	try {
+		if (!EntityManager.isAutoloaded) {
+			await EntityManager.autoload();
+		}
+		let entityName = options.include;
+		if (!entityName) {
+			const result = await prompts({
+				type: "select",
+				name: "entity",
+				message: "탐색할 Entity:",
+				choices: EntityManager.getAllIds().map((id) => ({
+					title: id,
+					value: id
+				}))
+			});
+			if (!result.entity) {
+				console.log(chalk.yellow("취소되었습니다."));
+				return;
+			}
+			entityName = result.entity;
+		}
+		if (!entityName) {
+			throw new Error("Entity name is required");
+		}
+		const strategy = options.strategy ?? "sample";
+		const limit = options.limit ? Number.parseInt(options.limit, 10) : 10;
+		const db = DB.getDB("r");
+		const explorer = new DataExplorer(db, EntityManager);
+		const data = await explorer.explore(entityName, {
+			strategy,
+			limit
+		});
+		console.log(chalk.cyan(`\n${entityName} ${data.length}개 조회 완료:`));
+		console.table(data);
+	} catch (error) {
+		console.error(chalk.red("데이터 조회 중 오류가 발생했습니다.\n" + "원인: DB 연결이나 Entity 정의를 확인해주세요.\n" + "자세한 내용:"), error);
+		throw error;
+	}
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/bin/fixture.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport prompts from \"prompts\";\nimport { Sonamu } from \"../api\";\nimport { DB } from \"../database/db\";\nimport { createKnexInstance } from \"../database/knex\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { DataExplorer, type DataExplorerStrategy } from \"../testing/data-explorer\";\nimport { FixtureGenerator } from \"../testing/fixture-generator\";\n\ninterface FixtureCommandOptions {\n  _?: string[];\n  all?: boolean;\n  include?: string;\n  exclude?: string;\n  count?: string;\n  \"save-to\"?: string;\n  strategy?: DataExplorerStrategy;\n  limit?: string;\n  \"use-llm\"?: boolean;\n  \"no-cache\"?: boolean;\n}\n\n/**\n * fixture gen 명령어 - cone 메타데이터를 활용하여 자동으로 fixture를 생성합니다.\n */\nexport async function fixtureGenCommand(options: FixtureCommandOptions) {\n  try {\n    if (!EntityManager.isAutoloaded) {\n      await EntityManager.autoload();\n    }\n\n    let entityNames: string[];\n\n    if (options.all) {\n      entityNames = EntityManager.getAllIds();\n      if (options.exclude) {\n        const excludeList = options.exclude.split(\",\").map((s: string) => s.trim());\n        entityNames = entityNames.filter((name) => !excludeList.includes(name));\n      }\n    } else if (options.include) {\n      entityNames = options.include.split(\",\").map((s: string) => s.trim());\n    } else {\n      const result = await prompts({\n        type: \"multiselect\",\n        name: \"entities\",\n        message: \"Fixture를 생성할 Entity를 선택하세요:\",\n        choices: EntityManager.getAllIds().map((id) => ({ title: id, value: id })),\n        min: 1,\n      });\n\n      if (!result.entities || result.entities.length === 0) {\n        console.log(chalk.yellow(\"취소되었습니다.\"));\n        return;\n      }\n\n      entityNames = result.entities;\n    }\n\n    let count = options.count ? Number.parseInt(options.count, 10) : 5;\n    if (!options.count) {\n      const result = await prompts({\n        type: \"number\",\n        name: \"count\",\n        message: \"각 Entity별 생성 개수:\",\n        initial: 5,\n        min: 1,\n      });\n\n      if (!result.count) {\n        console.log(chalk.yellow(\"취소되었습니다.\"));\n        return;\n      }\n\n      count = result.count;\n    }\n\n    let saveTarget = options[\"save-to\"] || \"db\";\n    if (!options[\"save-to\"]) {\n      const result = await prompts({\n        type: \"select\",\n        name: \"saveTarget\",\n        message: \"저장 방식:\",\n        choices: [\n          { title: \"Fixture DB에 저장\", value: \"db\" },\n          { title: \"파일로 저장 (자동 파일명)\", value: \"file\" },\n          { title: \"파일로 저장 (파일명 지정)\", value: \"file:custom\" },\n          { title: \"저장 안 함 (출력만)\", value: \"none\" },\n        ],\n      });\n\n      saveTarget = result.saveTarget;\n\n      if (saveTarget === \"file:custom\") {\n        const filenameResult = await prompts({\n          type: \"text\",\n          name: \"filename\",\n          message: \"파일명:\",\n          initial: \"fixtures.json\",\n        });\n\n        if (!filenameResult.filename) {\n          console.log(chalk.yellow(\"취소되었습니다.\"));\n          return;\n        }\n\n        saveTarget = `file:${filenameResult.filename}`;\n      }\n    }\n\n    // LLM 사용 여부 결정\n    let useLLM = options[\"use-llm\"] ?? false;\n    if (!options[\"use-llm\"]) {\n      const llmResult = await prompts({\n        type: \"confirm\",\n        name: \"useLLM\",\n        message:\n          \"LLM으로 더 현실적인 데이터를 생성할까요? (fixtureHint 기반, ANTHROPIC_API_KEY 필요)\",\n        initial: false,\n      });\n      useLLM = llmResult.useLLM ?? false;\n    }\n\n    const enableLLMCache = !options[\"no-cache\"];\n\n    // fixture gen: fixture DB 내에서 참조 관계를 해결하고 저장합니다\n    const fixtureDb = createKnexInstance(Sonamu.dbConfig.fixture);\n    const generator = new FixtureGenerator(fixtureDb, fixtureDb, \"fixture\", EntityManager, {\n      useLLM,\n      enableLLMCache,\n    });\n\n    if (useLLM) {\n      console.log(\n        chalk.cyan(\n          `\\nLLM 모드로 ${entityNames.join(\", \")} 생성 중... (캐싱: ${enableLLMCache ? \"ON\" : \"OFF\"})`,\n        ),\n      );\n    } else {\n      console.log(chalk.cyan(`\\n${entityNames.join(\", \")} 생성 중...`));\n    }\n\n    const specs = entityNames.map((entityName) => ({\n      entity: entityName,\n      count,\n      overrides: {},\n    }));\n\n    const results = await generator.generateBatch(specs);\n\n    if (useLLM) {\n      const stats = generator.getLLMCacheStats();\n      console.log(chalk.cyan(`[LLM Cache] 캐시 크기: ${stats.size}`));\n    }\n\n    console.log(chalk.green(`\\n✅ ${results.length}개 fixture 생성 완료`));\n\n    if (saveTarget === \"none\") {\n      console.log(JSON.stringify(results, null, 2));\n    } else if (saveTarget === \"db\") {\n      // generateBatch가 이미 DB에 저장했으므로 별도 저장이 불필요합니다.\n      console.log(chalk.green(\"Fixture DB에 저장되었습니다.\"));\n    } else if (saveTarget.startsWith(\"file\")) {\n      const fs = await import(\"node:fs/promises\");\n      const path = await import(\"node:path\");\n\n      const fixturesDir = path.join(process.cwd(), \"test\", \"fixtures\");\n      try {\n        await fs.access(fixturesDir);\n      } catch {\n        await fs.mkdir(fixturesDir, { recursive: true });\n      }\n\n      for (const entityName of entityNames) {\n        const entityResults = results.filter((r) => r.entityId === entityName);\n\n        if (entityResults.length === 0) {\n          continue;\n        }\n\n        let filename: string;\n        if (saveTarget === \"file\") {\n          const entity = EntityManager.get(entityName);\n          filename = `${entity.table}.json`;\n        } else {\n          filename = saveTarget.replace(\"file:\", \"\");\n        }\n\n        const filepath = path.join(fixturesDir, filename);\n        await fs.writeFile(\n          filepath,\n          JSON.stringify(\n            entityResults.map((r) => r.data),\n            null,\n            2,\n          ),\n        );\n        console.log(chalk.green(`✅ ${filepath} 저장 완료`));\n      }\n    }\n  } catch (error) {\n    console.error(\n      chalk.red(\n        \"Fixture 생성 중 오류가 발생했습니다.\\n\" +\n          \"원인: Entity 정의나 DB 연결을 확인해주세요.\\n\" +\n          \"자세한 내용:\",\n      ),\n      error,\n    );\n    throw error;\n  }\n}\n\n/**\n * fixture fetch 명령어 - 실제 운영 DB에서 데이터를 가져와 fixture로 저장합니다.\n * 관계된 데이터도 함께 가져오므로 현실적인 테스트 데이터를 확보할 수 있습니다.\n */\nexport async function fixtureFetchCommand(options: FixtureCommandOptions) {\n  try {\n    if (!EntityManager.isAutoloaded) {\n      await EntityManager.autoload();\n    }\n\n    let entityNames: string[];\n\n    if (options.all) {\n      entityNames = EntityManager.getAllIds();\n      if (options.exclude) {\n        const excludeList = options.exclude.split(\",\").map((s: string) => s.trim());\n        entityNames = entityNames.filter((name) => !excludeList.includes(name));\n      }\n    } else if (options.include) {\n      entityNames = options.include.split(\",\").map((s: string) => s.trim());\n    } else {\n      const result = await prompts({\n        type: \"multiselect\",\n        name: \"entities\",\n        message: \"Import할 Entity를 선택하세요:\",\n        choices: EntityManager.getAllIds().map((id) => ({ title: id, value: id })),\n        min: 1,\n      });\n\n      if (!result.entities || result.entities.length === 0) {\n        console.log(chalk.yellow(\"취소되었습니다.\"));\n        return;\n      }\n\n      entityNames = result.entities;\n    }\n\n    const strategy: DataExplorerStrategy = options.strategy ?? \"recent\";\n    const limit = options.limit ? Number.parseInt(options.limit, 10) : 10;\n\n    // fixture fetch: production 데이터를 fixture DB로 import합니다\n    const sourceDb = DB.getDB(\"r\"); // production_master (또는 development_master)\n    const fixtureDb = createKnexInstance(Sonamu.dbConfig.fixture);\n    const generator = new FixtureGenerator(sourceDb, fixtureDb, \"fixture\", EntityManager);\n\n    console.log(chalk.cyan(`\\n${entityNames.join(\", \")} import 중...`));\n\n    for (const entityName of entityNames) {\n      const results = await generator.importFromSource(entityName, {\n        strategy,\n        limit,\n        includeRelations: true,\n        maxDepth: 2,\n      });\n\n      console.log(chalk.green(`✅ ${entityName}: ${results.length}개 import 완료`));\n    }\n  } catch (error) {\n    console.error(\n      chalk.red(\n        \"실제 DB에서 데이터를 가져오는 중 오류가 발생했습니다.\\n\" +\n          \"원인: 소스 DB 연결 설정(sonamu.config.ts)이나 Entity 관계 정의를 확인해주세요.\\n\" +\n          \"자세한 내용:\",\n      ),\n      error,\n    );\n    throw error;\n  }\n}\n\n/**\n * fixture explore 명령어 - DB의 실제 데이터를 조회하여 확인합니다.\n * 저장하지 않고 조회만 하므로 데이터를 빠르게 확인할 때 유용합니다.\n */\nexport async function fixtureExploreCommand(options: FixtureCommandOptions) {\n  try {\n    if (!EntityManager.isAutoloaded) {\n      await EntityManager.autoload();\n    }\n\n    let entityName = options.include;\n\n    if (!entityName) {\n      const result = await prompts({\n        type: \"select\",\n        name: \"entity\",\n        message: \"탐색할 Entity:\",\n        choices: EntityManager.getAllIds().map((id) => ({ title: id, value: id })),\n      });\n\n      if (!result.entity) {\n        console.log(chalk.yellow(\"취소되었습니다.\"));\n        return;\n      }\n\n      entityName = result.entity;\n    }\n\n    if (!entityName) {\n      throw new Error(\"Entity name is required\");\n    }\n\n    const strategy: DataExplorerStrategy = options.strategy ?? \"sample\";\n    const limit = options.limit ? Number.parseInt(options.limit, 10) : 10;\n\n    const db = DB.getDB(\"r\");\n    const explorer = new DataExplorer(db, EntityManager);\n    const data = await explorer.explore(entityName, { strategy, limit });\n\n    console.log(chalk.cyan(`\\n${entityName} ${data.length}개 조회 완료:`));\n    console.table(data);\n  } catch (error) {\n    console.error(\n      chalk.red(\n        \"데이터 조회 중 오류가 발생했습니다.\\n\" +\n          \"원인: DB 연결이나 Entity 정의를 확인해주세요.\\n\" +\n          \"자세한 내용:\",\n      ),\n      error,\n    );\n    throw error;\n  }\n}\n"],"names":["chalk","prompts","Sonamu","DB","createKnexInstance","EntityManager","DataExplorer","FixtureGenerator","fixtureGenCommand","options","isAutoloaded","autoload","entityNames","all","getAllIds","exclude","excludeList","split","map","s","trim","filter","name","includes","include","result","type","message","choices","id","title","value","min","entities","length","console","log","yellow","count","Number","parseInt","initial","saveTarget","filenameResult","filename","useLLM","llmResult","enableLLMCache","fixtureDb","dbConfig","fixture","generator","cyan","join","specs","entityName","entity","overrides","results","generateBatch","stats","getLLMCacheStats","size","green","JSON","stringify","startsWith","fs","path","fixturesDir","process","cwd","access","mkdir","recursive","entityResults","r","entityId","get","table","replace","filepath","writeFile","data","error","red","fixtureFetchCommand","strategy","limit","sourceDb","getDB","importFromSource","includeRelations","maxDepth","fixtureExploreCommand","Error","db","explorer","explore"],"mappings":"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"}
+//#endregion
+export { fixtureExploreCommand, fixtureFetchCommand, fixtureGenCommand };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"fixture.js","names":["entityNames: string[]","filename: string","strategy: DataExplorerStrategy"],"sources":["../../src/bin/fixture.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport prompts from \"prompts\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { DB } from \"../database/db\";\nimport { createKnexInstance } from \"../database/knex\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { DataExplorer } from \"../testing/data-explorer\";\nimport { type DataExplorerStrategy } from \"../testing/data-explorer\";\nimport { FixtureGenerator } from \"../testing/fixture-generator\";\n\ninterface FixtureCommandOptions {\n  _?: string[];\n  all?: boolean;\n  include?: string;\n  exclude?: string;\n  count?: string;\n  \"save-to\"?: string;\n  strategy?: DataExplorerStrategy;\n  limit?: string;\n  \"use-llm\"?: boolean;\n  \"no-cache\"?: boolean;\n}\n\n/**\n * fixture gen 명령어 - cone 메타데이터를 활용하여 자동으로 fixture를 생성합니다.\n */\nexport async function fixtureGenCommand(options: FixtureCommandOptions) {\n  try {\n    if (!EntityManager.isAutoloaded) {\n      await EntityManager.autoload();\n    }\n\n    let entityNames: string[];\n\n    if (options.all) {\n      entityNames = EntityManager.getAllIds();\n      if (options.exclude) {\n        const excludeList = options.exclude.split(\",\").map((s: string) => s.trim());\n        entityNames = entityNames.filter((name) => !excludeList.includes(name));\n      }\n    } else if (options.include) {\n      entityNames = options.include.split(\",\").map((s: string) => s.trim());\n    } else {\n      const result = await prompts({\n        type: \"multiselect\",\n        name: \"entities\",\n        message: \"Fixture를 생성할 Entity를 선택하세요:\",\n        choices: EntityManager.getAllIds().map((id) => ({ title: id, value: id })),\n        min: 1,\n      });\n\n      if (!result.entities || result.entities.length === 0) {\n        console.log(chalk.yellow(\"취소되었습니다.\"));\n        return;\n      }\n\n      entityNames = result.entities;\n    }\n\n    let count = options.count ? Number.parseInt(options.count, 10) : 5;\n    if (!options.count) {\n      const result = await prompts({\n        type: \"number\",\n        name: \"count\",\n        message: \"각 Entity별 생성 개수:\",\n        initial: 5,\n        min: 1,\n      });\n\n      if (!result.count) {\n        console.log(chalk.yellow(\"취소되었습니다.\"));\n        return;\n      }\n\n      count = result.count;\n    }\n\n    let saveTarget = options[\"save-to\"] || \"db\";\n    if (!options[\"save-to\"]) {\n      const result = await prompts({\n        type: \"select\",\n        name: \"saveTarget\",\n        message: \"저장 방식:\",\n        choices: [\n          { title: \"Fixture DB에 저장\", value: \"db\" },\n          { title: \"파일로 저장 (자동 파일명)\", value: \"file\" },\n          { title: \"파일로 저장 (파일명 지정)\", value: \"file:custom\" },\n          { title: \"저장 안 함 (출력만)\", value: \"none\" },\n        ],\n      });\n\n      saveTarget = result.saveTarget;\n\n      if (saveTarget === \"file:custom\") {\n        const filenameResult = await prompts({\n          type: \"text\",\n          name: \"filename\",\n          message: \"파일명:\",\n          initial: \"fixtures.json\",\n        });\n\n        if (!filenameResult.filename) {\n          console.log(chalk.yellow(\"취소되었습니다.\"));\n          return;\n        }\n\n        saveTarget = `file:${filenameResult.filename}`;\n      }\n    }\n\n    // LLM 사용 여부 결정\n    let useLLM = options[\"use-llm\"] ?? false;\n    if (!options[\"use-llm\"]) {\n      const llmResult = await prompts({\n        type: \"confirm\",\n        name: \"useLLM\",\n        message:\n          \"LLM으로 더 현실적인 데이터를 생성할까요? (fixtureHint 기반, ANTHROPIC_API_KEY 필요)\",\n        initial: false,\n      });\n      useLLM = llmResult.useLLM ?? false;\n    }\n\n    const enableLLMCache = !options[\"no-cache\"];\n\n    // fixture gen: fixture DB 내에서 참조 관계를 해결하고 저장합니다\n    const fixtureDb = createKnexInstance(Sonamu.dbConfig.fixture);\n    const generator = new FixtureGenerator(fixtureDb, fixtureDb, \"fixture\", EntityManager, {\n      useLLM,\n      enableLLMCache,\n    });\n\n    if (useLLM) {\n      console.log(\n        chalk.cyan(\n          `\\nLLM 모드로 ${entityNames.join(\", \")} 생성 중... (캐싱: ${enableLLMCache ? \"ON\" : \"OFF\"})`,\n        ),\n      );\n    } else {\n      console.log(chalk.cyan(`\\n${entityNames.join(\", \")} 생성 중...`));\n    }\n\n    const specs = entityNames.map((entityName) => ({\n      entity: entityName,\n      count,\n      overrides: {},\n    }));\n\n    const results = await generator.generateBatch(specs);\n\n    if (useLLM) {\n      const stats = generator.getLLMCacheStats();\n      console.log(chalk.cyan(`[LLM Cache] 캐시 크기: ${stats.size}`));\n    }\n\n    console.log(chalk.green(`\\n✅ ${results.length}개 fixture 생성 완료`));\n\n    if (saveTarget === \"none\") {\n      console.log(JSON.stringify(results, null, 2));\n    } else if (saveTarget === \"db\") {\n      // generateBatch가 이미 DB에 저장했으므로 별도 저장이 불필요합니다.\n      console.log(chalk.green(\"Fixture DB에 저장되었습니다.\"));\n    } else if (saveTarget.startsWith(\"file\")) {\n      const fs = await import(\"node:fs/promises\");\n      const path = await import(\"node:path\");\n\n      const fixturesDir = path.join(process.cwd(), \"test\", \"fixtures\");\n      try {\n        await fs.access(fixturesDir);\n      } catch {\n        await fs.mkdir(fixturesDir, { recursive: true });\n      }\n\n      for (const entityName of entityNames) {\n        const entityResults = results.filter((r) => r.entityId === entityName);\n\n        if (entityResults.length === 0) {\n          continue;\n        }\n\n        let filename: string;\n        if (saveTarget === \"file\") {\n          const entity = EntityManager.get(entityName);\n          filename = `${entity.table}.json`;\n        } else {\n          filename = saveTarget.replace(\"file:\", \"\");\n        }\n\n        const filepath = path.join(fixturesDir, filename);\n        await fs.writeFile(\n          filepath,\n          JSON.stringify(\n            entityResults.map((r) => r.data),\n            null,\n            2,\n          ),\n        );\n        console.log(chalk.green(`✅ ${filepath} 저장 완료`));\n      }\n    }\n  } catch (error) {\n    console.error(\n      chalk.red(\n        \"Fixture 생성 중 오류가 발생했습니다.\\n\" +\n          \"원인: Entity 정의나 DB 연결을 확인해주세요.\\n\" +\n          \"자세한 내용:\",\n      ),\n      error,\n    );\n    throw error;\n  }\n}\n\n/**\n * fixture fetch 명령어 - 실제 운영 DB에서 데이터를 가져와 fixture로 저장합니다.\n * 관계된 데이터도 함께 가져오므로 현실적인 테스트 데이터를 확보할 수 있습니다.\n */\nexport async function fixtureFetchCommand(options: FixtureCommandOptions) {\n  try {\n    if (!EntityManager.isAutoloaded) {\n      await EntityManager.autoload();\n    }\n\n    let entityNames: string[];\n\n    if (options.all) {\n      entityNames = EntityManager.getAllIds();\n      if (options.exclude) {\n        const excludeList = options.exclude.split(\",\").map((s: string) => s.trim());\n        entityNames = entityNames.filter((name) => !excludeList.includes(name));\n      }\n    } else if (options.include) {\n      entityNames = options.include.split(\",\").map((s: string) => s.trim());\n    } else {\n      const result = await prompts({\n        type: \"multiselect\",\n        name: \"entities\",\n        message: \"Import할 Entity를 선택하세요:\",\n        choices: EntityManager.getAllIds().map((id) => ({ title: id, value: id })),\n        min: 1,\n      });\n\n      if (!result.entities || result.entities.length === 0) {\n        console.log(chalk.yellow(\"취소되었습니다.\"));\n        return;\n      }\n\n      entityNames = result.entities;\n    }\n\n    const strategy: DataExplorerStrategy = options.strategy ?? \"recent\";\n    const limit = options.limit ? Number.parseInt(options.limit, 10) : 10;\n\n    // fixture fetch: production 데이터를 fixture DB로 import합니다\n    const sourceDb = DB.getDB(\"r\"); // production_master (또는 development_master)\n    const fixtureDb = createKnexInstance(Sonamu.dbConfig.fixture);\n    const generator = new FixtureGenerator(sourceDb, fixtureDb, \"fixture\", EntityManager);\n\n    console.log(chalk.cyan(`\\n${entityNames.join(\", \")} import 중...`));\n\n    for (const entityName of entityNames) {\n      const results = await generator.importFromSource(entityName, {\n        strategy,\n        limit,\n        includeRelations: true,\n        maxDepth: 2,\n      });\n\n      console.log(chalk.green(`✅ ${entityName}: ${results.length}개 import 완료`));\n    }\n  } catch (error) {\n    console.error(\n      chalk.red(\n        \"실제 DB에서 데이터를 가져오는 중 오류가 발생했습니다.\\n\" +\n          \"원인: 소스 DB 연결 설정(sonamu.config.ts)이나 Entity 관계 정의를 확인해주세요.\\n\" +\n          \"자세한 내용:\",\n      ),\n      error,\n    );\n    throw error;\n  }\n}\n\n/**\n * fixture explore 명령어 - DB의 실제 데이터를 조회하여 확인합니다.\n * 저장하지 않고 조회만 하므로 데이터를 빠르게 확인할 때 유용합니다.\n */\nexport async function fixtureExploreCommand(options: FixtureCommandOptions) {\n  try {\n    if (!EntityManager.isAutoloaded) {\n      await EntityManager.autoload();\n    }\n\n    let entityName = options.include;\n\n    if (!entityName) {\n      const result = await prompts({\n        type: \"select\",\n        name: \"entity\",\n        message: \"탐색할 Entity:\",\n        choices: EntityManager.getAllIds().map((id) => ({ title: id, value: id })),\n      });\n\n      if (!result.entity) {\n        console.log(chalk.yellow(\"취소되었습니다.\"));\n        return;\n      }\n\n      entityName = result.entity;\n    }\n\n    if (!entityName) {\n      throw new Error(\"Entity name is required\");\n    }\n\n    const strategy: DataExplorerStrategy = options.strategy ?? \"sample\";\n    const limit = options.limit ? Number.parseInt(options.limit, 10) : 10;\n\n    const db = DB.getDB(\"r\");\n    const explorer = new DataExplorer(db, EntityManager);\n    const data = await explorer.explore(entityName, { strategy, limit });\n\n    console.log(chalk.cyan(`\\n${entityName} ${data.length}개 조회 완료:`));\n    console.table(data);\n  } catch (error) {\n    console.error(\n      chalk.red(\n        \"데이터 조회 중 오류가 발생했습니다.\\n\" +\n          \"원인: DB 연결이나 Entity 정의를 확인해주세요.\\n\" +\n          \"자세한 내용:\",\n      ),\n      error,\n    );\n    throw error;\n  }\n}\n"],"mappings":"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"}