sonamu 0.7.53 → 0.8.0

package/src/database/_batch_update.ts

@@ -3,8 +3,11 @@
   https://github.com/knex/knex/issues/5716
 */
 
+import { getLogger } from "@logtape/logtape";
 import type { Knex } from "knex";
 
+const logger = getLogger(["sonamu", "internal", "batch-update"]);
+
 type ColumnValue = string | number | boolean | null;
 export type RowWithId<Id extends string> = {
   [key in Id]: ColumnValue;
@@ -39,11 +42,19 @@ export async function batchUpdate<Id extends string>(
 
   if (trx) {
     for (const chunk of chunks) {
+      logger.debug("Processing Batch Chunk in Existing Transaction: {current} / {total}", {
+        current: chunk.length,
+        total: chunks.length,
+      });
       await executeUpdate(chunk, trx);
     }
   } else {
     await knex.transaction(async (newTrx) => {
       for (const chunk of chunks) {
+        logger.debug("Processing Batch Chunk in New Transaction: {current} / {total}", {
+          current: chunk.length,
+          total: chunks.length,
+        });
         await executeUpdate(chunk, newTrx);
       }
     });

package/src/database/puri-subset.test-d.ts

@@ -109,7 +109,7 @@ describe("LoadersResult", () => {
   it("단일 로더의 결과 타입을 생성한다", () => {
     type MockLoaderQb = (
       qbWrapper: PuriWrapper<DatabaseSchemaExtend>,
-      fromIds: number[],
+      fromIds: number[] | string[],
     ) => MockPuri<{ id: number; title: string; refId: number }>;
 
     type Loaders = [
@@ -129,12 +129,12 @@ describe("LoadersResult", () => {
   it("중첩 로더를 처리한다", () => {
     type CommentLoaderQb = (
       qbWrapper: PuriWrapper<DatabaseSchemaExtend>,
-      fromIds: number[],
+      fromIds: number[] | string[],
     ) => MockPuri<{ id: number; content: string; refId: number }>;
 
     type PostLoaderQb = (
       qbWrapper: PuriWrapper<DatabaseSchemaExtend>,
-      fromIds: number[],
+      fromIds: number[] | string[],
     ) => MockPuri<{ id: number; title: string; refId: number }>;
 
     type Loaders = [
@@ -166,7 +166,7 @@ describe("LoadersResult", () => {
       refId: "id";
       qb: (
         qbWrapper: PuriWrapper<DatabaseSchemaExtend>,
-        fromIds: number[],
+        fromIds: number[] | string[],
       ) => MockPuri<{ id: number; name: string; refId: number }>;
     };
     type DepartmentLoader = {
@@ -174,7 +174,7 @@ describe("LoadersResult", () => {
       refId: "id";
       qb: (
         qbWrapper: PuriWrapper<DatabaseSchemaExtend>,
-        fromIds: number[],
+        fromIds: number[] | string[],
       ) => MockPuri<{ id: number; name: string; company_name: string; refId: number }>;
     };
     type EmployeeLoader = {
@@ -182,7 +182,7 @@ describe("LoadersResult", () => {
       refId: "id";
       qb: (
         qbWrapper: PuriWrapper<DatabaseSchemaExtend>,
-        fromIds: number[],
+        fromIds: number[] | string[],
       ) => MockPuri<{ id: number; employee_number: string; refId: number }>;
       loaders: [
         {
@@ -190,7 +190,7 @@ describe("LoadersResult", () => {
           refId: "id";
           qb: (
             qbWrapper: PuriWrapper<DatabaseSchemaExtend>,
-            fromIds: number[],
+            fromIds: number[] | string[],
           ) => MockPuri<{ id: number; name: string; email: string; refId: number }>;
         },
       ];
@@ -267,7 +267,7 @@ describe("InferAllSubsets", () => {
         refId: "company__id";
         qb: (
           qbWrapper: PuriWrapper<DatabaseSchemaExtend>,
-          fromIds: number[],
+          fromIds: number[] | string[],
         ) => MockPuri<{ id: number; name: string; refId: number }>;
       };
       type DepartmentProjectsLoader = {
@@ -275,7 +275,7 @@ describe("InferAllSubsets", () => {
         refId: "department__id";
         qb: (
           qbWrapper: PuriWrapper<DatabaseSchemaExtend>,
-          fromIds: number[],
+          fromIds: number[] | string[],
         ) => MockPuri<{ id: number; name: string; status: string; refId: number }>;
       };
       type LoaderQueries = {
@@ -316,7 +316,7 @@ describe("InferAllSubsets", () => {
         refId: "company__id";
         qb: (
           qbWrapper: PuriWrapper<DatabaseSchemaExtend>,
-          fromIds: number[],
+          fromIds: number[] | string[],
         ) => MockPuri<{ id: number; name: string; refId: number }>;
         loaders: [
           {
@@ -324,7 +324,7 @@ describe("InferAllSubsets", () => {
             refId: "id";
             qb: (
               qbWrapper: PuriWrapper<DatabaseSchemaExtend>,
-              fromIds: number[],
+              fromIds: number[] | string[],
             ) => MockPuri<{ id: number; name: string; status: string; refId: number }>;
           },
         ];
@@ -428,7 +428,7 @@ describe("InferAllSubsets", () => {
         refId: "id";
         qb: (
           qbWrapper: PuriWrapper<DatabaseSchemaExtend>,
-          fromIds: number[],
+          fromIds: number[] | string[],
         ) => MockPuri<{ id: number; name: string; status: string; refId: number }>;
         loaders: [
           {
@@ -436,7 +436,7 @@ describe("InferAllSubsets", () => {
             refId: "id";
             qb: (
               qbWrapper: PuriWrapper<DatabaseSchemaExtend>,
-              fromIds: number[],
+              fromIds: number[] | string[],
             ) => MockPuri<{ id: number; name: string; refId: number }>;
           },
         ];

package/src/database/puri-subset.types.ts

@@ -41,7 +41,7 @@ export type ExtractPuriResult<T> = T extends Puri<any, any, infer R> ? R : never
  */
 export type PuriLoaderQbFn = (
   qbWrapper: PuriWrapper<DatabaseSchemaExtend>,
-  fromIds: number[],
+  fromIds: number[] | string[],
 ) => Puri<any, any, any>;
 
 /**

package/src/database/puri.ts

@@ -748,9 +748,13 @@ export class Puri<TSchema, TTables extends Record<string, any>, TResult> {
     // 기존 ORDER BY clear
     this.knexQuery.clear("order");
     if (distinctOn) {
-      // DISTINCT ON은 SELECT 절의 맨 앞에 와야 하므로, 기존 select를 clear하고 다시 추가
+      // DISTINCT ON은 SELECT 절의 맨 앞에 와야 하므로, 기존 select(subset 필드들)를 보존 후 clear하고 다시 추가
+      const existingSubsetCols = (this.knexQuery as any)._statements
+        .filter((s: any) => s.grouping === "columns")
+        .flatMap((s: any) => s.value);
       this.knexQuery.clear("select");
       this.knexQuery.select(this.knex.raw(`DISTINCT ON (??) ??`, [distinctOn, distinctOn]));
+      existingSubsetCols.map((col: any) => this.knexQuery.select(col));
       this.knexQuery.select(similarityExpr);
       this.knexQuery.orderByRaw(`??, ?? ${operator} ?::vector`, [
         distinctOn,
@@ -1120,6 +1124,25 @@ export class WhereGroup<TTables extends Record<string, any>> {
     return this;
   }
 
+  // whereIn / whereNotIn 메서드들
+  whereIn<TColumn extends AvailableColumns<TTables>>(
+    column: TColumn,
+    values: ExtractColumnType<TTables, TColumn & string>[],
+  ): this;
+  whereIn(...args: any[]): WhereGroup<TTables> {
+    this.builder.whereIn(args[0], args[1]);
+    return this;
+  }
+
+  whereNotIn<TColumn extends AvailableColumns<TTables>>(
+    column: TColumn,
+    values: ExtractColumnType<TTables, TColumn & string>[],
+  ): this;
+  whereNotIn(...args: any[]): WhereGroup<TTables> {
+    this.builder.whereNotIn(args[0], args[1]);
+    return this;
+  }
+
   // orWhere 메서드들
   orWhere(conditions: WhereCondition<TTables>): this;
   orWhere<TColumn extends AvailableColumns<TTables>>(
@@ -1136,6 +1159,25 @@ export class WhereGroup<TTables extends Record<string, any>> {
     return this;
   }
 
+  // orWhereIn / orWhereNotIn 메서드들
+  orWhereIn<TColumn extends AvailableColumns<TTables>>(
+    column: TColumn,
+    values: ExtractColumnType<TTables, TColumn & string>[],
+  ): this;
+  orWhereIn(...args: any[]): WhereGroup<TTables> {
+    this.builder.orWhereIn(args[0], args[1]);
+    return this;
+  }
+
+  orWhereNotIn<TColumn extends AvailableColumns<TTables>>(
+    column: TColumn,
+    values: ExtractColumnType<TTables, TColumn & string>[],
+  ): this;
+  orWhereNotIn(...args: any[]): WhereGroup<TTables> {
+    this.builder.orWhereNotIn(args[0], args[1]);
+    return this;
+  }
+
   // 중첩 그룹
   whereGroup(callback: (g: WhereGroup<TTables>) => void): this;
   whereGroup(callback: (g: WhereGroup<TTables>) => void): WhereGroup<TTables> {

package/src/database/upsert-builder.ts

@@ -1,3 +1,4 @@
+import { getLogger } from "@logtape/logtape";
 import { randomUUID } from "crypto";
 import type { Knex } from "knex";
 import { isArray, unique } from "radashi";
@@ -8,6 +9,8 @@ import { assertDefined, chunk, nonNullable } from "../utils/utils";
 import { batchUpdate, type RowWithId } from "./_batch_update";
 import type { ColumnKeys, ForeignKeyColumns, IdType, TableName } from "./puri.types";
 
+const logger = getLogger(["sonamu", "internal", "upsert-builder"]);
+
 /**
  * FK 타입 추론을 위해 DatabaseForeignKeys export
  * (module augmentation 자동 로드 보장)
@@ -256,7 +259,13 @@ export class UpsertBuilder {
     const allIds: (number | string)[] = [];
 
     // 레벨별로 순차 처리
-    for (const levelRows of levels) {
+    for (let levelIdx = 0; levelIdx < levels.length; levelIdx++) {
+      const levelRows = levels[levelIdx];
+      logger.debug("Processing Query Level: {current} / {total}", {
+        current: levelIdx + 1,
+        total: levels.length,
+      });
+
       // 이전 레벨에서 얻은 ID로 자기 참조 해결
       const resolvedRows = levelRows.map((row) => {
         const resolved = { ...row };
@@ -284,8 +293,13 @@ export class UpsertBuilder {
       const levelChunks = chunkSize ? chunk(resolvedRows, chunkSize) : [resolvedRows];
       const selectFields = unique(["id", ...extractFields]);
 
-      for (const dataChunk of levelChunks) {
+      for (let index = 0; index < levelChunks.length; index++) {
+        const dataChunk = levelChunks[index];
         if (dataChunk.length === 0) continue;
+        logger.debug("Processing Chunk: {current} / {total}", {
+          current: index + 1,
+          total: levelChunks.length,
+        });
 
         // uuid를 별도로 보관하고, DB에 저장할 데이터에서 제거
         const originalUuids = dataChunk.map((r) => r.uuid as string);

package/src/dict/en.ts

@@ -18,6 +18,7 @@ export default {
   "error.alreadyProcessed": "Already processed",
   "error.duplicateRow": "Duplicate data",
   "error.targetNotFound": "Target not found",
+  "error.api.notFound": "API not found",
 
   // Common UI
   "common.save": "Save",

package/src/dict/ko.ts

@@ -18,6 +18,7 @@ export default {
   "error.alreadyProcessed": "이미 처리되었습니다",
   "error.duplicateRow": "중복된 데이터입니다",
   "error.targetNotFound": "대상을 찾을 수 없습니다",
+  "error.api.notFound": "존재하지 않는 API입니다",
 
   // 공통 UI
   "common.save": "저장",

package/src/dict/rc-keys.ts

@@ -77,6 +77,22 @@ export const rcKeysKo = {
   "rc.calendar.month.10": "11월",
   "rc.calendar.month.11": "12월",
 
+  // Sonamu Filter Component
+  "rc.sonamuFilter.title": "소나무 필터",
+  "rc.sonamuFilter.apply": "적용",
+  "rc.sonamuFilter.reset": "초기화",
+  "rc.sonamuFilter.addRule": "규칙 추가",
+  "rc.sonamuFilter.noRulesYet": '아직 규칙이 없습니다. "+ 규칙 추가"를 클릭하여 시작하세요.',
+  "rc.sonamuFilter.selectField": "필드 선택",
+  "rc.sonamuFilter.selectOperator": "연산자 선택",
+  "rc.sonamuFilter.selectOperatorFirst": "먼저 연산자를 선택하세요",
+  "rc.sonamuFilter.enterValue": "값 입력",
+  "rc.sonamuFilter.enterNumber": "숫자 입력",
+  "rc.sonamuFilter.notSupported": "지원하지 않음",
+  "rc.sonamuFilter.startDate": "시작일",
+  "rc.sonamuFilter.endDate": "종료일",
+  "rc.sonamuFilter.appliedFilters": "🌲 적용된 소나무 필터",
+
   // Common
   "rc.common.cancel": "취소",
   "rc.common.save": "저장",
@@ -157,6 +173,22 @@ export const rcKeysEn = {
   "rc.calendar.month.10": "November",
   "rc.calendar.month.11": "December",
 
+  // Sonamu Filter Component
+  "rc.sonamuFilter.title": "Sonamu Filter",
+  "rc.sonamuFilter.apply": "Apply",
+  "rc.sonamuFilter.reset": "Reset",
+  "rc.sonamuFilter.addRule": "Add Rule",
+  "rc.sonamuFilter.noRulesYet": 'No rules yet. Click "+ Add Rule" to start.',
+  "rc.sonamuFilter.selectField": "Select field",
+  "rc.sonamuFilter.selectOperator": "Operator",
+  "rc.sonamuFilter.selectOperatorFirst": "Select operator first",
+  "rc.sonamuFilter.enterValue": "Enter value",
+  "rc.sonamuFilter.enterNumber": "Enter number",
+  "rc.sonamuFilter.notSupported": "Not supported",
+  "rc.sonamuFilter.startDate": "Start date",
+  "rc.sonamuFilter.endDate": "End date",
+  "rc.sonamuFilter.appliedFilters": "🌲 Applied SonamuFilters",
+
   // Common
   "rc.common.cancel": "Cancel",
   "rc.common.save": "Save",

package/src/dict/sd.ts

@@ -25,11 +25,31 @@ type SDReturnType<K extends DictKey> = SonamuDict[K] extends (...args: infer P)
   ? (...args: P) => LocalizedString
   : LocalizedString;
 
-const FALLBACK_LOCALE = "en";
 function getDictValue<K extends DictKey>(key: K, locale: string): SDReturnType<K> {
+  const { defaultLocale, supportedLocales } = Sonamu.config.i18n;
+
+  // 1. 지정된 locale에서 조회
   const dict = dictionaries[locale];
-  const value = dict?.[key] ?? dictionaries[FALLBACK_LOCALE]?.[key] ?? key;
-  return value as unknown as SDReturnType<K>;
+  if (dict?.[key] !== undefined) {
+    return dict[key] as unknown as SDReturnType<K>;
+  }
+
+  // 2. default locale에서 조회
+  if (locale !== defaultLocale && dictionaries[defaultLocale]?.[key] !== undefined) {
+    return dictionaries[defaultLocale][key] as unknown as SDReturnType<K>;
+  }
+
+  // 3. supported locales 순회
+  for (const supportedLocale of supportedLocales) {
+    if (supportedLocale !== locale && supportedLocale !== defaultLocale) {
+      if (dictionaries[supportedLocale]?.[key] !== undefined) {
+        return dictionaries[supportedLocale][key] as unknown as SDReturnType<K>;
+      }
+    }
+  }
+
+  // 4. 모두 실패 시 key 반환
+  return key as unknown as SDReturnType<K>;
 }
 
 /**

package/src/entity/entity-manager.ts

@@ -104,6 +104,10 @@ class EntityManagerClass {
     return Array.from(EntityManager.entities.keys()).sort();
   }
 
+  getAllEntities(): Entity[] {
+    return Array.from(this.entities.values());
+  }
+
   getAllParentIds(): string[] {
     return this.getAllIds().filter((entityId) => {
       const entity = this.get(entityId);

package/src/entity/entity-template-cone.ts

@@ -0,0 +1,298 @@
+import { type FakerMappingConfig, fakerMappings } from "../testing/faker-mappings";
+import type { Cone, EntityJson, EntityProp, OneToOneRelationProp, SubsetDef } from "../types/types";
+import {
+  isBelongsToOneRelationProp,
+  isEnumDefWithCone,
+  isOneToOneRelationProp,
+  isRelationProp,
+  isSubsetDefWithCone,
+} from "../types/types";
+
+/**
+ * Entity의 템플릿 cone을 생성합니다.
+ *
+ * LLM을 사용하지 않고 faker-mappings.ts를 활용하여 기본 cone을 생성합니다.
+ * stub entity 생성 시 자동으로 호출되어 최소한의 cone 메타데이터를 제공합니다.
+ */
+export function generateTemplateCones(
+  entity: EntityJson,
+  locale: "ko" | "en" | "ja" = "ko",
+): {
+  entityCone?: Cone;
+  propCones: Record<string, Cone>;
+  subsetCones: Record<string, Cone>;
+  enumCones: Record<string, Cone>;
+} {
+  const mapping = fakerMappings[locale];
+
+  if (!mapping) {
+    throw new Error(`Unsupported locale: ${locale}`);
+  }
+
+  // 1. Entity cone
+  const entityCone: Cone = {
+    desc: getEntityDesc(entity, locale),
+    fixtureHint: getEntityFixtureHint(entity, locale),
+  };
+
+  // 2. Prop cones
+  const propCones: Record<string, Cone> = {};
+  for (const prop of entity.props) {
+    const fakerConfig = findFakerMapping(prop, mapping);
+
+    propCones[prop.name] = {
+      desc: fakerConfig?.comment || getDefaultDesc(prop, locale),
+      fixtureGenerator: fakerConfig?.faker,
+      fixtureHint: getFixtureHint(prop, fakerConfig, locale),
+      dataSource: shouldHaveDataSource(prop)
+        ? { strategy: "recent", config: { limit: 5 } }
+        : undefined,
+    };
+  }
+
+  // 3. Subset cones
+  const subsetCones: Record<string, Cone> = {};
+  for (const [key, subset] of Object.entries(entity.subsets || {})) {
+    subsetCones[key] = {
+      desc: getSubsetDesc(key, subset, locale),
+      note: getSubsetNote(key, subset, locale),
+    };
+  }
+
+  // 4. Enum cones
+  const enumCones: Record<string, Cone> = {};
+  for (const [enumId, enumDef] of Object.entries(entity.enums || {})) {
+    const values = isEnumDefWithCone(enumDef) ? enumDef.values : enumDef;
+
+    enumCones[enumId] = {
+      desc: getEnumDesc(enumId, locale),
+      note: getEnumNote(enumId, values, locale),
+      values: Object.keys(values).reduce(
+        (acc, key) => {
+          acc[key] = {
+            desc: getEnumValueDesc(values[key] || key, locale),
+          };
+          return acc;
+        },
+        {} as Record<string, { desc: string }>,
+      ),
+    };
+  }
+
+  return { entityCone, propCones, subsetCones, enumCones };
+}
+
+/**
+ * Prop에 맞는 faker mapping을 찾습니다.
+ *
+ * 우선순위:
+ * 1. field_patterns에서 prop name 매칭 (정확한 이름 매칭)
+ * 2. field_patterns에서 부분 매칭 (name 필드가 user_name이면 name 매칭)
+ * 3. type_defaults에서 prop type 매칭
+ */
+function findFakerMapping(
+  prop: EntityProp,
+  mapping: {
+    field_patterns: Record<string, FakerMappingConfig>;
+    type_defaults: Record<string, FakerMappingConfig>;
+  },
+): FakerMappingConfig | undefined {
+  if (isRelationProp(prop)) {
+    return undefined;
+  }
+
+  const propName = prop.name.toLowerCase();
+
+  // 1. 정확한 필드명 매칭
+  if (mapping.field_patterns[propName]) {
+    return mapping.field_patterns[propName];
+  }
+
+  // 2. 부분 매칭 (user_name → name, email_address → email)
+  for (const [pattern, config] of Object.entries(mapping.field_patterns)) {
+    if (propName.includes(pattern) || propName.endsWith(`_${pattern}`)) {
+      return config;
+    }
+  }
+
+  // 3. 타입 기본값 매칭
+  const typeKey = prop.type;
+  if (mapping.type_defaults[typeKey]) {
+    return mapping.type_defaults[typeKey];
+  }
+
+  return undefined;
+}
+
+/**
+ * Entity 설명을 생성합니다.
+ */
+function getEntityDesc(entity: EntityJson, locale: "ko" | "en" | "ja"): string {
+  const title = entity.title || entity.id;
+
+  const templates = {
+    ko: `${title} 엔티티`,
+    en: `${title} entity`,
+    ja: `${title}エンティティ`,
+  };
+
+  return templates[locale];
+}
+
+/**
+ * Entity fixture hint를 생성합니다.
+ */
+function getEntityFixtureHint(entity: EntityJson, locale: "ko" | "en" | "ja"): string {
+  const title = entity.title || entity.id;
+
+  const templates = {
+    ko: `${title} 테스트 데이터를 생성합니다. 각 필드는 실제 데이터와 유사한 형식으로 생성됩니다.`,
+    en: `Generates ${title} test data. Each field is generated in a format similar to real data.`,
+    ja: `${title}のテストデータを生成します。各フィールドは実際のデータに似た形式で生成されます。`,
+  };
+
+  return templates[locale];
+}
+
+/**
+ * Prop 기본 설명을 생성합니다 (faker mapping이 없는 경우).
+ */
+function getDefaultDesc(prop: EntityProp, locale: "ko" | "en" | "ja"): string {
+  if (isRelationProp(prop)) {
+    const templates = {
+      ko: `${prop.with} 참조`,
+      en: `Reference to ${prop.with}`,
+      ja: `${prop.with}への参照`,
+    };
+    return templates[locale];
+  }
+
+  const templates = {
+    ko: prop.name,
+    en: prop.name,
+    ja: prop.name,
+  };
+
+  return templates[locale];
+}
+
+/**
+ * Prop fixture hint를 생성합니다.
+ */
+function getFixtureHint(
+  prop: EntityProp,
+  fakerConfig: FakerMappingConfig | undefined,
+  locale: "ko" | "en" | "ja",
+): string | undefined {
+  if (isRelationProp(prop)) {
+    const templates = {
+      ko: `기존 ${prop.with} 데이터를 참조합니다`,
+      en: `References existing ${prop.with} data`,
+      ja: `既存の${prop.with}データを参照します`,
+    };
+    return templates[locale];
+  }
+
+  if (fakerConfig?.comment) {
+    const templates = {
+      ko: `${fakerConfig.comment} 형식으로 생성됩니다`,
+      en: `Generated as ${fakerConfig.comment}`,
+      ja: `${fakerConfig.comment}形式で生成されます`,
+    };
+    return templates[locale];
+  }
+
+  return undefined;
+}
+
+/**
+ * Prop이 dataSource를 가져야 하는지 판단합니다.
+ *
+ * BelongsToOne 또는 OneToOne (hasJoinColumn: true)인 경우 dataSource가 필요합니다.
+ */
+function shouldHaveDataSource(prop: EntityProp): boolean {
+  if (!isRelationProp(prop)) {
+    return false;
+  }
+
+  // BelongsToOne은 항상 dataSource 필요
+  if (isBelongsToOneRelationProp(prop)) {
+    return true;
+  }
+
+  // OneToOne은 hasJoinColumn: true인 경우에만 dataSource 필요
+  if (isOneToOneRelationProp(prop)) {
+    return (prop as OneToOneRelationProp).hasJoinColumn === true;
+  }
+
+  return false;
+}
+
+/**
+ * Subset 설명을 생성합니다.
+ */
+function getSubsetDesc(key: string, _subset: SubsetDef, locale: "ko" | "en" | "ja"): string {
+  const templates = {
+    ko: `${key} 서브셋`,
+    en: `${key} subset`,
+    ja: `${key}サブセット`,
+  };
+
+  return templates[locale];
+}
+
+/**
+ * Subset note를 생성합니다.
+ */
+function getSubsetNote(_key: string, subset: SubsetDef, locale: "ko" | "en" | "ja"): string {
+  const fields = isSubsetDefWithCone(subset) ? subset.fields : subset;
+  const fieldNames = fields.map((f) => (typeof f === "string" ? f : f.field)).join(", ");
+
+  const templates = {
+    ko: `포함된 필드: ${fieldNames}`,
+    en: `Included fields: ${fieldNames}`,
+    ja: `含まれるフィールド: ${fieldNames}`,
+  };
+
+  return templates[locale];
+}
+
+/**
+ * Enum 설명을 생성합니다.
+ */
+function getEnumDesc(_enumId: string, locale: "ko" | "en" | "ja"): string {
+  const templates = {
+    ko: `열거형`,
+    en: `enum`,
+    ja: `列挙型`,
+  };
+
+  return templates[locale];
+}
+
+/**
+ * Enum note를 생성합니다.
+ */
+function getEnumNote(
+  _enumId: string,
+  values: Record<string, string>,
+  locale: "ko" | "en" | "ja",
+): string {
+  const valueList = Object.keys(values).join(", ");
+
+  const templates = {
+    ko: `가능한 값: ${valueList}`,
+    en: `Possible values: ${valueList}`,
+    ja: `可能な値: ${valueList}`,
+  };
+
+  return templates[locale];
+}
+
+/**
+ * Enum value 설명을 생성합니다.
+ */
+function getEnumValueDesc(label: string, _locale: "ko" | "en" | "ja"): string {
+  // label을 그대로 사용
+  return label;
+}