@ekodb/ekodb-client 0.19.0 → 0.20.0

package/dist/client.test.js

@@ -1816,6 +1816,69 @@ function mockErrorResponse(status, message) {
         (0, vitest_1.expect)(dataCall[1]?.method).toBe("POST");
         (0, vitest_1.expect)(dataCall[1]?.headers?.Accept).toBe("text/event-stream");
     });
+    (0, vitest_1.it)("sends a resolved Bearer token, not a Promise (regression #124)", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            text: async () => 'data: {"token":"ok"}\n',
+            headers: new Headers({ "content-type": "text/event-stream" }),
+        });
+        client.chatMessageStream("chat_789", { message: "Test" });
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        const calls = global.fetch.mock.calls;
+        const auth = calls[1][1]?.headers
+            ?.Authorization;
+        (0, vitest_1.expect)(auth).toBe("Bearer test-jwt-token");
+        (0, vitest_1.expect)(auth).not.toContain("[object Promise]");
+    });
+    (0, vitest_1.it)("streams SSE events incrementally from response.body, reassembling split lines (regression #125)", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        // A data line is deliberately split across chunk boundaries to exercise the
+        // incremental buffer (the old code buffered the whole body via text()).
+        const enc = new TextEncoder();
+        const chunks = [
+            'data: {"token":"He"}\nda',
+            'ta: {"token":"llo"}\n',
+            'data: {"content":"Hello","message_id":"m1","execution_time_ms":1}\n',
+        ];
+        const body = new ReadableStream({
+            start(controller) {
+                for (const c of chunks)
+                    controller.enqueue(enc.encode(c));
+                controller.close();
+            },
+        });
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            body,
+            text: async () => chunks.join(""),
+            headers: new Headers({ "content-type": "text/event-stream" }),
+        });
+        const events = [];
+        const stream = client.chatMessageStream("chat_s", { message: "Hi" });
+        stream.on("event", (evt) => events.push(evt));
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        (0, vitest_1.expect)(events.filter((e) => e.type === "chunk").map((e) => e.content)).toEqual(["He", "llo"]);
+        (0, vitest_1.expect)(events[events.length - 1].type).toBe("end");
+        (0, vitest_1.expect)(events[events.length - 1].messageId).toBe("m1");
+    });
+});
+(0, vitest_1.describe)("EkoDBClient retry backoff", () => {
+    (0, vitest_1.it)("backoffSeconds grows, caps at 5s, and jitters within [d/2, d] (#126)", () => {
+        const client = createTestClient();
+        for (let attempt = 0; attempt < 10; attempt++) {
+            const d = Math.min(0.2 * 2 ** attempt, 5);
+            for (let i = 0; i < 50; i++) {
+                const v = client.backoffSeconds(attempt);
+                (0, vitest_1.expect)(v).toBeGreaterThanOrEqual(d / 2);
+                (0, vitest_1.expect)(v).toBeLessThanOrEqual(d);
+            }
+        }
+    });
 });
 // ============================================================================
 // Schedule CRUD Tests
@@ -2259,3 +2322,57 @@ function mockErrorResponse(status, message) {
         (0, vitest_1.expect)(errors[0]).toContain("401");
     });
 });
