@rebasepro/client 0.13.0 → 0.13.1-canary.g18cfeb7

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

@@ -1288,6 +1288,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 +1806,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) => {