npm - @ekodb/ekodb-client - Versions diffs - 0.3.0 → 0.4.0 - Mend

@ekodb/ekodb-client 0.3.0 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/client.d.ts CHANGED Viewed

@@ -4,6 +4,7 @@
 import { QueryBuilder } from "./query-builder";
 import { SearchQuery, SearchQueryBuilder, SearchResponse } from "./search";
 import { Schema, SchemaBuilder, CollectionMetadata } from "./schema";
+import { Script, FunctionResult } from "./functions";
 export interface Record {
     [key: string]: any;
 }
@@ -395,6 +396,32 @@ export declare class EkoDBClient {
      * Merge multiple chat sessions into one
      */
     mergeChatSessions(request: MergeSessionsRequest): Promise<ChatSessionResponse>;
+    /**
+     * Save a new script definition
+     */
+    saveScript(script: Script): Promise<string>;
+    /**
+     * Get a script by ID
+     */
+    getScript(id: string): Promise<Script>;
+    /**
+     * List all scripts, optionally filtered by tags
+     */
+    listScripts(tags?: string[]): Promise<Script[]>;
+    /**
+     * Update an existing script by ID
+     */
+    updateScript(id: string, script: Script): Promise<void>;
+    /**
+     * Delete a script by ID
+     */
+    deleteScript(id: string): Promise<void>;
+    /**
+     * Call a saved script by ID or label
+     */
+    callScript(idOrLabel: string, params?: {
+        [key: string]: any;
+    }): Promise<FunctionResult>;
     /**
      * Create a WebSocket client
      */

package/dist/client.js CHANGED Viewed

@@ -548,6 +548,47 @@ class EkoDBClient {
     async mergeChatSessions(request) {
         return this.makeRequest("POST", "/api/chat/merge", request, 0, true);
     }
+    // ========================================================================
+    // SCRIPTS API
+    // ========================================================================
+    /**
+     * Save a new script definition
+     */
+    async saveScript(script) {
+        const result = await this.makeRequest("POST", "/api/functions", script);
+        return result.id;
+    }
+    /**
+     * Get a script by ID
+     */
+    async getScript(id) {
+        return this.makeRequest("GET", `/api/functions/${id}`);
+    }
+    /**
+     * List all scripts, optionally filtered by tags
+     */
+    async listScripts(tags) {
+        const params = tags ? `?tags=${tags.join(",")}` : "";
+        return this.makeRequest("GET", `/api/functions${params}`);
+    }
+    /**
+     * Update an existing script by ID
+     */
+    async updateScript(id, script) {
+        await this.makeRequest("PUT", `/api/functions/${id}`, script);
+    }
+    /**
+     * Delete a script by ID
+     */
+    async deleteScript(id) {
+        await this.makeRequest("DELETE", `/api/functions/${id}`);
+    }
+    /**
+     * Call a saved script by ID or label
+     */
+    async callScript(idOrLabel, params) {
+        return this.makeRequest("POST", `/api/functions/${idOrLabel}`, params || {});
+    }
     /**
      * Create a WebSocket client
      */

package/dist/functions.d.ts ADDED Viewed

@@ -0,0 +1,195 @@
+/**
+ * Scripts API for ekoDB TypeScript client
+ */
+export interface Script {
+    label: string;
+    name: string;
+    description?: string;
+    version: string;
+    parameters: {
+        [key: string]: ParameterDefinition;
+    };
+    functions: FunctionStageConfig[];
+    tags: string[];
+    created_at?: string;
+    updated_at?: string;
+}
+export interface ParameterDefinition {
+    required: boolean;
+    default?: any;
+    description?: string;
+    param_type?: string;
+}
+export type FunctionStageConfig = {
+    type: "FindAll";
+    collection: string;
+} | {
+    type: "Query";
+    collection: string;
+    filter?: Record<string, any>;
+    sort?: SortFieldConfig[];
+    limit?: number;
+    skip?: number;
+} | {
+    type: "Project";
+    fields: string[];
+    exclude: boolean;
+} | {
+    type: "Group";
+    by_fields: string[];
+    functions: GroupFunctionConfig[];
+} | {
+    type: "Count";
+    output_field: string;
+} | {
+    type: "Filter";
+    filter: Record<string, any>;
+} | {
+    type: "Sort";
+    sort: SortFieldConfig[];
+} | {
+    type: "Limit";
+    limit: number;
+} | {
+    type: "Skip";
+    skip: number;
+} | {
+    type: "Insert";
+    collection: string;
+    record: Record<string, any>;
+    bypass_ripple?: boolean;
+    ttl?: number;
+} | {
+    type: "Update";
+    collection: string;
+    filter: Record<string, any>;
+    updates: Record<string, any>;
+    bypass_ripple?: boolean;
+    ttl?: number;
+} | {
+    type: "UpdateById";
+    collection: string;
+    record_id: string;
+    updates: Record<string, any>;
+    bypass_ripple?: boolean;
+    ttl?: number;
+} | {
+    type: "Delete";
+    collection: string;
+    filter: Record<string, any>;
+    bypass_ripple?: boolean;
+} | {
+    type: "DeleteById";
+    collection: string;
+    record_id: string;
+    bypass_ripple?: boolean;
+} | {
+    type: "BatchInsert";
+    collection: string;
+    records: Record<string, any>[];
+    bypass_ripple?: boolean;
+} | {
+    type: "BatchDelete";
+    collection: string;
+    record_ids: string[];
+    bypass_ripple?: boolean;
+} | {
+    type: "HttpRequest";
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: any;
+} | {
+    type: "VectorSearch";
+    collection: string;
+    query_vector: number[];
+    limit?: number;
+    threshold?: number;
+} | {
+    type: "TextSearch";
+    collection: string;
+    query_text: string;
+    fields?: string[];
+    limit?: number;
+    fuzzy?: boolean;
+} | {
+    type: "HybridSearch";
+    collection: string;
+    query_text: string;
+    query_vector?: number[];
+    limit?: number;
+} | {
+    type: "Chat";
+    messages: ChatMessage[];
+    model?: string;
+    temperature?: number;
+    max_tokens?: number;
+} | {
+    type: "Embed";
+    input_field: string;
+    output_field: string;
+    model?: string;
+};
+export interface ChatMessage {
+    role: string;
+    content: string;
+}
+export declare const ChatMessage: {
+    system: (content: string) => ChatMessage;
+    user: (content: string) => ChatMessage;
+    assistant: (content: string) => ChatMessage;
+};
+export interface GroupFunctionConfig {
+    output_field: string;
+    operation: "Sum" | "Average" | "Count" | "Min" | "Max" | "First" | "Last" | "Push";
+    input_field?: string;
+}
+export interface SortFieldConfig {
+    field: string;
+    ascending: boolean;
+}
+export interface FunctionResult {
+    records: Record<string, any>[];
+    stats: FunctionStats;
+}
+export interface FunctionStats {
+    input_count: number;
+    output_count: number;
+    execution_time_ms: number;
+    stages_executed: number;
+    stage_stats: StageStats[];
+}
+export interface StageStats {
+    stage: string;
+    input_count: number;
+    output_count: number;
+    execution_time_ms: number;
+}
+export declare const Stage: {
+    findAll: (collection: string) => FunctionStageConfig;
+    query: (collection: string, filter?: Record<string, any>, sort?: SortFieldConfig[], limit?: number, skip?: number) => FunctionStageConfig;
+    project: (fields: string[], exclude?: boolean) => FunctionStageConfig;
+    group: (by_fields: string[], functions: GroupFunctionConfig[]) => FunctionStageConfig;
+    count: (output_field?: string) => FunctionStageConfig;
+    insert: (collection: string, record: Record<string, any>, bypassRipple?: boolean, ttl?: number) => FunctionStageConfig;
+    update: (collection: string, filter: Record<string, any>, updates: Record<string, any>, bypassRipple?: boolean, ttl?: number) => FunctionStageConfig;
+    updateById: (collection: string, record_id: string, updates: Record<string, any>, bypassRipple?: boolean, ttl?: number) => FunctionStageConfig;
+    delete: (collection: string, filter: Record<string, any>, bypassRipple?: boolean) => FunctionStageConfig;
+    deleteById: (collection: string, record_id: string, bypassRipple?: boolean) => FunctionStageConfig;
+    batchInsert: (collection: string, records: Record<string, any>[], bypassRipple?: boolean) => FunctionStageConfig;
+    batchDelete: (collection: string, record_ids: string[], bypassRipple?: boolean) => FunctionStageConfig;
+    filter: (filter: Record<string, any>) => FunctionStageConfig;
+    sort: (sort: SortFieldConfig[]) => FunctionStageConfig;
+    limit: (limit: number) => FunctionStageConfig;
+    skip: (skip: number) => FunctionStageConfig;
+    httpRequest: (url: string, method?: string, headers?: Record<string, string>, body?: any) => FunctionStageConfig;
+    vectorSearch: (collection: string, query_vector: number[], limit?: number, threshold?: number) => FunctionStageConfig;
+    textSearch: (collection: string, query_text: string, options?: {
+        fields?: string[];
+        limit?: number;
+        fuzzy?: boolean;
+    }) => FunctionStageConfig;
+    hybridSearch: (collection: string, query_text: string, query_vector?: number[], limit?: number) => FunctionStageConfig;
+    chat: (messages: ChatMessage[], model?: string, temperature?: number, max_tokens?: number) => FunctionStageConfig;
+    embed: (input_field: string, output_field: string, model?: string) => FunctionStageConfig;
+};

package/dist/functions.js ADDED Viewed

@@ -0,0 +1,154 @@
+"use strict";
+/**
+ * Scripts API for ekoDB TypeScript client
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stage = exports.ChatMessage = void 0;
+exports.ChatMessage = {
+    system: (content) => ({
+        role: "system",
+        content: content,
+    }),
+    user: (content) => ({
+        role: "user",
+        content: content,
+    }),
+    assistant: (content) => ({
+        role: "assistant",
+        content: content,
+    }),
+};
+// Stage builder functions
+exports.Stage = {
+    findAll: (collection) => ({
+        type: "FindAll",
+        collection,
+    }),
+    query: (collection, filter, sort, limit, skip) => ({
+        type: "Query",
+        collection,
+        filter,
+        sort,
+        limit,
+        skip,
+    }),
+    project: (fields, exclude = false) => ({
+        type: "Project",
+        fields,
+        exclude,
+    }),
+    group: (by_fields, functions) => ({
+        type: "Group",
+        by_fields,
+        functions,
+    }),
+    count: (output_field = "count") => ({
+        type: "Count",
+        output_field,
+    }),
+    insert: (collection, record, bypassRipple = false, ttl) => ({
+        type: "Insert",
+        collection,
+        record,
+        bypass_ripple: bypassRipple,
+        ttl,
+    }),
+    update: (collection, filter, updates, bypassRipple = false, ttl) => ({
+        type: "Update",
+        collection,
+        filter,
+        updates,
+        bypass_ripple: bypassRipple,
+        ttl,
+    }),
+    updateById: (collection, record_id, updates, bypassRipple = false, ttl) => ({
+        type: "UpdateById",
+        collection,
+        record_id,
+        updates,
+        bypass_ripple: bypassRipple,
+        ttl,
+    }),
+    delete: (collection, filter, bypassRipple = false) => ({
+        type: "Delete",
+        collection,
+        filter,
+        bypass_ripple: bypassRipple,
+    }),
+    deleteById: (collection, record_id, bypassRipple = false) => ({
+        type: "DeleteById",
+        collection,
+        record_id,
+        bypass_ripple: bypassRipple,
+    }),
+    batchInsert: (collection, records, bypassRipple = false) => ({
+        type: "BatchInsert",
+        collection,
+        records,
+        bypass_ripple: bypassRipple,
+    }),
+    batchDelete: (collection, record_ids, bypassRipple = false) => ({
+        type: "BatchDelete",
+        collection,
+        record_ids,
+        bypass_ripple: bypassRipple,
+    }),
+    filter: (filter) => ({
+        type: "Filter",
+        filter,
+    }),
+    sort: (sort) => ({
+        type: "Sort",
+        sort,
+    }),
+    limit: (limit) => ({
+        type: "Limit",
+        limit,
+    }),
+    skip: (skip) => ({
+        type: "Skip",
+        skip,
+    }),
+    httpRequest: (url, method = "GET", headers, body) => ({
+        type: "HttpRequest",
+        url,
+        method,
+        headers,
+        body,
+    }),
+    vectorSearch: (collection, query_vector, limit, threshold) => ({
+        type: "VectorSearch",
+        collection,
+        query_vector,
+        limit,
+        threshold,
+    }),
+    textSearch: (collection, query_text, options) => ({
+        type: "TextSearch",
+        collection,
+        query_text,
+        fields: options?.fields,
+        limit: options?.limit,
+        fuzzy: options?.fuzzy,
+    }),
+    hybridSearch: (collection, query_text, query_vector, limit) => ({
+        type: "HybridSearch",
+        collection,
+        query_text,
+        query_vector,
+        limit,
+    }),
+    chat: (messages, model, temperature, max_tokens) => ({
+        type: "Chat",
+        messages,
+        model,
+        temperature,
+        max_tokens,
+    }),
+    embed: (input_field, output_field, model) => ({
+        type: "Embed",
+        input_field,
+        output_field,
+        model,
+    }),
+};

package/dist/index.d.ts CHANGED Viewed

@@ -3,7 +3,9 @@ export { QueryBuilder, SortOrder } from "./query-builder";
 export { SearchQueryBuilder } from "./search";
 export { SchemaBuilder, FieldTypeSchemaBuilder, VectorIndexAlgorithm, DistanceMetric, } from "./schema";
 export { JoinBuilder } from "./join";
+export { Stage, ChatMessage } from "./functions";
 export type { SearchQuery, SearchResult, SearchResponse } from "./search";
 export type { Schema, FieldTypeSchema, IndexConfig, CollectionMetadata, } from "./schema";
 export type { JoinConfig } from "./join";
+export type { Script, ParameterDefinition, FunctionStageConfig, GroupFunctionConfig, SortFieldConfig, FunctionResult, FunctionStats, StageStats, } from "./functions";
 export type { Record, Query, BatchOperationResult, ClientConfig, RateLimitInfo, CollectionConfig, ChatRequest, CreateChatSessionRequest, ChatMessageRequest, TokenUsage, ChatResponse, ChatSession, ChatSessionResponse, ListSessionsQuery, ListSessionsResponse, GetMessagesQuery, GetMessagesResponse, UpdateSessionRequest, MergeSessionsRequest, } from "./client";

package/dist/index.js CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JoinBuilder = exports.DistanceMetric = exports.VectorIndexAlgorithm = exports.FieldTypeSchemaBuilder = exports.SchemaBuilder = exports.SearchQueryBuilder = exports.SortOrder = exports.QueryBuilder = exports.RateLimitError = exports.MergeStrategy = exports.SerializationFormat = exports.WebSocketClient = exports.EkoDBClient = void 0;
+exports.ChatMessage = exports.Stage = exports.JoinBuilder = exports.DistanceMetric = exports.VectorIndexAlgorithm = exports.FieldTypeSchemaBuilder = exports.SchemaBuilder = exports.SearchQueryBuilder = exports.SortOrder = exports.QueryBuilder = exports.RateLimitError = exports.MergeStrategy = exports.SerializationFormat = exports.WebSocketClient = exports.EkoDBClient = void 0;
 var client_1 = require("./client");
 Object.defineProperty(exports, "EkoDBClient", { enumerable: true, get: function () { return client_1.EkoDBClient; } });
 Object.defineProperty(exports, "WebSocketClient", { enumerable: true, get: function () { return client_1.WebSocketClient; } });
@@ -19,3 +19,6 @@ Object.defineProperty(exports, "VectorIndexAlgorithm", { enumerable: true, get:
 Object.defineProperty(exports, "DistanceMetric", { enumerable: true, get: function () { return schema_1.DistanceMetric; } });
 var join_1 = require("./join");
 Object.defineProperty(exports, "JoinBuilder", { enumerable: true, get: function () { return join_1.JoinBuilder; } });
+var functions_1 = require("./functions");
+Object.defineProperty(exports, "Stage", { enumerable: true, get: function () { return functions_1.Stage; } });
+Object.defineProperty(exports, "ChatMessage", { enumerable: true, get: function () { return functions_1.ChatMessage; } });

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@ekodb/ekodb-client",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Official TypeScript/JavaScript client for ekoDB",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/client.ts CHANGED Viewed

@@ -6,6 +6,7 @@ import { encode, decode } from "@msgpack/msgpack";
 import { QueryBuilder, Query as QueryBuilderQuery } from "./query-builder";
 import { SearchQuery, SearchQueryBuilder, SearchResponse } from "./search";
 import { Schema, SchemaBuilder, CollectionMetadata } from "./schema";
+import { Script, FunctionResult } from "./functions";
 export interface Record {
   [key: string]: any;
@@ -954,6 +955,65 @@ export class EkoDBClient {
     );
   }
+  // ========================================================================
+  // SCRIPTS API
+  // ========================================================================
+  /**
+   * Save a new script definition
+   */
+  async saveScript(script: Script): Promise<string> {
+    const result = await this.makeRequest<{ id: string }>(
+      "POST",
+      "/api/functions",
+      script,
+    );
+    return result.id;
+  }
+  /**
+   * Get a script by ID
+   */
+  async getScript(id: string): Promise<Script> {
+    return this.makeRequest<Script>("GET", `/api/functions/${id}`);
+  }
+  /**
+   * List all scripts, optionally filtered by tags
+   */
+  async listScripts(tags?: string[]): Promise<Script[]> {
+    const params = tags ? `?tags=${tags.join(",")}` : "";
+    return this.makeRequest<Script[]>("GET", `/api/functions${params}`);
+  }
+  /**
+   * Update an existing script by ID
+   */
+  async updateScript(id: string, script: Script): Promise<void> {
+    await this.makeRequest<void>("PUT", `/api/functions/${id}`, script);
+  }
+  /**
+   * Delete a script by ID
+   */
+  async deleteScript(id: string): Promise<void> {
+    await this.makeRequest<void>("DELETE", `/api/functions/${id}`);
+  }
+  /**
+   * Call a saved script by ID or label
+   */
+  async callScript(
+    idOrLabel: string,
+    params?: { [key: string]: any },
+  ): Promise<FunctionResult> {
+    return this.makeRequest<FunctionResult>(
+      "POST",
+      `/api/functions/${idOrLabel}`,
+      params || {},
+    );
+  }
   /**
    * Create a WebSocket client
    */

package/src/functions.ts ADDED Viewed

@@ -0,0 +1,420 @@
+/**
+ * Scripts API for ekoDB TypeScript client
+ */
+export interface Script {
+  label: string;
+  name: string;
+  description?: string;
+  version: string;
+  parameters: { [key: string]: ParameterDefinition };
+  functions: FunctionStageConfig[];
+  tags: string[];
+  created_at?: string;
+  updated_at?: string;
+}
+export interface ParameterDefinition {
+  required: boolean;
+  default?: any;
+  description?: string;
+  param_type?: string;
+}
+// ParameterValue removed - use plain values instead
+export type FunctionStageConfig =
+  | { type: "FindAll"; collection: string }
+  | {
+      type: "Query";
+      collection: string;
+      filter?: Record<string, any>;
+      sort?: SortFieldConfig[];
+      limit?: number;
+      skip?: number;
+    }
+  | { type: "Project"; fields: string[]; exclude: boolean }
+  | {
+      type: "Group";
+      by_fields: string[];
+      functions: GroupFunctionConfig[];
+    }
+  | { type: "Count"; output_field: string }
+  | { type: "Filter"; filter: Record<string, any> }
+  | { type: "Sort"; sort: SortFieldConfig[] }
+  | { type: "Limit"; limit: number }
+  | { type: "Skip"; skip: number }
+  | {
+      type: "Insert";
+      collection: string;
+      record: Record<string, any>;
+      bypass_ripple?: boolean;
+      ttl?: number;
+    }
+  | {
+      type: "Update";
+      collection: string;
+      filter: Record<string, any>;
+      updates: Record<string, any>;
+      bypass_ripple?: boolean;
+      ttl?: number;
+    }
+  | {
+      type: "UpdateById";
+      collection: string;
+      record_id: string;
+      updates: Record<string, any>;
+      bypass_ripple?: boolean;
+      ttl?: number;
+    }
+  | {
+      type: "Delete";
+      collection: string;
+      filter: Record<string, any>;
+      bypass_ripple?: boolean;
+    }
+  | {
+      type: "DeleteById";
+      collection: string;
+      record_id: string;
+      bypass_ripple?: boolean;
+    }
+  | {
+      type: "BatchInsert";
+      collection: string;
+      records: Record<string, any>[];
+      bypass_ripple?: boolean;
+    }
+  | {
+      type: "BatchDelete";
+      collection: string;
+      record_ids: string[];
+      bypass_ripple?: boolean;
+    }
+  | {
+      type: "HttpRequest";
+      url: string;
+      method?: string;
+      headers?: Record<string, string>;
+      body?: any;
+    }
+  | {
+      type: "VectorSearch";
+      collection: string;
+      query_vector: number[];
+      limit?: number;
+      threshold?: number;
+    }
+  | {
+      type: "TextSearch";
+      collection: string;
+      query_text: string;
+      fields?: string[];
+      limit?: number;
+      fuzzy?: boolean;
+    }
+  | {
+      type: "HybridSearch";
+      collection: string;
+      query_text: string;
+      query_vector?: number[];
+      limit?: number;
+    }
+  | {
+      type: "Chat";
+      messages: ChatMessage[];
+      model?: string;
+      temperature?: number;
+      max_tokens?: number;
+    }
+  | {
+      type: "Embed";
+      input_field: string;
+      output_field: string;
+      model?: string;
+    };
+export interface ChatMessage {
+  role: string;
+  content: string;
+}
+export const ChatMessage = {
+  system: (content: string): ChatMessage => ({
+    role: "system",
+    content: content,
+  }),
+  user: (content: string): ChatMessage => ({
+    role: "user",
+    content: content,
+  }),
+  assistant: (content: string): ChatMessage => ({
+    role: "assistant",
+    content: content,
+  }),
+};
+export interface GroupFunctionConfig {
+  output_field: string;
+  operation:
+    | "Sum"
+    | "Average"
+    | "Count"
+    | "Min"
+    | "Max"
+    | "First"
+    | "Last"
+    | "Push";
+  input_field?: string;
+}
+export interface SortFieldConfig {
+  field: string;
+  ascending: boolean;
+}
+export interface FunctionResult {
+  records: Record<string, any>[];
+  stats: FunctionStats;
+}
+export interface FunctionStats {
+  input_count: number;
+  output_count: number;
+  execution_time_ms: number;
+  stages_executed: number;
+  stage_stats: StageStats[];
+}
+export interface StageStats {
+  stage: string;
+  input_count: number;
+  output_count: number;
+  execution_time_ms: number;
+}
+// Stage builder functions
+export const Stage = {
+  findAll: (collection: string): FunctionStageConfig => ({
+    type: "FindAll",
+    collection,
+  }),
+  query: (
+    collection: string,
+    filter?: Record<string, any>,
+    sort?: SortFieldConfig[],
+    limit?: number,
+    skip?: number,
+  ): FunctionStageConfig => ({
+    type: "Query",
+    collection,
+    filter,
+    sort,
+    limit,
+    skip,
+  }),
+  project: (fields: string[], exclude = false): FunctionStageConfig => ({
+    type: "Project",
+    fields,
+    exclude,
+  }),
+  group: (
+    by_fields: string[],
+    functions: GroupFunctionConfig[],
+  ): FunctionStageConfig => ({
+    type: "Group",
+    by_fields,
+    functions,
+  }),
+  count: (output_field = "count"): FunctionStageConfig => ({
+    type: "Count",
+    output_field,
+  }),
+  insert: (
+    collection: string,
+    record: Record<string, any>,
+    bypassRipple = false,
+    ttl?: number,
+  ): FunctionStageConfig => ({
+    type: "Insert",
+    collection,
+    record,
+    bypass_ripple: bypassRipple,
+    ttl,
+  }),
+  update: (
+    collection: string,
+    filter: Record<string, any>,
+    updates: Record<string, any>,
+    bypassRipple = false,
+    ttl?: number,
+  ): FunctionStageConfig => ({
+    type: "Update",
+    collection,
+    filter,
+    updates,
+    bypass_ripple: bypassRipple,
+    ttl,
+  }),
+  updateById: (
+    collection: string,
+    record_id: string,
+    updates: Record<string, any>,
+    bypassRipple = false,
+    ttl?: number,
+  ): FunctionStageConfig => ({
+    type: "UpdateById",
+    collection,
+    record_id,
+    updates,
+    bypass_ripple: bypassRipple,
+    ttl,
+  }),
+  delete: (
+    collection: string,
+    filter: Record<string, any>,
+    bypassRipple = false,
+  ): FunctionStageConfig => ({
+    type: "Delete",
+    collection,
+    filter,
+    bypass_ripple: bypassRipple,
+  }),
+  deleteById: (
+    collection: string,
+    record_id: string,
+    bypassRipple = false,
+  ): FunctionStageConfig => ({
+    type: "DeleteById",
+    collection,
+    record_id,
+    bypass_ripple: bypassRipple,
+  }),
+  batchInsert: (
+    collection: string,
+    records: Record<string, any>[],
+    bypassRipple = false,
+  ): FunctionStageConfig => ({
+    type: "BatchInsert",
+    collection,
+    records,
+    bypass_ripple: bypassRipple,
+  }),
+  batchDelete: (
+    collection: string,
+    record_ids: string[],
+    bypassRipple = false,
+  ): FunctionStageConfig => ({
+    type: "BatchDelete",
+    collection,
+    record_ids,
+    bypass_ripple: bypassRipple,
+  }),
+  filter: (filter: Record<string, any>): FunctionStageConfig => ({
+    type: "Filter",
+    filter,
+  }),
+  sort: (sort: SortFieldConfig[]): FunctionStageConfig => ({
+    type: "Sort",
+    sort,
+  }),
+  limit: (limit: number): FunctionStageConfig => ({
+    type: "Limit",
+    limit,
+  }),
+  skip: (skip: number): FunctionStageConfig => ({
+    type: "Skip",
+    skip,
+  }),
+  httpRequest: (
+    url: string,
+    method = "GET",
+    headers?: Record<string, string>,
+    body?: any,
+  ): FunctionStageConfig => ({
+    type: "HttpRequest",
+    url,
+    method,
+    headers,
+    body,
+  }),
+  vectorSearch: (
+    collection: string,
+    query_vector: number[],
+    limit?: number,
+    threshold?: number,
+  ): FunctionStageConfig => ({
+    type: "VectorSearch",
+    collection,
+    query_vector,
+    limit,
+    threshold,
+  }),
+  textSearch: (
+    collection: string,
+    query_text: string,
+    options?: { fields?: string[]; limit?: number; fuzzy?: boolean },
+  ): FunctionStageConfig => ({
+    type: "TextSearch",
+    collection,
+    query_text,
+    fields: options?.fields,
+    limit: options?.limit,
+    fuzzy: options?.fuzzy,
+  }),
+  hybridSearch: (
+    collection: string,
+    query_text: string,
+    query_vector?: number[],
+    limit?: number,
+  ): FunctionStageConfig => ({
+    type: "HybridSearch",
+    collection,
+    query_text,
+    query_vector,
+    limit,
+  }),
+  chat: (
+    messages: ChatMessage[],
+    model?: string,
+    temperature?: number,
+    max_tokens?: number,
+  ): FunctionStageConfig => ({
+    type: "Chat",
+    messages,
+    model,
+    temperature,
+    max_tokens,
+  }),
+  embed: (
+    input_field: string,
+    output_field: string,
+    model?: string,
+  ): FunctionStageConfig => ({
+    type: "Embed",
+    input_field,
+    output_field,
+    model,
+  }),
+};

package/src/index.ts CHANGED Viewed

@@ -14,6 +14,7 @@ export {
   DistanceMetric,
 } from "./schema";
 export { JoinBuilder } from "./join";
+export { Stage, ChatMessage } from "./functions";
 export type { SearchQuery, SearchResult, SearchResponse } from "./search";
 export type {
   Schema,
@@ -22,6 +23,16 @@ export type {
   CollectionMetadata,
 } from "./schema";
 export type { JoinConfig } from "./join";
+export type {
+  Script,
+  ParameterDefinition,
+  FunctionStageConfig,
+  GroupFunctionConfig,
+  SortFieldConfig,
+  FunctionResult,
+  FunctionStats,
+  StageStats,
+} from "./functions";
 export type {
   Record,
   Query,