@ekodb/ekodb-client 0.18.2 → 0.20.0

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();
@@ -665,6 +665,51 @@ describe("EkoDBClient chat", () => {
 
     await expect(client.deleteChatSession("chat_123")).resolves.not.toThrow();
   });
+
+  it("compacts chat history", async () => {
+    const client = createTestClient();
+
+    mockTokenResponse();
+    mockJsonResponse({
+      folded: 12,
+      kept_recent: 8,
+      summary_chars: 1024,
+      summary_message_id: "msg_summary_001",
+      already_compact: false,
+    });
+
+    const result = await client.compactChat("chat_123", 8);
+
+    expect(result).toHaveProperty("folded", 12);
+    expect(result).toHaveProperty("kept_recent", 8);
+    expect(result).toHaveProperty("summary_message_id", "msg_summary_001");
+    expect(result).toHaveProperty("already_compact", false);
+
+    const [, init] = mockFetch.mock.calls[1];
+    expect(init.method).toBe("POST");
+    expect(JSON.parse(init.body as string)).toEqual({ keep_recent: 8 });
+  });
+
+  it("compacts chat history without keepRecent", async () => {
+    const client = createTestClient();
+
+    mockTokenResponse();
+    mockJsonResponse({
+      folded: 0,
+      kept_recent: 0,
+      summary_chars: 0,
+      summary_message_id: null,
+      already_compact: true,
+    });
+
+    const result = await client.compactChat("chat_123");
+
+    expect(result.already_compact).toBe(true);
+    expect(result.summary_message_id).toBeNull();
+
+    const [, init] = mockFetch.mock.calls[1];
+    expect(JSON.parse(init.body as string)).toEqual({});
+  });
 });
 
 // ============================================================================
@@ -2387,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);
+      }
+    }
+  });
 });
 
 // ============================================================================
@@ -2914,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");
+  });
+});