+(0, vitest_1.describe)("baseURL normalization", () => {
+    (0, vitest_1.it)("strips a trailing slash so request URLs have no double slash", async () => {
+        mockTokenResponse();
+        const client = new client_1.EkoDBClient({
+            baseURL: "http://localhost:8080/",
+            apiKey: "test-api-key",
+            format: client_1.SerializationFormat.Json,
+            shouldRetry: false,
+        });
+        await client.init();
+        const url = mockFetch.mock.calls[0][0];
+        (0, vitest_1.expect)(url).toBe("http://localhost:8080/api/auth/token");
+        (0, vitest_1.expect)(url).not.toContain("//api");
+    });
+    (0, vitest_1.it)("leaves a URL without a trailing slash unchanged", async () => {
+        mockTokenResponse();
+        const client = new client_1.EkoDBClient({
+            baseURL: "http://localhost:8080",
+            apiKey: "test-api-key",
+            format: client_1.SerializationFormat.Json,
+            shouldRetry: false,
+        });
+        await client.init();
+        const url = mockFetch.mock.calls[0][0];
+        (0, vitest_1.expect)(url).toBe("http://localhost:8080/api/auth/token");
+    });
+});
+(0, vitest_1.describe)("extractRecordId", () => {
+    (0, vitest_1.it)("returns a plain string id", () => {
+        (0, vitest_1.expect)((0, client_1.extractRecordId)({ id: "abc" })).toBe("abc");
+    });
+    (0, vitest_1.it)("unwraps a genuine typed wrapper id", () => {
+        (0, vitest_1.expect)((0, client_1.extractRecordId)({ id: { type: "String", value: "abc" } })).toBe("abc");
+    });
+    (0, vitest_1.it)("stringifies a wrapped numeric id", () => {
+        (0, vitest_1.expect)((0, client_1.extractRecordId)({ id: { type: "Integer", value: 123 } })).toBe("123");
+    });
+    (0, vitest_1.it)("does not treat a user object with a value key (no type) as the id", () => {
+        // Regression for #134: { value: 1, currency: "USD" } is a user object,
+        // not a typed wrapper, so it must not be unwrapped into the id.
+        (0, vitest_1.expect)((0, client_1.extractRecordId)({ id: { value: 1, currency: "USD" } })).toBeUndefined();
+    });
+    (0, vitest_1.it)("prefers an alias candidate over id", () => {
+        (0, vitest_1.expect)((0, client_1.extractRecordId)({ users_id: "u1", id: "x" }, ["users_id"])).toBe("u1");
+    });
+    (0, vitest_1.it)("ignores a non-wrapper alias object and falls back to id", () => {
+        (0, vitest_1.expect)((0, client_1.extractRecordId)({ users_id: { value: 7, label: "lvl" }, id: "real" }, [
+            "users_id",
+        ])).toBe("real");
+    });
+    (0, vitest_1.it)("falls back to _id", () => {
+        (0, vitest_1.expect)((0, client_1.extractRecordId)({ _id: "underscore" })).toBe("underscore");
+    });
+});

package/dist/functions.test.d.ts

@@ -3,7 +3,6 @@
  *
  * These tests cover the pure-data construction helpers and the structural
  * parameter placeholder. They don't hit a running ekoDB — server-side
- * behavior is covered by the Rust integration tests in
- * `ekodb/ekodb_server/tests/function_parameters_tests.rs`.
+ * behavior is covered by the server-side integration tests.
  */
 export {};

package/dist/functions.test.js

@@ -4,8 +4,7 @@
  *
  * These tests cover the pure-data construction helpers and the structural
  * parameter placeholder. They don't hit a running ekoDB — server-side
- * behavior is covered by the Rust integration tests in
- * `ekodb/ekodb_server/tests/function_parameters_tests.rs`.
+ * behavior is covered by the server-side integration tests.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const vitest_1 = require("vitest");

package/dist/query-builder.d.ts

@@ -86,10 +86,6 @@ export declare class QueryBuilder {
      * Add an ends-with filter
      */
     endsWith(field: string, suffix: string): this;
-    /**
-     * Add a regex filter
-     */
-    regex(field: string, pattern: string): this;
     /**
      * Combine filters with AND logic
      */

package/dist/query-builder.js

@@ -189,20 +189,8 @@ class QueryBuilder {
         });
         return this;
     }
-    /**
-     * Add a regex filter
-     */
-    regex(field, pattern) {
-        this.filters.push({
-            type: "Condition",
-            content: {
-                field,
-                operator: "Regex",
-                value: pattern,
-            },
-        });
-        return this;
-    }
+    // Note: regex filtering is pending server-side support. The server has no
+    // Regex filter operator; use contains/startsWith/endsWith instead.
     // ========================================================================
     // Logical Operators
     // ========================================================================

package/dist/query-builder.test.js

@@ -95,10 +95,6 @@ const query_builder_1 = require("./query-builder");
         const query = new query_builder_1.QueryBuilder().endsWith("filename", ".pdf").build();
         (0, vitest_1.expect)(query.filter.content.operator).toBe("EndsWith");
     });
-    (0, vitest_1.it)("builds regex filter", () => {
-        const query = new query_builder_1.QueryBuilder().regex("phone", "^\\+1").build();
-        (0, vitest_1.expect)(query.filter.content.operator).toBe("Regex");
-    });
 });
 // ============================================================================
 // Logical Operators Tests
