sonamu 0.7.4 → 0.7.5

package/dist/vector/vector-search.js

@@ -0,0 +1,176 @@
+import pgvector from "pgvector/knex";
+import { DEFAULT_VECTOR_CONFIG } from "./config.js";
+import { Embedding } from "./embedding.js";
+/**
+ * 벡터 검색
+ * pgvector를 활용한 벡터 검색 및 하이브리드 검색 지원
+ */ export class VectorSearch {
+    db;
+    config;
+    embedding;
+    tableName;
+    constructor(db, tableName, config = {}){
+        this.db = db;
+        this.tableName = tableName;
+        this.config = {
+            voyage: {
+                ...DEFAULT_VECTOR_CONFIG.voyage,
+                ...config.voyage
+            },
+            openai: {
+                ...DEFAULT_VECTOR_CONFIG.openai,
+                ...config.openai
+            },
+            chunking: {
+                ...DEFAULT_VECTOR_CONFIG.chunking,
+                ...config.chunking
+            },
+            search: {
+                ...DEFAULT_VECTOR_CONFIG.search,
+                ...config.search
+            },
+            pgvector: {
+                ...DEFAULT_VECTOR_CONFIG.pgvector,
+                ...config.pgvector
+            }
+        };
+        this.embedding = new Embedding(config);
+    }
+    /**
+   * 단일 항목에 임베딩 저장
+   */ async saveEmbedding(id, text, provider, embeddingColumn = "content_embedding") {
+        const { embedding } = await this.embedding.embedOne(text, provider, "document");
+        await this.db(this.tableName).where("id", id).update({
+            [embeddingColumn]: pgvector.toSql(embedding)
+        });
+    }
+    /**
+   * 여러 항목에 임베딩 일괄 저장
+   */ async saveEmbeddingsBatch(items, provider, embeddingColumn = "content_embedding", onProgress) {
+        const texts = items.map((item)=>item.text);
+        const embeddings = await this.embedding.embedBatch(texts, provider, "document", onProgress);
+        await this.db.transaction(async (trx)=>{
+            for(let i = 0; i < items.length; i++){
+                await trx(this.tableName).where("id", items[i].id).update({
+                    [embeddingColumn]: pgvector.toSql(embeddings[i].embedding)
+                });
+            }
+        });
+    }
+    /**
+   * 벡터 검색 (코사인 유사도)
+   */ async search(query, provider, options = {}) {
+        const { embeddingColumn = "content_embedding", limit = this.config.search.defaultLimit, threshold = this.config.search.similarityThreshold, where } = options;
+        // 쿼리 임베딩 (input_type: 'query' 중요!)
+        const { embedding } = await this.embedding.embedOne(query, provider, "query");
+        // pgvector 세션 설정
+        if (this.config.pgvector.iterativeScan) {
+            await this.db.raw("SET hnsw.iterative_scan = relaxed_order");
+        }
+        await this.db.raw(`SET hnsw.ef_search = ${this.config.pgvector.efSearch}`);
+        // 코사인 유사도 = 1 - 코사인 거리
+        const vectorStr = pgvector.toSql(embedding);
+        let queryBuilder = this.db(this.tableName).select("*").select(this.db.raw(`1 - (${embeddingColumn} <=> ?::vector) AS similarity`, [
+            vectorStr
+        ])).whereNotNull(embeddingColumn).orderByRaw(`${embeddingColumn} <=> ?::vector`, [
+            vectorStr
+        ]).limit(limit);
+        if (where) {
+            queryBuilder = queryBuilder.whereRaw(where);
+        }
+        const rows = await queryBuilder;
+        return rows.filter((row)=>row.similarity >= threshold).map((row)=>({
+                id: row.id,
+                similarity: parseFloat(String(row.similarity)),
+                data: row
+            }));
+    }
+    /**
+   * 하이브리드 검색 (Vector + FTS)
+   */ async hybridSearch(query, provider, options = {}) {
+        const { embeddingColumn = "content_embedding", ftsColumn = "content_tsv", limit = this.config.search.defaultLimit, vectorWeight = this.config.search.vectorWeight, ftsWeight = this.config.search.ftsWeight } = options;
+        const { embedding } = await this.embedding.embedOne(query, provider, "query");
+        const vectorStr = pgvector.toSql(embedding);
+        // pgvector 세션 설정
+        if (this.config.pgvector.iterativeScan) {
+            await this.db.raw("SET hnsw.iterative_scan = relaxed_order");
+        }
+        await this.db.raw(`SET hnsw.ef_search = ${this.config.pgvector.efSearch}`);
+        const sql = `
+      WITH vector_search AS (
+        SELECT
+          id,
+          ROW_NUMBER() OVER (ORDER BY ${embeddingColumn} <=> ?::vector) AS rank
+        FROM ${this.tableName}
+        WHERE ${embeddingColumn} IS NOT NULL
+        ORDER BY ${embeddingColumn} <=> ?::vector
+        LIMIT 50
+      ),
+      fts_search AS (
+        SELECT
+          id,
+          ROW_NUMBER() OVER (ORDER BY ts_rank(${ftsColumn}, query) DESC) AS rank
+        FROM ${this.tableName}, plainto_tsquery('simple', ?) query
+        WHERE ${ftsColumn} @@ query
+        LIMIT 50
+      ),
+      combined AS (
+        SELECT
+          COALESCE(v.id, f.id) AS id,
+          COALESCE(1.0 / (60 + v.rank), 0) AS vector_score,
+          COALESCE(1.0 / (60 + f.rank), 0) AS fts_score
+        FROM vector_search v
+        FULL OUTER JOIN fts_search f ON v.id = f.id
+      )
+      SELECT
+        t.*,
+        c.vector_score,
+        c.fts_score,
+        (c.vector_score * ? + c.fts_score * ?) AS similarity
+      FROM combined c
+      JOIN ${this.tableName} t ON c.id = t.id
+      ORDER BY similarity DESC
+      LIMIT ?
+    `;
+        const { rows } = await this.db.raw(sql, [
+            vectorStr,
+            vectorStr,
+            query,
+            vectorWeight,
+            ftsWeight,
+            limit
+        ]);
+        return rows.map((row)=>({
+                id: row.id,
+                similarity: parseFloat(String(row.similarity)),
+                vectorScore: parseFloat(String(row.vector_score)),
+                ftsScore: parseFloat(String(row.fts_score)),
+                data: row
+            }));
+    }
+    /**
+   * 임베딩 현황 조회
+   */ async getEmbeddingStatus(embeddingColumn = "content_embedding") {
+        const result = await this.db(this.tableName).count("* as total").count(`${embeddingColumn} as with_embedding`).first();
+        const total = parseInt(String(result?.total ?? 0), 10);
+        const withEmbedding = parseInt(String(result?.with_embedding ?? 0), 10);
+        return {
+            total,
+            withEmbedding,
+            withoutEmbedding: total - withEmbedding
+        };
+    }
+    /**
+   * 임베딩이 없는 항목 ID 조회
+   */ async getItemsWithoutEmbedding(embeddingColumn = "content_embedding", limit = 100) {
+        const rows = await this.db(this.tableName).select("id").whereNull(embeddingColumn).orderBy("id").limit(limit);
+        return rows.map((row)=>row.id);
+    }
+    /**
+   * Embedding 인스턴스 반환 (고급 사용)
+   */ getEmbedding() {
+        return this.embedding;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/vector/vector-search.ts"],"sourcesContent":["import type { Knex } from \"knex\";\nimport pgvector from \"pgvector/knex\";\nimport { DEFAULT_VECTOR_CONFIG } from \"./config\";\nimport { Embedding } from \"./embedding\";\nimport type {\n  EmbeddingItem,\n  EmbeddingProvider,\n  HybridSearchOptions,\n  HybridSearchResult,\n  ProgressCallback,\n  VectorConfig,\n  VectorSearchOptions,\n  VectorSearchResult,\n} from \"./types\";\n\n/**\n * 벡터 검색\n * pgvector를 활용한 벡터 검색 및 하이브리드 검색 지원\n */\nexport class VectorSearch<T = Record<string, unknown>> {\n  private db: Knex;\n  private config: VectorConfig;\n  private embedding: Embedding;\n  private tableName: string;\n\n  constructor(db: Knex, tableName: string, config: Partial<VectorConfig> = {}) {\n    this.db = db;\n    this.tableName = tableName;\n    this.config = {\n      voyage: { ...DEFAULT_VECTOR_CONFIG.voyage, ...config.voyage },\n      openai: { ...DEFAULT_VECTOR_CONFIG.openai, ...config.openai },\n      chunking: { ...DEFAULT_VECTOR_CONFIG.chunking, ...config.chunking },\n      search: { ...DEFAULT_VECTOR_CONFIG.search, ...config.search },\n      pgvector: { ...DEFAULT_VECTOR_CONFIG.pgvector, ...config.pgvector },\n    };\n    this.embedding = new Embedding(config);\n  }\n\n  /**\n   * 단일 항목에 임베딩 저장\n   */\n  async saveEmbedding(\n    id: number,\n    text: string,\n    provider: EmbeddingProvider,\n    embeddingColumn: string = \"content_embedding\",\n  ): Promise<void> {\n    const { embedding } = await this.embedding.embedOne(text, provider, \"document\");\n\n    await this.db(this.tableName)\n      .where(\"id\", id)\n      .update({\n        [embeddingColumn]: pgvector.toSql(embedding),\n      });\n  }\n\n  /**\n   * 여러 항목에 임베딩 일괄 저장\n   */\n  async saveEmbeddingsBatch(\n    items: EmbeddingItem[],\n    provider: EmbeddingProvider,\n    embeddingColumn: string = \"content_embedding\",\n    onProgress?: ProgressCallback,\n  ): Promise<void> {\n    const texts = items.map((item) => item.text);\n    const embeddings = await this.embedding.embedBatch(texts, provider, \"document\", onProgress);\n\n    await this.db.transaction(async (trx) => {\n      for (let i = 0; i < items.length; i++) {\n        await trx(this.tableName)\n          .where(\"id\", items[i].id)\n          .update({\n            [embeddingColumn]: pgvector.toSql(embeddings[i].embedding),\n          });\n      }\n    });\n  }\n\n  /**\n   * 벡터 검색 (코사인 유사도)\n   */\n  async search(\n    query: string,\n    provider: EmbeddingProvider,\n    options: VectorSearchOptions = {},\n  ): Promise<VectorSearchResult<T>[]> {\n    const {\n      embeddingColumn = \"content_embedding\",\n      limit = this.config.search.defaultLimit,\n      threshold = this.config.search.similarityThreshold,\n      where,\n    } = options;\n\n    // 쿼리 임베딩 (input_type: 'query' 중요!)\n    const { embedding } = await this.embedding.embedOne(query, provider, \"query\");\n\n    // pgvector 세션 설정\n    if (this.config.pgvector.iterativeScan) {\n      await this.db.raw(\"SET hnsw.iterative_scan = relaxed_order\");\n    }\n    await this.db.raw(`SET hnsw.ef_search = ${this.config.pgvector.efSearch}`);\n\n    // 코사인 유사도 = 1 - 코사인 거리\n    const vectorStr = pgvector.toSql(embedding);\n    let queryBuilder = this.db(this.tableName)\n      .select(\"*\")\n      .select(this.db.raw(`1 - (${embeddingColumn} <=> ?::vector) AS similarity`, [vectorStr]))\n      .whereNotNull(embeddingColumn)\n      .orderByRaw(`${embeddingColumn} <=> ?::vector`, [vectorStr])\n      .limit(limit);\n\n    if (where) {\n      queryBuilder = queryBuilder.whereRaw(where);\n    }\n\n    const rows = await queryBuilder;\n\n    return rows\n      .filter((row: { similarity: number }) => row.similarity >= threshold)\n      .map((row: T & { similarity: number }) => ({\n        id: (row as unknown as { id: number }).id,\n        similarity: parseFloat(String(row.similarity)),\n        data: row as T,\n      }));\n  }\n\n  /**\n   * 하이브리드 검색 (Vector + FTS)\n   */\n  async hybridSearch(\n    query: string,\n    provider: EmbeddingProvider,\n    options: HybridSearchOptions = {},\n  ): Promise<HybridSearchResult<T>[]> {\n    const {\n      embeddingColumn = \"content_embedding\",\n      ftsColumn = \"content_tsv\",\n      limit = this.config.search.defaultLimit,\n      vectorWeight = this.config.search.vectorWeight,\n      ftsWeight = this.config.search.ftsWeight,\n    } = options;\n\n    const { embedding } = await this.embedding.embedOne(query, provider, \"query\");\n    const vectorStr = pgvector.toSql(embedding);\n\n    // pgvector 세션 설정\n    if (this.config.pgvector.iterativeScan) {\n      await this.db.raw(\"SET hnsw.iterative_scan = relaxed_order\");\n    }\n    await this.db.raw(`SET hnsw.ef_search = ${this.config.pgvector.efSearch}`);\n\n    const sql = `\n      WITH vector_search AS (\n        SELECT\n          id,\n          ROW_NUMBER() OVER (ORDER BY ${embeddingColumn} <=> ?::vector) AS rank\n        FROM ${this.tableName}\n        WHERE ${embeddingColumn} IS NOT NULL\n        ORDER BY ${embeddingColumn} <=> ?::vector\n        LIMIT 50\n      ),\n      fts_search AS (\n        SELECT\n          id,\n          ROW_NUMBER() OVER (ORDER BY ts_rank(${ftsColumn}, query) DESC) AS rank\n        FROM ${this.tableName}, plainto_tsquery('simple', ?) query\n        WHERE ${ftsColumn} @@ query\n        LIMIT 50\n      ),\n      combined AS (\n        SELECT\n          COALESCE(v.id, f.id) AS id,\n          COALESCE(1.0 / (60 + v.rank), 0) AS vector_score,\n          COALESCE(1.0 / (60 + f.rank), 0) AS fts_score\n        FROM vector_search v\n        FULL OUTER JOIN fts_search f ON v.id = f.id\n      )\n      SELECT\n        t.*,\n        c.vector_score,\n        c.fts_score,\n        (c.vector_score * ? + c.fts_score * ?) AS similarity\n      FROM combined c\n      JOIN ${this.tableName} t ON c.id = t.id\n      ORDER BY similarity DESC\n      LIMIT ?\n    `;\n\n    const { rows } = await this.db.raw(sql, [\n      vectorStr,\n      vectorStr,\n      query,\n      vectorWeight,\n      ftsWeight,\n      limit,\n    ]);\n\n    return rows.map(\n      (\n        row: T & {\n          similarity: number;\n          vector_score: number;\n          fts_score: number;\n        },\n      ) => ({\n        id: (row as unknown as { id: number }).id,\n        similarity: parseFloat(String(row.similarity)),\n        vectorScore: parseFloat(String(row.vector_score)),\n        ftsScore: parseFloat(String(row.fts_score)),\n        data: row as T,\n      }),\n    );\n  }\n\n  /**\n   * 임베딩 현황 조회\n   */\n  async getEmbeddingStatus(embeddingColumn: string = \"content_embedding\"): Promise<{\n    total: number;\n    withEmbedding: number;\n    withoutEmbedding: number;\n  }> {\n    const result = await this.db(this.tableName)\n      .count(\"* as total\")\n      .count(`${embeddingColumn} as with_embedding`)\n      .first();\n\n    const total = parseInt(String(result?.total ?? 0), 10);\n    const withEmbedding = parseInt(String(result?.with_embedding ?? 0), 10);\n\n    return {\n      total,\n      withEmbedding,\n      withoutEmbedding: total - withEmbedding,\n    };\n  }\n\n  /**\n   * 임베딩이 없는 항목 ID 조회\n   */\n  async getItemsWithoutEmbedding(\n    embeddingColumn: string = \"content_embedding\",\n    limit: number = 100,\n  ): Promise<number[]> {\n    const rows = await this.db(this.tableName)\n      .select(\"id\")\n      .whereNull(embeddingColumn)\n      .orderBy(\"id\")\n      .limit(limit);\n\n    return rows.map((row: { id: number }) => row.id);\n  }\n\n  /**\n   * Embedding 인스턴스 반환 (고급 사용)\n   */\n  getEmbedding(): Embedding {\n    return this.embedding;\n  }\n}\n"],"names":["pgvector","DEFAULT_VECTOR_CONFIG","Embedding","VectorSearch","db","config","embedding","tableName","voyage","openai","chunking","search","saveEmbedding","id","text","provider","embeddingColumn","embedOne","where","update","toSql","saveEmbeddingsBatch","items","onProgress","texts","map","item","embeddings","embedBatch","transaction","trx","i","length","query","options","limit","defaultLimit","threshold","similarityThreshold","iterativeScan","raw","efSearch","vectorStr","queryBuilder","select","whereNotNull","orderByRaw","whereRaw","rows","filter","row","similarity","parseFloat","String","data","hybridSearch","ftsColumn","vectorWeight","ftsWeight","sql","vectorScore","vector_score","ftsScore","fts_score","getEmbeddingStatus","result","count","first","total","parseInt","withEmbedding","with_embedding","withoutEmbedding","getItemsWithoutEmbedding","whereNull","orderBy","getEmbedding"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonamu",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "Sonamu — TypeScript Fullstack API Framework",
   "keywords": [
     "typescript",
@@ -70,15 +70,16 @@
     "minimatch": "^10.0.3",
     "node-sql-parser": "^5.2.0",
     "pg": "^8.16.3",
+    "pgvector": "^0.2.1",
     "prompts": "^2.4.2",
     "qs": "^6.11.0",
     "radashi": "^12.2.0",
     "tsicli": "^1.0.5",
     "vitest": "^4.0.10",
     "zod": "^4.1.12",
+    "@sonamu-kit/hmr-runner": "^0.1.1",
     "@sonamu-kit/ts-loader": "^2.1.3",
-    "@sonamu-kit/hmr-hook": "^0.4.1",
-    "@sonamu-kit/hmr-runner": "^0.1.1"
+    "@sonamu-kit/hmr-hook": "^0.4.1"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.7",
@@ -94,15 +95,15 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
+    "@ai-sdk/openai": "^3.0.0-beta.75",
+    "@ai-sdk/provider": "^3.0.0-beta.22",
+    "@ai-sdk/provider-utils": "^4.0.0-beta.40",
     "@swc/cli": "^0.7.8",
     "@swc/core": "^1.13.5",
+    "ai": "^6.0.0-beta.138",
     "fastify": "^4.23.2",
     "knex": "^3.1.0",
-    "typescript": "^5.9.3",
-    "@ai-sdk/openai": "^3.0.0-beta.75",
-    "@ai-sdk/provider": "^3.0.0-beta.22",
-    "@ai-sdk/provider-utils": "^4.0.0-beta.40",
-    "ai": "^6.0.0-beta.138"
+    "typescript": "^5.9.3"
   },
   "peerDependenciesMeta": {
     "@ai-sdk/openai": {

package/src/api/config.ts

@@ -97,10 +97,6 @@ export type SonamuConfigExport =
   | (() => SonamuConfig)
   | (() => Promise<SonamuConfig>);
 
-export function defineConfig(config: SonamuConfig): Promise<SonamuConfig>;
-export function defineConfig(config: Promise<SonamuConfig>): Promise<SonamuConfig>;
-export function defineConfig(config: () => SonamuConfig): Promise<SonamuConfig>;
-export function defineConfig(config: () => Promise<SonamuConfig>): Promise<SonamuConfig>;
 export function defineConfig(config: SonamuConfigExport): Promise<SonamuConfig> {
   if (typeof config === "function") {
     return Promise.resolve(config());

package/src/api/sonamu.ts

@@ -17,6 +17,8 @@ import type { ExtendedApi } from "./decorators";
 
 export type SonamuSecrets = {
   anthropic_api_key?: string;
+  voyage_api_key?: string;
+  openai_api_key?: string;
 };
 class SonamuClass {
   public isInitialized: boolean = false;
@@ -155,10 +157,19 @@ class SonamuClass {
     // sonamu.config.ts 기본값 설정
     this.config.database.database = this.config.database.database ?? "postgresql";
 
+    // API 키 환경변수 로드
+    const secrets: SonamuSecrets = {};
     if (process.env.ANTHROPIC_API_KEY) {
-      this.secrets = {
-        anthropic_api_key: process.env.ANTHROPIC_API_KEY,
-      };
+      secrets.anthropic_api_key = process.env.ANTHROPIC_API_KEY;
+    }
+    if (process.env.VOYAGE_API_KEY) {
+      secrets.voyage_api_key = process.env.VOYAGE_API_KEY;
+    }
+    if (process.env.OPENAI_API_KEY) {
+      secrets.openai_api_key = process.env.OPENAI_API_KEY;
+    }
+    if (Object.keys(secrets).length > 0) {
+      this.secrets = secrets;
     }
 
     // DB 로드
@@ -169,16 +180,18 @@ class SonamuClass {
       console.log(chalk.green("DB Config Loaded!"));
     }
 
-    // 테스팅인 경우 엔티티 로드 & 싱크 없이 중단
+    // Entity 로드
+    // 테스트에서도 Entity 정보는 필요합니다.
+    // upsert가 제대로 작동하려면 entity의 unique index 정보가 필요하기 때문입니다.
+    const { EntityManager } = await import("../entity/entity-manager");
+    await EntityManager.autoload(doSilent);
+
+    // 테스팅인 경우 싱크 없이 중단
     if (forTesting) {
       this.isInitialized = true;
       return;
     }
 
-    // Entity 로드
-    const { EntityManager } = await import("../entity/entity-manager");
-    await EntityManager.autoload(doSilent);
-
     // Syncer
     const { Syncer } = await import("../syncer/syncer");
     this.syncer = new Syncer();
@@ -387,30 +400,6 @@ class SonamuClass {
       // Content-Type
       reply.type(api.options.contentType ?? "application/json");
 
-      // 캐시
-      const { cacheKey, cacheTtl, cachedData } = await (async () => {
-        if (config.cache) {
-          try {
-            const cacheKeyRes = config.cache.resolveKey(api.path, reqBody);
-            if (cacheKeyRes.cache === false) {
-              return { cacheKey: null, cachedData: null };
-            }
-
-            const cacheKey = cacheKeyRes.key;
-            const cacheTtl = cacheKeyRes.ttl;
-            const cachedData = await config.cache.get(cacheKey);
-            return { cacheKey, cacheTtl, cachedData };
-          } catch (e) {
-            console.error(e);
-          }
-          return { cacheKey: null, cachedData: null };
-        }
-        return { cacheKey: null, cachedData: null };
-      })();
-      if (cachedData !== null) {
-        return cachedData;
-      }
-
       // createSSEFactory 함수에 미리 request의 socket과 reply를 바인딩.
       const { createSSEFactory } = await import("../stream/sse");
       const createSSE = (<T extends ZodObject>(
@@ -458,10 +447,6 @@ class SonamuClass {
         );
         reply.type(api.options.contentType ?? "application/json");
 
-        // 캐시 키 있는 경우 갱신 후 저장
-        if (config.cache && cacheKey) {
-          await config.cache.put(cacheKey, result, cacheTtl);
-        }
         return result;
       });
     };

package/src/bin/cli.ts

@@ -22,7 +22,7 @@ import { BUILD_DIR, SWC_BUILD_COMMAND, TSC_TYPE_CHECK_COMMAND } from "./build-co
 let migrator: Migrator;
 
 async function bootstrap() {
-  const notToInit = ["dev", "build", "start"].includes(process.argv[2] ?? "");
+  const notToInit = ["dev", "build", "start", "ui"].includes(process.argv[2] ?? "");
   if (!notToInit) {
     await Sonamu.init(false, false);
   }
@@ -451,9 +451,11 @@ async function scaffold_model_test(entityId: string) {
 
 async function ui() {
   try {
+    const apiRootPath = findApiRootPath();
+
     // 사용자 프로젝트의 패키지들 중에서 @sonamu-kit/ui를 찾습니다.
     // 이를 위해서 createRequire를 사용하여 프로젝트 경로 기준으로 resolve합니다.
-    const projectRequire = createRequire(path.join(Sonamu.apiRootPath, "package.json"));
+    const projectRequire = createRequire(path.join(apiRootPath, "package.json"));
     const uiPackagePath = projectRequire.resolve("@sonamu-kit/ui"); // 없으면 여기서 터져요(MODULE_NOT_FOUND)
     const uiNodePath = path.join(path.dirname(uiPackagePath), "run-ui.js");
 
@@ -481,9 +483,7 @@ async function ui() {
         env: {
           ...process.env,
           HOT: "yes",
-          PROJECT_NAME: Sonamu.config.projectName ?? path.basename(Sonamu.apiRootPath),
-          API_ROOT_PATH: Sonamu.apiRootPath,
-          UI_PORT: (Sonamu.config.ui?.port ?? 57000).toString(),
+          API_ROOT_PATH: apiRootPath, // UI는 얘만 알면 돼요! 나머지는 얘가 떠서 알아서 할 것임 ㅎ
         },
       },
     );

package/src/database/base-model.ts

@@ -306,23 +306,32 @@ export class BaseModelClass<
    * Flat 레코드를 중첩 객체로 변환
    *
    * - `user__name` → `{ user: { name } }`
-   * - nullable relation의 경우 모든 필드가 null이면 객체 자체를 null로
+   * - nullable relation의 경우 id 필드가 null이면 객체 자체를 null로
    */
   hydrate<T extends UnknownDBRecord>(rows: T[]): T[] {
     return rows.map((row: T) => {
-      // nullable relation 처리: 관련 필드가 전부 null인 경우 방지
+      // nullable relation 처리: 그룹의 id 필드가 null이면 객체 전체를 null로
       const nestedKeys = Object.keys(row).filter((key) => key.includes("__"));
       const groups = Object.groupBy(nestedKeys, (key) => key.split("__")[0]);
+
+      // id 필드가 null인 그룹 찾기 (예: parent__id가 null이면 parent 그룹 전체가 null)
       const nullKeys = Object.entries(groups)
-        .filter(
-          ([_, data]) =>
-            data &&
-            data.length > 1 &&
-            data.every(
-              (field) =>
-                row[field] === null || (Array.isArray(row[field]) && row[field].length === 0),
-            ),
-        )
+        .filter(([groupKey, fields]) => {
+          if (!fields || fields.length === 0) return false;
+
+          // 그룹의 id 필드 찾기 (예: "parent__id")
+          const idField = `${groupKey}__id`;
+          if (idField in row) {
+            // id 필드가 null이면 객체 전체가 null
+            return row[idField] === null;
+          }
+
+          // id 필드가 없으면 기존 로직: 모든 필드가 null인지 확인
+          return fields.every(
+            (field) =>
+              row[field] === null || (Array.isArray(row[field]) && row[field].length === 0),
+          );
+        })
         .map(([key]) => key);
 
       const hydrated = Object.keys(row).reduce((r, field) => {

package/src/database/code-generator.ts

@@ -38,8 +38,12 @@ export class CodeGenerator {
       drop: [] as MigrationIndex[],
     };
     const extraIndexes = {
-      db: diff(dbIndexes, entityIndexes, (col) => [col.type, col.columns.join("-")].join("//")),
-      entity: diff(entityIndexes, dbIndexes, (col) => [col.type, col.columns.join("-")].join("//")),
+      db: diff(dbIndexes, entityIndexes, (col) =>
+        [col.type, col.columns.map((c) => c.name).join("-")].join("//"),
+      ),
+      entity: diff(entityIndexes, dbIndexes, (col) =>
+        [col.type, col.columns.map((c) => c.name).join("-")].join("//"),
+      ),
     };
     if (extraIndexes.entity.length > 0) {
       indexesTo.add = indexesTo.add.concat(extraIndexes.entity);

package/src/database/db.ts

@@ -1,6 +1,7 @@
 import { AsyncLocalStorage } from "async_hooks";
 import knex, { type Knex } from "knex";
 import { assign } from "radashi";
+
 import { Sonamu } from "../api";
 import type { DatabaseConfig, SonamuConfig } from "../api/config";
 import { TransactionContext } from "./transaction-context";

package/src/database/puri-wrapper.ts

@@ -5,8 +5,8 @@ import type { Knex } from "knex";
 import type { DatabaseSchemaExtend } from "../types/types";
 import type { DBPreset } from "./db";
 import { Puri } from "./puri";
-import type { ColumnKeys, OmitMetadataColumns, PuriTable } from "./puri.types";
-import type { UBRef, UpsertBuilder } from "./upsert-builder";
+import type { ColumnKeys, OmitInternalTypeKeys, PuriTable } from "./puri.types";
+import type { InsertOnlyOptions, UBRef, UpsertBuilder, UpsertOptions } from "./upsert-builder";
 
 type TableName<TSchema extends DatabaseSchemaExtend> = Extract<keyof TSchema, string>;
 
@@ -32,7 +32,7 @@ export class PuriWrapper<TSchema extends DatabaseSchemaExtend = DatabaseSchemaEx
   ): Puri<
     TSchema,
     Record<TTable, PuriTable<TSchema[TTable]>>,
-    OmitMetadataColumns<PuriTable<TSchema[TTable]>>
+    OmitInternalTypeKeys<PuriTable<TSchema[TTable]>>
   >;
   // 테이블명 + Alias로 시작
   from<TTable extends keyof TSchema, TAlias extends string>(
@@ -42,7 +42,7 @@ export class PuriWrapper<TSchema extends DatabaseSchemaExtend = DatabaseSchemaEx
   ): Puri<
     TSchema,
     Record<TAlias, PuriTable<TSchema[TTable]>>,
-    OmitMetadataColumns<PuriTable<TSchema[TTable]>>
+    OmitInternalTypeKeys<PuriTable<TSchema[TTable]>>
   >;
   // 서브쿼리로 시작
   from<TAlias extends string, TSubResult>(
@@ -52,7 +52,7 @@ export class PuriWrapper<TSchema extends DatabaseSchemaExtend = DatabaseSchemaEx
   ): Puri<
     TSchema,
     Record<TAlias, PuriTable<TSubResult>>,
-    OmitMetadataColumns<PuriTable<TSubResult>>
+    OmitInternalTypeKeys<PuriTable<TSubResult>>
   >;
   from(spec: any): any {
     return new Puri(this.knex, spec);
@@ -64,7 +64,7 @@ export class PuriWrapper<TSchema extends DatabaseSchemaExtend = DatabaseSchemaEx
   ): Puri<
     TSchema,
     Record<TTable, PuriTable<TSchema[TTable]>>,
-    OmitMetadataColumns<PuriTable<TSchema[TTable]>>
+    OmitInternalTypeKeys<PuriTable<TSchema[TTable]>>
   >;
   // 테이블명 + Alias로 시작
   table<TTable extends keyof TSchema, TAlias extends string>(
@@ -74,7 +74,7 @@ export class PuriWrapper<TSchema extends DatabaseSchemaExtend = DatabaseSchemaEx
   ): Puri<
     TSchema,
     Record<TAlias, PuriTable<TSchema[TTable]>>,
-    OmitMetadataColumns<PuriTable<TSchema[TTable]>>
+    OmitInternalTypeKeys<PuriTable<TSchema[TTable]>>
   >;
   // 서브쿼리로 시작
   table<TAlias extends string, TSubResult>(
@@ -84,7 +84,7 @@ export class PuriWrapper<TSchema extends DatabaseSchemaExtend = DatabaseSchemaEx
   ): Puri<
     TSchema,
     Record<TAlias, PuriTable<TSubResult>>,
-    OmitMetadataColumns<PuriTable<TSubResult>>
+    OmitInternalTypeKeys<PuriTable<TSubResult>>
   >;
   table(spec: any): any {
     return new Puri(this.knex, spec);
@@ -147,20 +147,26 @@ export class PuriWrapper<TSchema extends DatabaseSchemaExtend = DatabaseSchemaEx
     return this.upsertBuilder.register(tableName, row);
   }
 
-  ubUpsert(tableName: TableName<TSchema>, chunkSize?: number): Promise<number[]> {
-    return this.upsertBuilder.upsert(this.knex, tableName, { chunkSize });
+  ubUpsert<TTable extends TableName<TSchema> & keyof DatabaseSchemaExtend>(
+    tableName: TTable,
+    options?: UpsertOptions<TTable>,
+  ): Promise<number[]> {
+    return this.upsertBuilder.upsert(this.knex, tableName, options);
   }
 
-  ubInsertOnly(tableName: TableName<TSchema>, chunkSize?: number): Promise<number[]> {
-    return this.upsertBuilder.insertOnly(this.knex, tableName, chunkSize);
+  ubInsertOnly<TTable extends TableName<TSchema> & keyof DatabaseSchemaExtend>(
+    tableName: TTable,
+    options?: InsertOnlyOptions,
+  ): Promise<number[]> {
+    return this.upsertBuilder.insertOnly(this.knex, tableName, options);
   }
 
-  ubUpsertOrInsert(
-    tableName: TableName<TSchema>,
+  ubUpsertOrInsert<TTable extends TableName<TSchema> & keyof DatabaseSchemaExtend>(
+    tableName: TTable,
     mode: "upsert" | "insert",
-    chunkSize?: number,
+    options?: UpsertOptions<TTable>,
   ): Promise<number[]> {
-    return this.upsertBuilder.upsertOrInsert(this.knex, tableName, mode, { chunkSize });
+    return this.upsertBuilder.upsertOrInsert(this.knex, tableName, mode, options);
   }
 
   ubUpdateBatch(