sonamu 0.7.53 → 0.8.0

package/dist/bin/fixture.d.ts

@@ -0,0 +1,27 @@
+import { type DataExplorerStrategy } from "../testing/data-explorer";
+interface FixtureCommandOptions {
+    _?: string[];
+    all?: boolean;
+    include?: string;
+    exclude?: string;
+    count?: string;
+    "save-to"?: string;
+    strategy?: DataExplorerStrategy;
+    limit?: string;
+}
+/**
+ * fixture gen 명령어 - cone 메타데이터를 활용하여 자동으로 fixture를 생성합니다.
+ */
+export declare function fixtureGenCommand(options: FixtureCommandOptions): Promise<void>;
+/**
+ * fixture fetch 명령어 - 실제 운영 DB에서 데이터를 가져와 fixture로 저장합니다.
+ * 관계된 데이터도 함께 가져오므로 현실적인 테스트 데이터를 확보할 수 있습니다.
+ */
+export declare function fixtureFetchCommand(options: FixtureCommandOptions): Promise<void>;
+/**
+ * fixture explore 명령어 - DB의 실제 데이터를 조회하여 확인합니다.
+ * 저장하지 않고 조회만 하므로 데이터를 빠르게 확인할 때 유용합니다.
+ */
+export declare function fixtureExploreCommand(options: FixtureCommandOptions): Promise<void>;
+export {};
+//# sourceMappingURL=fixture.d.ts.map

package/dist/bin/fixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixture.d.ts","sourceRoot":"","sources":["../../src/bin/fixture.ts"],"names":[],"mappings":"AAMA,OAAO,EAAgB,KAAK,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAGnF,UAAU,qBAAqB;IAC7B,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IACb,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,qBAAqB,iBA0JrE;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,iBAgEvE;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,qBAAqB,iBAgDzE"}

package/dist/bin/fixture.js

@@ -0,0 +1,245 @@
+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";
+/**
+ * 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}`;
+            }
+        }
+        // fixture gen: fixture DB 내에서 참조 관계를 해결하고 저장합니다
+        const fixtureDb = createKnexInstance(Sonamu.dbConfig.fixture);
+        const generator = new FixtureGenerator(fixtureDb, fixtureDb, "fixture", EntityManager);
+        console.log(chalk.cyan(`\n${entityNames.join(", ")} 생성 중...`));
+        const specs = entityNames.map((entityName)=>({
+                entity: entityName,
+                count,
+                overrides: {}
+            }));
+        const results = await generator.generateBatch(specs);
+        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 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 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;
+    }
+}
+
+//# 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}\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    // fixture gen: fixture DB 내에서 참조 관계를 해결하고 저장합니다\n    const fixtureDb = createKnexInstance(Sonamu.dbConfig.fixture);\n    const generator = new FixtureGenerator(fixtureDb, fixtureDb, \"fixture\", EntityManager);\n\n    console.log(chalk.cyan(`\\n${entityNames.join(\", \")} 생성 중...`));\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    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","fixtureDb","dbConfig","fixture","generator","cyan","join","specs","entityName","entity","overrides","results","generateBatch","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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"}

package/dist/cache/decorator.d.ts

@@ -18,11 +18,12 @@ export declare function getCacheManagerRef(): CacheManager | null;
  * 메서드의 결과를 캐싱합니다.
  *
  * @example
- * class UserModelClass extends BaseModel {
+ * class UserModelClass extends BaseModelClass<...> {
  *   @cache({ ttl: '10m', tags: ['user'] })
  *   @api()
- *   async findById(id: number) {
- *     return this.findOne(['id', id]);
+ *   async findById(subset: UserSubsetKey, id: string) {
+ *     const { rows } = await this.findMany(subset, { id, num: 1, page: 1 });
+ *     return rows[0];
  *   }
  * }
  */