@@ -368,7 +364,6 @@ const query_builder_1 = require("./query-builder");
         (0, vitest_1.expect)(qb.contains("i", "j")).toBe(qb);
         (0, vitest_1.expect)(qb.startsWith("k", "l")).toBe(qb);
         (0, vitest_1.expect)(qb.endsWith("m", "n")).toBe(qb);
-        (0, vitest_1.expect)(qb.regex("o", "p")).toBe(qb);
         (0, vitest_1.expect)(qb.sortAsc("q")).toBe(qb);
         (0, vitest_1.expect)(qb.sortDesc("r")).toBe(qb);
         (0, vitest_1.expect)(qb.limit(1)).toBe(qb);

package/dist/utils.js

@@ -33,7 +33,13 @@ exports.extractRecord = extractRecord;
  * ```
  */
 function getValue(field) {
-    if (field && typeof field === "object" && "value" in field) {
+    // Only unwrap a genuine typed wrapper — one carrying BOTH a "type"
+    // discriminator and a "value". A user object that merely has a "value" key
+    // (e.g. { value: 1, currency: "USD" }) must pass through untouched.
+    if (field &&
+        typeof field === "object" &&
+        "type" in field &&
+        "value" in field) {
         return field.value;
     }
     return field;

package/dist/utils.test.js

@@ -29,6 +29,10 @@ const utils_1 = require("./utils");
         const field = { type: "Null", value: null };
         (0, vitest_1.expect)((0, utils_1.getValue)(field)).toBeNull();
     });
+    (0, vitest_1.it)("passes through a user object that has a value key but no type (regression #134)", () => {
+        const field = { value: 1, currency: "USD" };
+        (0, vitest_1.expect)((0, utils_1.getValue)(field)).toEqual(field);
+    });
     (0, vitest_1.it)("returns plain string as-is", () => {
         (0, vitest_1.expect)((0, utils_1.getValue)("plain string")).toBe("plain string");
     });

package/dist/websocket.test.js

@@ -91,6 +91,31 @@ function waitForMessage(ws) {
         });
     });
     // --------------------------------------------------------------------------
+    // URL normalization
+    // --------------------------------------------------------------------------
+    (0, vitest_1.describe)("URL normalization", () => {
+        function captureRequestPath() {
+            return new Promise((resolve) => {
+                wss.once("connection", (_ws, req) => resolve(req.url ?? ""));
+            });
+        }
+        (0, vitest_1.it)("appends /api/ws without a double slash when the base URL has a trailing slash", async () => {
+            const pathPromise = captureRequestPath();
+            const client = new client_1.WebSocketClient(`ws://localhost:${port}/`, "test-token");
+            // Trigger a connect; we only assert the path the server receives.
+            client.findAll("users").catch(() => { });
+            (0, vitest_1.expect)(await pathPromise).toBe("/api/ws");
+            client.close();
+        });
+        (0, vitest_1.it)("does not duplicate /api/ws when the URL already ends with it plus a trailing slash", async () => {
+            const pathPromise = captureRequestPath();
+            const client = new client_1.WebSocketClient(`ws://localhost:${port}/api/ws/`, "test-token");
+            client.findAll("users").catch(() => { });
+            (0, vitest_1.expect)(await pathPromise).toBe("/api/ws");
+            client.close();
+        });
+    });
+    // --------------------------------------------------------------------------
     // subscribe
     // --------------------------------------------------------------------------
     (0, vitest_1.describe)("subscribe", () => {
@@ -493,4 +518,159 @@ function waitForMessage(ws) {
             client.close();
         });
     });
