@rebasepro/client 0.13.0 → 0.13.1-canary.g06dbe5b

package/src/transport.ts

@@ -190,6 +190,18 @@ export function buildQueryString(params?: FindParams): string {
 
     if (params.searchString) {
         parts.push(`searchString=${encodeURIComponent(params.searchString)}`);
+        if (params.searchExplain) parts.push("searchExplain=true");
+    }
+
+    // The server keys vector search off `vector_search` naming the property and
+    // `vector` carrying the embedding as a JSON array; both must be present or
+    // it ignores the pair entirely.
+    if (params.vectorSearch) {
+        const vs = params.vectorSearch;
+        parts.push(`vector_search=${encodeURIComponent(vs.property)}`);
+        parts.push(`vector=${encodeURIComponent(JSON.stringify(vs.vector))}`);
+        if (vs.distance) parts.push(`vector_distance=${encodeURIComponent(vs.distance)}`);
+        if (vs.threshold !== undefined) parts.push(`vector_threshold=${encodeURIComponent(String(vs.threshold))}`);
     }
 
     if (params.include && params.include.length > 0) {
@@ -259,6 +271,28 @@ function resolveBaseUrl(configured?: string): string {
 export function createTransport(config: RebaseClientConfig, environment?: TransportEnvironment): Transport {
     const fetchFn = config.fetch || globalThis.fetch;
     const apiPath = config.apiPath || "/api";
+
+    // `apiPath` is appended to `baseUrl`, so a `baseUrl` that already ends in it
+    // builds `/api/api/…` and every request 404s. That was documented on
+    // `baseUrl` and left to be discovered at runtime — including by this
+    // package's own tests, which configured it that way a dozen times. A 404 on
+    // every call looks like a server that is down, not like a doubled path.
+    // `storageUrlOrigin` is checked alongside it because `storage.ts` composes
+    // it the same way — `${storageUrlOrigin ?? baseUrl}${apiPath}` — and its own
+    // docblock carries the same "no path" caveat.
+    for (const field of ["baseUrl", "storageUrlOrigin"] as const) {
+        const value = config[field];
+        if (!value || !apiPath) continue;
+        const trimmed = value.replace(/\/+$/, "");
+        if (!trimmed.endsWith(apiPath)) continue;
+        console.warn(
+            `[Rebase] ${field} ${JSON.stringify(value)} already ends with the API path ` +
+            `${JSON.stringify(apiPath)}, which is appended to it — requests will go to ` +
+            `${trimmed}${apiPath}/… and 404. Pass the origin only ` +
+            `(${JSON.stringify(trimmed.slice(0, trimmed.length - apiPath.length) || "/")}), or set ` +
+            "`apiPath` if the server really does mount the API one level deeper."
+        );
+    }
     let token = config.token;
     let tokenGetter: (() => Promise<string | null>) | undefined;
     let onUnauthorizedHandler = config.onUnauthorized;

package/src/vector-search-query.test.ts

@@ -0,0 +1,55 @@
+/**
+ * The SDK's route to vector search.
+ *
+ * The Postgres driver has served `vector_search` since vectors landed, but no
+ * method on the query builder ever reached it and it appeared in no OpenAPI
+ * spec — so the only way to use a shipped feature was to hand-build the URL.
+ * These tests pin the wire format the server's parser actually expects.
+ */
+import { buildQueryString } from "./transport";
+import type { FindParams } from "@rebasepro/types";
+
+const params = (p: FindParams): URLSearchParams =>
+    new URLSearchParams(buildQueryString(p).replace(/^\?/, ""));
+
+describe("vector search serialization", () => {
+    it("sends the property under `vector_search` and the embedding as a JSON array", () => {
+        const q = params({ vectorSearch: { property: "embedding", vector: [0.1, -0.2, 0.3] } });
+        expect(q.get("vector_search")).toBe("embedding");
+        expect(q.get("vector")).toBe("[0.1,-0.2,0.3]");
+    });
+
+    it("omits distance and threshold when not asked for, so the server's defaults stand", () => {
+        const q = params({ vectorSearch: { property: "embedding", vector: [1] } });
+        expect(q.has("vector_distance")).toBe(false);
+        expect(q.has("vector_threshold")).toBe(false);
+    });
+
+    it("sends distance and threshold when given", () => {
+        const q = params({
+            vectorSearch: { property: "embedding", vector: [1], distance: "l2", threshold: 0.35 }
+        });
+        expect(q.get("vector_distance")).toBe("l2");
+        expect(q.get("vector_threshold")).toBe("0.35");
+    });
+
+    it("sends a threshold of 0, which is a real bound and not an absent one", () => {
+        const q = params({ vectorSearch: { property: "embedding", vector: [1], threshold: 0 } });
+        expect(q.get("vector_threshold")).toBe("0");
+    });
+
+    it("adds nothing at all when there is no vector search", () => {
+        expect(buildQueryString({ limit: 10 })).not.toContain("vector");
+    });
+
+    it("stacks with filters and limit, which the server ANDs before ordering by distance", () => {
+        const q = params({
+            vectorSearch: { property: "embedding", vector: [0.5] },
+            where: { status: ["==", "published"] },
+            limit: 5
+        });
+        expect(q.get("vector_search")).toBe("embedding");
+        expect(q.get("limit")).toBe("5");
+        expect(buildQueryString({ where: { status: ["==", "published"] } })).toContain("status");
+    });
+});

package/src/websocket-url.test.ts

@@ -0,0 +1,97 @@
+import { jest } from "@jest/globals";
+import { createRebaseClient } from "./index";
+
+/**
+ * Where the realtime socket dials, given a `baseUrl`.
+ *
+ * The socket URL is derived rather than configured, so every disagreement
+ * between how it is derived and where the API actually lives shows up only as
+ * realtime not working — never as an error naming a cause.
+ */
+
+function setWindow(origin: string | undefined) {
+    if (origin === undefined) {
+        delete (globalThis as never as { window?: unknown }).window;
+        return;
+    }
+    (globalThis as never as { window: unknown }).window = {
+        location: { origin, href: origin + "/" }
+    };
+}
+
+function trackingWebSocket() {
+    const opened: string[] = [];
+    class FakeWebSocket {
+        static readonly OPEN = 1;
+        readyState = 0;
+        onopen: (() => void) | null = null;
+        onclose: (() => void) | null = null;
+        onerror: (() => void) | null = null;
+        onmessage: (() => void) | null = null;
+        constructor(public url: string) { opened.push(url); }
+        close() { /* no-op */ }
+        send() { /* no-op */ }
+    }
+    return { FakeWebSocket: FakeWebSocket as unknown as typeof WebSocket, opened };
+}
+
+describe("realtime socket URL", () => {
+    const originalWebSocket = globalThis.WebSocket;
+
+    afterEach(() => {
+        globalThis.WebSocket = originalWebSocket;
+        setWindow(undefined);
+        jest.restoreAllMocks();
+    });
+
+    it("keeps the path of a relative baseUrl, as it does for an absolute one", () => {
+        // A backend mounted under a path is the reason `baseUrl` accepts one.
+        // Resolving the relative form to `.origin` dropped it, so the same
+        // deployment dialled two different URLs depending on whether its
+        // baseUrl was written as "/backend" or "https://app.example.com/backend".
+        const { FakeWebSocket, opened } = trackingWebSocket();
+        globalThis.WebSocket = FakeWebSocket;
+        setWindow("https://app.example.com");
+
+        const relative = createRebaseClient({ baseUrl: "/backend" });
+        relative.collection("posts").listen!(undefined, () => {});
+
+        const absolute = createRebaseClient({ baseUrl: "https://app.example.com/backend" });
+        absolute.collection("posts").listen!(undefined, () => {});
+
+        expect(opened[0]).toBe("wss://app.example.com/backend");
+        expect(opened[0]).toBe(opened[1]);
+    });
+
+    it("dials the page origin when no baseUrl is set in a browser", () => {
+        const { FakeWebSocket, opened } = trackingWebSocket();
+        globalThis.WebSocket = FakeWebSocket;
+        setWindow("https://app.example.com");
+
+        const client = createRebaseClient({});
+        client.collection("posts").listen!(undefined, () => {});
+
+        expect(opened[0]).toBe("wss://app.example.com");
+    });
+
+    it("says why realtime is unavailable when no URL could be derived", () => {
+        // Node, with a relative baseUrl there is nothing to resolve against.
+        // The client silently had no socket, and `realtime.channel()` then
+        // blamed `realtime: false` — an option the caller never passed.
+        setWindow(undefined);
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => {});
+        const client = createRebaseClient({ baseUrl: "/backend" });
+
+        expect(client.ws).toBeUndefined();
+        expect(warn).toHaveBeenCalledWith(expect.stringContaining("websocketUrl"));
+        expect(() => client.realtime.channel("room")).toThrow(/no WebSocket URL could be derived/i);
+        // It may still *suggest* `realtime: false` as the way to make this
+        // deliberate; what it must not do is claim that is what happened.
+        expect(() => client.realtime.channel("room")).not.toThrow(/disabled on this client/);
+    });
+
+    it("still blames the opt-out when realtime really was switched off", () => {
+        const client = createRebaseClient({ baseUrl: "https://api.example.com", realtime: false });
+        expect(() => client.realtime.channel("room")).toThrow(/realtime: false/);
+    });
+});

package/src/websocket.ts

@@ -895,6 +895,22 @@ export class RebaseWebSocketClient {
             } else {
                 callback.onUpdate(message);
             }
+            return;
+        }
+
+        // An error that matched no waiter used to fall off the end of this
+        // method and disappear. Channel frames are the ones that always do:
+        // they are fire-and-forget by design, so no `pendingRequests` entry
+        // exists to reject and the server's errors about them — RATE_LIMITED,
+        // CHANNEL_FORBIDDEN, CHANNEL_HISTORY_WRITE_FAILED — were dropped while
+        // `await channel.broadcast(...)` resolved as if it had been sent. A
+        // console warning is the floor, not the answer: an `onError` on
+        // `RebaseRealtimeChannel` is the shape this should eventually take.
+        if (type === "ERROR" || type === "error" || message.error) {
+            const { errorMessage, errorCode } = extractMessageError(message);
+            console.warn(
+                `[Rebase] Realtime error from the server${errorCode ? ` (${errorCode})` : ""}: ${errorMessage}`
+            );
         }
     }
 
@@ -1288,6 +1304,9 @@ options }
 
             const obj = val as Record<string, unknown>;
             if (obj.__type === "relation") {
+                // `data` is dropped on purpose: a relation compares by the
+                // reference it holds, not by the row it happens to have loaded.
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
                 const { data, ...rest } = obj;
                 return rest;
             }
