sonamu 0.7.4 → 0.7.5

package/src/template/implementations/view_list.template.ts

@@ -86,6 +86,9 @@ export class Template__view_list extends Template {
       }
       case "array":
         return `<>{ /* array ${colName} */ }</>`;
+      case "vector":
+        // vector 타입은 차원 수만 표시 (실제 데이터는 너무 김)
+        return `<>{${col.nullable ? `${colName} ? ` : ""}[Vector: {${colName}${col.nullable ? "" : " ?? []"}.length}d]${col.nullable ? " : '-'" : ""}}</>`;
       default:
         throw new Error(`렌더 불가 컬럼 ${col.renderType}`);
     }
@@ -98,7 +101,7 @@ export class Template__view_list extends Template {
   ): (string | null)[] {
     if (col.renderType === "enums") {
       const { id: enumId } = getEnumInfoFromColName(names.capital, col.name);
-      return [`import { ${enumId}Label } from 'src/services/sonamu.generated';`];
+      return [`import { ${enumId}Label } from '@/services/sonamu.generated';`];
     } else if (col.renderType === "object") {
       try {
         const relProp = getRelationPropFromColName(entityId, col.name);
@@ -121,11 +124,11 @@ export class Template__view_list extends Template {
 
   renderFilterImport(entityId: string, col: RenderingNode, names: EntityNamesRecord) {
     if (col.name === "search") {
-      return `import { ${names.capital}SearchInput } from "src/components/${names.fs}/${names.capital}SearchInput";`;
+      return `import { ${names.capital}SearchInput } from "@/components/${names.fs}/${names.capital}SearchInput";`;
     } else if (col.renderType === "enums") {
       if (col.name === "orderBy") {
         const componentId = `${names.capital}${inflection.camelize(col.name)}Select`;
-        return `import { ${componentId} } from "src/components/${names.fs}/${componentId}";`;
+        return `import { ${componentId} } from "@/components/${names.fs}/${componentId}";`;
       } else {
         try {
           const { id, targetEntityNames: targetMDNames } = getEnumInfoFromColName(
@@ -133,7 +136,7 @@ export class Template__view_list extends Template {
             col.name,
           );
           const componentId = `${id}Select`;
-          return `import { ${componentId} } from "src/components/${targetMDNames.fs}/${componentId}";`;
+          return `import { ${componentId} } from "@/components/${targetMDNames.fs}/${componentId}";`;
         } catch {
           return "";
         }
@@ -143,7 +146,7 @@ export class Template__view_list extends Template {
         const relProp = getRelationPropFromColName(entityId, col.name.replace("_id", ""));
         const targetNames = EntityManager.getNamesFromId(relProp.with);
         const componentId = `${relProp.with}IdAsyncSelect`;
-        return `import { ${componentId} } from "src/components/${targetNames.fs}/${componentId}";`;
+        return `import { ${componentId} } from "@/components/${targetNames.fs}/${componentId}";`;
       } catch {
         return "";
       }
@@ -322,9 +325,9 @@ import classNames from 'classnames';
 import { DateTime } from "luxon";
 import { DelButton, EditButton, AppBreadcrumbs, AddButton, useSelection, useListParams, SonamuCol, numF, formatDate, formatDateTime } from '@sonamu-kit/react-sui';
 
-import { ${names.capital}SubsetA } from "src/services/sonamu.generated";
-import { ${names.capital}Service } from 'src/services/${names.fs}/${names.fs}.service';
-import { ${names.capital}ListParams } from 'src/services/${names.fs}/${names.fs}.types';
+import { ${names.capital}SubsetA } from "@/services/sonamu.generated";
+import { ${names.capital}Service } from '@/services/${names.fs}/${names.fs}.service';
+import { ${names.capital}ListParams } from '@/services/${names.fs}/${names.fs}.types';
 ${columnImports}
 ${filterColumns
   .map((col) => {

package/src/template/implementations/view_search_input.template.ts

@@ -23,7 +23,7 @@ export class Template__view_search_input extends Template {
 import React from "react";
 import { useState } from "react";
 import { DropdownProps, Input, InputProps } from "semantic-ui-react";
-import { ${names.capital}SearchFieldDropdown } from "src/components/${names.fs}/${names.capital}SearchFieldDropdown";
+import { ${names.capital}SearchFieldDropdown } from "@/components/${names.fs}/${names.capital}SearchFieldDropdown";
 
 export function ${names.capital}SearchInput({
   input: { value: inputValue, onChange: inputOnChange, ...inputProps },

package/src/template/template.ts

@@ -70,7 +70,7 @@ export abstract class Template {
     const instance = Template.templates.get(key);
     if (!instance) {
       throw new Error(
-        `Template ${key} not found. It might be becasuse you tried to find a template before loading all templates. Did you call Template.loadAll()?`,
+        `Template ${key} not found. It might be because you tried to find a template before loading all templates. Did you call Template.loadAll()?`,
       );
     }
     return instance;

package/src/template/zod-converter.ts

@@ -49,6 +49,8 @@ import {
   isStringSingleProp,
   isUuidArrayProp,
   isUuidSingleProp,
+  isVectorArrayProp,
+  isVectorSingleProp,
   isVirtualProp,
   type RenderingNode,
 } from "../types/types";
@@ -131,6 +133,10 @@ export async function propToZodType(prop: EntityProp): Promise<z.ZodTypeAny> {
     zodType = z.uuid().array();
   } else if (isJsonProp(prop)) {
     zodType = await getZodTypeById(prop.id);
+  } else if (isVectorSingleProp(prop)) {
+    zodType = z.array(z.number());
+  } else if (isVectorArrayProp(prop)) {
+    zodType = z.array(z.array(z.number()));
   } else if (isVirtualProp(prop)) {
     zodType = await getZodTypeById(prop.id);
   } else if (isRelationProp(prop)) {
@@ -205,6 +211,10 @@ export function propToZodTypeDef(prop: EntityProp, injectImportKeys: string[]):
   } else if (isJsonProp(prop)) {
     stmt = `${prop.name}: ${prop.id}`;
     injectImportKeys.push(prop.id);
+  } else if (isVectorSingleProp(prop)) {
+    stmt = `${prop.name}: z.array(z.number())`;
+  } else if (isVectorArrayProp(prop)) {
+    stmt = `${prop.name}: z.array(z.array(z.number()))`;
   } else if (isVirtualProp(prop)) {
     stmt = `${prop.name}: ${prop.id}`;
     injectImportKeys.push(prop.id);
@@ -506,6 +516,16 @@ export function zodTypeToRenderingNode(
         renderType: "array-images",
       };
     }
+    // vector 타입 판별: number 배열이면서 embedding, vector 등의 이름을 가진 경우
+    if (
+      innerType instanceof z.ZodNumber &&
+      (baseKey.includes("embedding") || baseKey.includes("vector"))
+    ) {
+      return {
+        ...def,
+        renderType: "vector",
+      };
+    }
     return {
       ...def,
       renderType: "array",

package/src/testing/fixture-manager.ts

@@ -13,6 +13,7 @@ import { type UBRef, UpsertBuilder } from "../database/upsert-builder";
 import type { Entity } from "../entity/entity";
 import { EntityManager } from "../entity/entity-manager";
 import {
+  type DatabaseSchemaExtend,
   type EntityProp,
   type FixtureImportResult,
   type FixtureRecord,
@@ -95,47 +96,45 @@ export class FixtureManagerClass {
   }
 
   /**
-    이제 FixtureManager.sync() 는 checksum 비교 없이 create database template 으로 수행합니다.
+    원격 fixture DB를 로컬 test DB로 복사합니다.
+    pg_dump로 원격 DB를 덤프하고, pg_restore로 로컬에 복원합니다.
   */
   async sync() {
     const fixtureConn = Sonamu.dbConfig.fixture_remote.connection as Knex.PgConnectionConfig;
     const testConn = Sonamu.dbConfig.test.connection as Knex.PgConnectionConfig;
 
-    // PostgreSQL 패스워드 환경변수 설정
-    const pgEnv = { PGPASSWORD: testConn.password || "" };
-
-    // 1. 연결 강제 종료
+    // 1. 로컬 test DB 연결 종료 및 재생성
+    const testPgEnv = { PGPASSWORD: testConn.password || "" };
     execSync(
       `psql -h ${testConn.host} -p ${testConn.port ?? 5432} -U ${testConn.user} -d postgres -c "
-      SELECT pg_terminate_backend(pg_stat_activity.pid)
-      FROM pg_stat_activity
-      WHERE datname = '${testConn.database}'
-        AND pid <> pg_backend_pid();
-    "`,
-      { stdio: "inherit", env: { ...process.env, ...pgEnv } as NodeJS.ProcessEnv },
-    );
-
-    execSync(
-      `psql -h ${fixtureConn.host} -p ${fixtureConn.port ?? 5432} -U ${fixtureConn.user} -d postgres -c "
         SELECT pg_terminate_backend(pg_stat_activity.pid)
         FROM pg_stat_activity
-        WHERE datname = '${fixtureConn.database}'
+        WHERE datname = '${testConn.database}'
           AND pid <> pg_backend_pid();
       "`,
-      { stdio: "inherit", env: { ...process.env, ...pgEnv } as NodeJS.ProcessEnv },
+      { stdio: "inherit", env: { ...process.env, ...testPgEnv } as NodeJS.ProcessEnv },
     );
 
-    // 2. DROP DATABASE (별도 실행!)
     execSync(
       `psql -h ${testConn.host} -p ${testConn.port ?? 5432} -U ${testConn.user} -d postgres -c "DROP DATABASE IF EXISTS \\"${testConn.database}\\""`,
-      { stdio: "inherit", env: { ...process.env, ...pgEnv } as NodeJS.ProcessEnv },
+      { stdio: "inherit", env: { ...process.env, ...testPgEnv } as NodeJS.ProcessEnv },
     );
 
-    // 3. CREATE DATABASE
     execSync(
-      `psql -h ${testConn.host} -p ${testConn.port ?? 5432} -U ${testConn.user} -d postgres -c "CREATE DATABASE \\"${testConn.database}\\" TEMPLATE \\"${fixtureConn.database}\\""`,
-      { stdio: "inherit", env: { ...process.env, ...pgEnv } as NodeJS.ProcessEnv },
+      `psql -h ${testConn.host} -p ${testConn.port ?? 5432} -U ${testConn.user} -d postgres -c "CREATE DATABASE \\"${testConn.database}\\""`,
+      { stdio: "inherit", env: { ...process.env, ...testPgEnv } as NodeJS.ProcessEnv },
     );
+
+    // 2. 원격 fixture DB → 로컬 test DB로 복사 (pg_dump | pg_restore)
+    const fixturePgEnv = { PGPASSWORD: fixtureConn.password || "" };
+    const dumpCmd = `pg_dump -h ${fixtureConn.host} -p ${fixtureConn.port ?? 5432} -U ${fixtureConn.user} -d ${fixtureConn.database} -Fc`;
+    const restoreCmd = `pg_restore -h ${testConn.host} -p ${testConn.port ?? 5432} -U ${testConn.user} -d ${testConn.database} --no-owner --no-acl`;
+
+    execSync(`${dumpCmd} | PGPASSWORD="${testConn.password || ""}" ${restoreCmd}`, {
+      stdio: "inherit",
+      env: { ...process.env, ...fixturePgEnv } as NodeJS.ProcessEnv,
+      shell: "/bin/bash",
+    });
   }
 
   private visitedRecords = new Set<string>();
@@ -506,7 +505,9 @@ export class FixtureManagerClass {
           // upsert된 row들의 uuid -> id 매핑 구축
           if (uuids.length > 0) {
             const uuidToId = new Map<string, number>();
-            const rows = await trx(tableName).select("uuid", "id").whereIn("uuid", uuids);
+            const rows = await trx(tableName as string)
+              .select("uuid", "id")
+              .whereIn("uuid", uuids);
 
             for (const row of rows) {
               uuidToId.set(row.uuid, row.id);
@@ -656,7 +657,7 @@ export class FixtureManagerClass {
   /**
    * 테이블 순서 추출 (fixtures에 포함된 테이블만)
    */
-  private getTableOrder(fixtures: FixtureRecord[]): string[] {
+  private getTableOrder(fixtures: FixtureRecord[]): (keyof DatabaseSchemaExtend)[] {
     const tables: string[] = [];
     const seen = new Set<string>();
 
@@ -668,7 +669,7 @@ export class FixtureManagerClass {
       }
     }
 
-    return tables;
+    return tables as (keyof DatabaseSchemaExtend)[];
   }
 
   private async processManyToManyRelations(
@@ -755,7 +756,7 @@ export class FixtureManagerClass {
     const _uniqueIndexes = entity.indexes?.filter((i) => i.type === "unique") ?? [];
 
     const uniqueIndexes = _uniqueIndexes.filter((index) =>
-      index.columns.every((column) => !column.startsWith(`${entity.table}__`)),
+      index.columns.every((column) => !column.name.startsWith(`${entity.table}__`)),
     );
     if (uniqueIndexes.length === 0) {
       return null;
@@ -767,7 +768,7 @@ export class FixtureManagerClass {
     for (const index of uniqueIndexes) {
       // 컬럼 중 하나라도 null이면 유니크 제약을 위반하지 않기 때문에 해당 인덱스는 무시
       const containsNull = index.columns.some((column) => {
-        const field = column.replace(/_id$/, "");
+        const field = column.name.replace(/_id$/, "");
         return fixture.columns[field]?.value === null;
       });
       if (containsNull) {
@@ -776,12 +777,12 @@ export class FixtureManagerClass {
 
       uniqueQuery = uniqueQuery.orWhere((qb) => {
         for (const column of index.columns) {
-          const field = column.replace(/_id$/, "");
+          const field = column.name.replace(/_id$/, "");
 
           if (Array.isArray(fixture.columns[field]?.value)) {
-            qb.whereIn(column, fixture.columns[field].value);
+            qb.whereIn(column.name, fixture.columns[field].value);
           } else {
-            qb.andWhere(column, fixture.columns[field]?.value);
+            qb.andWhere(column.name, fixture.columns[field]?.value);
           }
         }
       });

package/src/types/types.ts

@@ -15,12 +15,18 @@ export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K
 /*
   Model-Defintion
 */
+export type GeneratedColumnType = "STORED" | "VIRTUAL";
+export type GeneratedColumn = {
+  type: GeneratedColumnType;
+  expression: string;
+};
 export type CommonProp = {
   name: string;
   nullable?: boolean;
   toFilter?: true;
   desc?: string;
   dbDefault?: string;
+  generated?: GeneratedColumn;
 };
 export type IntegerProp = CommonProp & {
   type: "integer";
@@ -99,7 +105,14 @@ export type VirtualProp = CommonProp & {
   type: "virtual";
   id: string;
 }; // PG: none / TS: any(id) / JSON: any
-
+export type VectorProp = CommonProp & {
+  type: "vector";
+  dimensions: number;
+};
+export type VectorArrayProp = CommonProp & {
+  type: "vector[]";
+  dimensions: number;
+};
 export type RelationType = "HasMany" | "BelongsToOne" | "ManyToMany" | "OneToOne";
 export type RelationOn = "CASCADE" | "SET NULL" | "NO ACTION" | "SET DEFAULT" | "RESTRICT";
 type _RelationProp = {
@@ -170,13 +183,82 @@ export type EntityProp =
   | UuidArrayProp
   | JsonProp
   | VirtualProp
+  | VectorProp
+  | VectorArrayProp
   | RelationProp;
 
+/**
+ * pgvector 거리 연산자 클래스
+ *
+ * @description
+ * - `vector_cosine_ops`: 코사인 거리 (Cosine Distance) - 권장
+ *   - SQL 연산자: `<=>`
+ *   - 벡터의 방향만 비교 (크기 무시), 1 - cosine_similarity
+ *   - 텍스트 임베딩, 시맨틱 검색에 가장 일반적으로 사용
+ *   - 사용 예: OpenAI, Voyage 등 대부분의 임베딩 모델에 권장
+ *
+ * - `vector_ip_ops`: 내적 (Inner Product)
+ *   - SQL 연산자: `<#>`
+ *   - 두 벡터의 내적을 계산 (sum(a[i] * b[i]))
+ *   - 정규화된 벡터에서 코사인 유사도와 동일한 결과
+ *   - 값이 클수록 유사 (음수 연산자이므로 ORDER BY에서 주의)
+ *   - 사용 예: 이미 정규화된 임베딩에서 가장 빠른 성능
+ *
+ * - `vector_l2_ops`: 유클리드 거리 (L2 Distance)
+ *   - SQL 연산자: `<->`
+ *   - 두 벡터 간의 직선 거리를 계산 (sqrt(sum((a[i] - b[i])^2)))
+ *   - 벡터의 크기(magnitude)가 중요할 때 사용
+ *   - 사용 예: 이미지 유사도, 절대적 거리 측정이 필요한 경우
+ */
+export type VectorOps = "vector_cosine_ops" | "vector_ip_ops" | "vector_l2_ops";
+
+type EntityIndexColumn = {
+  name: string;
+  nullsFirst?: boolean;
+  sortOrder?: "ASC" | "DESC";
+  /** pgvector 인덱스에서 사용할 거리 연산자 (vector 컬럼에만 적용) */
+  vectorOps?: VectorOps;
+};
 export type EntityIndex = {
-  type: "index" | "unique" | "fulltext";
-  columns: string[];
+  type: "index" | "unique" | "fulltext" | "hnsw" | "ivfflat";
+  columns: EntityIndexColumn[];
   name: string;
   parser?: "built-in" | "ngram";
+  nullsNotDistinct?: boolean; // unique index only
+  /**
+   * HNSW (Hierarchical Navigable Small World) 인덱스: 각 노드의 최대 연결 수
+   *
+   * @description
+   * 그래프에서 각 노드가 가질 수 있는 최대 연결 수입니다.
+   * HNSW는 빠른 검색 속도와 높은 정확도를 제공하므로 권장됩니다.
+   * - 기본값: 16
+   * - 범위: 2 ~ 100
+   * - 높을수록: 정확도↑, 빌드 시간↑, 메모리↑
+   * - 권장: 빠른 빌드(8), 균형(16), 높은 정확도(32), 최고 정확도(64)
+   */
+  m?: number;
+  /**
+   * HNSW (Hierarchical Navigable Small World) 인덱스: 구성 시 탐색 범위
+   *
+   * @description
+   * 인덱스 구성 시 각 노드에서 탐색할 범위입니다.
+   * - 기본값: 64
+   * - 범위: 4 ~ 1000
+   * - 높을수록: 정확도↑, 빌드 시간↑
+   * - 권장: 빠른 빌드(32), 균형(64), 높은 정확도(128), 최고 정확도(256)
+   */
+  efConstruction?: number;
+  /**
+   * IVFFlat (Inverted File with Flat Compression) 인덱스: 클러스터링 리스트 수
+   *
+   * @description
+   * 벡터를 클러스터링할 버킷 수를 지정합니다.
+   * IVFFlat은 빠른 빌드와 낮은 메모리 사용이 필요할 때 사용합니다.
+   * - 권장값: sqrt(row_count) ~ row_count / 1000
+   * - 예시: 10,000행 → 100, 100,000행 → 300, 1,000,000행 → 1000
+   * - 많을수록 정확도↑, 검색 속도↓
+   */
+  lists?: number;
 };
 export type EntityJson = {
   id: string;
@@ -327,6 +409,15 @@ export function isJsonProp(p: unknown): p is JsonProp {
 export function isVirtualProp(p: unknown): p is VirtualProp {
   return (p as VirtualProp)?.type === "virtual";
 }
+export function isVectorSingleProp(p: unknown): p is VectorProp {
+  return (p as VectorProp)?.type === "vector";
+}
+export function isVectorArrayProp(p: unknown): p is VectorArrayProp {
+  return (p as VectorArrayProp)?.type === "vector[]";
+}
+export function isVectorProp(p: unknown): p is VectorProp | VectorArrayProp {
+  return isVectorSingleProp(p) || isVectorArrayProp(p);
+}
 export function isRelationProp(p: unknown): p is RelationProp {
   return (p as RelationProp)?.type === "relation";
 }
@@ -439,7 +530,10 @@ export type MigrationColumnType =
   | "date[]"
   | "uuid"
   | "uuid[]"
-  | "json";
+  | "json"
+  | "vector"
+  | "vector[]"
+  | "tsvector";
 export type MigrationColumn = {
   name: string;
   type: MigrationColumnType;
@@ -449,12 +543,21 @@ export type MigrationColumn = {
   defaultTo?: string;
   precision?: number;
   scale?: number;
+  dimensions?: number;
+  generated?: GeneratedColumn;
 };
 export type MigrationIndex = {
+  type: "unique" | "index" | "fulltext" | "hnsw" | "ivfflat";
+  columns: EntityIndexColumn[];
   name: string;
-  columns: string[];
-  type: "unique" | "index" | "fulltext";
   parser?: "built-in" | "ngram";
+  nullsNotDistinct?: boolean;
+  /** HNSW (Hierarchical Navigable Small World): 각 노드의 최대 연결 수 */
+  m?: number;
+  /** HNSW (Hierarchical Navigable Small World): 구성 시 탐색 범위 */
+  efConstruction?: number;
+  /** IVFFlat (Inverted File with Flat Compression): 클러스터링 리스트 수 */
+  lists?: number;
 };
 export type MigrationForeign = {
   columns: string[];
@@ -698,7 +801,8 @@ export type RenderingNode = {
     | "array-images"
     | "object"
     | "object-pick"
-    | "record";
+    | "record"
+    | "vector";
   zodType: z.ZodTypeAny;
   element?: RenderingNode;
   children?: RenderingNode[];
@@ -709,12 +813,18 @@ export type RenderingNode = {
   nullable?: boolean;
 };
 
+const GeneratedColumnSchema = z.object({
+  type: z.enum(["STORED", "VIRTUAL"]),
+  expression: z.string(),
+});
+
 const BasePropFields = {
   name: z.string(),
   desc: z.string().optional(),
   nullable: z.boolean().optional(),
-  toFilter: z.literal(true).optional(),
+  toFilter: z.boolean().default(false).optional(),
   dbDefault: z.union([z.string(), z.number(), z.boolean()]).optional(),
+  generated: GeneratedColumnSchema.optional(),
 };
 
 // 부가 필드가 필요없는 prop
@@ -764,6 +874,7 @@ const EnumPropSchema = z
     ...BasePropFields,
     type: z.literal("enum"),
     id: z.string(),
+    length: z.number().optional(),
   })
   .strict();
 const EnumArrayPropSchema = z
@@ -822,6 +933,21 @@ const VirtualPropSchema = z
   })
   .strict();
 
+const VectorPropSchema = z
+  .object({
+    ...BasePropFields,
+    type: z.literal("vector"),
+    dimensions: z.number(),
+  })
+  .strict();
+const VectorArrayPropSchema = z
+  .object({
+    ...BasePropFields,
+    type: z.literal("vector[]"),
+    dimensions: z.number(),
+  })
+  .strict();
+
 // Relation 타입은 relationType에 따라 세분화
 const BaseRelationFields = {
   ...BasePropFields,
@@ -910,27 +1036,84 @@ const NormalPropTypes = [
   "uuid[]",
   "json",
   "virtual",
+  "vector",
+  "vector[]",
+] as const;
+
+// VIRTUAL Generated Column에서 사용 불가능한 타입들
+const VirtualGeneratedDisallowedTypes = [
+  "json",
+  "vector",
+  "vector[]",
+  "string[]",
+  "integer[]",
+  "bigInteger[]",
+  "boolean[]",
+  "date[]",
+  "uuid[]",
+  "number[]",
+  "numeric[]",
+  "enum[]",
 ] as const;
-export const NormalPropSchema = z.discriminatedUnion(
-  "type",
-  [
-    BasePropFieldsWithoutAdditional,
-    StringPropSchema,
-    StringArrayPropSchema,
-    EnumPropSchema,
-    EnumArrayPropSchema,
-    NumberPropSchema,
-    NumberArrayPropSchema,
-    NumericPropSchema,
-    NumericArrayPropSchema,
-    JsonPropSchema,
-    VirtualPropSchema,
-  ],
-  {
-    error: (iss) =>
-      `type은 ${NormalPropTypes.map((t) => `'${t}'`).join(", ")} 중 하나여야 합니다. 입력값: "${(iss.input as Record<string, unknown>)?.type}"`,
-  },
-);
+
+export const NormalPropSchema = z
+  .discriminatedUnion(
+    "type",
+    [
+      BasePropFieldsWithoutAdditional,
+      StringPropSchema,
+      StringArrayPropSchema,
+      EnumPropSchema,
+      EnumArrayPropSchema,
+      NumberPropSchema,
+      NumberArrayPropSchema,
+      NumericPropSchema,
+      NumericArrayPropSchema,
+      JsonPropSchema,
+      VirtualPropSchema,
+      VectorPropSchema,
+      VectorArrayPropSchema,
+    ],
+    {
+      error: (iss) =>
+        `type은 ${NormalPropTypes.map((t) => `'${t}'`).join(", ")} 중 하나여야 합니다. 입력값: "${(iss.input as Record<string, unknown>)?.type}"`,
+    },
+  )
+  .superRefine((data, ctx) => {
+    if (!data.generated) {
+      return;
+    }
+
+    // dbDefault와 generated 동시 사용 불가
+    if (data.dbDefault !== undefined) {
+      ctx.addIssue({
+        code: "custom",
+        message: "dbDefault와 generated는 함께 사용할 수 없습니다",
+        path: ["generated"],
+      });
+    }
+
+    // virtual 타입은 generated 불가
+    if (data.type === "virtual") {
+      ctx.addIssue({
+        code: "custom",
+        message: "virtual 타입은 generated column을 지원하지 않습니다",
+        path: ["generated"],
+      });
+    }
+
+    // VIRTUAL Generated Column 타입 제한 검증
+    if (data.generated.type === "VIRTUAL") {
+      if ((VirtualGeneratedDisallowedTypes as readonly string[]).includes(data.type)) {
+        ctx.addIssue({
+          code: "custom",
+          message: `VIRTUAL generated column은 ${data.type} 타입을 지원하지 않습니다. STORED를 사용하세요.`,
+          path: ["generated", "type"],
+          fatal: true,
+        });
+      }
+    }
+  });
 
 const AllPropTypes = [...NormalPropTypes, "relation"] as const;
 const EntityPropSchema = z.discriminatedUnion("type", [NormalPropSchema, RelationPropSchema], {
@@ -938,13 +1121,24 @@ const EntityPropSchema = z.discriminatedUnion("type", [NormalPropSchema, Relatio
     `type은 ${AllPropTypes.map((t) => `'${t}'`).join(", ")} 중 하나여야 합니다. 입력값: "${(iss.input as Record<string, unknown>)?.type}"`,
 });
 
+const EntityIndexColumnSchema = z.object({
+  name: z.string(),
+  nullsFirst: z.boolean().optional(),
+  sortOrder: z.enum(["ASC", "DESC"]).optional(),
+  vectorOps: z.enum(["vector_cosine_ops", "vector_ip_ops", "vector_l2_ops"]).optional(),
+});
+
 // EntityIndex 스키마 정의
 const EntityIndexSchema = z
   .object({
-    type: z.enum(["index", "unique", "fulltext"]),
-    columns: z.array(z.string()),
+    type: z.enum(["index", "unique", "fulltext", "hnsw", "ivfflat"]),
+    columns: z.array(EntityIndexColumnSchema),
     name: z.string().min(1).max(63),
     parser: z.enum(["built-in", "ngram"]).optional(),
+    nullsNotDistinct: z.boolean().optional(),
+    m: z.number().optional(),
+    efConstruction: z.number().optional(),
+    lists: z.number().optional(),
   })
   .strict();
 
@@ -1121,6 +1315,8 @@ export type RelationNode = {
 
 // biome-ignore lint/suspicious/noEmptyInterface: sonamu.generated.sso 에서 확장을 위해 준비된 빈 인터페이스
 export interface DatabaseSchemaExtend {}
+// biome-ignore lint/suspicious/noEmptyInterface: sonamu.generated.sso 에서 확장을 위해 준비된 빈 인터페이스
+export interface DatabaseForeignKeys {}
 export type ManyToManyBaseSchema<FromIdKey extends string, ToIdKey extends string> = {
   id: number;
 } & {
@@ -1149,22 +1345,4 @@ export type SonamuFastifyConfig = {
       options: ApiDecoratorOptions;
     },
   ) => void;
-  cache?: {
-    get: (key: string) => Promise<unknown | null>;
-    put: (key: string, value: unknown, ttl?: number) => Promise<void>;
-    resolveKey: (
-      path: string,
-      reqBody: {
-        [key: string]: unknown;
-      },
-    ) =>
-      | {
-          cache: false;
-        }
-      | {
-          cache: true;
-          key: string;
-          ttl?: number;
-        };
-  };
 };