+    // --------------------------------------------------------------------------
+    // Per-request timeout
+    // --------------------------------------------------------------------------
+    (0, vitest_1.describe)("per-request timeout", () => {
+        (0, vitest_1.it)("rejects a pending request when no response arrives", async () => {
+            const client = new client_1.WebSocketClient(`ws://localhost:${port}/api/ws`, "test-token", { requestTimeoutMs: 50, autoReconnect: false });
+            const resultPromise = client.findAll("users");
+            await new Promise((r) => wss.once("connection", r));
+            const ws = getLastConnection();
+            await waitForMessage(ws); // receive FindAll but never respond
+            await (0, vitest_1.expect)(resultPromise).rejects.toThrow(/timed out after 50ms/);
+            client.close();
+        });
+        (0, vitest_1.it)("does not time out when a response arrives in time", async () => {
+            const client = new client_1.WebSocketClient(`ws://localhost:${port}/api/ws`, "test-token", { requestTimeoutMs: 500, autoReconnect: false });
+            const resultPromise = client.findAll("users");
+            await new Promise((r) => wss.once("connection", r));
+            const ws = getLastConnection();
+            const msg = await waitForMessage(ws);
+            ws.send(JSON.stringify({
+                type: "Success",
+                payload: { message_id: msg.messageId, data: [{ id: "1" }] },
+            }));
+            await (0, vitest_1.expect)(resultPromise).resolves.toEqual([{ id: "1" }]);
+            client.close();
+        });
+    });
+    // --------------------------------------------------------------------------
+    // Reject pending requests on disconnect
+    // --------------------------------------------------------------------------
+    (0, vitest_1.describe)("disconnect handling", () => {
+        (0, vitest_1.it)("rejects in-flight requests when the socket drops", async () => {
+            const client = new client_1.WebSocketClient(`ws://localhost:${port}/api/ws`, "test-token", { autoReconnect: false });
+            const resultPromise = client.findAll("users");
+            await new Promise((r) => wss.once("connection", r));
+            const ws = getLastConnection();
+            await waitForMessage(ws); // FindAll received, never answered
+            // Server drops the connection.
+            ws.close();
+            await (0, vitest_1.expect)(resultPromise).rejects.toThrow(/connection closed/i);
+            client.close();
+        });
+    });
+    // --------------------------------------------------------------------------
+    // Backoff helper
+    // --------------------------------------------------------------------------
+    (0, vitest_1.describe)("computeBackoff", () => {
+        (0, vitest_1.it)("grows exponentially, stays within jittered bounds, and caps", () => {
+            const client = new client_1.WebSocketClient(`ws://localhost:${port}/api/ws`, "test-token", { reconnectInitialDelayMs: 200, reconnectMaxDelayMs: 5000 });
+            // attempt 0 -> base 200, +/-25% => [150, 250]
+            for (let i = 0; i < 20; i++) {
+                const d0 = client.computeBackoff(0);
+                (0, vitest_1.expect)(d0).toBeGreaterThanOrEqual(150);
+                (0, vitest_1.expect)(d0).toBeLessThanOrEqual(250);
+            }
+            // attempt 3 -> base 1600, +/-25% => [1200, 2000]
+            const d3 = client.computeBackoff(3);
+            (0, vitest_1.expect)(d3).toBeGreaterThanOrEqual(1200);
+            (0, vitest_1.expect)(d3).toBeLessThanOrEqual(2000);
+            // attempt 20 -> capped at 5000, +/-25% => [3750, 6250]
+            const dBig = client.computeBackoff(20);
+            (0, vitest_1.expect)(dBig).toBeGreaterThanOrEqual(3750);
+            (0, vitest_1.expect)(dBig).toBeLessThanOrEqual(6250);
+            client.close();
+        });
+    });
+    // --------------------------------------------------------------------------
+    // Auto-reconnect + re-subscribe + fresh token
+    // --------------------------------------------------------------------------
+    (0, vitest_1.describe)("auto-reconnect", () => {
+        (0, vitest_1.it)("re-subscribes after a socket drop and re-evaluates the token", async () => {
+            // Token provider returns a new token each call so we can assert the
+            // reconnect used a freshly-obtained token (not a stale snapshot).
+            let tokenCalls = 0;
+            const tokenProvider = () => `token-${++tokenCalls}`;
+            const client = new client_1.WebSocketClient(`ws://localhost:${port}/api/ws`, tokenProvider, {
+                autoReconnect: true,
+                reconnectInitialDelayMs: 10,
+                reconnectMaxDelayMs: 30,
+            });
+            // Establish the subscription on the first connection.
+            const streamPromise = client.subscribe("orders");
+            await new Promise((r) => wss.once("connection", r));
+            const ws1 = getLastConnection();
+            const sub1 = await waitForMessage(ws1);
+            (0, vitest_1.expect)(sub1.type).toBe("Subscribe");
+            (0, vitest_1.expect)(sub1.payload.collection).toBe("orders");
+            ws1.send(JSON.stringify({
+                type: "Success",
+                payload: { message_id: sub1.messageId, status: "subscribed" },
+            }));
+            const stream = await streamPromise;
+            (0, vitest_1.expect)(tokenCalls).toBe(1);
+            // Arm the next-connection handler BEFORE dropping so we don't miss it.
+            const nextConn = new Promise((resolve) => {
+                wss.once("connection", (ws) => resolve(ws));
+            });
+            // Simulate a transient drop: server closes the socket.
+            ws1.close();
+            // The client should auto-reconnect (new connection) and re-send Subscribe.
+            const ws2 = await nextConn;
+            const sub2 = await waitForMessage(ws2);
+            (0, vitest_1.expect)(sub2.type).toBe("Subscribe");
+            (0, vitest_1.expect)(sub2.payload.collection).toBe("orders");
+            // Reconnect re-evaluated the token provider.
+            (0, vitest_1.expect)(tokenCalls).toBeGreaterThanOrEqual(2);
+            // Ack the re-subscribe.
+            ws2.send(JSON.stringify({
+                type: "Success",
+                payload: { message_id: sub2.messageId, status: "subscribed" },
+            }));
+            // The SAME stream still delivers mutations over the new socket.
+            const mutationPromise = new Promise((resolve) => {
+                stream.on("mutation", resolve);
+            });
+            ws2.send(JSON.stringify({
+                type: "MutationNotification",
+                payload: {
+                    collection: "orders",
+                    event: "insert",
+                    record_ids: ["order-9"],
+                    timestamp: "2026-06-02T00:00:00Z",
+                },
+            }));
+            const mutation = await mutationPromise;
+            (0, vitest_1.expect)(mutation.recordIds).toEqual(["order-9"]);
+            (0, vitest_1.expect)(stream.closed).toBe(false);
+            client.close();
+        });
+        (0, vitest_1.it)("does not reconnect after an intentional close()", async () => {
+            const client = new client_1.WebSocketClient(`ws://localhost:${port}/api/ws`, "test-token", { autoReconnect: true, reconnectInitialDelayMs: 10 });
+            const streamPromise = client.subscribe("widgets");
+            await new Promise((r) => wss.once("connection", r));
+            const ws = getLastConnection();
+            const sub = await waitForMessage(ws);
+            ws.send(JSON.stringify({
+                type: "Success",
+                payload: { message_id: sub.messageId, status: "subscribed" },
+            }));
+            await streamPromise;
+            const connectionsBefore = serverConnections.length;
+            // Intentional close: must NOT reconnect.
+            client.close();
+            // Give any erroneous reconnect time to land.
+            await new Promise((r) => setTimeout(r, 80));
+            (0, vitest_1.expect)(serverConnections.length).toBe(connectionsBefore);
+        });
+    });
+    (0, vitest_1.describe)("auth token validation", () => {
+        (0, vitest_1.it)("rejects connect when the token provider returns null (no Bearer null)", async () => {
+            const client = new client_1.WebSocketClient(`ws://localhost:${port}/api/ws`, () => null);
+            await (0, vitest_1.expect)(client.findAll("users")).rejects.toThrow(/token is unavailable/i);
+            client.close();
+        });
+    });
 });