@@ -1803,16 +1822,22 @@ onError });
     }
 
     private createCollectionSubscriptionKey(props: FetchCollectionProps): string {
-        // Create a deterministic key based on subscription parameters
+        // Derived from the props, not a hand-listed subset of them.
+        //
+        // Two subscriptions share one server subscription when their keys
+        // match, so a field left off the key makes two different queries
+        // collide and hands the second listener the first one's rows. `offset`
+        // and `logical` were both missing: page two of a live list showed page
+        // one, and two views filtered by different `or(...)` groups saw the
+        // same rows. Listing fields by hand is what let that happen, so the key
+        // now covers whatever `FetchCollectionProps` carries.
+        //
+        // `collection` is the exception: it is the whole collection config,
+        // property thunks and all, so it contributes its name as before.
+        const { collection, ...query } = props as FetchCollectionProps & Record<string, unknown>;
         const key = {
-            path: props.path,
-            filter: props.filter,
-            limit: props.limit,
-            startAfter: props.startAfter,
-            orderBy: props.orderBy,
-            order: props.order,
-            searchString: props.searchString,
-            collection: props.collection?.name
+            ...query,
+            collection: collection?.name
         };
         // Use replacer function (not array) to sort keys at all levels for deterministic output
         return JSON.stringify(key, (_, value) => {