@rebasepro/client 0.13.0 → 0.13.1-canary.g249daa1

package/src/realtime-optout.test.ts

@@ -50,7 +50,7 @@ describe("realtime opt-out", () => {
         const { FakeWebSocket, opened } = trackingWebSocket();
         globalThis.WebSocket = FakeWebSocket;
 
-        createRebaseClient({ baseUrl: "http://localhost:3000/api" });
+        createRebaseClient({ baseUrl: "http://localhost:3000" });
 
         expect(opened).toHaveLength(0);
     });
@@ -59,7 +59,7 @@ describe("realtime opt-out", () => {
         const { FakeWebSocket, opened } = trackingWebSocket();
         globalThis.WebSocket = FakeWebSocket;
 
-        const client = createRebaseClient({ baseUrl: "http://localhost:3000/api" });
+        const client = createRebaseClient({ baseUrl: "http://localhost:3000" });
 
         // Asking for the channel is not using it.
         const channel = client.realtime.channel("doc:1");
@@ -73,7 +73,7 @@ describe("realtime opt-out", () => {
         const { FakeWebSocket, opened } = trackingWebSocket();
         globalThis.WebSocket = FakeWebSocket;
 
-        const client = createRebaseClient({ baseUrl: "http://localhost:3000/api" });
+        const client = createRebaseClient({ baseUrl: "http://localhost:3000" });
         expect(opened).toHaveLength(0);
 
         client.collection("posts").listen!(undefined, () => { /* noop */ });
@@ -85,7 +85,7 @@ describe("realtime opt-out", () => {
         const { FakeWebSocket, opened } = trackingWebSocket();
         globalThis.WebSocket = FakeWebSocket;
 
-        const client = createRebaseClient({ baseUrl: "http://localhost:3000/api" });
+        const client = createRebaseClient({ baseUrl: "http://localhost:3000" });
 
         client.collection("posts").listen!(undefined, () => { /* noop */ });
         client.collection("authors").listen!(undefined, () => { /* noop */ });
@@ -102,7 +102,7 @@ describe("realtime opt-out", () => {
         const warn = jest.spyOn(console, "warn").mockImplementation(() => { /* capture */ });
         const debug = jest.spyOn(console, "debug").mockImplementation(() => { /* capture */ });
 
-        const client = createRebaseClient({ baseUrl: "http://localhost:3000/api" });
+        const client = createRebaseClient({ baseUrl: "http://localhost:3000" });
         void client.realtime.channel("doc:1"); // obtained, never used
 
         expect(opened).toHaveLength(0);
@@ -118,7 +118,7 @@ describe("realtime opt-out", () => {
         delete globalThis.WebSocket;
         const warn = jest.spyOn(console, "warn").mockImplementation(() => { /* capture */ });
 
-        const client = createRebaseClient({ baseUrl: "http://localhost:3000/api" });
+        const client = createRebaseClient({ baseUrl: "http://localhost:3000" });
         expect(warn).not.toHaveBeenCalled();
 
         void client.realtime.channel("doc:1").join();
@@ -134,7 +134,7 @@ describe("realtime opt-out", () => {
         globalThis.WebSocket = FakeWebSocket;
 
         const client = createRebaseClient({
-            baseUrl: "http://localhost:3000/api",
+            baseUrl: "http://localhost:3000",
             realtime: false
         });
 
@@ -148,7 +148,7 @@ describe("realtime opt-out", () => {
         globalThis.WebSocket = FakeWebSocket;
 
         createRebaseClient({
-            baseUrl: "http://localhost:3000/api",
+            baseUrl: "http://localhost:3000",
             websocketUrl: "ws://localhost:3000",
             realtime: false
         });
@@ -160,7 +160,7 @@ describe("realtime opt-out", () => {
         const { FakeWebSocket, opened, closed } = trackingWebSocket();
         globalThis.WebSocket = FakeWebSocket;
 
-        const client = createRebaseClient({ baseUrl: "http://localhost:3000/api" });
+        const client = createRebaseClient({ baseUrl: "http://localhost:3000" });
         client.collection("posts").listen!(undefined, () => { /* noop */ });
         expect(opened).toHaveLength(1);
 
@@ -176,7 +176,7 @@ describe("realtime opt-out", () => {
         const { FakeWebSocket, opened } = trackingWebSocket();
         globalThis.WebSocket = FakeWebSocket;
 
-        const client = createRebaseClient({ baseUrl: "http://localhost:3000/api" });
+        const client = createRebaseClient({ baseUrl: "http://localhost:3000" });
         client.collection("posts").listen!(undefined, () => { /* noop */ });
         expect(opened).toHaveLength(1);
 
@@ -190,10 +190,10 @@ describe("realtime opt-out", () => {
         const { FakeWebSocket } = trackingWebSocket();
         globalThis.WebSocket = FakeWebSocket;
 
-        const offline = createRebaseClient({ baseUrl: "http://localhost:3000/api", realtime: false });
+        const offline = createRebaseClient({ baseUrl: "http://localhost:3000", realtime: false });
         expect(() => offline.close()).not.toThrow();
 
-        const live = createRebaseClient({ baseUrl: "http://localhost:3000/api" });
+        const live = createRebaseClient({ baseUrl: "http://localhost:3000" });
         live.close();
         expect(() => live.close()).not.toThrow();
     });
@@ -205,7 +205,7 @@ describe("realtime opt-out", () => {
         globalThis.WebSocket = FakeWebSocket;
 
         const client = createRebaseClient({
-            baseUrl: "http://localhost:3000/api",
+            baseUrl: "http://localhost:3000",
             realtime: false
         });
 
@@ -244,7 +244,7 @@ isAnonymous: false }
         })) as unknown as typeof globalThis.fetch;
 
         const client = createRebaseClient({
-            baseUrl: "http://localhost:3000/api",
+            baseUrl: "http://localhost:3000",
             fetch: fetchMock
         });
 
@@ -265,7 +265,7 @@ isAnonymous: false }
         globalThis.WebSocket = FakeWebSocket;
 
         const client = createRebaseClient({
-            baseUrl: "http://localhost:3000/api",
+            baseUrl: "http://localhost:3000",
             realtime: false
         });
 

package/src/realtime-subscription-key.test.ts

@@ -0,0 +1,92 @@
+import { jest } from "@jest/globals";
+import { RebaseWebSocketClient } from "./websocket";
+import { or, cond } from "@rebasepro/common";
+
+/**
+ * Two subscriptions are the same subscription only when they ask for the same
+ * rows. The key that decides this was built from a hand-listed subset of the
+ * props, so any field left off it made two different queries collide — and the
+ * second listener was handed the first one's rows, which is worse than not
+ * subscribing at all.
+ */
+
+function fakeSocket() {
+    const sent: Record<string, unknown>[] = [];
+
+    class FakeWS {
+        static readonly OPEN = 1;
+        readyState = 1;
+        onopen: (() => void) | null = null;
+        onclose: (() => void) | null = null;
+        onerror: (() => void) | null = null;
+        onmessage: ((event: { data: string }) => void) | null = null;
+
+        constructor(public url: string) {
+            setTimeout(() => this.onopen?.(), 0);
+        }
+
+        send(raw: string) {
+            const message = JSON.parse(raw) as Record<string, unknown>;
+            sent.push(message);
+            if (message.type === "AUTHENTICATE") {
+                setTimeout(() => this.onmessage?.({
+                    data: JSON.stringify({ type: "AUTH_SUCCESS", requestId: message.requestId })
+                }), 0);
+            }
+        }
+
+        close() { /* noop */ }
+    }
+
+    return { FakeWS: FakeWS as unknown as typeof WebSocket, sent };
+}
+
+function subscribeFrames(sent: Record<string, unknown>[]) {
+    return sent.filter((m) => m.type === "subscribe_collection");
+}
+
+describe("collection subscription identity", () => {
+    beforeEach(() => jest.useFakeTimers());
+    afterEach(() => jest.useRealTimers());
+
+    async function twoSubscriptions(
+        a: Record<string, unknown>,
+        b: Record<string, unknown>
+    ) {
+        const { FakeWS, sent } = fakeSocket();
+        const client = new RebaseWebSocketClient({
+            websocketUrl: "ws://localhost:1234",
+            WebSocket: FakeWS,
+            getAuthToken: async () => "token"
+        });
+        client.listenCollection({ path: "posts", ...a } as never, () => {});
+        client.listenCollection({ path: "posts", ...b } as never, () => {});
+        await jest.advanceTimersByTimeAsync(50);
+        return subscribeFrames(sent);
+    }
+
+    it("treats different offsets as different subscriptions", async () => {
+        // Page one and page two of the same live list. Sharing a subscription
+        // here shows page one's rows on page two.
+        const frames = await twoSubscriptions({ limit: 10, offset: 0 }, { limit: 10, offset: 10 });
+        expect(frames).toHaveLength(2);
+    });
+
+    it("treats different logical groups as different subscriptions", async () => {
+        const frames = await twoSubscriptions(
+            { logical: or(cond("status", "==", "draft")) },
+            { logical: or(cond("status", "==", "published")) }
+        );
+        expect(frames).toHaveLength(2);
+    });
+
+    it("still shares one subscription for genuinely identical queries", async () => {
+        // The de-duplication itself is the point of the key: two components
+        // watching the same list must not open two server subscriptions.
+        const frames = await twoSubscriptions(
+            { limit: 10, offset: 10, logical: or(cond("status", "==", "draft")) },
+            { limit: 10, offset: 10, logical: or(cond("status", "==", "draft")) }
+        );
+        expect(frames).toHaveLength(1);
+    });
+});

package/src/sdk_query_builder.ts

@@ -5,7 +5,8 @@ import {
     SDKCollectionClient,
     SDKQueryBuilderInterface,
     WhereFilterOp,
-    WhereValue
+    WhereValue,
+    type ComputedSortField
 } from "@rebasepro/types";
 
 /**
@@ -72,7 +73,7 @@ export class SDKQueryBuilder<M extends Record<string, unknown> = Record<string,
     /**
      * Order the results by a specific column.
      */
-    orderBy(column: keyof M & string, direction: "asc" | "desc" = "asc"): this {
+    orderBy(column: (keyof M & string) | ComputedSortField, direction: "asc" | "desc" = "asc"): this {
         this.params.orderBy = [column, direction];
         return this;
     }
@@ -95,9 +96,60 @@ export class SDKQueryBuilder<M extends Record<string, unknown> = Record<string,
 
     /**
      * Set a free-text search string if supported by the backend.
+     *
+     * By default this is a substring match across the collection's top-level
+     * string properties. A Postgres collection that declares a `search` block
+     * gets ranked full-text matching over the fields it named instead, and each
+     * row comes back with a `_score` you can sort on:
+     *
+     * ```ts
+     * client.data.talents.search("auditor iso 14001").orderBy("_score", "desc").find()
+     * ```
+     *
+     * Pass `{ explain: true }` to have each row report which of the declared
+     * fields matched, with a highlighted snippet, on `_matches`:
+     *
+     * ```ts
+     * const { data } = await client.data.talents.search("iso 14001", { explain: true }).find();
+     * data[0]._matches
+     * // [{ field: "questionnaire.certifications", snippet: "<mark>ISO</mark> <mark>14001</mark> Lead Auditor" }]
+     * ```
      */
-    search(searchString: string): this {
+    search(searchString: string, options?: { explain?: boolean }): this {
         this.params.searchString = searchString;
+        if (options?.explain !== undefined) this.params.searchExplain = options.explain;
+        return this;
+    }
+
+    /**
+     * Order rows by nearest-neighbour distance to `vector`.
+     *
+     * The server has supported this from the REST layer since vectors landed;
+     * this is the SDK reaching it. Results come back closest-first with a
+     * `_distance` on each row, and any `where` / `orderBy` on the same query is
+     * a filter applied before the ordering — distance decides the order.
+     *
+     * You supply the query vector. Rebase stores and searches embeddings; it
+     * does not produce them, so this is where whatever model you already use
+     * for the stored vectors gets called.
+     *
+     * @param property - Name of the `vector` property to compare against.
+     * @param vector - The query embedding. Its length must match the property's
+     *                 declared `dimensions`, or the server answers 400.
+     * @example
+     * client.data.docs.vectorSearch("embedding", queryVector, { threshold: 0.35 }).limit(10).find()
+     */
+    vectorSearch(
+        property: string,
+        vector: number[],
+        options?: { distance?: "cosine" | "l2" | "inner_product"; threshold?: number }
+    ): this {
+        this.params.vectorSearch = {
+            property,
+            vector,
+            ...(options?.distance !== undefined && { distance: options.distance }),
+            ...(options?.threshold !== undefined && { threshold: options.threshold })
+        };
         return this;
     }
 

package/src/transport-baseurl.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, afterEach } from "@jest/globals";
+import { describe, it, expect, afterEach, jest } from "@jest/globals";
 import { createTransport } from "./transport";
 
 /**
@@ -51,3 +51,51 @@ describe("transport baseUrl resolution", () => {
         expect(createTransport({}).baseUrl).toBe("");
     });
 });
+
+describe("baseUrl that already contains the apiPath", () => {
+    /**
+     * The docblock on `baseUrl` says this "silently builds `/api/api/…` and
+     * every request 404s" — a failure mode understood well enough to be written
+     * down, and still left to be discovered at runtime. This package's own
+     * tests configured it that way a dozen times over, which is about as clear
+     * a signal as a trap gets.
+     */
+    it("warns rather than silently building /api/api", () => {
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => {});
+        createTransport({ baseUrl: "http://localhost:3000/api" });
+
+        expect(warn).toHaveBeenCalledWith(expect.stringContaining("/api/api"));
+        warn.mockRestore();
+    });
+
+    it("warns for a custom apiPath too, and tolerates a trailing slash", () => {
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => {});
+        createTransport({ baseUrl: "https://api.example.com/v2/", apiPath: "/v2" });
+
+        expect(warn).toHaveBeenCalledTimes(1);
+        warn.mockRestore();
+    });
+
+    it("says nothing about a baseUrl that merely ends in a similar word", () => {
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => {});
+        createTransport({ baseUrl: "https://rapid.example.com" });
+        createTransport({ baseUrl: "https://example.com/myapi" });
+        createTransport({ baseUrl: "https://example.com" });
+
+        expect(warn).not.toHaveBeenCalled();
+        warn.mockRestore();
+    });
+});
+
+describe("storageUrlOrigin that already contains the apiPath", () => {
+    it("warns, because storage composes it the same way baseUrl is composed", () => {
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => {});
+        createTransport({
+            baseUrl: "https://example.com",
+            storageUrlOrigin: "https://files.example.com/api"
+        });
+
+        expect(warn).toHaveBeenCalledWith(expect.stringContaining("storageUrlOrigin"));
+        warn.mockRestore();
+    });
+});

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

@@ -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) => {