package/package.json

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

package/src/client.test.ts

@@ -6,7 +6,7 @@
  */
 
 import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
-import { EkoDBClient, SerializationFormat } from "./client";
+import { EkoDBClient, SerializationFormat, extractRecordId } from "./client";
 
 // Mock fetch globally
 const mockFetch = vi.fn();
@@ -2432,6 +2432,80 @@ describe("EkoDBClient chatMessageStream", () => {
     expect(dataCall[1]?.method).toBe("POST");
     expect(dataCall[1]?.headers?.Accept).toBe("text/event-stream");
   });
+
+  it("sends a resolved Bearer token, not a Promise (regression #124)", async () => {
+    const client = createTestClient();
+    mockTokenResponse();
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      text: async () => 'data: {"token":"ok"}\n',
+      headers: new Headers({ "content-type": "text/event-stream" }),
+    });
+
+    client.chatMessageStream("chat_789", { message: "Test" });
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    const calls = (global.fetch as ReturnType<typeof vi.fn>).mock.calls;
+    const auth = (calls[1][1]?.headers as Record<string, string>)
+      ?.Authorization;
+    expect(auth).toBe("Bearer test-jwt-token");
+    expect(auth).not.toContain("[object Promise]");
+  });
+
+  it("streams SSE events incrementally from response.body, reassembling split lines (regression #125)", async () => {
+    const client = createTestClient();
+    mockTokenResponse();
+
+    // A data line is deliberately split across chunk boundaries to exercise the
+    // incremental buffer (the old code buffered the whole body via text()).
+    const enc = new TextEncoder();
+    const chunks = [
+      'data: {"token":"He"}\nda',
+      'ta: {"token":"llo"}\n',
+      'data: {"content":"Hello","message_id":"m1","execution_time_ms":1}\n',
+    ];
+    const body = new ReadableStream({
+      start(controller) {
+        for (const c of chunks) controller.enqueue(enc.encode(c));
+        controller.close();
+      },
+    });
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      body,
+      text: async () => chunks.join(""),
+      headers: new Headers({ "content-type": "text/event-stream" }),
+    });
+
+    const events: any[] = [];
+    const stream = client.chatMessageStream("chat_s", { message: "Hi" });
+    stream.on("event", (evt: any) => events.push(evt));
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    expect(
+      events.filter((e) => e.type === "chunk").map((e) => e.content),
+    ).toEqual(["He", "llo"]);
+    expect(events[events.length - 1].type).toBe("end");
+    expect(events[events.length - 1].messageId).toBe("m1");
+  });
+});
+
+describe("EkoDBClient retry backoff", () => {
+  it("backoffSeconds grows, caps at 5s, and jitters within [d/2, d] (#126)", () => {
+    const client = createTestClient() as any;
+    for (let attempt = 0; attempt < 10; attempt++) {
+      const d = Math.min(0.2 * 2 ** attempt, 5);
+      for (let i = 0; i < 50; i++) {
+        const v = client.backoffSeconds(attempt);
+        expect(v).toBeGreaterThanOrEqual(d / 2);
+        expect(v).toBeLessThanOrEqual(d);
+      }
+    }
+  });
 });
 
 // ============================================================================
