sonamu 0.7.9 → 0.7.11

package/src/database/upsert-builder.ts

@@ -6,7 +6,7 @@ import { Naite } from "../naite/naite";
 import type { DatabaseForeignKeys, DatabaseSchemaExtend, EntityIndex } from "../types/types";
 import { assertDefined, chunk, nonNullable } from "../utils/utils";
 import { batchUpdate, type RowWithId } from "./_batch_update";
-import type { ForeignKeyColumns, TableName } from "./puri.types";
+import type { ColumnKeys, ForeignKeyColumns, TableName } from "./puri.types";
 
 /**
  * FK 타입 추론을 위해 DatabaseForeignKeys export
@@ -14,6 +14,9 @@ import type { ForeignKeyColumns, TableName } from "./puri.types";
  */
 export type { DatabaseForeignKeys };
 
+type InheritableColumns<TTable extends TableName<DatabaseSchemaExtend>> =
+  TTable extends keyof DatabaseSchemaExtend ? ColumnKeys<DatabaseSchemaExtend[TTable]> : never;
+
 // 테이블 데이터 타입
 type TableData = {
   references: Set<string>;
@@ -33,6 +36,7 @@ export type UBRef = {
 export type UpsertOptions<TTable extends TableName<DatabaseSchemaExtend>> = {
   chunkSize?: number;
   cleanOrphans?: ForeignKeyColumns<TTable> | ForeignKeyColumns<TTable>[];
+  inherit?: InheritableColumns<TTable>[];
 };
 
 // insertOnly 옵션
@@ -289,16 +293,30 @@ export class UpsertBuilder {
           resultRows = await wdb.insert(dataForDb).into(tableName).returning(selectFields);
         } else {
           // UPSERT 모드 - onConflict 사용 (unique index 없으면 PK fallback)
-          const conflictColumns =
-            table.uniqueIndexes.length > 0
-              ? table.uniqueIndexes[0].columns.map((c) => c.name)
-              : ["id"];
-          const updateColumns = Object.keys(dataForDb[0]).filter(
-            (col) => !conflictColumns.includes(col),
-          );
+          const conflictColumns = table.uniqueIndexes[0]?.columns.map((c) => c.name) ?? ["id"];
+
+          const allColumns = Object.keys(dataForDb[0]);
+          let updateColumns = allColumns.filter((c) => !conflictColumns.includes(c));
+
+          // inherit 옵션 처리 - inherit 컬럼은 update 대상에서 제외
+          if (options?.inherit?.length) {
+            const inheritColumns = options.inherit as string[];
+
+            const excludedFromUpdate = updateColumns.filter((c) => inheritColumns.includes(c));
+            updateColumns = updateColumns.filter((c) => !inheritColumns.includes(c));
+
+            // 실제로 제외된 컬럼 로깅
+            if (excludedFromUpdate.length) {
+              Naite.t("puri:ub-inherit", {
+                tableName,
+                inheritColumns,
+                excludedFromUpdate,
+              });
+            }
+          }
 
           // updateColumns가 비어있어도 merge()를 사용하여 모든 행이 RETURNING되도록 보장
-          const mergeColumns = updateColumns.length > 0 ? updateColumns : conflictColumns;
+          const mergeColumns = updateColumns.length ? updateColumns : conflictColumns;
 
           resultRows = await wdb
             .insert(dataForDb)

package/src/naite/naite-reporter.ts

@@ -2,22 +2,46 @@
  * NaiteReporter
  *
  * 테스트 결과와 Trace 정보를 Unix Socket으로 VS Code extension에 전달합니다.
- * extension이 ~/.sonamu/naite.sock에 소켓 서버를 열어둡니다.
+ * extension이 ~/.sonamu/naite-{hash}.sock에 소켓 서버를 열어둡니다.
+ *
+ * 프로젝트별로 고유한 소켓을 사용하기 위해 sonamu.config.ts 경로의 해시를 사용합니다.
  *
  * fs mock 충돌을 피하기 위해 net 모듈만 사용합니다.
  */
 /** biome-ignore-all lint/suspicious/noExplicitAny: Naite는 expect와 호응하도록 any를 허용함 */
 
+import { createHash } from "crypto";
 import { connect, type Socket } from "net";
 import { homedir } from "os";
 import { join } from "path";
+import { findApiRootPath } from "../utils/utils";
 import type { NaiteMessagingTypes } from "./messaging-types";
 
-// 소켓 경로
-const SOCKET_PATH =
-  process.platform === "win32" ? "\\\\.\\pipe\\naite" : join(homedir(), ".sonamu", "naite.sock");
+/**
+ * sonamu.config.ts 경로를 받아서 프로젝트별 고유 해시를 생성합니다.
+ * 익스텐션과 동일한 방식으로 계산해야 합니다.
+ */
+function getProjectHash(configPath: string): string {
+  return createHash("md5").update(configPath).digest("hex").slice(0, 8);
+}
+
+/**
+ * 현재 프로젝트의 소켓 경로를 계산합니다.
+ * Sonamu.apiRootPath가 설정된 후에 호출해야 합니다.
+ */
+function getSocketPath(): string {
+  // sonamu.config.ts의 절대 경로 계산
+  // apiRootPath는 /project/api 형태이고, config는 /project/api/src/sonamu.config.ts에 있음
+  const configPath = join(findApiRootPath(), "src", "sonamu.config.ts");
+  const hash = getProjectHash(configPath);
+
+  return process.platform === "win32"
+    ? `\\\\.\\pipe\\naite-${hash}`
+    : join(homedir(), ".sonamu", `naite-${hash}.sock`);
+}
 
 class NaiteReporterClass {
+  private socketPath: string | null = null;
   private socket: Socket | null = null;
   private connected = false;
   private buffer: string[] = [];
@@ -25,11 +49,16 @@ class NaiteReporterClass {
   /**
    * 소켓 연결 시도
    */
-  private ensureConnection(): void {
-    if (this.connected || this.socket) return;
+  private async ensureConnection(): Promise<void> {
+    if (this.connected || this.socket) {
+      return;
+    }
 
-    try {
-      this.socket = connect(SOCKET_PATH);
+    return new Promise((res, rej) => {
+      if (!this.socketPath) {
+        this.socketPath = getSocketPath();
+      }
+      this.socket = connect(this.socketPath);
 
       this.socket.on("connect", () => {
         this.connected = true;
@@ -38,30 +67,30 @@ class NaiteReporterClass {
           this.socket?.write(msg);
         }
         this.buffer = [];
+        res();
       });
 
-      this.socket.on("error", () => {
+      this.socket.on("error", (e) => {
         // 연결 실패 무시 (extension이 꺼져있을 수 있음)
         this.connected = false;
         this.socket = null;
+        rej(e);
       });
 
       this.socket.on("close", () => {
         this.connected = false;
         this.socket = null;
       });
-    } catch {
-      // 연결 실패 무시
-    }
+    });
   }
 
   /**
    * 메시지 전송 (줄바꿈으로 구분)
    */
-  private send(data: NaiteMessagingTypes.NaiteMessage): void {
+  private async send(data: NaiteMessagingTypes.NaiteMessage): Promise<void> {
     const msg = `${JSON.stringify(data)}\n`;
 
-    this.ensureConnection();
+    await this.ensureConnection().catch((_) => {});
 
     if (this.connected && this.socket) {
       this.socket.write(msg);
@@ -75,12 +104,12 @@ class NaiteReporterClass {
    * beforeAll에서 호출합니다.
    * 테스트 run 시작을 알립니다 (데이터 클리어 신호).
    */
-  startTestRun(): void {
+  async startTestRun(): Promise<void> {
     if (process.env.CI) {
       return;
     }
 
-    this.send({
+    await this.send({
       type: "run/start",
       startedAt: new Date().toISOString(),
     });
@@ -90,12 +119,14 @@ class NaiteReporterClass {
    * afterEach에서 호출합니다.
    * 테스트 케이스 결과를 traces와 함께 전송합니다.
    */
-  reportTestResult(result: Omit<NaiteMessagingTypes.TestResult, "receivedAt">): void {
+  async reportTestResult(
+    result: Omit<NaiteMessagingTypes.TestResult, "receivedAt">,
+  ): Promise<void> {
     if (process.env.CI) {
       return;
     }
 
-    this.send({
+    await this.send({
       type: "test/result",
       receivedAt: new Date().toISOString(),
       ...result,
@@ -106,12 +137,12 @@ class NaiteReporterClass {
    * afterAll에서 호출합니다.
    * 테스트 run 종료를 알립니다.
    */
-  endTestRun(): void {
+  async endTestRun(): Promise<void> {
     if (process.env.CI) {
       return;
     }
 
-    this.send({
+    await this.send({
       type: "run/end",
       endedAt: new Date().toISOString(),
     });

package/src/template/implementations/model.template.ts

@@ -105,7 +105,7 @@ class ${entityId}ModelClass extends BaseModelClass<
       search: "${def.search}" as const,
       orderBy: "${def.orderBy}" as const,
       ...rawParams,
-    };
+    } satisfies ${entityId}ListParams;
 
     // build queries
     const { qb, onSubset: _ } = this.getSubsetQueries(subset);

package/src/template/zod-converter.ts

@@ -47,6 +47,7 @@ import {
   isRelationProp,
   isStringArrayProp,
   isStringSingleProp,
+  isTsVectorProp,
   isUuidArrayProp,
   isUuidSingleProp,
   isVectorArrayProp,
@@ -215,6 +216,8 @@ export function propToZodTypeDef(prop: EntityProp, injectImportKeys: string[]):
     stmt = `${prop.name}: z.array(z.number())`;
   } else if (isVectorArrayProp(prop)) {
     stmt = `${prop.name}: z.array(z.array(z.number()))`;
+  } else if (isTsVectorProp(prop)) {
+    stmt = `${prop.name}: z.string()`;
   } else if (isVirtualProp(prop)) {
     stmt = `${prop.name}: ${prop.id}`;
     injectImportKeys.push(prop.id);

package/src/types/types.ts

@@ -422,6 +422,9 @@ export function isVectorArrayProp(p: unknown): p is VectorArrayProp {
 export function isVectorProp(p: unknown): p is VectorProp | VectorArrayProp {
   return isVectorSingleProp(p) || isVectorArrayProp(p);
 }
+export function isTsVectorProp(p: unknown): p is TsVectorProp {
+  return (p as TsVectorProp)?.type === "tsvector";
+}
 export function isRelationProp(p: unknown): p is RelationProp {
   return (p as RelationProp)?.type === "relation";
 }

package/src/utils/console-util.ts

@@ -1,4 +1,4 @@
 export function centerText(text: string): string {
-  const margin = (process.stdout.columns - text.length) / 2;
+  const margin = Math.max(0, Math.floor((process.stdout.columns - text.length) / 2));
   return " ".repeat(margin) + text + " ".repeat(margin);
 }