package/dist/cache/decorator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decorator.d.ts","sourceRoot":"","sources":["../../src/cache/decorator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEnE,KAAK,eAAe,GAAG;IAAE,WAAW,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC;AAKzD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI,CAErE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,YAAY,GAAG,IAAI,CAExD;AAoDD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,OAAO,GAAE,qBAA0B,IAC/C,SAAS,eAAe,EAAE,aAAa,MAAM,EAAE,YAAY,kBAAkB,wBA2BtF"}
+{"version":3,"file":"decorator.d.ts","sourceRoot":"","sources":["../../src/cache/decorator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEnE,KAAK,eAAe,GAAG;IAAE,WAAW,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC;AAKzD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI,CAErE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,YAAY,GAAG,IAAI,CAExD;AAoDD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,OAAO,GAAE,qBAA0B,IAC/C,SAAS,eAAe,EAAE,aAAa,MAAM,EAAE,YAAY,kBAAkB,wBA2BtF"}

package/dist/cache/decorator.js

@@ -54,11 +54,12 @@ let cacheManagerRef = null;
  * 메서드의 결과를 캐싱합니다.
  *
  * @example
- * class UserModelClass extends BaseModel {
+ * class UserModelClass extends BaseModelClass<...> {
  *   @cache({ ttl: '10m', tags: ['user'] })
  *   @api()
- *   async findById(id: number) {
- *     return this.findOne(['id', id]);
+ *   async findById(subset: UserSubsetKey, id: string) {
+ *     const { rows } = await this.findMany(subset, { id, num: 1, page: 1 });
+ *     return rows[0];
  *   }
  * }
  */ export function cache(options = {}) {
@@ -83,4 +84,4 @@ let cacheManagerRef = null;
     };
 }
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jYWNoZS9kZWNvcmF0b3IudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBCYXNlRnJhbWVDbGFzcyB9IGZyb20gXCIuLi9hcGkvYmFzZS1mcmFtZVwiO1xuaW1wb3J0IHsgQmFzZU1vZGVsQ2xhc3MgfSBmcm9tIFwiLi4vZGF0YWJhc2UvYmFzZS1tb2RlbFwiO1xuaW1wb3J0IHR5cGUgeyBDYWNoZURlY29yYXRvck9wdGlvbnMsIENhY2hlTWFuYWdlciB9IGZyb20gXCIuL3R5cGVzXCI7XG5cbnR5cGUgRGVjb3JhdG9yVGFyZ2V0ID0geyBjb25zdHJ1Y3RvcjogeyBuYW1lOiBzdHJpbmcgfSB9O1xuXG4vLyDsupDsi5wg66ek64uI7KCAIOywuOyhsCAoU29uYW11LmluaXTsl5DshJwg7ISk7KCV65CoKVxubGV0IGNhY2hlTWFuYWdlclJlZjogQ2FjaGVNYW5hZ2VyIHwgbnVsbCA9IG51bGw7XG5cbi8qKlxuICog7LqQ7IucIOunpOuLiOyggCDssLjsobAg7ISk7KCVICjrgrTrtoAg7IKs7JqpKVxuICovXG5leHBvcnQgZnVuY3Rpb24gc2V0Q2FjaGVNYW5hZ2VyUmVmKG1hbmFnZXI6IENhY2hlTWFuYWdlciB8IG51bGwpOiB2b2lkIHtcbiAgY2FjaGVNYW5hZ2VyUmVmID0gbWFuYWdlcjtcbn1cblxuLyoqXG4gKiDsupDsi5wg66ek64uI7KCAIOywuOyhsCDqsIDsoLjsmKTquLAgKOuCtOu2gCDsgqzsmqkpXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRDYWNoZU1hbmFnZXJSZWYoKTogQ2FjaGVNYW5hZ2VyIHwgbnVsbCB7XG4gIHJldHVybiBjYWNoZU1hbmFnZXJSZWY7XG59XG5cbi8qKlxuICog7LqQ7IucIO2CpCDsg53shLFcbiAqL1xuZnVuY3Rpb24gZ2VuZXJhdGVDYWNoZUtleShcbiAgbW9kZWxOYW1lOiBzdHJpbmcsXG4gIG1ldGhvZE5hbWU6IHN0cmluZyxcbiAgYXJnczogdW5rbm93bltdLFxuICBrZXlPcHRpb24/OiBDYWNoZURlY29yYXRvck9wdGlvbnNbXCJrZXlcIl0sXG4pOiBzdHJpbmcge1xuICAvLyDsu6TsiqTthYAg7YKkIO2VqOyImCDsgqzsmqlcbiAgaWYgKHR5cGVvZiBrZXlPcHRpb24gPT09IFwiZnVuY3Rpb25cIikge1xuICAgIHJldHVybiBrZXlPcHRpb24oLi4uYXJncyk7XG4gIH1cblxuICAvLyDrrLjsnpDsl7Qg7YKkICsgYXJncyBzdWZmaXhcbiAgaWYgKHR5cGVvZiBrZXlPcHRpb24gPT09IFwic3RyaW5nXCIpIHtcbiAgICBjb25zdCBhcmdzU3VmZml4ID0gc2VyaWFsaXplQXJncyhhcmdzKTtcbiAgICByZXR1cm4gYXJnc1N1ZmZpeCA/IGAke2tleU9wdGlvbn06JHthcmdzU3VmZml4fWAgOiBrZXlPcHRpb247XG4gIH1cblxuICAvLyDsnpDrj5kg7IOd7ISxOiBNb2RlbE5hbWUubWV0aG9kTmFtZTpzZXJpYWxpemVkQXJnc1xuICBjb25zdCBiYXNlS2V5ID0gYCR7bW9kZWxOYW1lfS4ke21ldGhvZE5hbWV9YDtcbiAgY29uc3QgYXJnc1N1ZmZpeCA9IHNlcmlhbGl6ZUFyZ3MoYXJncyk7XG4gIHJldHVybiBhcmdzU3VmZml4ID8gYCR7YmFzZUtleX06JHthcmdzU3VmZml4fWAgOiBiYXNlS2V5O1xufVxuXG4vKipcbiAqIOyduOyekCDsp4HroKztmZRcbiAqL1xuZnVuY3Rpb24gc2VyaWFsaXplQXJncyhhcmdzOiB1bmtub3duW10pOiBzdHJpbmcge1xuICBpZiAoYXJncy5sZW5ndGggPT09IDApIHJldHVybiBcIlwiO1xuXG4gIC8vIOuLqOydvCBwcmltaXRpdmUg6rCSXG4gIGlmIChhcmdzLmxlbmd0aCA9PT0gMSkge1xuICAgIGNvbnN0IGFyZyA9IGFyZ3NbMF07XG4gICAgaWYgKGFyZyA9PT0gbnVsbCB8fCBhcmcgPT09IHVuZGVmaW5lZCkgcmV0dXJuIFwiXCI7XG4gICAgaWYgKHR5cGVvZiBhcmcgPT09IFwic3RyaW5nXCIgfHwgdHlwZW9mIGFyZyA9PT0gXCJudW1iZXJcIiB8fCB0eXBlb2YgYXJnID09PSBcImJvb2xlYW5cIikge1xuICAgICAgcmV0dXJuIFN0cmluZyhhcmcpO1xuICAgIH1cbiAgfVxuXG4gIC8vIOuzteyeoe2VnCDqsJLsnYAgSlNPTiDsp4HroKztmZRcbiAgdHJ5IHtcbiAgICByZXR1cm4gSlNPTi5zdHJpbmdpZnkoYXJncyk7XG4gIH0gY2F0Y2gge1xuICAgIC8vIOyngeugrO2ZlCDsi6TtjKgg7IucIHRvU3RyaW5nIOyCrOyaqVxuICAgIHJldHVybiBhcmdzLm1hcCgoYXJnKSA9PiBTdHJpbmcoYXJnKSkuam9pbihcIjpcIik7XG4gIH1cbn1cblxuLyoqXG4gKiBAY2FjaGUg642w7L2U66CI7J207YSwXG4gKlxuICog66mU7ISc65Oc7J2YIOqysOqzvOulvCDsupDsi7Htlanri4jri6QuXG4gKlxuICogQGV4YW1wbGVcbiAqIGNsYXNzIFVzZXJNb2RlbENsYXNzIGV4dGVuZHMgQmFzZU1vZGVsIHtcbiAqICAgQGNhY2hlKHsgdHRsOiAnMTBtJywgdGFnczogWyd1c2VyJ10gfSlcbiAqICAgQGFwaSgpXG4gKiAgIGFzeW5jIGZpbmRCeUlkKGlkOiBudW1iZXIpIHtcbiAqICAgICByZXR1cm4gdGhpcy5maW5kT25lKFsnaWQnLCBpZF0pO1xuICogICB9XG4gKiB9XG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjYWNoZShvcHRpb25zOiBDYWNoZURlY29yYXRvck9wdGlvbnMgPSB7fSkge1xuICByZXR1cm4gKF90YXJnZXQ6IERlY29yYXRvclRhcmdldCwgcHJvcGVydHlLZXk6IHN0cmluZywgZGVzY3JpcHRvcjogUHJvcGVydHlEZXNjcmlwdG9yKSA9PiB7XG4gICAgY29uc3Qgb3JpZ2luYWxNZXRob2QgPSBkZXNjcmlwdG9yLnZhbHVlO1xuXG4gICAgZGVzY3JpcHRvci52YWx1ZSA9IGFzeW5jIGZ1bmN0aW9uICh0aGlzOiBCYXNlTW9kZWxDbGFzcyB8IEJhc2VGcmFtZUNsYXNzLCAuLi5hcmdzOiB1bmtub3duW10pIHtcbiAgICAgIGNvbnN0IG1hbmFnZXIgPSBjYWNoZU1hbmFnZXJSZWY7XG5cbiAgICAgIGlmICghbWFuYWdlcikge1xuICAgICAgICB0aHJvdyBuZXcgRXJyb3IoXG4gICAgICAgICAgXCJDYWNoZU1hbmFnZXIgaXMgbm90IGluaXRpYWxpemVkLiBQbGVhc2UgY29uZmlndXJlICdjYWNoZScgaW4gc29uYW11LmNvbmZpZy50cy5cIixcbiAgICAgICAgKTtcbiAgICAgIH1cblxuICAgICAgY29uc3QgbW9kZWxOYW1lID0gdGhpcyBpbnN0YW5jZW9mIEJhc2VNb2RlbENsYXNzID8gdGhpcy5tb2RlbE5hbWUgOiB0aGlzLmZyYW1lTmFtZTtcbiAgICAgIGNvbnN0IG1ldGhvZE5hbWUgPSBwcm9wZXJ0eUtleTtcblxuICAgICAgY29uc3QgY2FjaGVLZXkgPSBnZW5lcmF0ZUNhY2hlS2V5KG1vZGVsTmFtZSwgbWV0aG9kTmFtZSwgYXJncywgb3B0aW9ucy5rZXkpO1xuICAgICAgY29uc3Qgc3RvcmUgPSBvcHRpb25zLnN0b3JlID8gbWFuYWdlci51c2Uob3B0aW9ucy5zdG9yZSkgOiBtYW5hZ2VyO1xuXG4gICAgICByZXR1cm4gc3RvcmUuZ2V0T3JTZXQoe1xuICAgICAgICAuLi5vcHRpb25zLFxuICAgICAgICBrZXk6IGNhY2hlS2V5LFxuICAgICAgICBmYWN0b3J5OiAoKSA9PiBvcmlnaW5hbE1ldGhvZC5hcHBseSh0aGlzLCBhcmdzKSxcbiAgICAgIH0pO1xuICAgIH07XG5cbiAgICByZXR1cm4gZGVzY3JpcHRvcjtcbiAgfTtcbn1cbiJdLCJuYW1lcyI6WyJCYXNlTW9kZWxDbGFzcyIsImNhY2hlTWFuYWdlclJlZiIsInNldENhY2hlTWFuYWdlclJlZiIsIm1hbmFnZXIiLCJnZXRDYWNoZU1hbmFnZXJSZWYiLCJnZW5lcmF0ZUNhY2hlS2V5IiwibW9kZWxOYW1lIiwibWV0aG9kTmFtZSIsImFyZ3MiLCJrZXlPcHRpb24iLCJhcmdzU3VmZml4Iiwic2VyaWFsaXplQXJncyIsImJhc2VLZXkiLCJsZW5ndGgiLCJhcmciLCJ1bmRlZmluZWQiLCJTdHJpbmciLCJKU09OIiwic3RyaW5naWZ5IiwibWFwIiwiam9pbiIsImNhY2hlIiwib3B0aW9ucyIsIl90YXJnZXQiLCJwcm9wZXJ0eUtleSIsImRlc2NyaXB0b3IiLCJvcmlnaW5hbE1ldGhvZCIsInZhbHVlIiwiRXJyb3IiLCJmcmFtZU5hbWUiLCJjYWNoZUtleSIsImtleSIsInN0b3JlIiwidXNlIiwiZ2V0T3JTZXQiLCJmYWN0b3J5IiwiYXBwbHkiXSwibWFwcGluZ3MiOiJBQUNBLFNBQVNBLGNBQWMsUUFBUSw0QkFBeUI7QUFLeEQsZ0NBQWdDO0FBQ2hDLElBQUlDLGtCQUF1QztBQUUzQzs7Q0FFQyxHQUNELE9BQU8sU0FBU0MsbUJBQW1CQyxPQUE0QjtJQUM3REYsa0JBQWtCRTtBQUNwQjtBQUVBOztDQUVDLEdBQ0QsT0FBTyxTQUFTQztJQUNkLE9BQU9IO0FBQ1Q7QUFFQTs7Q0FFQyxHQUNELFNBQVNJLGlCQUNQQyxTQUFpQixFQUNqQkMsVUFBa0IsRUFDbEJDLElBQWUsRUFDZkMsU0FBd0M7SUFFeEMsY0FBYztJQUNkLElBQUksT0FBT0EsY0FBYyxZQUFZO1FBQ25DLE9BQU9BLGFBQWFEO0lBQ3RCO0lBRUEsc0JBQXNCO0lBQ3RCLElBQUksT0FBT0MsY0FBYyxVQUFVO1FBQ2pDLE1BQU1DLGFBQWFDLGNBQWNIO1FBQ2pDLE9BQU9FLGFBQWEsR0FBR0QsVUFBVSxDQUFDLEVBQUVDLFlBQVksR0FBR0Q7SUFDckQ7SUFFQSw2Q0FBNkM7SUFDN0MsTUFBTUcsVUFBVSxHQUFHTixVQUFVLENBQUMsRUFBRUMsWUFBWTtJQUM1QyxNQUFNRyxhQUFhQyxjQUFjSDtJQUNqQyxPQUFPRSxhQUFhLEdBQUdFLFFBQVEsQ0FBQyxFQUFFRixZQUFZLEdBQUdFO0FBQ25EO0FBRUE7O0NBRUMsR0FDRCxTQUFTRCxjQUFjSCxJQUFlO0lBQ3BDLElBQUlBLEtBQUtLLE1BQU0sS0FBSyxHQUFHLE9BQU87SUFFOUIsaUJBQWlCO0lBQ2pCLElBQUlMLEtBQUtLLE1BQU0sS0FBSyxHQUFHO1FBQ3JCLE1BQU1DLE1BQU1OLElBQUksQ0FBQyxFQUFFO1FBQ25CLElBQUlNLFFBQVEsUUFBUUEsUUFBUUMsV0FBVyxPQUFPO1FBQzlDLElBQUksT0FBT0QsUUFBUSxZQUFZLE9BQU9BLFFBQVEsWUFBWSxPQUFPQSxRQUFRLFdBQVc7WUFDbEYsT0FBT0UsT0FBT0Y7UUFDaEI7SUFDRjtJQUVBLGtCQUFrQjtJQUNsQixJQUFJO1FBQ0YsT0FBT0csS0FBS0MsU0FBUyxDQUFDVjtJQUN4QixFQUFFLE9BQU07UUFDTix1QkFBdUI7UUFDdkIsT0FBT0EsS0FBS1csR0FBRyxDQUFDLENBQUNMLE1BQVFFLE9BQU9GLE1BQU1NLElBQUksQ0FBQztJQUM3QztBQUNGO0FBRUE7Ozs7Ozs7Ozs7Ozs7Q0FhQyxHQUNELE9BQU8sU0FBU0MsTUFBTUMsVUFBaUMsQ0FBQyxDQUFDO0lBQ3ZELE9BQU8sQ0FBQ0MsU0FBMEJDLGFBQXFCQztRQUNyRCxNQUFNQyxpQkFBaUJELFdBQVdFLEtBQUs7UUFFdkNGLFdBQVdFLEtBQUssR0FBRyxlQUF1RCxHQUFHbkIsSUFBZTtZQUMxRixNQUFNTCxVQUFVRjtZQUVoQixJQUFJLENBQUNFLFNBQVM7Z0JBQ1osTUFBTSxJQUFJeUIsTUFDUjtZQUVKO1lBRUEsTUFBTXRCLFlBQVksSUFBSSxZQUFZTixpQkFBaUIsSUFBSSxDQUFDTSxTQUFTLEdBQUcsSUFBSSxDQUFDdUIsU0FBUztZQUNsRixNQUFNdEIsYUFBYWlCO1lBRW5CLE1BQU1NLFdBQVd6QixpQkFBaUJDLFdBQVdDLFlBQVlDLE1BQU1jLFFBQVFTLEdBQUc7WUFDMUUsTUFBTUMsUUFBUVYsUUFBUVUsS0FBSyxHQUFHN0IsUUFBUThCLEdBQUcsQ0FBQ1gsUUFBUVUsS0FBSyxJQUFJN0I7WUFFM0QsT0FBTzZCLE1BQU1FLFFBQVEsQ0FBQztnQkFDcEIsR0FBR1osT0FBTztnQkFDVlMsS0FBS0Q7Z0JBQ0xLLFNBQVMsSUFBTVQsZUFBZVUsS0FBSyxDQUFDLElBQUksRUFBRTVCO1lBQzVDO1FBQ0Y7UUFFQSxPQUFPaUI7SUFDVDtBQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cone/cone-generator.d.ts

@@ -0,0 +1,33 @@
+import type { Cone, EntityJson } from "../types/types";
+/**
+ * Cone 생성 컨텍스트
+ *
+ * Entity 정보와 생성 옵션을 담고 있습니다.
+ */
+export type ConeGenerationContext = {
+    entity: EntityJson;
+    locale?: "ko" | "en" | "ja";
+    existingCones?: Record<string, Cone>;
+    /** true인 경우 fixtureHint가 없는 cone만 생성 */
+    onlyEmpty?: boolean;
+};
+/**
+ * Cone 생성 결과
+ *
+ * Entity, Props, Subsets, Enums의 cone 메타데이터를 담고 있습니다.
+ */
+export type ConeGenerationResult = {
+    entityCone?: Cone;
+    propCones: Record<string, Cone>;
+    subsetCones: Record<string, Cone>;
+    enumCones: Record<string, Cone>;
+    tokensUsed: number;
+};
+/**
+ * LLM을 사용하여 Entity의 cone 메타데이터를 생성합니다.
+ *
+ * @param context - Entity 정보와 생성 옵션
+ * @returns 생성된 cone 메타데이터
+ */
+export declare function generateCones(context: ConeGenerationContext): Promise<ConeGenerationResult>;
+//# sourceMappingURL=cone-generator.d.ts.map

package/dist/cone/cone-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cone-generator.d.ts","sourceRoot":"","sources":["../../src/cone/cone-generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEvD;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,UAAU,CAAC;IACnB,MAAM,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACrC,wCAAwC;IACxC,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,CAAC,EAAE,IAAI,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAejG"}