@@ -2959,3 +3033,78 @@ describe("subscribeSSE", () => {
     expect(errors[0]).toContain("401");
   });
 });
+
+describe("baseURL normalization", () => {
+  it("strips a trailing slash so request URLs have no double slash", async () => {
+    mockTokenResponse();
+    const client = new EkoDBClient({
+      baseURL: "http://localhost:8080/",
+      apiKey: "test-api-key",
+      format: SerializationFormat.Json,
+      shouldRetry: false,
+    });
+    await client.init();
+
+    const url = mockFetch.mock.calls[0][0] as string;
+    expect(url).toBe("http://localhost:8080/api/auth/token");
+    expect(url).not.toContain("//api");
+  });
+
+  it("leaves a URL without a trailing slash unchanged", async () => {
+    mockTokenResponse();
+    const client = new EkoDBClient({
+      baseURL: "http://localhost:8080",
+      apiKey: "test-api-key",
+      format: SerializationFormat.Json,
+      shouldRetry: false,
+    });
+    await client.init();
+
+    const url = mockFetch.mock.calls[0][0] as string;
+    expect(url).toBe("http://localhost:8080/api/auth/token");
+  });
+});
+
+describe("extractRecordId", () => {
+  it("returns a plain string id", () => {
+    expect(extractRecordId({ id: "abc" })).toBe("abc");
+  });
+
+  it("unwraps a genuine typed wrapper id", () => {
+    expect(extractRecordId({ id: { type: "String", value: "abc" } })).toBe(
+      "abc",
+    );
+  });
+
+  it("stringifies a wrapped numeric id", () => {
+    expect(extractRecordId({ id: { type: "Integer", value: 123 } })).toBe(
+      "123",
+    );
+  });
+
+  it("does not treat a user object with a value key (no type) as the id", () => {
+    // Regression for #134: { value: 1, currency: "USD" } is a user object,
+    // not a typed wrapper, so it must not be unwrapped into the id.
+    expect(
+      extractRecordId({ id: { value: 1, currency: "USD" } }),
+    ).toBeUndefined();
+  });
+
+  it("prefers an alias candidate over id", () => {
+    expect(extractRecordId({ users_id: "u1", id: "x" }, ["users_id"])).toBe(
+      "u1",
+    );
+  });
+
+  it("ignores a non-wrapper alias object and falls back to id", () => {
+    expect(
+      extractRecordId({ users_id: { value: 7, label: "lvl" }, id: "real" }, [
+        "users_id",
+      ]),
+    ).toBe("real");
+  });
+
+  it("falls back to _id", () => {
+    expect(extractRecordId({ _id: "underscore" })).toBe("underscore");
+  });
+});