sonamu 0.7.53 → 0.8.0

package/src/entity/entity.ts

@@ -6,11 +6,14 @@ import { group, unique } from "radashi";
 import { z } from "zod";
 import { Sonamu } from "../api/sonamu";
 import {
+  type Cone,
   type EntityIndex,
   type EntityJson,
   type EntityProp,
   type EntityPropNode,
   type EntitySubsetRow,
+  getEnumDefValues,
+  getSubsetFields,
   isBelongsToOneRelationProp,
   isEnumProp,
   isHasManyRelationProp,
@@ -37,6 +40,7 @@ export class Entity {
   parentId?: string;
   table: string;
   title: string;
+  cone?: Cone;
   names: {
     parentFs: string;
     fs: string;
@@ -67,13 +71,20 @@ export class Entity {
       [key: string]: string;
     };
   } = {};
+  enumCones: {
+    [enumId: string]: Cone;
+  } = {};
+  subsetCones: {
+    [subsetKey: string]: Cone;
+  } = {};
 
-  constructor({ id, parentId, table, title, props, indexes, subsets, enums }: EntityJson) {
+  constructor({ id, parentId, table, title, cone, props, indexes, subsets, enums }: EntityJson) {
     // id
     this.id = id;
     this.parentId = parentId;
     this.title = title ?? this.id;
     this.table = table ?? inflection.underscore(inflection.pluralize(id));
+    this.cone = cone;
 
     // props
     if (props) {
@@ -104,16 +115,30 @@ export class Entity {
     // indexes
     this.indexes = indexes ?? [];
 
-    // subsets: SubsetField[]를 파싱하여 subsets(일반)와 subsetsInternal(internal)로 분리
+    // subsets: SubsetDef에서 SubsetField[]를 추출하여 subsets(일반)와 subsetsInternal(internal)로 분리
     this.subsets = {};
     this.subsetsInternal = {};
-    for (const [key, fields] of Object.entries(subsets ?? {})) {
+    for (const [key, subsetDef] of Object.entries(subsets ?? {})) {
+      const fields = getSubsetFields(subsetDef);
       this.subsets[key] = fields.filter((f) => !isInternalSubsetField(f)).map(normalizeSubsetField);
       this.subsetsInternal[key] = fields.filter(isInternalSubsetField).map(normalizeSubsetField);
+
+      // cone 추출
+      if (!Array.isArray(subsetDef) && "cone" in subsetDef && subsetDef.cone) {
+        this.subsetCones[key] = subsetDef.cone;
+      }
     }
 
-    // enums
-    this.enumLabels = enums ?? {};
+    // enums: EnumDef에서 values와 cone를 추출하여 처리
+    this.enumLabels = Object.fromEntries(
+      Object.entries(enums ?? {}).map(([key, enumDef]) => {
+        // cone 추출
+        if ("values" in enumDef && "cone" in enumDef && enumDef.cone) {
+          this.enumCones[key] = enumDef.cone as Cone;
+        }
+        return [key, getEnumDefValues(enumDef)];
+      }),
+    );
     this.enums = Object.fromEntries(
       Object.entries(this.enumLabels).map(([key, enumLabel]) => {
         return [key, z.enum(Object.keys(enumLabel) as unknown as readonly [string, ...string[]])];
@@ -290,12 +315,17 @@ export class Entity {
       const loaderLines: string[] = [];
 
       for (const loader of loaders) {
-        const { toTable, toCol, through } = loader.manyJoin;
+        const { toTable, toCol, through, fromTable } = loader.manyJoin;
+
+        // fromTable의 Entity를 가져와서 PK 타입 확인
+        const fromEntity = EntityManager.getByTable(fromTable);
+        const fromIdsType = fromEntity.getPkArrayType();
+
         loaderLines.push(
           "{",
           `as: "${loader.as}",`,
           `refId: "${loader.manyJoin.idField}",`,
-          `qb: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>, fromIds: number[]) => {`,
+          `qb: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>, fromIds: number[] | string[]) => {`,
         );
 
         if (through === undefined) {
@@ -327,7 +357,7 @@ export class Entity {
           const selectObj = this.buildNestedSelectObject(loader.select);
           selectObj.refId = `"${toTable}.${toCol}"`;
           loaderLines.push(
-            `.whereIn("${toTable}.${toCol}", fromIds)`,
+            `.whereIn("${toTable}.${toCol}", fromIds as ${fromIdsType})`,
             `.select(${this.stringifyNestedSelectObject(selectObj)});`,
           );
         } else {
@@ -359,7 +389,7 @@ export class Entity {
           const selectObj = this.buildNestedSelectObject(loader.select);
           selectObj.refId = `"${through.table}.${through.fromCol}"`;
           loaderLines.push(
-            `.whereIn("${through.table}.${through.fromCol}", fromIds)`,
+            `.whereIn("${through.table}.${through.fromCol}", fromIds as ${fromIdsType})`,
             `.select(${this.stringifyNestedSelectObject(selectObj)});`,
           );
         }
@@ -841,15 +871,39 @@ export class Entity {
   }
 
   toJson(): EntityJson {
-    // subsets와 subsetsInternal을 SubsetField[] 형태로 복원
-    const subsets: { [key: string]: SubsetField[] } = {};
+    // subsets와 subsetsInternal을 SubsetDef 형태로 복원 (cone 포함)
+    const subsets: { [key: string]: import("../types/types").SubsetDef } = {};
     for (const key of Object.keys(this.subsets)) {
       const normalFields: SubsetField[] = this.subsets[key];
       const internalFields: SubsetField[] = (this.subsetsInternal[key] ?? []).map((field) => ({
         field,
         internal: true,
       }));
-      subsets[key] = [...normalFields, ...internalFields];
+      const fields = [...normalFields, ...internalFields];
+
+      // cone이 있으면 새로운 객체 형태로, 없으면 배열 형태로
+      if (this.subsetCones[key]) {
+        subsets[key] = {
+          fields,
+          cone: this.subsetCones[key],
+        };
+      } else {
+        subsets[key] = fields;
+      }
+    }
+
+    // enums를 EnumDef 형태로 복원 (cone 포함)
+    const enums: { [key: string]: import("../types/types").EnumDef } = {};
+    for (const [key, values] of Object.entries(this.enumLabels)) {
+      // cone이 있으면 새로운 객체 형태로, 없으면 Record 형태로
+      if (this.enumCones[key]) {
+        enums[key] = {
+          values,
+          cone: this.enumCones[key],
+        };
+      } else {
+        enums[key] = values;
+      }
     }
 
     return {
@@ -857,10 +911,11 @@ export class Entity {
       parentId: this.parentId,
       table: this.table,
       title: this.title,
+      cone: this.cone,
       props: this.props,
       indexes: this.indexes,
       subsets,
-      enums: this.enumLabels,
+      enums,
     };
   }
 
@@ -890,6 +945,118 @@ export class Entity {
     await EntityManager.register(json);
   }
 
+  /**
+   * 템플릿 cone 메타데이터를 생성합니다.
+   *
+   * LLM을 사용하지 않고 faker-mappings.ts를 활용하여 기본 cone을 생성합니다.
+   * stub entity 생성 시 자동으로 호출되어 최소한의 cone 메타데이터를 제공합니다.
+   *
+   * @param locale - 생성 시 사용할 locale (기본값: Sonamu.config.i18n.defaultLocale 또는 "ko")
+   */
+  async generateTemplateCones(locale?: "ko" | "en" | "ja"): Promise<void> {
+    const { generateTemplateCones } = await import("./entity-template-cone");
+    const configLocale = Sonamu.config.i18n?.defaultLocale;
+    const effectiveLocale =
+      locale ||
+      (configLocale === "ko" || configLocale === "en" || configLocale === "ja"
+        ? configLocale
+        : "ko");
+    const result = generateTemplateCones(this.toJson(), effectiveLocale);
+
+    // 결과를 Entity에 적용 (applyCones와 동일한 방식)
+    if (result.entityCone) {
+      this.cone = result.entityCone;
+    }
+
+    for (const [propName, cone] of Object.entries(result.propCones)) {
+      const prop = this.props.find((p) => p.name === propName);
+      if (prop) {
+        (prop as { cone?: Cone }).cone = cone;
+      }
+    }
+
+    this.enumCones = { ...this.enumCones, ...result.enumCones };
+    this.subsetCones = { ...this.subsetCones, ...result.subsetCones };
+
+    await this.save();
+  }
+
+  /**
+   * LLM을 사용하여 cone 메타데이터를 생성합니다.
+   *
+   * @param options.preserveExisting - 기존 cone 보존 여부 (기본값: true)
+   * @param options.onlyEmpty - fixtureHint가 없는 cone만 생성 (기본값: false)
+   * @param options.locale - 생성 시 사용할 locale (기본값: "ko")
+   */
+  async generateCones(options?: {
+    preserveExisting?: boolean;
+    onlyEmpty?: boolean;
+    locale?: "ko" | "en" | "ja";
+  }): Promise<import("../cone/cone-generator").ConeGenerationResult> {
+    const { generateCones } = await import("../cone/cone-generator");
+    const context: import("../cone/cone-generator").ConeGenerationContext = {
+      entity: this.toJson(),
+      locale: options?.locale || "ko",
+      existingCones: options?.preserveExisting !== false ? this.collectExistingCones() : undefined,
+      onlyEmpty: options?.onlyEmpty ?? false,
+    };
+
+    const result = await generateCones(context);
+    this.applyCones(result);
+    await this.save();
+    return result;
+  }
+
+  /**
+   * 기존 cone들을 수집합니다 (entity, props, enums, subsets).
+   *
+   * @returns 키가 "entity:id", "prop:name", "enum:enumId", "subset:key" 형식인 cone 맵
+   */
+  private collectExistingCones(): Record<string, Cone> {
+    const cones: Record<string, Cone> = {};
+
+    if (this.cone) {
+      cones[`entity:${this.id}`] = this.cone;
+    }
+
+    for (const prop of this.props) {
+      if (prop.cone) {
+        cones[`prop:${prop.name}`] = prop.cone;
+      }
+    }
+
+    for (const [enumId, cone] of Object.entries(this.enumCones)) {
+      cones[`enum:${enumId}`] = cone;
+    }
+
+    for (const [subsetKey, cone] of Object.entries(this.subsetCones)) {
+      cones[`subset:${subsetKey}`] = cone;
+    }
+
+    return cones;
+  }
+
+  /**
+   * 생성된 cone들을 Entity에 적용합니다.
+   *
+   * @param result - LLM으로 생성된 cone 결과
+   */
+  private applyCones(result: import("../cone/cone-generator").ConeGenerationResult): void {
+    if (result.entityCone) {
+      this.cone = result.entityCone;
+    }
+
+    for (const [propName, cone] of Object.entries(result.propCones)) {
+      const prop = this.props.find((p) => p.name === propName);
+      if (prop) {
+        (prop as { cone?: Cone }).cone = cone;
+      }
+    }
+
+    this.enumCones = { ...this.enumCones, ...result.enumCones };
+    this.subsetCones = { ...this.subsetCones, ...result.subsetCones };
+  }
+
   getSubsetRows(
     _subsets?: { [key: string]: string[] },
     _subsetsInternal?: { [key: string]: string[] },
@@ -1179,4 +1346,13 @@ export class Entity {
     }
     return idProp;
   }
+
+  /**
+   * 엔티티의 PK 배열 타입을 반환합니다.
+   * LoaderQuery의 fromIds 타입으로 사용됩니다.
+   */
+  getPkArrayType(): string {
+    const pkType = this.getPkType();
+    return pkType === "integer" ? "number[]" : "string[]";
+  }
 }

package/src/shared/app.shared.ts.txt

@@ -1,3 +1,8 @@
+/**
+ * @generated
+ * 최초 1회 생성되며, 이후에는 덮어쓰지 않습니다.
+ * 필요시 직접 수정할 수 있습니다.
+ */
 /** biome-ignore-all lint/correctness/useExhaustiveDependencies: shared */
 /** biome-ignore-all lint/suspicious/noExplicitAny: shared */
 

package/src/shared/web.shared.ts.txt

@@ -1,3 +1,8 @@
+/**
+ * @generated
+ * 최초 1회 생성되며, 이후에는 덮어쓰지 않습니다.
+ * 필요시 직접 수정할 수 있습니다.
+ */
 /** biome-ignore-all lint/correctness/useExhaustiveDependencies: shared */
 /** biome-ignore-all lint/suspicious/noExplicitAny: shared */
 
@@ -368,12 +373,11 @@ export function useSSEStream<T extends Record<string, any>>(
       const fullUrl = queryString ? `${url}?${queryString}` : url;
 
       const eventSource = new EventSource(fullUrl, {
-        fetch: (url, options) =>
-          fetch({
-            url: url.toString(),
-            ...options,
+        fetch: (url, init) =>
+          globalThis.fetch(url, {
+            ...init,
             headers: {
-              ...options?.headers,
+              ...init?.headers,
               "Accept-Language": getCurrentLocale(),
             },
           }),

package/src/skills/project/README.md

@@ -0,0 +1,21 @@
+# Project Skills
+
+이 디렉토리는 프로젝트 고유의 문서를 저장하는 공간입니다.
+
+## 용도
+
+- **requirements.md**: 프로젝트 요구사항 명세
+- **business-logic.md**: 비즈니스 로직 상세 (선택)
+- **architecture.md**: 아키텍처 설계 문서 (선택)
+
+## 사용 방법
+
+1. 프로젝트 생성 시 AI가 요구사항을 받으면 `requirements.md`에 자동으로 저장됩니다.
+2. 이후 대화에서 AI는 이 문서들을 지속적으로 참고합니다.
+3. 사용자가 직접 추가하고 싶은 내용이 있으면 이 디렉토리에 새로운 .md 파일을 추가하거나 기존 파일을 수정하세요.
+
+## 주의사항
+
+- 이 디렉토리의 파일들은 프로젝트별로 관리됩니다.
+- Sonamu skills sync 시에도 덮어쓰지 않고 유지됩니다.
+- 민감한 정보(비밀번호, API 키 등)는 절대 포함하지 마세요.