sonamu 0.7.10 → 0.7.12

package/src/migration/code-generation.ts

@@ -1,7 +1,8 @@
 import equal from "fast-deep-equal";
 import { alphabetical, diff } from "radashi";
-import { Naite } from "..";
+import { EntityManager, Naite } from "..";
 import type {
+  EntityProp,
   GenMigrationCode,
   MigrationColumn,
   MigrationForeign,
@@ -216,6 +217,10 @@ function genIndexDefinition(index: MigrationIndex, table: string): string {
     return genVectorIndexDefinition(index, table);
   }
 
+  if (index.using === "pgroonga") {
+    return genPgroongaIndexDefinition(index, table);
+  }
+
   const methodMap = {
     index: "INDEX",
     unique: "UNIQUE INDEX",
@@ -245,6 +250,40 @@ function genIndexDefinition(index: MigrationIndex, table: string): string {
   );`;
 }
 
+function genPgroongaIndexDefinition(index: MigrationIndex, table: string) {
+  const entity = EntityManager.getByTable(table);
+
+  // 복합 인덱스인 경우 ARRAY 사용
+  const columnClause = (() => {
+    if (index.columns.length === 1) {
+      const column = entity.propsDict[index.columns[0].name];
+      const option = getPgroongaColumnOption(column);
+      return `${index.columns[0].name}${option ? ` ${option}` : ""}`;
+    }
+
+    return `(ARRAY[${index.columns.map((col) => `${col.name}::text`).join(",")}])`;
+  })();
+
+  return `await knex.raw(
+  \`CREATE INDEX ${index.name} ON ${table} USING pgroonga (${columnClause}) WITH (tokenizer='TokenMecab');\`
+  )`;
+}
+
+/**
+ * PGroonga 컬럼 옵션 추출
+ *
+ * FullText 오퍼레이터를 지원하는 경우 우선 설정, 나머지는 디폴트 이용
+ * @link https://pgroonga.github.io/reference
+ */
+function getPgroongaColumnOption(column: EntityProp) {
+  if (column.type === "string" && column.length !== undefined) {
+    return "pgroonga_varchar_full_text_search_ops_v2";
+  } else if (column.type === "json") {
+    return "pgroonga_jsonb_full_text_search_ops_v2";
+  }
+  return null;
+}
+
 /**
  * @description
  * - HNSW (Hierarchical Navigable Small World): 느린 빌드, 빠른 검색 속도, 높은 메모리 및 정확도

package/src/migration/postgresql-schema-reader.ts

@@ -148,7 +148,7 @@ class PostgreSQLSchemaReaderClass {
           sortOrder: idx.sort_order,
         })),
         nullsNotDistinct: firstIndex.nulls_not_distinct,
-        using: firstIndex.index_type as "btree" | "hash" | "gin" | "gist" | undefined,
+        using: firstIndex.index_type as "btree" | "hash" | "gin" | "gist" | "pgroonga" | undefined,
       };
     });
 
@@ -219,34 +219,65 @@ class PostgreSQLSchemaReaderClass {
       throw new Error(`Table not found: ${tableName}`);
     }
 
-    // Indexes 조회
+    // Indexes 조회 (PGroonga 표현식 인덱스 포함)
     const indexesQuery = `
       SELECT
-        i.relname as index_name,
-        a.attname as column_name,
-        ix.indisunique as is_unique,
-        ix.indisprimary as is_primary,
-        am.amname as index_type,
-        -- NULLS FIRST/LAST 확인 (비트 연산)
-        (opt & 2) = 2 AS nulls_first,
-        -- ASC/DESC 확인
-        CASE 
-            WHEN (opt & 1) = 1 THEN 'DESC'
-            ELSE 'ASC'
-        END AS sort_order,
-        ix.indnullsnotdistinct AS nulls_not_distinct
+          i.relname AS index_name,
+          CASE
+              WHEN am.amname = 'pgroonga' AND u.attnum = 0 THEN
+                  regexp_replace(
+                      regexp_replace(
+                          TRIM(pgroonga_col.column_expr),
+                          '::text',
+                          '',
+                          'g'
+                      ),
+                      '[()]',
+                      '',
+                      'g'
+                  )
+              ELSE a.attname
+          END AS column_name,
+          ix.indisunique AS is_unique,
+          ix.indisprimary AS is_primary,
+          am.amname AS index_type,
+          COALESCE((u.opt & 2) = 2, FALSE) AS nulls_first,
+          CASE 
+              WHEN (u.opt & 1) = 1 THEN 'DESC'
+              ELSE 'ASC'
+          END AS sort_order,
+          ix.indnullsnotdistinct AS nulls_not_distinct
       FROM pg_class t
       JOIN pg_index ix ON t.oid = ix.indrelid
       JOIN pg_class i ON i.oid = ix.indexrelid
       JOIN pg_am am ON i.relam = am.oid
-        JOIN LATERAL unnest(ix.indkey, ix.indoption)
-            WITH ORDINALITY AS u(attnum, opt, ord) ON true
-        -- unnest에서 나온 attnum으로 직접 조인
-      JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = u.attnum
+      JOIN LATERAL unnest(ix.indkey, ix.indoption)
+          WITH ORDINALITY AS u(attnum, opt, ord) ON true
+      LEFT JOIN pg_attribute a ON a.attrelid = t.oid 
+          AND a.attnum = u.attnum 
+          AND u.attnum > 0
+      LEFT JOIN LATERAL (
+          SELECT 
+              unnest(
+                  CASE 
+                      WHEN pg_get_expr(ix.indexprs, ix.indrelid) ~ '^ARRAY\\[' THEN
+                          string_to_array(
+                              regexp_replace(
+                                  pg_get_expr(ix.indexprs, ix.indrelid),
+                                  '^ARRAY\\[(.*)\\]$',
+                                  '\\1'
+                              ),
+                              ', '
+                          )
+                      ELSE
+                          ARRAY[pg_get_expr(ix.indexprs, ix.indrelid)]
+                  END
+              ) as column_expr
+      ) pgroonga_col ON am.amname = 'pgroonga' AND u.attnum = 0
       WHERE t.relname = ?
-        AND a.attnum = ANY(ix.indkey)
-      ORDER BY i.relname, array_position(ix.indkey, a.attnum)
-    `;
+          AND (u.attnum > 0 OR (am.amname = 'pgroonga' AND u.attnum = 0))
+      ORDER BY i.relname, u.ord;
+`;
     const indexes = (await compareDB.raw(indexesQuery, [tableName])).rows;
 
     // Foreign Keys 조회

package/src/naite/messaging-types.ts

@@ -5,47 +5,46 @@
  * 이 파일은 cartanova-ai/sonamu와 cartanova-ai/vscode-sonamu에서 공통으로 사용됩니다.
  */
 export namespace NaiteMessagingTypes {
-    export type NaiteRunStartMessage = {
-      type: "run/start";
-      startedAt: string;
-    };
-  
-    export type NaiteTestResultMessage = {
-      type: "test/result";
-      receivedAt: string;
-    } & TestResult;
-  
-    export type NaiteRunEndMessage = {
-      type: "run/end";
-      endedAt: string;
-    };
-  
-    export type NaiteMessage = NaiteRunStartMessage | NaiteTestResultMessage | NaiteRunEndMessage;
-  
-    export type NaiteTrace = {
-      key: string;
-      value: any;
-      filePath: string;
-      lineNumber: number;
-      at: string;
-    };
-  
-    export type TestError = {
-      message: string;
-      stack?: string;
-    };
-  
-    export type TestResult = {
-      suiteName: string;
-      suiteFilePath?: string;
-      testName: string;
-      testFilePath: string;
-      testLine: number;
-      status: string;
-      duration: number;
-      error?: TestError;
-      traces: NaiteTrace[];
-      receivedAt: string;
-    };
-  }
-  
+  export type NaiteRunStartMessage = {
+    type: "run/start";
+    startedAt: string;
+  };
+
+  export type NaiteTestResultMessage = {
+    type: "test/result";
+    receivedAt: string;
+  } & TestResult;
+
+  export type NaiteRunEndMessage = {
+    type: "run/end";
+    endedAt: string;
+  };
+
+  export type NaiteMessage = NaiteRunStartMessage | NaiteTestResultMessage | NaiteRunEndMessage;
+
+  export type NaiteTrace = {
+    key: string;
+    value: any;
+    filePath: string;
+    lineNumber: number;
+    at: string;
+  };
+
+  export type TestError = {
+    message: string;
+    stack?: string;
+  };
+
+  export type TestResult = {
+    suiteName: string;
+    suiteFilePath?: string;
+    testName: string;
+    testFilePath: string;
+    testLine: number;
+    status: string;
+    duration: number;
+    error?: TestError;
+    traces: NaiteTrace[];
+    receivedAt: string;
+  };
+}

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/naite/naite.ts

@@ -349,7 +349,7 @@ export class NaiteClass {
     // 이로 인해 "직렬화 가능한 값들만 허용"하는 제약이 생깁니다.
     //
     // 이 제약을 의식하여 Naite.t에 직렬화 가능한 값만 넘기게 할 수도 있었지만, 그렇게 하면 불편해질 것 같아서 하지 않았습니다.
-    // 따라서 현재 Naite.t는 모든 값을 받을 수 있게 되어 있습니다. 
+    // 따라서 현재 Naite.t는 모든 값을 받을 수 있게 되어 있습니다.
     // 대신 이렇게(getAllTraces) 그 값들을 빼낼 때 JSON.stringify를 사용하여 강제로 직렬화 가능하게 만들었습니다,,
     for (const trace of traces) {
       const check = isSerializable(trace.data);

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

@@ -180,6 +180,19 @@ export type ListResult<LP extends { queryMode?: SonamuQueryMode }, T> = LP["quer
 export const SonamuQueryMode = z.enum(["both", "list", "count"]);
 export type SonamuQueryMode = z.infer<typeof SonamuQueryMode>;
 
+/* Semantic Query */
+export const SonamuSemanticParams = z
+  .object({
+    semanticQuery: z.object({
+      embedding: z.array(z.number()).min(1024).max(1024),
+      threshold: z.number().optional(),
+      method: z.enum(["cosine", "l2", "inner_product"]).optional(),
+      which: z.string(),
+    }),
+  })
+  .partial();
+export type SonamuSemanticParams = z.infer<typeof SonamuSemanticParams>;
+
 /*
   SWR
 */

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

@@ -95,6 +95,19 @@ export type ListResult<LP extends { queryMode?: SonamuQueryMode }, T> = LP["quer
 export const SonamuQueryMode = z.enum(["both", "list", "count"]);
 export type SonamuQueryMode = z.infer<typeof SonamuQueryMode>;
 
+/* Semantic Query */
+export const SonamuSemanticParams = z
+  .object({
+    semanticQuery: z.object({
+      embedding: z.array(z.number()).min(1024).max(1024),
+      threshold: z.number().optional(),
+      method: z.enum(["cosine", "l2", "inner_product"]).optional(),
+      which: z.string(),
+    }),
+  })
+  .partial();
+export type SonamuSemanticParams = z.infer<typeof SonamuSemanticParams>;
+
 /*
   SWR
 */

package/src/stream/sse.ts

@@ -6,11 +6,23 @@ export function createSSEFactory<T extends z.ZodObject>(
   socket: FastifyRequest["socket"],
   reply: FastifyReply,
   _events: T,
-) {
-  return new SSEConnection<T>(socket, reply);
+): SSEConnection<T> {
+  return new SSEConnectionImpl<T>(socket, reply);
 }
 
-class SSEConnection<T extends z.ZodObject> {
+export function createMockSSEFactory<T extends z.ZodObject>(_events: T): SSEConnection<T> {
+  return {
+    publish: (_event, _data) => {},
+    end: () => Promise.resolve(),
+  };
+}
+
+export interface SSEConnection<T extends z.ZodObject> {
+  publish<K extends keyof z.infer<T>>(event: K, data: z.infer<T>[K]): void;
+  end(): Promise<void>;
+}
+
+class SSEConnectionImpl<T extends z.ZodObject> implements SSEConnection<T> {
   private _closed = false;
 
   constructor(

package/src/syncer/api-parser.ts

@@ -229,6 +229,10 @@ function resolveTypeNode(typeNode: ts.TypeNode): ApiParamType {
         };
       }
       break;
+    case ts.SyntaxKind.ParenthesizedType:
+      // 괄호로 묶인 타입 (예: (A & B)[] 에서 (A & B))
+      // 내부 타입을 재귀적으로 resolve
+      return resolveTypeNode((typeNode as ts.ParenthesizedTypeNode).type);
     case undefined:
       throw new Error(`typeNode undefined`);
   }

package/src/syncer/file-patterns.ts

@@ -3,13 +3,14 @@ import { Sonamu } from "../api/sonamu";
 import type { AbsolutePath, ApiRelativePath } from "../utils/path-utils";
 
 export type FileType =
-  | "model"
-  | "types"
-  | "functions"
-  | "generated"
+  | "config"
   | "entity"
   | "frame"
-  | "config";
+  | "functions"
+  | "generated"
+  | "model"
+  | "types"
+  | "workflow";
 
 export type GlobPattern<T extends ApiRelativePath | AbsolutePath> = {
   [key in FileType]: T;
@@ -24,13 +25,14 @@ export type GlobPattern<T extends ApiRelativePath | AbsolutePath> = {
  * **사용**: getChecksumPatternGroupInAbsolutePath()로 절대 경로 변환 후 glob 사용
  */
 export const checksumPatternGroup: GlobPattern<ApiRelativePath> = {
+  config: "src/sonamu.config.ts",
   entity: "src/application/**/*.entity.json",
-  types: "src/application/**/*.types.ts",
-  generated: "src/application/sonamu.generated.ts",
-  model: "src/application/**/*.model.ts",
   frame: "src/application/**/*.frame.ts",
   functions: "src/application/**/*.functions.ts",
-  config: "src/sonamu.config.ts",
+  generated: "src/application/sonamu.generated.ts",
+  model: "src/application/**/*.model.ts",
+  types: "src/application/**/*.types.ts",
+  workflow: "src/application/**/*.workflow.ts",
 };
 
 /**

package/src/syncer/module-loader.ts

@@ -4,6 +4,7 @@ import type { BaseFrameClass } from "../api/base-frame";
 import type { ApiDecoratorOptions } from "../api/decorators";
 import { Sonamu } from "../api/sonamu";
 import type { BaseModelClass } from "../database/base-model";
+import type { WorkflowMetadata } from "../tasks/decorator";
 import type { ApiParam, ApiParamType } from "../types/types";
 import { globAsync } from "../utils/async-utils";
 import { importMembers } from "../utils/esm-utils";
@@ -126,3 +127,37 @@ export async function loadTypes(): Promise<LoadedTypes> {
 
   return types;
 }
+
+/**
+ * *.workflow.ts 파일들에서 Workflow 메타데이터를 로드합니다.
+ */
+export async function loadWorkflows() {
+  const workflowPathsPattern = path.join(
+    Sonamu.apiRootPath,
+    runtimePath("src/application/**/*.workflow.ts"),
+  );
+  const workflowPaths = await globAsync(workflowPathsPattern);
+  const workflows: Map<string, WorkflowMetadata[]> = new Map();
+  for (const filePath of workflowPaths) {
+    const importedMembers = await importMembers(filePath);
+    workflows.set(
+      filePath,
+      importedMembers
+        .filter(({ value }) => {
+          return (
+            typeof value === "object" &&
+            value !== null &&
+            "type" in value &&
+            value.type === "workflow" &&
+            "fn" in value &&
+            typeof value.fn === "function"
+          );
+        })
+        .map(({ value }) => {
+          return value as WorkflowMetadata;
+        }),
+    );
+  }
+
+  return workflows;
+}

package/src/syncer/syncer.ts

@@ -7,6 +7,7 @@ import { minimatch } from "minimatch";
 import path, { dirname } from "path";
 import { group, unique } from "radashi";
 import type { z } from "zod";
+import type { WorkflowMetadata } from "..";
 import { registeredApis } from "../api/decorators";
 import { Sonamu } from "../api/sonamu";
 import { EntityManager, type EntityNamesRecord } from "../entity/entity-manager";
@@ -31,6 +32,7 @@ import {
   loadApis,
   loadModels,
   loadTypes,
+  loadWorkflows,
 } from "./module-loader";
 
 type DiffGroups = {
@@ -41,6 +43,7 @@ export class Syncer {
   apis: LoadedApis = [];
   types: LoadedTypes = {};
   models: LoadedModels = {};
+  workflows: Map<string, WorkflowMetadata[]> = new Map();
   isSyncing: boolean = false;
 
   /**
@@ -127,6 +130,7 @@ export class Syncer {
     await this.autoloadTypes();
     await this.autoloadModels();
     await this.autoloadApis();
+    await this.autoloadWorkflows();
 
     this.syncUI();
   }
@@ -199,6 +203,11 @@ export class Syncer {
     this.apis = await loadApis();
   }
 
+  async autoloadWorkflows() {
+    this.workflows = await loadWorkflows();
+    await Sonamu.workflows.synchronize(this.workflows);
+  }
+
   /**
    * 실제 싱크를 수행하는 본체입니다.
    * 변경된 파일들을 타입별로 분류하고 각 타입에 맞는 액션을 실행합니다.
@@ -235,6 +244,11 @@ export class Syncer {
       await this.actionSyncConfig();
     }
 
+    // 트리거: workflow
+    if (diffTypes.includes("workflow")) {
+      await this.autoloadWorkflows();
+    }
+
     return {
       diffTypes,
     };