@rebasepro/client 0.13.0 → 0.13.1-canary.g3660bd5

package/dist/offline-query.d.ts

@@ -1,7 +1,14 @@
 import { FilterValues, FindResult, LogicalCondition, FilterCondition, OrderByTuple, WhereFilterOp } from "@rebasepro/types";
 import { FindParams } from "./transport";
-/** The server's page size when the caller does not ask for one. */
-export declare const DEFAULT_PAGE_SIZE = 20;
+/**
+ * The server's page size when the caller does not ask for one.
+ *
+ * Re-exported rather than redeclared. This was its own `= 20` — a third
+ * constant of this name in the workspace, next to `@rebasepro/common`'s 200 and
+ * the 50 the REST layer actually applies — and a local copy of a number that
+ * belongs to another process is a number that goes stale silently.
+ */
+export { DEFAULT_LIST_LIMIT as DEFAULT_PAGE_SIZE } from "@rebasepro/types";
 /**
  * Three-way compare with SQL's type coercion but not its collation. Returns
  * `undefined` when the two values are not ordered relative to each other,
@@ -33,7 +40,15 @@ export declare function matchesParams(row: Record<string, unknown>, params?: Fin
  * not shuffle rows between pages.
  */
 export declare function sortRows<M extends Record<string, unknown>>(rows: M[], orderBy?: OrderByTuple): M[];
