@ekodb/ekodb-client 0.25.0 → 0.26.1

package/src/functions.test.ts

@@ -722,4 +722,58 @@ describe("Crypto and concurrency stages", () => {
       expect(wire.type).toBe(s.type);
     }
   });
+
+  describe("filter/sort/limit/skip emit Query stages", () => {
+    // These four used to emit { type: "Filter" | "Sort" | "Limit" | "Skip" },
+    // none of which the server has a variant for. Because a function's stage
+    // array deserializes as a unit, a single one of them rejected the ENTIRE
+    // function. They are shorthands for a Query carrying that one field.
+
+    it("filter emits a Query with only the filter set", () => {
+      const wire = JSON.parse(
+        JSON.stringify(Stage.filter("users", { status: "active" })),
+      );
+      expect(wire.type).toBe("Query");
+      expect(wire.collection).toBe("users");
+      expect(wire.filter).toEqual({ status: "active" });
+    });
+
+    it("sort emits a Query with only the sort set", () => {
+      const wire = JSON.parse(
+        JSON.stringify(
+          Stage.sort("users", [{ field: "created_at", ascending: false }]),
+        ),
+      );
+      expect(wire.type).toBe("Query");
+      expect(wire.collection).toBe("users");
+      expect(wire.sort).toEqual([{ field: "created_at", ascending: false }]);
+    });
+
+    it("limit emits a Query with only the limit set", () => {
+      const wire = JSON.parse(JSON.stringify(Stage.limit("users", 10)));
+      expect(wire.type).toBe("Query");
+      expect(wire.collection).toBe("users");
+      expect(wire.limit).toBe(10);
+    });
+
+    it("skip emits a Query with only the skip set", () => {
+      const wire = JSON.parse(JSON.stringify(Stage.skip("users", 5)));
+      expect(wire.type).toBe("Query");
+      expect(wire.collection).toBe("users");
+      expect(wire.skip).toBe(5);
+    });
+
+    it("never emits a stage type the server has no variant for", () => {
+      const wire = [
+        Stage.filter("users", {}),
+        Stage.sort("users", []),
+        Stage.limit("users", 1),
+        Stage.skip("users", 1),
+      ].map((s) => JSON.parse(JSON.stringify(s)).type);
+      expect(wire).not.toContain("Filter");
+      expect(wire).not.toContain("Sort");
+      expect(wire).not.toContain("Limit");
+      expect(wire).not.toContain("Skip");
+    });
+  });
 });

package/src/functions.ts

@@ -55,10 +55,6 @@ export type FunctionStageConfig =
       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;
@@ -742,23 +738,45 @@ export const Stage = {
     bypass_ripple: bypassRipple,
   }),
 
