sonamu 0.8.26 → 0.9.0

package/dist/template/implementations/sd.template.js

@@ -1,36 +1,39 @@
-import fs from "node:fs";
+import { Sonamu, init_sonamu } from "../../api/sonamu.js";
+import { EntityManager, init_entity_manager } from "../../entity/entity-manager.js";
+import { Template, init_template } from "../template.js";
+import { extractObjectDeclaration, init_helpers } from "../helpers.js";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { Sonamu } from "../../api/sonamu.js";
-import { EntityManager } from "../../entity/entity-manager.js";
-import { extractObjectDeclaration } from "../helpers.js";
-import { Template } from "../template.js";
+import fs from "node:fs";
+
+//#region src/template/implementations/sd.template.ts
+init_sonamu();
+init_entity_manager();
+init_helpers();
+init_template();
 /**
- * Sonamu Dictionary (SD) 템플릿
- * i18n을 위한 sd.generated.ts 파일을 생성합니다.
- */ export class Template__sd extends Template {
-    constructor(){
-        super("sd");
-    }
-    getTargetAndPath(_names, sdTarget) {
-        const target = sdTarget ?? "api";
-        // api.dir은 상대 경로("api")이므로, web/app도 상대 경로로 맞춤
-        const dir = target === "api" ? Sonamu.config.api.dir : target;
-        return {
-            target: `${dir}/src/i18n`,
-            path: "sd.generated.ts"
-        };
-    }
-    render(options) {
-        const { target } = options;
-        const i18nConfig = Sonamu.config.i18n;
-        const { defaultLocale, supportedLocales } = i18nConfig;
-        // entity.json에서 entity labels 추출
-        const entityLabels = this.extractEntityLabels();
-        // rc-keys 소스 코드 추출
-        const rcKeysSourceCode = this.extractRCKeysSourceCode();
-        // 플랫폼별 locale 관리 코드
-        const localeManagementCode = target === "api" ? `
+* Sonamu Dictionary (SD) 템플릿
+* i18n을 위한 sd.generated.ts 파일을 생성합니다.
+*/
+var Template__sd = class extends Template {
+	constructor() {
+		super("sd");
+	}
+	getTargetAndPath(_names, sdTarget) {
+		const target = sdTarget ?? "api";
+		const dir = target === "api" ? Sonamu.config.api.dir : target;
+		return {
+			target: `${dir}/src/i18n`,
+			path: "sd.generated.ts"
+		};
+	}
+	render(options) {
+		const { target } = options;
+		const i18nConfig = Sonamu.config.i18n;
+		const { defaultLocale, supportedLocales } = i18nConfig;
+		const entityLabels = this.extractEntityLabels();
+		const rcKeysSourceCode = this.extractRCKeysSourceCode();
+		const localeManagementCode = target === "api" ? `
 import { Sonamu } from "sonamu";
 
 const DEFAULT_LOCALE = "${defaultLocale}" as const;
@@ -56,23 +59,17 @@ export function getCurrentLocale(): (typeof SUPPORTED_LOCALES)[number] {
   return _currentLocale;
 }
 `.trim();
-        // locale import
-        const localeImports = supportedLocales.map((locale)=>`import ${locale} from "./${locale}";`).join("\n");
-        // entityLabels를 코드로 변환
-        const entityLabelsCode = this.generateEntityLabelsCode(entityLabels);
-        // locale별 rcKeys 변수명 매핑
-        const getRCKeysVarName = (locale)=>{
-            // supportedLocales에 포함된 locale만 해당 변수 반환
-            if (locale === "ko" && supportedLocales.includes("ko")) return "rcKeysKo";
-            if (locale === "en" && supportedLocales.includes("en")) return "rcKeysEn";
-            // fallback: defaultLocale의 rcKeys
-            if (locale !== defaultLocale) {
-                return getRCKeysVarName(defaultLocale);
-            }
-            // defaultLocale조차 없는 경우 en을 fallback으로 사용
-            return "rcKeysEn";
-        };
-        const body = `
+		const localeImports = supportedLocales.map((locale) => `import ${locale} from "./${locale}";`).join("\n");
+		const entityLabelsCode = this.generateEntityLabelsCode(entityLabels);
+		const getRCKeysVarName = (locale) => {
+			if (locale === "ko" && supportedLocales.includes("ko")) return "rcKeysKo";
+			if (locale === "en" && supportedLocales.includes("en")) return "rcKeysEn";
+			if (locale !== defaultLocale) {
+				return getRCKeysVarName(defaultLocale);
+			}
+			return "rcKeysEn";
+		};
+		const body = `
 ${localeManagementCode}
 
 ${localeImports}
@@ -107,7 +104,7 @@ export function defineLocale(dict: Partial<MergedDictionary>) {
 // 각 locale별로 rc-keys + entity labels + 프로젝트 dict 합침
 const dictionaries: Record<string, Partial<MergedDictionary>> = {
   ${defaultLocale}: { ...${getRCKeysVarName(defaultLocale)}, ...entityLabels, ...${defaultLocale} },
-  ${supportedLocales.filter((locale)=>locale !== defaultLocale).map((locale)=>`  ${locale}: { ...${getRCKeysVarName(locale)}, ...${locale} },`).join("\n")}
+  ${supportedLocales.filter((locale) => locale !== defaultLocale).map((locale) => `  ${locale}: { ...${getRCKeysVarName(locale)}, ...${locale} },`).join("\n")}
 };
 
 type SDReturnType<K extends DictKey> = MergedDictionary[K] extends (...args: infer P) => string
@@ -221,102 +218,98 @@ SD.enumLabels = (enumName: string): Record<string, LocalizedString> => {
   });
 };
 `.trim();
-        return {
-            ...this.getTargetAndPath(undefined, target),
-            body,
-            importKeys: [],
-            customHeaders: [
-                "/**",
-                " * @generated",
-                " * 직접 수정하지 마세요.",
-                " */"
-            ]
-        };
-    }
-    /**
-   * react-components의 rc-keys를 추출합
-   * sonamu/src/dict/rc-keys.ts 파일의 소스 코드를 직접 읽어서 반환
-   */ extractRCKeysSourceCode() {
-        try {
-            // rc-keys.ts 파일 경로
-            const __filename = fileURLToPath(import.meta.url);
-            const __dirname = path.dirname(__filename);
-            // dist에서 실행될 때는 src로 경로 변경
-            const basePath = __dirname.includes("/dist/") ? __dirname.replace("/dist/", "/src/") : __dirname;
-            const rcKeysPath = path.join(basePath, "../../dict/rc-keys.ts");
-            // 파일 읽기
-            const sourceCode = fs.readFileSync(rcKeysPath, "utf-8");
-            // rcKeysKo 추출 (중괄호 카운팅 방식)
-            const koCode = extractObjectDeclaration(sourceCode, "rcKeysKo");
-            // rcKeysEn 추출 (중괄호 카운팅 방식)
-            const enCode = extractObjectDeclaration(sourceCode, "rcKeysEn");
-            return {
-                ko: koCode.replace(/^export /, ""),
-                en: enCode.replace(/^export /, "").replace(/ satisfies RCKeys/, " as const")
-            };
-        } catch (error) {
-            // rc-keys 파일이 없는 경우 빈 코드 반환
-            console.warn("Failed to load rc-keys source:", error);
-            return {
-                ko: "const rcKeysKo = {} as const;",
-                en: "const rcKeysEn = {} as const;"
-            };
-        }
-    }
-    /**
-   * 모든 entity.json에서 entity labels 추출
-   * entity.json에서 직접 관리되는 값만 포함 (자동 생성 값 제외)
-   * - entity.{entityId}: entity title
-   * - entity.{entityId}.{propName}: prop desc
-   * - enum.{EnumId}.{value}: enum label
-   */ extractEntityLabels() {
-        const labels = [];
-        if (!EntityManager.isAutoloaded) {
-            return labels;
-        }
-        const entityIds = EntityManager.getAllIds();
-        for (const entityId of entityIds){
-            const entity = EntityManager.get(entityId);
-            // entity title (entity.json에서 관리)
-            labels.push({
-                key: `entity.${entityId}`,
-                value: entity.title
-            });
-            // prop labels (entity.json에서 관리)
-            for (const prop of entity.props){
-                if (prop.desc) {
-                    labels.push({
-                        key: `entity.${entityId}.${prop.name}`,
-                        value: prop.desc
-                    });
-                }
-            }
-            // enum labels (entity.json에서 관리)
-            for (const [enumId, enumLabelsMap] of Object.entries(entity.enumLabels)){
-                for (const [value, label] of Object.entries(enumLabelsMap)){
-                    labels.push({
-                        key: `enum.${enumId}.${value}`,
-                        value: label
-                    });
-                }
-            }
-        }
-        return labels;
-    }
-    /**
-   * entityLabels를 TypeScript 코드로 변환
-   */ generateEntityLabelsCode(labels) {
-        if (labels.length === 0) {
-            return "const entityLabels = {} as const;";
-        }
-        const entries = labels.map(({ key, value })=>`  "${key}": "${this.escapeString(value)}",`);
-        return `const entityLabels = {
+		return {
+			...this.getTargetAndPath(undefined, target),
+			body,
+			importKeys: [],
+			customHeaders: [
+				"/**",
+				" * @generated",
+				" * 직접 수정하지 마세요.",
+				" */"
+			]
+		};
+	}
+	/**
+	* react-components의 rc-keys를 추출합
+	* sonamu/src/dict/rc-keys.ts 파일의 소스 코드를 직접 읽어서 반환
+	*/
+	extractRCKeysSourceCode() {
+		try {
+			const __filename = fileURLToPath(import.meta.url);
+			const __dirname = path.dirname(__filename);
+			const basePath = __dirname.includes("/dist/") ? __dirname.replace("/dist/", "/src/") : __dirname;
+			const rcKeysPath = path.join(basePath, "../../dict/rc-keys.ts");
+			const sourceCode = fs.readFileSync(rcKeysPath, "utf-8");
+			const koCode = extractObjectDeclaration(sourceCode, "rcKeysKo");
+			const enCode = extractObjectDeclaration(sourceCode, "rcKeysEn");
+			return {
+				ko: koCode.replace(/^export /, ""),
+				en: enCode.replace(/^export /, "").replace(/ satisfies RCKeys/, " as const")
+			};
+		} catch (error) {
+			console.warn("Failed to load rc-keys source:", error);
+			return {
+				ko: "const rcKeysKo = {} as const;",
+				en: "const rcKeysEn = {} as const;"
+			};
+		}
+	}
+	/**
+	* 모든 entity.json에서 entity labels 추출
+	* entity.json에서 직접 관리되는 값만 포함 (자동 생성 값 제외)
+	* - entity.{entityId}: entity title
+	* - entity.{entityId}.{propName}: prop desc
+	* - enum.{EnumId}.{value}: enum label
+	*/
+	extractEntityLabels() {
+		const labels = [];
+		if (!EntityManager.isAutoloaded) {
+			return labels;
+		}
+		const entityIds = EntityManager.getAllIds();
+		for (const entityId of entityIds) {
+			const entity = EntityManager.get(entityId);
+			labels.push({
+				key: `entity.${entityId}`,
+				value: entity.title
+			});
+			for (const prop of entity.props) {
+				if (prop.desc) {
+					labels.push({
+						key: `entity.${entityId}.${prop.name}`,
+						value: prop.desc
+					});
+				}
+			}
+			for (const [enumId, enumLabelsMap] of Object.entries(entity.enumLabels)) {
+				for (const [value, label] of Object.entries(enumLabelsMap)) {
+					labels.push({
+						key: `enum.${enumId}.${value}`,
+						value: label
+					});
+				}
+			}
+		}
+		return labels;
+	}
+	/**
+	* entityLabels를 TypeScript 코드로 변환
+	*/
+	generateEntityLabelsCode(labels) {
+		if (labels.length === 0) {
+			return "const entityLabels = {} as const;";
+		}
+		const entries = labels.map(({ key, value }) => `  "${key}": "${this.escapeString(value)}",`);
+		return `const entityLabels = {
 ${entries.join("\n")}
 } as const;`;
-    }
-    escapeString(str) {
-        return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
-    }
-}
+	}
+	escapeString(str) {
+		return str.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n");
+	}
+};
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/sd.template.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { Sonamu } from \"../../api/sonamu\";\nimport { EntityManager, type EntityNamesRecord } from \"../../entity/entity-manager\";\nimport type { TemplateOptions } from \"../../types/types\";\nimport { extractObjectDeclaration } from \"../helpers\";\nimport { Template } from \"../template\";\n\n/**\n * Sonamu Dictionary (SD) 템플릿\n * i18n을 위한 sd.generated.ts 파일을 생성합니다.\n */\nexport class Template__sd extends Template {\n  constructor() {\n    super(\"sd\");\n  }\n\n  getTargetAndPath(_names?: EntityNamesRecord, sdTarget?: \"api\" | \"web\" | \"app\") {\n    const target = sdTarget ?? \"api\";\n    // api.dir은 상대 경로(\"api\")이므로, web/app도 상대 경로로 맞춤\n    const dir = target === \"api\" ? Sonamu.config.api.dir : target;\n\n    return {\n      target: `${dir}/src/i18n`,\n      path: \"sd.generated.ts\",\n    };\n  }\n\n  render(options: TemplateOptions[\"sd\"]) {\n    const { target } = options;\n    const i18nConfig = Sonamu.config.i18n;\n\n    const { defaultLocale, supportedLocales } = i18nConfig;\n\n    // entity.json에서 entity labels 추출\n    const entityLabels = this.extractEntityLabels();\n\n    // rc-keys 소스 코드 추출\n    const rcKeysSourceCode = this.extractRCKeysSourceCode();\n\n    // 플랫폼별 locale 관리 코드\n    const localeManagementCode =\n      target === \"api\"\n        ? `\nimport { Sonamu } from \"sonamu\";\n\nconst DEFAULT_LOCALE = \"${defaultLocale}\" as const;\nconst SUPPORTED_LOCALES = ${JSON.stringify(supportedLocales)} as const;\nfunction getCurrentLocale(): (typeof SUPPORTED_LOCALES)[number] {\n  try {\n    const ctx = Sonamu.getContext();\n    return ctx.locale as (typeof SUPPORTED_LOCALES)[number] ?? DEFAULT_LOCALE;\n  } catch (_) {\n    return DEFAULT_LOCALE;\n  }\n}\n`.trim()\n        : `\nconst DEFAULT_LOCALE = \"${defaultLocale}\" as const;\nexport const SUPPORTED_LOCALES = ${JSON.stringify(supportedLocales)} as const;\nlet _currentLocale: (typeof SUPPORTED_LOCALES)[number] = DEFAULT_LOCALE;\n\nexport function setLocale(locale: (typeof SUPPORTED_LOCALES)[number]) {\n  _currentLocale = locale;\n}\n\nexport function getCurrentLocale(): (typeof SUPPORTED_LOCALES)[number] {\n  return _currentLocale;\n}\n`.trim();\n\n    // locale import\n    const localeImports = supportedLocales\n      .map((locale) => `import ${locale} from \"./${locale}\";`)\n      .join(\"\\n\");\n\n    // entityLabels를 코드로 변환\n    const entityLabelsCode = this.generateEntityLabelsCode(entityLabels);\n\n    // locale별 rcKeys 변수명 매핑\n    const getRCKeysVarName = (locale: string) => {\n      // supportedLocales에 포함된 locale만 해당 변수 반환\n      if (locale === \"ko\" && supportedLocales.includes(\"ko\")) return \"rcKeysKo\";\n      if (locale === \"en\" && supportedLocales.includes(\"en\")) return \"rcKeysEn\";\n      // fallback: defaultLocale의 rcKeys\n      if (locale !== defaultLocale) {\n        return getRCKeysVarName(defaultLocale);\n      }\n      // defaultLocale조차 없는 경우 en을 fallback으로 사용\n      return \"rcKeysEn\";\n    };\n\n    const body = `\n${localeManagementCode}\n\n${localeImports}\n\n// react-components i18n keys\n${supportedLocales.includes(\"ko\") ? rcKeysSourceCode.ko : \"\"}\n\n${supportedLocales.includes(\"en\") ? rcKeysSourceCode.en : \"\"}\n\n// entity.json에서 추출한 entity labels (defaultLocale 전용)\n${entityLabelsCode}\n\n// defaultLocale의 dictionary를 기준으로 키 추출\ntype RCKeys = typeof ${getRCKeysVarName(defaultLocale)};\ntype ProjectDictionary = typeof ${defaultLocale};\ntype EntityLabels = typeof entityLabels;\ntype RawMergedDictionary = RCKeys & Omit<EntityLabels, keyof (RCKeys & ProjectDictionary)> & ProjectDictionary;\n\n// 키는 유지하되, 값 타입은 string 또는 함수로 일반화 (다른 locale의 리터럴 타입 충돌 방지)\nexport type MergedDictionary = {\n  [K in keyof RawMergedDictionary]: RawMergedDictionary[K] extends (...args: infer P) => string\n    ? (...args: P) => string\n    : string;\n};\nexport type DictKey = keyof MergedDictionary;\nexport type LocalizedString = string & { __brand: \"LocalizedString\" };\n\nexport function defineLocale(dict: Partial<MergedDictionary>) {\n  return dict;\n}\n\n// 각 locale별로 rc-keys + entity labels + 프로젝트 dict 합침\nconst dictionaries: Record<string, Partial<MergedDictionary>> = {\n  ${defaultLocale}: { ...${getRCKeysVarName(defaultLocale)}, ...entityLabels, ...${defaultLocale} },\n  ${supportedLocales\n    .filter((locale) => locale !== defaultLocale)\n    .map((locale) => `  ${locale}: { ...${getRCKeysVarName(locale)}, ...${locale} },`)\n    .join(\"\\n\")}\n};\n\ntype SDReturnType<K extends DictKey> = MergedDictionary[K] extends (...args: infer P) => string\n  ? (...args: P) => LocalizedString\n  : LocalizedString;\n\nfunction getDictValue<K extends DictKey>(key: K, locale: string): SDReturnType<K> {\n  // 1. 지정된 locale에서 조회\n  const dict = dictionaries[locale];\n  if (dict?.[key] !== undefined) {\n    return dict[key] as unknown as SDReturnType<K>;\n  }\n\n  // 2. default locale에서 조회\n  if (locale !== DEFAULT_LOCALE && dictionaries[DEFAULT_LOCALE]?.[key] !== undefined) {\n    return dictionaries[DEFAULT_LOCALE][key] as unknown as SDReturnType<K>;\n  }\n\n  // 3. supported locales 순회\n  for (const supportedLocale of SUPPORTED_LOCALES) {\n    if (supportedLocale !== locale && supportedLocale !== DEFAULT_LOCALE) {\n      if (dictionaries[supportedLocale]?.[key] !== undefined) {\n        return dictionaries[supportedLocale][key] as unknown as SDReturnType<K>;\n      }\n    }\n  }\n\n  // 4. 모두 실패 시 key 반환\n  return key as unknown as SDReturnType<K>;\n}\n\n/**\n * Sonamu Dictionary 함수\n * locale에 맞는 번역 텍스트를 반환합니다.\n *\n * @example\n * SD(\"common.save\")  // → \"저장\" (LocalizedString)\n * SD(\"user.notFound\")(1)  // → \"존재하지 않는 User ID 1\" (LocalizedString)\n */\nexport function SD<K extends DictKey>(key: K): SDReturnType<K> {\n  const locale = getCurrentLocale();\n  return getDictValue(key, locale);\n}\n\n/**\n * 특정 locale의 번역 텍스트를 반환하는 함수를 생성합니다.\n *\n * @example\n * const EN = SD.locale(\"en\");\n * EN(\"common.save\")  // → \"Save\"\n */\nSD.locale = (locale: (typeof SUPPORTED_LOCALES)[number]) => <K extends DictKey>(key: K): SDReturnType<K> => {\n  return getDictValue(key, locale);\n};\n\n// Localized 가능한 Column 타입 계산\ntype LocalizedBaseColumn<T> = {\n  [K in keyof T & string]: K extends \\`\\${infer Base}_\\${(typeof SUPPORTED_LOCALES)[number]}\\` ? Base : K;\n}[keyof T & string];\n\n/**\n * locale에 따라 적절한 컬럼 값을 반환합니다.\n * DB에 name, name_ko, name_en처럼 localized column이 있을 때 사용합니다.\n *\n * 우선순위 (지원 로케일은 ko/jp/en이고, 서비스의 기본 로케일은 ko, 사용자의 로케일은 jp일 때): column_jp → column → column_ko → column_en\n * 우선순위 (지원 로케일은 ko/jp/en이고, 서비스의 기본 로케일은 en, 사용자의 로케일은 ko일 때): column_ko → column → column_en → column_jp\n *\n * @example\n * localizedColumn(tag, \"name\")\n */\nexport function localizedColumn<T extends Record<string, unknown>, K extends LocalizedBaseColumn<T>>(\n  row: T,\n  column: K,\n): string | undefined {\n  const locale = getCurrentLocale();\n  const otherLocales = SUPPORTED_LOCALES.filter((l: string) => l !== locale && l !== DEFAULT_LOCALE);\n  const localizedKey = (column: K, locale: (typeof SUPPORTED_LOCALES)[number]) => \\`\\${column}_\\${locale}\\`;\n  const keys = [\n    localizedKey(column, locale),\n    column,\n    localizedKey(column, DEFAULT_LOCALE),\n    ...otherLocales.map((l) => localizedKey(column, l)),\n  ];\n\n  for (const key of keys) {\n    if (!(key in row)) {\n      continue;\n    }\n\n    if (row[key] !== null && row[key] !== undefined && row[key] !== \"\") {\n      return String(row[key]);\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Enum의 localized labels를 Proxy로 반환합니다.\n * Select 컴포넌트 등에서 EnumLabel[key] 대신 사용합니다.\n *\n * @example\n * SD.enumLabels(\"TagOrderBy\")[key]  // → 현재 locale의 라벨\n */\nSD.enumLabels = (enumName: string): Record<string, LocalizedString> => {\n  return new Proxy({} as Record<string, LocalizedString>, {\n    get(_, key: string) {\n      const dictKey = \\`enum.\\${enumName}.\\${key}\\` as DictKey;\n      return getDictValue(dictKey, getCurrentLocale());\n    }\n  });\n};\n`.trim();\n\n    return {\n      ...this.getTargetAndPath(undefined, target),\n      body,\n      importKeys: [],\n      customHeaders: [\"/**\", \" * @generated\", \" * 직접 수정하지 마세요.\", \" */\"],\n    };\n  }\n\n  /**\n   * react-components의 rc-keys를 추출합\n   * sonamu/src/dict/rc-keys.ts 파일의 소스 코드를 직접 읽어서 반환\n   */\n  private extractRCKeysSourceCode(): { ko: string; en: string } {\n    try {\n      // rc-keys.ts 파일 경로\n      const __filename = fileURLToPath(import.meta.url);\n      const __dirname = path.dirname(__filename);\n\n      // dist에서 실행될 때는 src로 경로 변경\n      const basePath = __dirname.includes(\"/dist/\")\n        ? __dirname.replace(\"/dist/\", \"/src/\")\n        : __dirname;\n\n      const rcKeysPath = path.join(basePath, \"../../dict/rc-keys.ts\");\n\n      // 파일 읽기\n      const sourceCode = fs.readFileSync(rcKeysPath, \"utf-8\");\n\n      // rcKeysKo 추출 (중괄호 카운팅 방식)\n      const koCode = extractObjectDeclaration(sourceCode, \"rcKeysKo\");\n\n      // rcKeysEn 추출 (중괄호 카운팅 방식)\n      const enCode = extractObjectDeclaration(sourceCode, \"rcKeysEn\");\n\n      return {\n        ko: koCode.replace(/^export /, \"\"),\n        en: enCode.replace(/^export /, \"\").replace(/ satisfies RCKeys/, \" as const\"),\n      };\n    } catch (error) {\n      // rc-keys 파일이 없는 경우 빈 코드 반환\n      console.warn(\"Failed to load rc-keys source:\", error);\n      return {\n        ko: \"const rcKeysKo = {} as const;\",\n        en: \"const rcKeysEn = {} as const;\",\n      };\n    }\n  }\n\n  /**\n   * 모든 entity.json에서 entity labels 추출\n   * entity.json에서 직접 관리되는 값만 포함 (자동 생성 값 제외)\n   * - entity.{entityId}: entity title\n   * - entity.{entityId}.{propName}: prop desc\n   * - enum.{EnumId}.{value}: enum label\n   */\n  private extractEntityLabels(): { key: string; value: string }[] {\n    const labels: { key: string; value: string }[] = [];\n\n    if (!EntityManager.isAutoloaded) {\n      return labels;\n    }\n\n    const entityIds = EntityManager.getAllIds();\n\n    for (const entityId of entityIds) {\n      const entity = EntityManager.get(entityId);\n\n      // entity title (entity.json에서 관리)\n      labels.push({ key: `entity.${entityId}`, value: entity.title });\n\n      // prop labels (entity.json에서 관리)\n      for (const prop of entity.props) {\n        if (prop.desc) {\n          labels.push({ key: `entity.${entityId}.${prop.name}`, value: prop.desc });\n        }\n      }\n\n      // enum labels (entity.json에서 관리)\n      for (const [enumId, enumLabelsMap] of Object.entries(entity.enumLabels)) {\n        for (const [value, label] of Object.entries(enumLabelsMap)) {\n          labels.push({ key: `enum.${enumId}.${value}`, value: label });\n        }\n      }\n    }\n\n    return labels;\n  }\n\n  /**\n   * entityLabels를 TypeScript 코드로 변환\n   */\n  private generateEntityLabelsCode(labels: { key: string; value: string }[]): string {\n    if (labels.length === 0) {\n      return \"const entityLabels = {} as const;\";\n    }\n\n    const entries = labels.map(({ key, value }) => `  \"${key}\": \"${this.escapeString(value)}\",`);\n\n    return `const entityLabels = {\n${entries.join(\"\\n\")}\n} as const;`;\n  }\n\n  private escapeString(str: string): string {\n    return str.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\n/g, \"\\\\n\");\n  }\n}\n"],"names":["fs","path","fileURLToPath","Sonamu","EntityManager","extractObjectDeclaration","Template","Template__sd","getTargetAndPath","_names","sdTarget","target","dir","config","api","render","options","i18nConfig","i18n","defaultLocale","supportedLocales","entityLabels","extractEntityLabels","rcKeysSourceCode","extractRCKeysSourceCode","localeManagementCode","JSON","stringify","trim","localeImports","map","locale","join","entityLabelsCode","generateEntityLabelsCode","getRCKeysVarName","includes","body","ko","en","filter","undefined","importKeys","customHeaders","__filename","url","__dirname","dirname","basePath","replace","rcKeysPath","sourceCode","readFileSync","koCode","enCode","error","console","warn","labels","isAutoloaded","entityIds","getAllIds","entityId","entity","get","push","key","value","title","prop","props","desc","name","enumId","enumLabelsMap","Object","entries","enumLabels","label","length","escapeString","str"],"mappings":"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"}
+//#endregion
+export { Template__sd };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sd.template.js","names":["labels: { key: string; value: string }[]"],"sources":["../../../src/template/implementations/sd.template.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\n\nimport { Sonamu } from \"../../api/sonamu\";\nimport { EntityManager } from \"../../entity/entity-manager\";\nimport { type EntityNamesRecord } from \"../../entity/entity-manager\";\nimport { type TemplateOptions } from \"../../types/types\";\nimport { extractObjectDeclaration } from \"../helpers\";\nimport { Template } from \"../template\";\n\n/**\n * Sonamu Dictionary (SD) 템플릿\n * i18n을 위한 sd.generated.ts 파일을 생성합니다.\n */\nexport class Template__sd extends Template {\n  constructor() {\n    super(\"sd\");\n  }\n\n  getTargetAndPath(_names?: EntityNamesRecord, sdTarget?: \"api\" | \"web\" | \"app\") {\n    const target = sdTarget ?? \"api\";\n    // api.dir은 상대 경로(\"api\")이므로, web/app도 상대 경로로 맞춤\n    const dir = target === \"api\" ? Sonamu.config.api.dir : target;\n\n    return {\n      target: `${dir}/src/i18n`,\n      path: \"sd.generated.ts\",\n    };\n  }\n\n  render(options: TemplateOptions[\"sd\"]) {\n    const { target } = options;\n    const i18nConfig = Sonamu.config.i18n;\n\n    const { defaultLocale, supportedLocales } = i18nConfig;\n\n    // entity.json에서 entity labels 추출\n    const entityLabels = this.extractEntityLabels();\n\n    // rc-keys 소스 코드 추출\n    const rcKeysSourceCode = this.extractRCKeysSourceCode();\n\n    // 플랫폼별 locale 관리 코드\n    const localeManagementCode =\n      target === \"api\"\n        ? `\nimport { Sonamu } from \"sonamu\";\n\nconst DEFAULT_LOCALE = \"${defaultLocale}\" as const;\nconst SUPPORTED_LOCALES = ${JSON.stringify(supportedLocales)} as const;\nfunction getCurrentLocale(): (typeof SUPPORTED_LOCALES)[number] {\n  try {\n    const ctx = Sonamu.getContext();\n    return ctx.locale as (typeof SUPPORTED_LOCALES)[number] ?? DEFAULT_LOCALE;\n  } catch (_) {\n    return DEFAULT_LOCALE;\n  }\n}\n`.trim()\n        : `\nconst DEFAULT_LOCALE = \"${defaultLocale}\" as const;\nexport const SUPPORTED_LOCALES = ${JSON.stringify(supportedLocales)} as const;\nlet _currentLocale: (typeof SUPPORTED_LOCALES)[number] = DEFAULT_LOCALE;\n\nexport function setLocale(locale: (typeof SUPPORTED_LOCALES)[number]) {\n  _currentLocale = locale;\n}\n\nexport function getCurrentLocale(): (typeof SUPPORTED_LOCALES)[number] {\n  return _currentLocale;\n}\n`.trim();\n\n    // locale import\n    const localeImports = supportedLocales\n      .map((locale) => `import ${locale} from \"./${locale}\";`)\n      .join(\"\\n\");\n\n    // entityLabels를 코드로 변환\n    const entityLabelsCode = this.generateEntityLabelsCode(entityLabels);\n\n    // locale별 rcKeys 변수명 매핑\n    const getRCKeysVarName = (locale: string) => {\n      // supportedLocales에 포함된 locale만 해당 변수 반환\n      if (locale === \"ko\" && supportedLocales.includes(\"ko\")) return \"rcKeysKo\";\n      if (locale === \"en\" && supportedLocales.includes(\"en\")) return \"rcKeysEn\";\n      // fallback: defaultLocale의 rcKeys\n      if (locale !== defaultLocale) {\n        return getRCKeysVarName(defaultLocale);\n      }\n      // defaultLocale조차 없는 경우 en을 fallback으로 사용\n      return \"rcKeysEn\";\n    };\n\n    const body = `\n${localeManagementCode}\n\n${localeImports}\n\n// react-components i18n keys\n${supportedLocales.includes(\"ko\") ? rcKeysSourceCode.ko : \"\"}\n\n${supportedLocales.includes(\"en\") ? rcKeysSourceCode.en : \"\"}\n\n// entity.json에서 추출한 entity labels (defaultLocale 전용)\n${entityLabelsCode}\n\n// defaultLocale의 dictionary를 기준으로 키 추출\ntype RCKeys = typeof ${getRCKeysVarName(defaultLocale)};\ntype ProjectDictionary = typeof ${defaultLocale};\ntype EntityLabels = typeof entityLabels;\ntype RawMergedDictionary = RCKeys & Omit<EntityLabels, keyof (RCKeys & ProjectDictionary)> & ProjectDictionary;\n\n// 키는 유지하되, 값 타입은 string 또는 함수로 일반화 (다른 locale의 리터럴 타입 충돌 방지)\nexport type MergedDictionary = {\n  [K in keyof RawMergedDictionary]: RawMergedDictionary[K] extends (...args: infer P) => string\n    ? (...args: P) => string\n    : string;\n};\nexport type DictKey = keyof MergedDictionary;\nexport type LocalizedString = string & { __brand: \"LocalizedString\" };\n\nexport function defineLocale(dict: Partial<MergedDictionary>) {\n  return dict;\n}\n\n// 각 locale별로 rc-keys + entity labels + 프로젝트 dict 합침\nconst dictionaries: Record<string, Partial<MergedDictionary>> = {\n  ${defaultLocale}: { ...${getRCKeysVarName(defaultLocale)}, ...entityLabels, ...${defaultLocale} },\n  ${supportedLocales\n    .filter((locale) => locale !== defaultLocale)\n    .map((locale) => `  ${locale}: { ...${getRCKeysVarName(locale)}, ...${locale} },`)\n    .join(\"\\n\")}\n};\n\ntype SDReturnType<K extends DictKey> = MergedDictionary[K] extends (...args: infer P) => string\n  ? (...args: P) => LocalizedString\n  : LocalizedString;\n\nfunction getDictValue<K extends DictKey>(key: K, locale: string): SDReturnType<K> {\n  // 1. 지정된 locale에서 조회\n  const dict = dictionaries[locale];\n  if (dict?.[key] !== undefined) {\n    return dict[key] as unknown as SDReturnType<K>;\n  }\n\n  // 2. default locale에서 조회\n  if (locale !== DEFAULT_LOCALE && dictionaries[DEFAULT_LOCALE]?.[key] !== undefined) {\n    return dictionaries[DEFAULT_LOCALE][key] as unknown as SDReturnType<K>;\n  }\n\n  // 3. supported locales 순회\n  for (const supportedLocale of SUPPORTED_LOCALES) {\n    if (supportedLocale !== locale && supportedLocale !== DEFAULT_LOCALE) {\n      if (dictionaries[supportedLocale]?.[key] !== undefined) {\n        return dictionaries[supportedLocale][key] as unknown as SDReturnType<K>;\n      }\n    }\n  }\n\n  // 4. 모두 실패 시 key 반환\n  return key as unknown as SDReturnType<K>;\n}\n\n/**\n * Sonamu Dictionary 함수\n * locale에 맞는 번역 텍스트를 반환합니다.\n *\n * @example\n * SD(\"common.save\")  // → \"저장\" (LocalizedString)\n * SD(\"user.notFound\")(1)  // → \"존재하지 않는 User ID 1\" (LocalizedString)\n */\nexport function SD<K extends DictKey>(key: K): SDReturnType<K> {\n  const locale = getCurrentLocale();\n  return getDictValue(key, locale);\n}\n\n/**\n * 특정 locale의 번역 텍스트를 반환하는 함수를 생성합니다.\n *\n * @example\n * const EN = SD.locale(\"en\");\n * EN(\"common.save\")  // → \"Save\"\n */\nSD.locale = (locale: (typeof SUPPORTED_LOCALES)[number]) => <K extends DictKey>(key: K): SDReturnType<K> => {\n  return getDictValue(key, locale);\n};\n\n// Localized 가능한 Column 타입 계산\ntype LocalizedBaseColumn<T> = {\n  [K in keyof T & string]: K extends \\`\\${infer Base}_\\${(typeof SUPPORTED_LOCALES)[number]}\\` ? Base : K;\n}[keyof T & string];\n\n/**\n * locale에 따라 적절한 컬럼 값을 반환합니다.\n * DB에 name, name_ko, name_en처럼 localized column이 있을 때 사용합니다.\n *\n * 우선순위 (지원 로케일은 ko/jp/en이고, 서비스의 기본 로케일은 ko, 사용자의 로케일은 jp일 때): column_jp → column → column_ko → column_en\n * 우선순위 (지원 로케일은 ko/jp/en이고, 서비스의 기본 로케일은 en, 사용자의 로케일은 ko일 때): column_ko → column → column_en → column_jp\n *\n * @example\n * localizedColumn(tag, \"name\")\n */\nexport function localizedColumn<T extends Record<string, unknown>, K extends LocalizedBaseColumn<T>>(\n  row: T,\n  column: K,\n): string | undefined {\n  const locale = getCurrentLocale();\n  const otherLocales = SUPPORTED_LOCALES.filter((l: string) => l !== locale && l !== DEFAULT_LOCALE);\n  const localizedKey = (column: K, locale: (typeof SUPPORTED_LOCALES)[number]) => \\`\\${column}_\\${locale}\\`;\n  const keys = [\n    localizedKey(column, locale),\n    column,\n    localizedKey(column, DEFAULT_LOCALE),\n    ...otherLocales.map((l) => localizedKey(column, l)),\n  ];\n\n  for (const key of keys) {\n    if (!(key in row)) {\n      continue;\n    }\n\n    if (row[key] !== null && row[key] !== undefined && row[key] !== \"\") {\n      return String(row[key]);\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Enum의 localized labels를 Proxy로 반환합니다.\n * Select 컴포넌트 등에서 EnumLabel[key] 대신 사용합니다.\n *\n * @example\n * SD.enumLabels(\"TagOrderBy\")[key]  // → 현재 locale의 라벨\n */\nSD.enumLabels = (enumName: string): Record<string, LocalizedString> => {\n  return new Proxy({} as Record<string, LocalizedString>, {\n    get(_, key: string) {\n      const dictKey = \\`enum.\\${enumName}.\\${key}\\` as DictKey;\n      return getDictValue(dictKey, getCurrentLocale());\n    }\n  });\n};\n`.trim();\n\n    return {\n      ...this.getTargetAndPath(undefined, target),\n      body,\n      importKeys: [],\n      customHeaders: [\"/**\", \" * @generated\", \" * 직접 수정하지 마세요.\", \" */\"],\n    };\n  }\n\n  /**\n   * react-components의 rc-keys를 추출합\n   * sonamu/src/dict/rc-keys.ts 파일의 소스 코드를 직접 읽어서 반환\n   */\n  private extractRCKeysSourceCode(): { ko: string; en: string } {\n    try {\n      // rc-keys.ts 파일 경로\n      const __filename = fileURLToPath(import.meta.url);\n      const __dirname = path.dirname(__filename);\n\n      // dist에서 실행될 때는 src로 경로 변경\n      const basePath = __dirname.includes(\"/dist/\")\n        ? __dirname.replace(\"/dist/\", \"/src/\")\n        : __dirname;\n\n      const rcKeysPath = path.join(basePath, \"../../dict/rc-keys.ts\");\n\n      // 파일 읽기\n      const sourceCode = fs.readFileSync(rcKeysPath, \"utf-8\");\n\n      // rcKeysKo 추출 (중괄호 카운팅 방식)\n      const koCode = extractObjectDeclaration(sourceCode, \"rcKeysKo\");\n\n      // rcKeysEn 추출 (중괄호 카운팅 방식)\n      const enCode = extractObjectDeclaration(sourceCode, \"rcKeysEn\");\n\n      return {\n        ko: koCode.replace(/^export /, \"\"),\n        en: enCode.replace(/^export /, \"\").replace(/ satisfies RCKeys/, \" as const\"),\n      };\n    } catch (error) {\n      // rc-keys 파일이 없는 경우 빈 코드 반환\n      console.warn(\"Failed to load rc-keys source:\", error);\n      return {\n        ko: \"const rcKeysKo = {} as const;\",\n        en: \"const rcKeysEn = {} as const;\",\n      };\n    }\n  }\n\n  /**\n   * 모든 entity.json에서 entity labels 추출\n   * entity.json에서 직접 관리되는 값만 포함 (자동 생성 값 제외)\n   * - entity.{entityId}: entity title\n   * - entity.{entityId}.{propName}: prop desc\n   * - enum.{EnumId}.{value}: enum label\n   */\n  private extractEntityLabels(): { key: string; value: string }[] {\n    const labels: { key: string; value: string }[] = [];\n\n    if (!EntityManager.isAutoloaded) {\n      return labels;\n    }\n\n    const entityIds = EntityManager.getAllIds();\n\n    for (const entityId of entityIds) {\n      const entity = EntityManager.get(entityId);\n\n      // entity title (entity.json에서 관리)\n      labels.push({ key: `entity.${entityId}`, value: entity.title });\n\n      // prop labels (entity.json에서 관리)\n      for (const prop of entity.props) {\n        if (prop.desc) {\n          labels.push({ key: `entity.${entityId}.${prop.name}`, value: prop.desc });\n        }\n      }\n\n      // enum labels (entity.json에서 관리)\n      for (const [enumId, enumLabelsMap] of Object.entries(entity.enumLabels)) {\n        for (const [value, label] of Object.entries(enumLabelsMap)) {\n          labels.push({ key: `enum.${enumId}.${value}`, value: label });\n        }\n      }\n    }\n\n    return labels;\n  }\n\n  /**\n   * entityLabels를 TypeScript 코드로 변환\n   */\n  private generateEntityLabelsCode(labels: { key: string; value: string }[]): string {\n    if (labels.length === 0) {\n      return \"const entityLabels = {} as const;\";\n    }\n\n    const entries = labels.map(({ key, value }) => `  \"${key}\": \"${this.escapeString(value)}\",`);\n\n    return `const entityLabels = {\n${entries.join(\"\\n\")}\n} as const;`;\n  }\n\n  private escapeString(str: string): string {\n    return str.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\n/g, \"\\\\n\");\n  }\n}\n"],"mappings":"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"}

package/dist/template/implementations/services.template.d.ts

@@ -1,4 +1,4 @@
-import type { TemplateOptions } from "../../types/types";
+import { type TemplateOptions } from "../../types/types";
 import { Template } from "../template";
 export declare class Template__services extends Template {
     constructor();

package/dist/template/implementations/services.template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"services.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/services.template.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGzD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC,qBAAa,kBAAmB,SAAQ,QAAQ;;IAK9C,gBAAgB;;;;IAOhB,MAAM,CAAC,EAAE,EAAE,eAAe,CAAC,UAAU,CAAC;;;;;;;CAgWvC"}
+{"version":3,"file":"services.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/services.template.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGzD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC,qBAAa,kBAAmB,SAAQ,QAAQ;;IAK9C,gBAAgB;;;;IAOhB,MAAM,CAAC,EAAE,EAAE,eAAe,CAAC,UAAU,CAAC;;;;;;;CA2VvC"}