-/** Resolve `page`/`offset`/`limit` the way the server does. */
+/**
+ * Resolve `page`/`offset`/`limit` the way the server does.
+ *
+ * It did not: this defaulted an absent limit to 20 while `/api/data` pages by
+ * 50, so the same `observe()` answered with 20 rows from the local database and
+ * 50 from the network — a list that changed length depending on which side
+ * answered, with `page` striding differently on each. Delegated now, so the
+ * sentence above is true by construction rather than by agreement.
+ */
 export declare function resolvePagination(params?: FindParams): {
     limit: number;
     offset: number;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/client",
   "type": "module",
-  "version": "0.13.0",
+  "version": "0.13.1-canary.g3660bd5",
   "description": "HTTP SDK client for the Rebase custom backend",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -29,9 +29,9 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@rebasepro/common": "0.13.0",
-    "@rebasepro/utils": "0.13.0",
-    "@rebasepro/types": "0.13.0"
+    "@rebasepro/common": "0.13.1-canary.g3660bd5",
+    "@rebasepro/utils": "0.13.1-canary.g3660bd5",
+    "@rebasepro/types": "0.13.1-canary.g3660bd5"
   },
   "devDependencies": {
     "@jest/globals": "^30.4.1",

package/src/auth-listener-errors.test.ts

@@ -0,0 +1,57 @@
+import { jest } from "@jest/globals";
+import { createAuth } from "./auth";
+import type { Transport } from "./transport";
+
+/**
+ * What happens to an error thrown by the app's own auth listener.
+ *
+ * `emit` isolates listeners from each other, which is right — one bad handler
+ * must not stop the rest from being told about a sign-in. It also discarded the
+ * error entirely, which is not: the throw came from the *caller's* code, and it
+ * vanished with nothing in the console, so a broken `onAuthStateChange` handler
+ * looked like an event that never fired.
+ *
+ * The socket in this same package already reports these
+ * ("Error in channel handler:"). This was the one listener loop that did not.
+ */
+function transport(): Transport {
+    return {
+        request: jest.fn<any>().mockResolvedValue({}),
+        setToken: jest.fn(),
+        setAuthTokenGetter: jest.fn(),
+        setOnUnauthorized: jest.fn(),
+        baseUrl: "http://localhost:3000",
+        apiPath: "/api",
+        fetchFn: globalThis.fetch,
+        getHeaders: () => ({}),
+        resolveToken: jest.fn<any>().mockResolvedValue(null)
+    } as unknown as Transport;
+}
+
+describe("auth state listeners", () => {
+    let error: ReturnType<typeof jest.spyOn>;
+
+    beforeEach(() => { error = jest.spyOn(console, "error").mockImplementation(() => { /* quiet */ }); });
+    afterEach(() => error.mockRestore());
+
+    it("keeps telling the other listeners when one throws", () => {
+        const auth = createAuth(transport());
+        const second = jest.fn();
+
+        auth.onAuthStateChange(() => { throw new Error("handler blew up"); });
+        auth.onAuthStateChange(second);
+        auth.signOut();
+
+        expect(second).toHaveBeenCalled();
+    });
+
+    it("reports the throw instead of discarding it", () => {
+        const auth = createAuth(transport());
+        auth.onAuthStateChange(() => { throw new Error("handler blew up"); });
+
+        auth.signOut();
+
+        const said = error.mock.calls.map((c: unknown[]) => c.map(String).join(" ")).join("\n");
+        expect(said).toMatch(/handler blew up/);
+    });
+});

package/src/auth.ts

@@ -129,7 +129,16 @@ export function createAuth(transport: Transport, options?: CreateAuthOptions) {
 
     function emit(event: AuthChangeEvent, session: RebaseSession | null) {
         for (const fn of listeners) {
-            try { fn(event, session); } catch (e) { /* ignore */ }
+            try {
+                fn(event, session);
+            } catch (e) {
+                // Isolated so one bad handler cannot stop the rest being told —
+                // but reported, because the throw came from the caller's own
+                // code and discarding it made a broken `onAuthStateChange`
+                // handler look like an event that never fired. The socket in
+                // this package already reports handler errors this way.
+                console.error("Error in auth state change listener:", e);
+            }
         }
     }
 

package/src/collection-listen-meta.test.ts

@@ -0,0 +1,105 @@
+import { jest } from "@jest/globals";
+import { DEFAULT_LIST_LIMIT } from "@rebasepro/types";
+import { createCollectionClient } from "./collection";
+import type { FindResult } from "@rebasepro/types";
+import type { Transport } from "./transport";
+import type { RebaseWebSocketClient } from "./websocket";
+
+type Row = { id: string };
+
+/**
+ * `listen()` gets rows off the socket and has to describe the window they came
+ * from itself. Everything it reports is therefore something it decided, and
+ * these tests are about which of those decisions are claims it can support.
+ */
+
+const flush = () => new Promise<void>((r) => setTimeout(r, 0));
+
+function createWs() {
+    let push: ((rows: Record<string, unknown>[]) => void) | undefined;
+    const ws = {
+        listenCollection: (_p: unknown, onUpdate: (rows: Record<string, unknown>[]) => void) => {
+            push = onUpdate;
+            return () => { push = undefined; };
+        }
+    } as unknown as RebaseWebSocketClient;
+    return { ws, push: (rows: Record<string, unknown>[]) => push?.(rows) };
+}
+
+function createTransport(count: () => Promise<unknown>): Transport {
+    return {
+        request: jest.fn<any>((url: string) => {
+            if (url.includes("/count")) return count();
+            return Promise.resolve({ data: [], meta: {} });
+        }),
+        setToken: jest.fn(),
+        setAuthTokenGetter: jest.fn(),
+        setOnUnauthorized: jest.fn(),
+        baseUrl: "http://localhost:3000",
+        apiPath: "/api",
+        fetchFn: globalThis.fetch,
+        getHeaders: () => ({}),
+        resolveToken: jest.fn<any>().mockResolvedValue(null)
+    } as unknown as Transport;
+}
+
+describe("listen() pagination metadata", () => {
+    it("reports the page size the server actually applies when none was requested", async () => {
+        const transport = createTransport(() => Promise.resolve({ count: 3 }));
+        const { ws, push } = createWs();
+        const client = createCollectionClient<Row>(transport, "products", ws);
+
+        const updates: FindResult<Row>[] = [];
+        const stop = client.listen!(undefined, (r) => updates.push(r));
+        push([{ id: "1" }, { id: "2" }, { id: "3" }]);
+        await flush();
+
+        // Not 20. A caller who names no limit gets `DEFAULT_LIST_LIMIT` rows
+        // from the REST layer, so any other number here describes a window the
+        // rows did not come from.
+        expect(updates.at(-1)?.meta.limit).toBe(DEFAULT_LIST_LIMIT);
+        stop!();
+    });
+
+    it("does not shrink the total to one page when the count request fails", async () => {
+        let counts = 0;
+        const transport = createTransport(() => {
+            counts += 1;
+            return counts === 1
+                ? Promise.resolve({ count: 500 })
+                : Promise.reject(new Error("count unavailable"));
+        });
+        const { ws, push } = createWs();
+        const client = createCollectionClient<Row>(transport, "products", ws);
+
+        const updates: FindResult<Row>[] = [];
+        const stop = client.listen!({ limit: 2 }, (r) => updates.push(r));
+
+        push([{ id: "1" }, { id: "2" }]);
+        await flush();
+        expect(updates.at(-1)?.meta.total).toBe(500);
+
+        // The collection did not lose 498 rows because a count request failed.
+        push([{ id: "1" }, { id: "2" }]);
+        await flush();
+        expect(updates.at(-1)?.meta.total).toBe(500);
+        expect(updates.at(-1)?.meta.hasMore).toBe(true);
+        stop!();
+    });
+
+    it("never claims a total below the rows already skipped", async () => {
+        const transport = createTransport(() => Promise.reject(new Error("nope")));
+        const { ws, push } = createWs();
+        const client = createCollectionClient<Row>(transport, "products", ws);
+
+        const updates: FindResult<Row>[] = [];
+        const stop = client.listen!({ limit: 2, offset: 10 }, (r) => updates.push(r));
+        push([{ id: "11" }, { id: "12" }]);
+        await flush();
+
+        // With no count ever obtained the total is unknown, but it cannot be 2:
+        // ten rows were paged past to reach these.
+        expect(updates.at(-1)?.meta.total).toBe(12);
+        stop!();
+    });
+});

package/src/collection-observe.test.ts

@@ -0,0 +1,138 @@
+import { jest } from "@jest/globals";
+import { createCollectionClient, type LiveResult } from "./collection";
+import type { Transport } from "./transport";
+import type { RebaseWebSocketClient } from "./websocket";
+
+type Row = { id: string; name: string };
+
+/**
+ * `observe()` on a client without the offline layer is two sources feeding one
+ * callback: a one-shot `find()` and a realtime subscription. Neither of these
+ * tests is about the sources — they are about what the callback is allowed to
+ * be told, which is the part an app actually depends on.
+ */
+
+function deferred<T>() {
+    let resolve!: (value: T) => void;
+    let reject!: (error: unknown) => void;
+    const promise = new Promise<T>((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+
+/** Let every already-queued microtask run. */
+const flush = () => new Promise<void>((r) => setTimeout(r, 0));
+
+function createTransport(handlers: {
+    find?: () => Promise<unknown>;
+    count?: () => Promise<unknown>;
+}): Transport {
+    return {
+        request: jest.fn<any>((url: string) => {
+            if (url.includes("/count")) return handlers.count?.() ?? Promise.resolve({ count: 0 });
+            return handlers.find?.() ?? Promise.resolve({ data: [], meta: {} });
+        }),
+        setToken: jest.fn(),
+        setAuthTokenGetter: jest.fn(),
+        setOnUnauthorized: jest.fn(),
+        baseUrl: "http://localhost:3000",
+        apiPath: "/api",
+        fetchFn: globalThis.fetch,
+        getHeaders: () => ({}),
+        resolveToken: jest.fn<any>().mockResolvedValue(null)
+    } as unknown as Transport;
+}
+
+/** A socket whose collection updates this test drives by hand. */
+function createWs() {
+    let push: ((rows: Record<string, unknown>[]) => void) | undefined;
+    const ws = {
+        listenCollection: (
+            _props: unknown,
+            onUpdate: (rows: Record<string, unknown>[]) => void
+        ) => {
+            push = onUpdate;
+            return () => { push = undefined; };
+        }
+    } as unknown as RebaseWebSocketClient;
+    return {
+        ws,
+        push: (rows: Record<string, unknown>[]) => push?.(rows)
+    };
+}
+
+describe("observe() without the offline layer", () => {
+    it("does not replace a live update with the initial fetch that resolved after it", async () => {
+        // The initial `find()` is in flight for the whole test; the socket
+        // answers first. This is not exotic — `listenCollection` replays cached
+        // rows synchronously when another observer already holds the same
+        // subscription, so a second component observing the same query hits it
+        // every time.
+        const find = deferred<unknown>();
+        const transport = createTransport({
+            find: () => find.promise,
+            count: () => Promise.resolve({ count: 1 })
+        });
+        const { ws, push } = createWs();
+        const client = createCollectionClient<Row>(transport, "products", ws);
+
+        const results: LiveResult<Row>[] = [];
+        const stop = client.observe(undefined, (r) => results.push(r));
+
+        push([{ id: "1", name: "live" }]);
+        await flush();
+
+        find.resolve({ data: [{ id: "1", name: "stale" }], meta: { total: 1 } });
+        await flush();
+
+        expect(results.at(-1)?.data).toEqual([{ id: "1", name: "live" }]);
+        stop();
+    });
+
+    it("de-duplicates emissions, as the contract on observe() states", async () => {
+        const transport = createTransport({
+            find: () => Promise.resolve({ data: [{ id: "1", name: "a" }], meta: { total: 1 } }),
+            count: () => Promise.resolve({ count: 1 })
+        });
+        const { ws, push } = createWs();
+        const client = createCollectionClient<Row>(transport, "products", ws);
+
+        const results: LiveResult<Row>[] = [];
+        const stop = client.observe(undefined, (r) => results.push(r));
+        await flush();
+
+        const afterInitial = results.length;
+
+        // Two socket updates carrying exactly the rows the app already has.
+        push([{ id: "1", name: "a" }]);
+        await flush();
+        push([{ id: "1", name: "a" }]);
+        await flush();
+
+        expect(results.length).toBe(afterInitial);
+
+        // A real change still gets through.
+        push([{ id: "1", name: "b" }]);
+        await flush();
+        expect(results.length).toBe(afterInitial + 1);
+        expect(results.at(-1)?.data).toEqual([{ id: "1", name: "b" }]);
+        stop();
+    });
+
+    it("stops emitting once unsubscribed, including for a fetch still in flight", async () => {
+        const find = deferred<unknown>();
+        const transport = createTransport({ find: () => find.promise });
+        const client = createCollectionClient<Row>(transport, "products");
+
+        const results: LiveResult<Row>[] = [];
+        const stop = client.observe(undefined, (r) => results.push(r));
+        stop();
+
+        find.resolve({ data: [{ id: "1", name: "a" }], meta: { total: 1 } });
+        await flush();
+
+        expect(results).toHaveLength(0);
+    });
+});

package/src/collection.ts

@@ -11,7 +11,7 @@ import {
     WhereValue,
     WriteOptions
 } from "@rebasepro/types";
-import { collectAllPages, paginateFind } from "@rebasepro/common";
+import { collectAllPages, paginateFind, resolveFindWindow } from "@rebasepro/common";
 
 import { SDKQueryBuilder } from "./sdk_query_builder";
 
@@ -212,15 +212,36 @@ export function createCollectionClient<M extends Record<string, unknown> = Recor
             options?: ObserveOptions
         ) {
             let closed = false;
-            const emit = (result: FindResult<M>) => {
+            // Two sources race into one callback: the one-shot fetch below and
+            // the subscription beside it. Whichever resolves last used to win,
+            // so a socket update that landed first was overwritten by the
+            // fetch's older snapshot and stayed wrong until the next change.
+            // `listenCollection` replays cached rows synchronously to a second
+            // subscriber, so a second component observing the same query hit
+            // that ordering every time.
+            let liveDelivered = false;
+            let signature: string | undefined;
+
+            const deliver = (result: FindResult<M>, fromLive: boolean) => {
                 if (closed) return;
+                // Once the socket has spoken, the fetch issued alongside it is
+                // older news — delivering it would move the app backwards.
+                if (fromLive) liveDelivered = true;
+                else if (liveDelivered) return;
+                // The de-duplication `observe()` documents. Keyed on the rows
+                // and the total, the same two things the offline layer keys on,
+                // so both implementations mean the same thing by "changed".
+                const next = `${result.meta?.total ?? ""}|${JSON.stringify(result.data)}`;
+                if (signature !== undefined && next === signature) return;
+                signature = next;
                 onResult({ ...result, fromCache: false, hasPendingWrites: false, partial: false });
             };
-            client.find(params).then(emit).catch((error) => {
+
+            client.find(params).then((result) => deliver(result, false)).catch((error) => {
                 if (!closed) onError?.(error as Error);
             });
             const live = options?.realtime !== false && client.listen
-                ? client.listen(params, emit, onError)
+                ? client.listen(params, (result) => deliver(result, true), onError)
                 : undefined;
             return () => {
                 closed = true;
@@ -235,15 +256,25 @@ export function createCollectionClient<M extends Record<string, unknown> = Recor
             options?: ObserveOptions
         ) {
             let closed = false;
-            const emit = (row: M | undefined) => {
+            let liveDelivered = false;
+            let signature: string | undefined;
+
+            // Same ordering and de-duplication rules as `observe`, for one row.
+            const deliver = (row: M | undefined, fromLive: boolean) => {
                 if (closed) return;
+                if (fromLive) liveDelivered = true;
+                else if (liveDelivered) return;
+                const next = row === undefined ? "missing" : JSON.stringify(row);
+                if (signature !== undefined && next === signature) return;
+                signature = next;
                 onResult(row, { fromCache: false, hasPendingWrites: false });
             };
-            client.findById(id).then(emit).catch((error) => {
+
+            client.findById(id).then((row) => deliver(row, false)).catch((error) => {
                 if (!closed) onError?.(error as Error);
             });
             const live = options?.realtime !== false && client.listenById
-                ? client.listenById(id, emit, onError)
+                ? client.listenById(id, (row) => deliver(row, true), onError)
                 : undefined;
             return () => {
                 closed = true;
@@ -280,69 +311,80 @@ export function createCollectionClient<M extends Record<string, unknown> = Recor
         client.listen = (params: FindParams<M> | undefined, onUpdate: (response: FindResult<M>) => void, onError?: (error: Error) => void) => {
             let active = true;
             let lastUpdateId = 0;
+            // The last total a `count()` actually returned. A later count that
+            // fails says nothing about how big the collection is, so it must
+            // not be allowed to replace this with the length of one page.
+            let lastKnownTotal: number | undefined;
+            const window = resolveFindWindow(params);
             const unsub = ws.listenCollection(
                 {
                     path: slug,
                     filter: params?.where,
+                    // The group used to be dropped here, so a subscription
+                    // filtered with `or(...)` was pushed every row instead.
+                    logical: params?.logical,
                     limit: params?.limit,
-                    startAfter: params?.offset ? String(params.offset) : undefined,
+                    // `offset` used to be stringified into `startAfter`, which
+                    // is a cursor *row*, not a row count — so the server was
+                    // handed "20" where it expected a keyset value, and the
+                    // offset it does understand never arrived at all.
+                    offset: window.driverOffset,
                     orderBy: params?.orderBy?.[0],
                     order: params?.orderBy?.[1],
                     searchString: params?.searchString
                 },
                 (incomingRows: Record<string, unknown>[]) => {
                     const currentUpdateId = ++lastUpdateId;
-                    const requestedLimit = params?.limit || 20;
-                    const offset = params?.offset || 0;
+                    // What the server pages by when the caller names no limit.
+                    // A hardcoded 20 here described a window the rows had not
+                    // come from, and any app sizing its next request off
+                    // `meta.limit` was told the wrong number.
+                    const requestedLimit = window.limit;
+                    const offset = window.offset;
 
                     // WS client already delivers flat rows — just cast
                     const rows = incomingRows as M[];
 
-                    // Heuristic metadata (used as fallback if count call fails)
-                    const heuristicTotal = rows.length;
-                    const heuristicHasMore = rows.length >= requestedLimit;
+                    const emit = (total: number, hasMore: boolean) => {
+                        if (!active || currentUpdateId !== lastUpdateId) return;
+                        onUpdate({
+                            data: rows,
+                            meta: {
+                                total,
+                                limit: requestedLimit,
+                                offset,
+                                hasMore
+                            }
+                        });
+                    };
+
+                    // With no count to go on, the only defensible total is a
+                    // lower bound: the rows on this page plus the ones paged
+                    // past to reach them. Reporting `rows.length` claimed a
+                    // collection read at offset 10 held two rows.
+                    const emitWithoutCount = () => emit(
+                        offset + rows.length,
+                        rows.length >= requestedLimit
+                    );
 
-                    // Try to get authoritative count; fall back to heuristic
                     if (client.count) {
                         client.count(params)
                             .then((total) => {
-                                if (active && currentUpdateId === lastUpdateId) {
-                                    onUpdate({
-                                        data: rows,
-                                        meta: {
-                                            total,
-                                            limit: requestedLimit,
-                                            offset,
-                                            hasMore: offset + rows.length < total
-                                        }
-                                    });
-                                }
+                                lastKnownTotal = total;
+                                emit(total, offset + rows.length < total);
                             })
                             .catch(() => {
-                                // Count failed — use heuristic meta
-                                if (active && currentUpdateId === lastUpdateId) {
-                                    onUpdate({
-                                        data: rows,
-                                        meta: {
-                                            total: heuristicTotal,
-                                            limit: requestedLimit,
-                                            offset,
-                                            hasMore: heuristicHasMore
-                                        }
-                                    });
+                                // A count that failed is not evidence about the
+                                // size of the collection. Keep the last real
+                                // answer; only guess if there has never been one.
+                                if (lastKnownTotal !== undefined) {
+                                    emit(lastKnownTotal, offset + rows.length < lastKnownTotal);
+                                } else {
+                                    emitWithoutCount();
                                 }
                             });
                     } else {
-                        // No count method — fire immediately with heuristic meta
-                        onUpdate({
-                            data: rows,
-                            meta: {
-                                total: heuristicTotal,
-                                limit: requestedLimit,
-                                offset,
-                                hasMore: heuristicHasMore
-                            }
-                        });
+                        emitWithoutCount();
                     }
                 },
                 onError