sonamu 0.7.11 → 0.7.12

package/src/database/puri.types.ts

@@ -13,13 +13,31 @@ type VirtualKey = "__virtual__";
 type LeftJoinedKey = "__leftJoined__";
 type HasDefault = "__hasDefault__";
 type GeneratedKey = "__generated__";
+type VectorKey = "__vector__";
 
-type InternalTypeKeys = FulltextKey | VirtualKey | LeftJoinedKey | HasDefault | GeneratedKey;
+type InternalTypeKeys =
+  | FulltextKey
+  | VirtualKey
+  | LeftJoinedKey
+  | HasDefault
+  | GeneratedKey
+  | VectorKey;
 
 // ============================================
 // 타입 유틸리티
 // ============================================
 
+// __vector__ 메타데이터에서 벡터 컬럼 추출
+type VectorColumnKeys<T> = T extends { [K in VectorKey]: readonly (infer V)[] }
+  ? V & string
+  : never;
+
+export type VectorColumns<TTables extends Record<string, any>> =
+  | {
+      [TAlias in keyof TTables]: `${TAlias & string}.${VectorColumnKeys<TTables[TAlias]>}`;
+    }[keyof TTables]
+  | (IsSingleKey<TTables> extends true ? VectorColumnKeys<TTables[keyof TTables]> : never);
+
 // 테이블명 타입
 export type TableName<TSchema> = keyof TSchema & string;
 
@@ -78,7 +96,7 @@ export type ResultAvailableColumns<TTables extends Record<string, any>, TResult
 // Select 값 타입 확장 (단일 컬럼 또는 SQL 표현식)
 export type SelectValue<TTables extends Record<string, any>> =
   | AvailableColumns<TTables>
-  | SqlExpression<"string" | "number" | "boolean" | "date">;
+  | SqlExpression<"string" | "number" | "boolean" | "date" | "string[]">;
 
 // 중첩 Select 객체 타입 (재귀적)
 // 예: { parent: { id: "parent.id", name: "parent.name" } }
@@ -178,7 +196,9 @@ type ParseSelectObjectWithPath<
           ? boolean
           : R extends "date"
             ? Date
-            : never
+            : R extends "string[]"
+              ? string[]
+              : never
     : IsNestedObject<TSelect[K]> extends true
       ? TSelect[K] extends NestedSelectObject<TTables>
         ? IsNullableJoinedTable<TTables, JoinPath<Prefix, K & string>> extends true // 주어진 테이블이 FK nullable에 leftJoin되었는지 여부에 따라 select 결과 객체의 타입이 달라집니다.
@@ -205,7 +225,9 @@ type ParseSelectObjectInner<
           ? boolean
           : R extends "date"
             ? Date
-            : never
+            : R extends "string[]"
+              ? string[]
+              : never
     : IsNestedObject<TSelect[K]> extends true
       ? TSelect[K] extends NestedSelectObject<TTables>
         ? IsNullableJoinedTable<TTables, JoinPath<Prefix, K & string>> extends true
@@ -274,7 +296,7 @@ export type ComparisonOperator = "=" | ">" | ">=" | "<" | "<=" | "<>" | "!=";
 export type WhereOperator = ComparisonOperator | "like" | "not like";
 
 // SQL Expression 타입 정의
-export type SqlExpression<T extends "string" | "number" | "boolean" | "date"> = {
+export type SqlExpression<T extends "string" | "number" | "boolean" | "date" | "string[]"> = {
   _type: "sql_expression"; // 또는 "computed_value"
   _return: T;
   _sql: string;
@@ -377,7 +399,7 @@ export type TsQueryOptions = {
   config?: TsQueryConfig;
 };
 
-export type HighlightOptions = {
+export type TsHighlightOptions = {
   /** 쿼리 변환 함수 (기본값: "websearch_to_tsquery") */
   parser?: TsQueryParser;
   /** 텍스트 검색 설정 (기본값: "simple") */
@@ -399,3 +421,24 @@ export type HighlightOptions = {
   /** 조각 구분자 (기본값: " ... ") */
   fragmentDelimiter?: string;
 };
+
+export type TsRankOptions = {
+  parser?: TsQueryParser;
+  config?: TsQueryConfig;
+  /** 가중치 배열 [D, C, B, A] (기본값: [0.1, 0.2, 0.4, 1.0]) */
+  weights?: [number, number, number, number];
+  /**
+   * 정규화 옵션
+   * 0: 문서 길이 무시 (기본값)
+   * 1: 1 + log(문서 길이)로 나눔
+   * 2: 문서 길이로 나눔
+   * 4: 평균 조화 거리로 나눔 (ts_rank_cd만)
+   * 8: 고유 단어 수로 나눔
+   * 16: 1 + log(고유 단어 수)로 나눔
+   * 32: rank/(rank+1) -> 0~1 사이의 값으로 스케일링
+   *
+   * 비트마스크를 사용하여 옵션을 조합할 수 있음
+   * 예: 8 | 32 -> 고유 단어 수로 나누고 0~1 스케일링
+   */
+  normalization?: number;
+};

package/src/entity/entity-manager.ts

@@ -85,6 +85,15 @@ class EntityManagerClass {
     return entity;
   }
 
+  getByTable(table: string): Entity {
+    const entity = Array.from(this.entities.values()).find((entity) => entity.table === table);
+    if (entity === undefined) {
+      throw new Error(`존재하지 않는 Entity 요청 ${table}`);
+    }
+
+    return entity;
+  }
+
   exists(entityId: string): boolean {
     const entity = this.entities.get(entityId);
     return entity !== undefined;

package/src/index.ts

@@ -22,6 +22,7 @@ export * from "./migration/types";
 export * from "./naite/naite";
 export * from "./naite/naite-reporter";
 export * from "./stream/sse";
+export * from "./tasks/decorator";
 export * from "./template/template";
 export * from "./template/template-manager";
 export * from "./testing/fixture-manager";
@@ -35,7 +36,6 @@ export * from "./vector/chunking";
 export * from "./vector/config";
 export * from "./vector/embedding";
 export * from "./vector/types";
-export * from "./vector/vector-search";
 
 // export * from "./api/code-converters";
 // export * from "./syncer/syncer";

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.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,
     };