-  filter: (filter: Record<string, any>): FunctionStageConfig => ({
-    type: "Filter",
+  /**
+   * Filter a collection.
+   *
+   * Shorthand for a `Query` stage carrying only `filter`. There is no separate
+   * `Filter` stage server-side — filtering, sorting, limiting and skipping are
+   * all fields on `Query`. This previously emitted `{ type: "Filter" }`, which
+   * the server has no variant for; because a function's stage array
+   * deserializes as a unit, one such stage rejected the ENTIRE function.
+   *
+   * Use {@link Stage.query} when you need more than one of these at once — it
+   * takes them together and produces a single stage.
+   */
+  filter: (
+    collection: string,
+    filter: Record<string, any>,
+  ): FunctionStageConfig => ({
+    type: "Query",
+    collection,
     filter,
   }),
 
-  sort: (sort: SortFieldConfig[]): FunctionStageConfig => ({
-    type: "Sort",
+  /** Sort a collection. Shorthand for a `Query` carrying only `sort`. */
+  sort: (collection: string, sort: SortFieldConfig[]): FunctionStageConfig => ({
+    type: "Query",
+    collection,
     sort,
   }),
 
-  limit: (limit: number): FunctionStageConfig => ({
-    type: "Limit",
+  /** Limit a collection read. Shorthand for a `Query` carrying only `limit`. */
+  limit: (collection: string, limit: number): FunctionStageConfig => ({
+    type: "Query",
+    collection,
     limit,
   }),
 
-  skip: (skip: number): FunctionStageConfig => ({
-    type: "Skip",
+  /** Skip rows of a collection read. Shorthand for a `Query` with only `skip`. */
+  skip: (collection: string, skip: number): FunctionStageConfig => ({
+    type: "Query",
+    collection,
     skip,
   }),
 

package/src/index.ts

@@ -88,6 +88,8 @@ export type {
   UpdateSessionRequest,
   MergeSessionsRequest,
   ChatModels,
+  ChatProviderState,
+  ChatProviderStatus,
   CompactChatRequest,
   CompactChatResponse,
   EmbedRequest,

package/src/search.ts

@@ -90,7 +90,7 @@ export interface SearchResponse {
   /** Total number of results found */
   total: number;
   /** Query execution time in milliseconds */
-  took_ms?: number;
+  execution_time_ms?: number;
 }
 
 /**

package/src/websocket.test.ts

@@ -432,6 +432,96 @@ describe("WebSocketClient", () => {
       client.close();
     });
 
+    // The WebSocket route carries the provider-failure classification like
+    // the SSE route does, in the event's camelCase shape.
+    it("carries the provider failure classification on a chat stream error", async () => {
+      const client = new WebSocketClient(
+        `ws://localhost:${port}/api/ws`,
+        "test-token",
+      );
+
+      const streamPromise = client.chatSend("chat-4", "test");
+
+      await new Promise((r) => wss.once("connection", r));
+      const ws = getLastConnection();
+      await waitForMessage(ws);
+
+      const stream = await streamPromise;
+      const events: any[] = [];
+      stream.on("event", (e) => events.push(e));
+
+      ws.send(
+        JSON.stringify({
+          type: "ChatStreamError",
+          payload: {
+            chat_id: "chat-4",
+            error: "OpenAI API error 429 Too Many Requests",
+            error_kind: "provider_rate_limited",
+            provider: "openai",
+            provider_status: 429,
+            retry_after_secs: 7,
+          },
+        }),
+      );
+
+      await new Promise((r) => stream.on("close", r));
+      expect(events).toEqual([
+        {
+          type: "error",
+          error: "OpenAI API error 429 Too Many Requests",
+          errorKind: "provider_rate_limited",
+          provider: "openai",
+          providerStatus: 429,
+          retryAfterSecs: 7,
+        },
+      ]);
+
+      client.close();
+    });
+
+    // A structured `error` value is still an error, with string text — the
+    // WebSocket route guards the shape exactly as the SSE route does.
+    it("keeps the error text a string when the payload's error is an object", async () => {
+      const client = new WebSocketClient(
+        `ws://localhost:${port}/api/ws`,
+        "test-token",
+      );
+
+      const streamPromise = client.chatSend("chat-5", "test");
+
+      await new Promise((r) => wss.once("connection", r));
+      const ws = getLastConnection();
+      await waitForMessage(ws);
+
+      const stream = await streamPromise;
+      const events: any[] = [];
+      stream.on("event", (e) => events.push(e));
+
+      ws.send(
+        JSON.stringify({
+          type: "ChatStreamError",
+          payload: {
+            chat_id: "chat-5",
+            error: { code: "upstream_down", status: 503 },
+            error_kind: "provider_unavailable",
+            provider: "gemini",
+          },
+        }),
+      );
+
+      await new Promise((r) => stream.on("close", r));
+      expect(events).toEqual([
+        {
+          type: "error",
+          error: "Unknown error",
+          errorKind: "provider_unavailable",
+          provider: "gemini",
+        },
+      ]);
+
+      client.close();
+    });
+
     it("sends options with ChatSend", async () => {
       const client = new WebSocketClient(
         `ws://localhost:${port}/api/ws`,

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     "target": "ES2020",
-    "module": "commonjs",
+    "module": "nodenext",
     "lib": ["ES2020"],
     "declaration": true,
     "outDir": "./dist",
@@ -10,7 +10,7 @@
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
-    "moduleResolution": "node",
+    "moduleResolution": "nodenext",
     "resolveJsonModule": true,
     "noUnusedLocals": true,
     "noUnusedParameters": true