sonamu 0.8.13 → 0.8.14

package/src/template/implementations/generated.template.ts

@@ -225,7 +225,10 @@ export class Template__generated extends Template {
      * - generated 속성이 있는 컬럼 (INSERT/UPDATE 시 값 제공 불가)
      */
     const generatedColumns = entity.props
-      .filter((prop) => prop.type !== "relation" && prop.generated !== undefined)
+      .filter(
+        (prop) =>
+          prop.type !== "relation" && (prop.generated !== undefined || prop.type === "searchText"),
+      )
       .map((prop) => prop.name);
 
     const hasMetadata =

package/src/template/implementations/init_types.template.ts

@@ -19,9 +19,24 @@ export class Template__init_types extends Template {
 
   render({ entityId }: TemplateOptions["init_types"]) {
     const names = EntityManager.getNamesFromId(entityId);
+    const entity = EntityManager.get(entityId);
 
-    const hasCreatedAt =
-      EntityManager.get(entityId).props.find((prop) => prop.name === "created_at") !== undefined;
+    const partialColumns = ["id"];
+    if (entity.props.some((prop) => prop.name === "created_at")) {
+      partialColumns.push("created_at");
+    }
+
+    const writeIneligibleColumns = entity.props
+      .filter(
+        (prop) =>
+          prop.type !== "relation" && (prop.generated !== undefined || prop.type === "searchText"),
+      )
+      .map((prop) => prop.name);
+
+    const omitGeneratedColumns =
+      writeIneligibleColumns.length > 0
+        ? `.omit({ ${writeIneligibleColumns.map((column) => `${column}: true`).join(", ")} })`
+        : "";
 
     return {
       ...this.getTargetAndPath(names),
@@ -34,9 +49,9 @@ export const ${entityId}ListParams = ${entityId}BaseListParams;
 export type ${entityId}ListParams = z.infer<typeof ${entityId}ListParams>;
 
 // ${entityId} - SaveParams
-export const ${entityId}SaveParams = ${entityId}BaseSchema.partial({ id: true${
-        hasCreatedAt ? ", created_at: true" : ""
-      } });
+export const ${entityId}SaveParams = ${entityId}BaseSchema${omitGeneratedColumns}.partial({ ${partialColumns
+        .map((column) => `${column}: true`)
+        .join(", ")} });
 export type ${entityId}SaveParams = z.infer<typeof ${entityId}SaveParams>;
 
       `.trim(),

package/src/template/zod-converter.ts

@@ -46,6 +46,7 @@ import {
   isNumericSingleProp,
   isOneToOneRelationProp,
   isRelationProp,
+  isSearchTextProp,
   isStringArrayProp,
   isStringSingleProp,
   isTsVectorProp,
@@ -248,6 +249,8 @@ export async function propToZodType(prop: EntityProp): Promise<z.ZodTypeAny> {
     zodType = z.uuid().array();
   } else if (isJsonProp(prop)) {
     zodType = await getZodTypeById(prop.id);
+  } else if (isSearchTextProp(prop)) {
+    zodType = z.string();
   } else if (isVectorSingleProp(prop)) {
     zodType = z.array(z.number());
   } else if (isVectorArrayProp(prop)) {
@@ -354,6 +357,8 @@ export function propToZodTypeDef(prop: EntityProp, injectImportKeys: string[]):
       stmt = `${prop.name}: ${prop.id}`;
       injectImportKeys.push(prop.id);
     }
+  } else if (isSearchTextProp(prop)) {
+    stmt = `${prop.name}: z.string()`;
   } else if (isVectorSingleProp(prop)) {
     stmt = `${prop.name}: z.array(z.number())`;
   } else if (isVectorArrayProp(prop)) {

package/src/testing/dev-test-routes.ts

@@ -200,10 +200,12 @@ export async function registerDevTestRoutes(
       };
       manager.addEventListener(listener);
 
-      request.socket.on("close", () => {
+      const cleanup = () => {
         clearInterval(heartbeatTimer);
         manager.removeEventListener(listener);
-      });
+      };
+      request.socket.on("close", cleanup);
+      request.socket.on("error", cleanup);
     });
   }
 

package/src/testing/fixture-generator.ts

@@ -123,6 +123,16 @@ export class FixtureGenerator {
 
       // 1. Relation prop 처리
       if (isRelationProp(prop)) {
+        // BelongsToOne / OneToOne(hasJoinColumn)은 FK 컬럼명({prop.name}_id)으로도 override를 받는다
+        const fkColName = `${prop.name}_id`;
+        if (
+          fkColName in overrides &&
+          (isBelongsToOneRelationProp(prop) || (isOneToOneRelationProp(prop) && prop.hasJoinColumn))
+        ) {
+          fixture[fkColName] = overrides[fkColName];
+          continue;
+        }
+
         const relationValue = await this.generateRelationValue(entity, prop, context);
         // BelongsToOne, OneToOne(hasJoinColumn)의 경우 foreign key 컬럼명으로 저장
         if (
@@ -803,13 +813,16 @@ export class FixtureGenerator {
       const { createAnthropic } = await import("@ai-sdk/anthropic");
       const { generateText } = await import("ai");
 
-      const { text } = await generateText({
+      const rowResponse = await generateText({
         model: createAnthropic({ apiKey })(this.options.llmModel || "claude-sonnet-4-5"),
         prompt: this.buildRowLLMPrompt(llmProps, entity),
       });
+      if (!rowResponse || typeof rowResponse.text !== "string") {
+        throw new Error("Invalid LLM response");
+      }
 
       // 응답을 파싱하여 각 필드에 대한 결과를 캐시에 저장
-      const rowResult = this.parseRowLLMResponse(text, llmProps);
+      const rowResult = this.parseRowLLMResponse(rowResponse.text, llmProps);
       for (const [fieldName, value] of Object.entries(rowResult)) {
         this.llmCache.set(`${rowKey}:${fieldName}`, value);
       }
@@ -844,12 +857,15 @@ export class FixtureGenerator {
     const { createAnthropic } = await import("@ai-sdk/anthropic");
     const { generateText } = await import("ai");
 
-    const { text } = await generateText({
+    const singleResponse = await generateText({
       model: createAnthropic({ apiKey })(this.options.llmModel || "claude-sonnet-4-5"),
       prompt: this.buildLLMPrompt(fixtureHint, prop, entity),
     });
+    if (!singleResponse || typeof singleResponse.text !== "string") {
+      throw new Error("Invalid LLM response");
+    }
 
-    const value = this.parseLLMResponse(text, prop.type);
+    const value = this.parseLLMResponse(singleResponse.text, prop.type);
     if (this.options.enableLLMCache) {
       this.llmCache.set(cacheKey, value);
     }
@@ -944,7 +960,13 @@ ${outputShape}
 
     let parsed: Record<string, unknown>;
     try {
-      parsed = JSON.parse(jsonText);
+      const raw = JSON.parse(jsonText);
+      if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        !isTest() &&
+          console.warn("[FixtureGenerator] Row LLM response is not a plain object:", text);
+        return {};
+      }
+      parsed = raw as Record<string, unknown>;
     } catch {
       !isTest() && console.warn("[FixtureGenerator] Failed to parse row LLM response:", text);
       return {};
@@ -1469,11 +1491,137 @@ Rules:
     // 3. targetDb에 삽입 (FixtureManager가 의존성 정렬 처리)
     const results = await FixtureManager.insertFixtures(this.targetDbName, fixtureRecords);
 
+    // 4. companion fixtures 생성 (fixtureCompanions가 선언된 경우)
+    const companionResults = await this.generateCompanions(specs, results);
+
+    const total = results.length + companionResults.length;
     !isTest() &&
-      console.log(
-        chalk.green(`Generated and saved ${results.length} fixtures to ${this.targetDbName}`),
-      );
-    return results;
+      console.log(chalk.green(`Generated and saved ${total} fixtures to ${this.targetDbName}`));
+    return [...results, ...companionResults];
+  }
+
+  /**
+   * 부모 fixture 결과를 기반으로 fixtureCompanions에 선언된 companion Entity를 생성합니다.
+   *
+   * generateBatch()에서만 호출되며, companion 생성 시 재귀를 방지하기 위해
+   * generateBatch()를 다시 호출하지 않고 직접 삽입합니다.
+   */
+  private async generateCompanions(
+    specs: Array<{ entity: string; count: number; overrides?: Record<string, unknown> }>,
+    parentResults: FixtureImportResult[],
+  ): Promise<FixtureImportResult[]> {
+    const allResults: FixtureImportResult[] = [];
+    const processedEntities = new Set<string>();
+
+    for (const spec of specs) {
+      if (processedEntities.has(spec.entity)) continue;
+      processedEntities.add(spec.entity);
+
+      const entity = this.entityManager.get(spec.entity);
+      const idProp = entity.props.find((p) => p.name === "id");
+      const companions = idProp?.cone?.fixtureCompanions;
+      if (!companions || companions.length === 0) continue;
+
+      const entityResults = parentResults.filter((r) => r.entityId === spec.entity);
+      if (entityResults.length === 0) continue;
+
+      for (const companion of companions) {
+        // companion entity에서 부모 entity로의 BelongsToOne FK 컬럼명 파악
+        const companionEntity = this.entityManager.get(companion.entity);
+        const fkProp = companionEntity.props.find(
+          (p) => isRelationProp(p) && isBelongsToOneRelationProp(p) && p.with === spec.entity,
+        );
+        if (!fkProp) {
+          !isTest() &&
+            console.warn(
+              chalk.yellow(
+                `[Companion] No BelongsToOne relation from ${companion.entity} to ${spec.entity}. Skipping.`,
+              ),
+            );
+          continue;
+        }
+        const fkColName = `${fkProp.name}_id`;
+
+        // companion의 idProp, usesSequence, count는 companion 단위로 고정
+        const companionIdProp = companionEntity.props.find((p) => p.name === "id");
+        const usesSequence =
+          companionIdProp?.type === "integer" ||
+          companionIdProp?.type === "bigInteger" ||
+          companionIdProp?.cone?.fixtureStrategy === "sequence";
+        const companionCount = companion.count ?? 1;
+
+        // 각 parent result에 대해 companion fixture 생성
+        const context = this.createContext();
+        const companionFixtureRecords: FixtureRecord[] = [];
+
+        for (const parentResult of entityResults) {
+          const resolvedOverrides = this.resolveTemplateOverrides(
+            companion.overrides ?? {},
+            parentResult.data,
+          );
+          resolvedOverrides[fkColName] = parentResult.data.id;
+
+          for (let i = 0; i < companionCount; i++) {
+            const fixture = await this.generate(companion.entity, resolvedOverrides, context);
+
+            const dataForRecord = usesSequence
+              ? { ...fixture, id: Math.floor(Math.random() * 1000000) }
+              : fixture;
+
+            const records = await FixtureManager.createFixtureRecord(
+              companionEntity,
+              dataForRecord as {
+                id: number | string;
+                [key: string]: string | number | boolean | null;
+              },
+              { singleRecord: true },
+            );
+            companionFixtureRecords.push(...records);
+          }
+        }
+
+        const companionResults = await FixtureManager.insertFixtures(
+          this.targetDbName,
+          companionFixtureRecords,
+        );
+        allResults.push(...companionResults);
+
+        !isTest() &&
+          console.log(
+            chalk.green(
+              `[Companion] Generated ${companionResults.length} ${companion.entity} fixtures`,
+            ),
+          );
+      }
+    }
+
+    return allResults;
+  }
+
+  /**
+   * overrides 값의 "{{fieldName}}" 템플릿을 부모 fixture 데이터로 치환합니다.
+   *
+   * 예: { "account_id": "{{email}}" } → { "account_id": "user@example.com" }
+   */
+  private resolveTemplateOverrides(
+    overrides: Record<string, unknown>,
+    parentData: { [key: string]: string | number | boolean | Date | null },
+  ): Record<string, unknown> {
+    const resolved: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(overrides)) {
+      if (typeof value === "string" && value.startsWith("{{") && value.endsWith("}}")) {
+        const fieldName = value.slice(2, -2).trim();
+        if (!(fieldName in parentData)) {
+          throw new Error(
+            `템플릿 필드 "${fieldName}"이(가) 부모 fixture 데이터에 존재하지 않습니다 (override key: "${key}")`,
+          );
+        }
+        resolved[key] = parentData[fieldName];
+      } else {
+        resolved[key] = value;
+      }
+    }
+    return resolved;
   }
 
   /**

package/src/testing/fixture-manager.ts

@@ -495,7 +495,21 @@ export class FixtureManagerClass {
     this.fixtureRefMap = new Map();
     this.skippedFixtures = new Map();
 
-    const db = createKnexInstance(Sonamu.dbConfig[dbName]);
+    // 병렬 테스트 모드에서는 worker별 DB에 저장
+    const dbConfig =
+      process.env.SONAMU_WORKER_DB === "true" && process.env.VITEST_POOL_ID
+        ? (() => {
+            const workerId = parseInt(process.env.VITEST_POOL_ID ?? "1", 10);
+            const baseConfig = Sonamu.dbConfig[dbName];
+            const connection = baseConfig.connection as { database: string };
+            return {
+              ...baseConfig,
+              connection: { ...connection, database: `${connection.database}_${workerId}` },
+              pool: { min: 1, max: 1 },
+            };
+          })()
+        : Sonamu.dbConfig[dbName];
+    const db = createKnexInstance(dbConfig);
     const results: FixtureImportResult[] = [];
 
     try {

package/src/types/__tests__/entity-json-schema-search-text.test.ts

@@ -0,0 +1,179 @@
+import { describe, expect, test } from "vitest";
+import { z } from "zod";
+import { EntityJsonSchema, isSearchTextJsonSourceZodType, TemplateOptions } from "../types";
+
+function createBaseEntity() {
+  return {
+    id: "SearchTextTest",
+    title: "SearchText Test",
+    table: "search_text_tests",
+    props: [
+      { name: "id", type: "integer" },
+      { name: "title", type: "string" },
+      { name: "tags", type: "string[]" },
+      { name: "aliases", type: "json", id: "StringArray" },
+      {
+        name: "search_text",
+        type: "searchText",
+        sourceColumns: [{ name: "title", caseInsensitive: true }],
+      },
+    ],
+    indexes: [
+      {
+        type: "index",
+        name: "search_text_tests_search_text_index",
+        using: "gin",
+        columns: [{ name: "search_text", opclass: "gin_trgm_ops" }],
+      },
+    ],
+    subsets: {
+      A: ["id", "title", "tags", "aliases", "search_text"],
+    },
+    enums: {},
+  } as const;
+}
+
+describe("EntityJsonSchema searchText/opclass validation", () => {
+  test("opclass known/free string과 vectorOps 하위호환을 허용해야 한다", () => {
+    const knownOpclass = createBaseEntity();
+    const knownResult = EntityJsonSchema.safeParse(knownOpclass);
+    expect(knownResult.success).toBe(true);
+
+    const freeOpclass = createBaseEntity();
+    freeOpclass.indexes[0] = {
+      ...freeOpclass.indexes[0],
+      columns: [{ name: "search_text", opclass: "custom_text_ops" }],
+    };
+    const freeResult = EntityJsonSchema.safeParse(freeOpclass);
+    expect(freeResult.success).toBe(true);
+
+    const legacyVectorOps = createBaseEntity();
+    legacyVectorOps.indexes[0] = {
+      type: "hnsw",
+      name: "search_text_tests_embedding_hnsw",
+      columns: [{ name: "embedding", vectorOps: "vector_cosine_ops" }],
+      m: 16,
+      efConstruction: 64,
+    };
+    const legacyResult = EntityJsonSchema.safeParse(legacyVectorOps);
+    expect(legacyResult.success).toBe(true);
+  });
+
+  test("searchText source column 존재/타입 검증이 동작해야 한다", () => {
+    const unknownSource = createBaseEntity();
+    unknownSource.props[4] = {
+      name: "search_text",
+      type: "searchText",
+      sourceColumns: [{ name: "missing_col", caseInsensitive: true }],
+    };
+    const unknownResult = EntityJsonSchema.safeParse(unknownSource);
+    expect(unknownResult.success).toBe(false);
+
+    const unsupportedSourceType = createBaseEntity();
+    unsupportedSourceType.props[4] = {
+      name: "search_text",
+      type: "searchText",
+      sourceColumns: [{ name: "id", caseInsensitive: true }],
+    };
+    const unsupportedResult = EntityJsonSchema.safeParse(unsupportedSourceType);
+    expect(unsupportedResult.success).toBe(false);
+  });
+
+  test("schema 단계에서는 searchText json source id naming을 강제하지 않아야 한다", () => {
+    const nullableWrapper = createBaseEntity();
+    nullableWrapper.props[3] = { name: "aliases", type: "json", id: "NullableStringArray" };
+    nullableWrapper.props[4] = {
+      name: "search_text",
+      type: "searchText",
+      sourceColumns: [{ name: "aliases", caseInsensitive: true }],
+    };
+    const wrapperResult = EntityJsonSchema.safeParse(nullableWrapper);
+    expect(wrapperResult.success).toBe(true);
+
+    const nullableElement = createBaseEntity();
+    nullableElement.props[3] = { name: "aliases", type: "json", id: "StringNullableArray" };
+    nullableElement.props[4] = {
+      name: "search_text",
+      type: "searchText",
+      sourceColumns: [{ name: "aliases", caseInsensitive: true }],
+    };
+    const nullableElementResult = EntityJsonSchema.safeParse(nullableElement);
+    expect(nullableElementResult.success).toBe(true);
+
+    const customNamedType = createBaseEntity();
+    customNamedType.props[3] = { name: "aliases", type: "json", id: "CustomAliasType" };
+    customNamedType.props[4] = {
+      name: "search_text",
+      type: "searchText",
+      sourceColumns: [{ name: "aliases", caseInsensitive: true }],
+    };
+    const customNamedTypeResult = EntityJsonSchema.safeParse(customNamedType);
+    expect(customNamedTypeResult.success).toBe(true);
+  });
+
+  test("TemplateOptions.entity 경로도 searchText source 검증을 동일하게 적용해야 한다", () => {
+    const validEntity = createBaseEntity();
+    const validTemplateEntity = {
+      entityId: validEntity.id,
+      title: validEntity.title,
+      table: validEntity.table,
+      props: validEntity.props,
+      indexes: validEntity.indexes,
+      subsets: validEntity.subsets,
+      enums: validEntity.enums,
+    };
+    const validResult = TemplateOptions.shape.entity.safeParse(validTemplateEntity);
+    expect(validResult.success).toBe(true);
+
+    const invalidEntity = createBaseEntity();
+    invalidEntity.props[4] = {
+      name: "search_text",
+      type: "searchText",
+      sourceColumns: [{ name: "missing_col", caseInsensitive: true }],
+    };
+    const invalidTemplateEntity = {
+      entityId: invalidEntity.id,
+      title: invalidEntity.title,
+      table: invalidEntity.table,
+      props: invalidEntity.props,
+      indexes: invalidEntity.indexes,
+      subsets: invalidEntity.subsets,
+      enums: invalidEntity.enums,
+    };
+    const invalidResult = TemplateOptions.shape.entity.safeParse(invalidTemplateEntity);
+    expect(invalidResult.success).toBe(false);
+  });
+
+  test("TemplateOptions.entity 경로도 json id naming에 의존하지 않아야 한다", () => {
+    const customNamedType = createBaseEntity();
+    customNamedType.props[3] = { name: "aliases", type: "json", id: "CustomAliasType" };
+    customNamedType.props[4] = {
+      name: "search_text",
+      type: "searchText",
+      sourceColumns: [{ name: "aliases", caseInsensitive: true }],
+    };
+
+    const customTemplateEntity = {
+      entityId: customNamedType.id,
+      title: customNamedType.title,
+      table: customNamedType.table,
+      props: customNamedType.props,
+      indexes: customNamedType.indexes,
+      subsets: customNamedType.subsets,
+      enums: customNamedType.enums,
+    };
+    const customTemplateResult = TemplateOptions.shape.entity.safeParse(customTemplateEntity);
+    expect(customTemplateResult.success).toBe(true);
+  });
+
+  test("searchText json source Zod 구조 검증 유틸이 wrapper/element 타입을 정확히 판정해야 한다", () => {
+    expect(isSearchTextJsonSourceZodType(z.array(z.string()))).toBe(true);
+    expect(isSearchTextJsonSourceZodType(z.array(z.string()).optional())).toBe(true);
+    expect(isSearchTextJsonSourceZodType(z.array(z.string()).nullable())).toBe(true);
+    expect(isSearchTextJsonSourceZodType(z.array(z.string()).nullish())).toBe(true);
+
+    expect(isSearchTextJsonSourceZodType(z.array(z.string().nullable()))).toBe(false);
+    expect(isSearchTextJsonSourceZodType(z.array(z.number()))).toBe(false);
+    expect(isSearchTextJsonSourceZodType(z.string())).toBe(false);
+  });
+});