@rebasepro/client 0.17.3-canary.gdd23447 → 0.18.0

package/src/backups.ts

@@ -1,40 +0,0 @@
-import { Transport } from "./transport";
-import type { BackupInfo, BackupDestinationKind } from "@rebasepro/types";
-
-export interface CreateBackupsOptions {
-    backupsPath?: string;
-}
-
-export function createBackups(transport: Transport, options?: CreateBackupsOptions) {
-    const backupsPath = options?.backupsPath || "/admin/backups";
-
-    async function list(): Promise<{
-        backups: BackupInfo[];
-        destinationKind: BackupDestinationKind;
-        configured: boolean;
-    }> {
-        return transport.request(backupsPath, { method: "GET" });
-    }
-
-    /**
-     * Download a backup's bytes. Uses an authenticated fetch (not the JSON
-     * transport) so the octet-stream response comes back as a Blob.
-     */
-    async function download(key: string): Promise<Blob> {
-        const token = await transport.resolveToken();
-        // Mirror transport.request's URL construction (baseUrl + apiPath + path)
-        // — this endpoint returns an octet-stream, so we fetch it directly
-        // instead of going through the JSON transport.
-        const url = `${transport.baseUrl}${transport.apiPath}${backupsPath}/download?key=${encodeURIComponent(key)}`;
-        const res = await fetch(url, {
-            method: "GET",
-            headers: token ? { Authorization: `Bearer ${token}` } : {}
-        });
-        if (!res.ok) {
-            throw new Error(`Failed to download backup (${res.status})`);
-        }
-        return res.blob();
-    }
-
-    return { list, download };
-}

package/src/client-close.test.ts

@@ -1,80 +0,0 @@
-import { jest } from "@jest/globals";
-import { createRebaseClient } from "./index";
-
-/**
- * `close()` has one job: leave nothing behind that can keep a process alive.
- *
- * The realtime socket is the obvious such handle and was the only one this
- * method released. The scheduled token refresh is the other, and it is easy to
- * miss because it only exists once somebody signs in: `scheduleRefresh` arms a
- * plain `setTimeout` for roughly the access token's lifetime, and it is not
- * `unref`'d. So a signed-in Node client — a seed script, a cron handler, a job,
- * an SSR request — released its socket, called `close()` exactly as documented,
- * and still hung until the token would have expired.
- *
- * Found by `tests/e2e/tests/client-sdk-e2e.ts`, which reported every check green and
- * then never exited. Pinned here rather than only there because that suite needs
- * Docker and a real Postgres, and this costs nothing.
- *
- * The assertion is the pending timer count, not a spy on `stopAutoRefresh`:
- * what matters is that no handle survives, not which internal call removed it.
- */
-describe("client.close()", () => {
-    const realFetch = globalThis.fetch;
-
-    afterEach(() => {
-        globalThis.fetch = realFetch;
-        jest.useRealTimers();
-        jest.restoreAllMocks();
-    });
-
-    /** A login response shaped exactly as `handleAuthResponse` reads it. */
-    function loginResponse(accessTokenExpiresAt: number) {
-        return new Response(
-            JSON.stringify({
-                tokens: { accessToken: "access-token",
-refreshToken: "refresh-token",
-accessTokenExpiresAt },
-                user: { uid: "user-1",
-email: "user@example.test" }
-            }),
-            { status: 200,
-headers: { "content-type": "application/json" } }
-        );
-    }
-
-    it("clears the scheduled token refresh, so a signed-in script can exit", async () => {
-        jest.useFakeTimers();
-
-        // An hour out, so the refresh is scheduled rather than fired
-        // immediately — `scheduleRefresh` runs the refresh inline when the
-        // delay has already elapsed, which would arm no timer and let a broken
-        // `close()` pass this test.
-        const expiresAt = Date.now() + 60 * 60 * 1000;
-        globalThis.fetch = jest.fn(async () => loginResponse(expiresAt)) as unknown as typeof fetch;
-
-        // `realtime: false` so the socket cannot account for a pending handle:
-        // the only thing this test may observe is the refresh timer.
-        const client = createRebaseClient({ baseUrl: "http://localhost:9999",
-realtime: false });
-
-        await client.auth.signInWithEmail("user@example.test", "password");
-        expect(jest.getTimerCount()).toBeGreaterThan(0);
-
-        client.close();
-        expect(jest.getTimerCount()).toBe(0);
-    });
-
-    it("is safe on a client that never signed in, and safe to call twice", () => {
-        jest.useFakeTimers();
-
-        const client = createRebaseClient({ baseUrl: "http://localhost:9999",
-realtime: false });
-
-        expect(() => {
-            client.close();
-            client.close();
-        }).not.toThrow();
-        expect(jest.getTimerCount()).toBe(0);
-    });
-});

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

@@ -1,105 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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.test.ts

@@ -1,293 +0,0 @@
-import { jest } from "@jest/globals";
-import { createCollectionClient } from "./collection";
-import type { Transport } from "./transport";
-
-function createMockTransport(): 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)
-    };
-}
-
-describe("createCollectionClient", () => {
-    let transport: Transport;
-
-    beforeEach(() => {
-        transport = createMockTransport();
-    });
-
-    describe("count()", () => {
-        it("should call the /count endpoint and return the count", async () => {
-            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({ count: 42 });
-
-            const client = createCollectionClient(transport, "products");
-            const result = await client.count();
-
-            expect(transport.request).toHaveBeenCalledWith(
-                "/data/products/count",
-                { method: "GET" }
-            );
-            expect(result).toBe(42);
-        });
-
-        it("should forward where filters to the count endpoint", async () => {
-            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({ count: 7 });
-
-            const client = createCollectionClient(transport, "products");
-            const result = await client.count({
-                where: { status: ["==", "published"] }
-            });
-
-            expect(transport.request).toHaveBeenCalledWith(
-                expect.stringContaining("/data/products/count?"),
-                { method: "GET" }
-            );
-            // Verify the query string includes the filter
-            const calledUrl = (transport.request as ReturnType<typeof jest.fn>).mock.calls[0][0] as string;
-            expect(calledUrl).toContain("status=");
-            expect(result).toBe(7);
-        });
-
-        it("should forward orderBy to the count endpoint", async () => {
-            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({ count: 15 });
-
-            const client = createCollectionClient(transport, "items");
-            const result = await client.count({
-                orderBy: ["created_at", "desc"]
-            });
-
-            const calledUrl = (transport.request as ReturnType<typeof jest.fn>).mock.calls[0][0] as string;
-            expect(calledUrl).toContain("/data/items/count?");
-            expect(calledUrl).toContain("orderBy=");
-            expect(result).toBe(15);
-        });
-
-        it("should NOT include limit or offset in the count request", async () => {
-            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({ count: 100 });
-
-            const client = createCollectionClient(transport, "users");
-            // Even if the caller passes limit/offset in params, they should be stripped
-            await client.count({ limit: 50,
-offset: 10 });
-
-            const calledUrl = (transport.request as ReturnType<typeof jest.fn>).mock.calls[0][0] as string;
-            expect(calledUrl).not.toContain("limit=");
-            expect(calledUrl).not.toContain("offset=");
-        });
-
-        it("should return 0 when meta.count is missing", async () => {
-            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({});
-
-            const client = createCollectionClient(transport, "empty");
-            const result = await client.count();
-
-            expect(result).toBe(0);
-        });
-
-        it("should forward searchString to the count endpoint", async () => {
-            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({ count: 3 });
-
-            const client = createCollectionClient(transport, "articles");
-            const result = await client.count({
-                searchString: "hello world"
-            });
-
-            const calledUrl = (transport.request as ReturnType<typeof jest.fn>).mock.calls[0][0] as string;
-            expect(calledUrl).toContain("searchString=");
-            expect(calledUrl).toContain("hello");
-            expect(result).toBe(3);
-        });
-
-        it("should forward multiple where filters correctly", async () => {
-            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({ count: 5 });
-
-            const client = createCollectionClient(transport, "orders");
-            await client.count({
-                where: {
-                    status: ["==", "active"],
-                    total: [">=", 100]
-                }
-            });
-
-            const calledUrl = (transport.request as ReturnType<typeof jest.fn>).mock.calls[0][0] as string;
-            expect(calledUrl).toContain("status=");
-            expect(calledUrl).toContain("total=");
-        });
-    });
-
-    describe("find()", () => {
-        it("should call the list endpoint and return flat rows", async () => {
-            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({
-                data: [{ id: "1",
-name: "Product A" }],
-                meta: { total: 1,
-limit: 20,
-offset: 0,
-hasMore: false }
-            });
-
-            const client = createCollectionClient(transport, "products");
-            const result = await client.find();
-
-            expect(transport.request).toHaveBeenCalledWith(
-                "/data/products",
-                { method: "GET" }
-            );
-            expect(result.data).toHaveLength(1);
-            // Flat row access — no .values wrapper
-            expect(result.data[0].id).toBe("1");
-            expect((result.data[0] as Record<string, unknown>).name).toBe("Product A");
-            // No path field — that's admin leakage
-            expect((result.data[0] as Record<string, unknown>).path).toBeUndefined();
-            expect(result.meta.total).toBe(1);
-        });
-    });
-
-    describe("findById()", () => {
-        it("should return a flat row directly", async () => {
-            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({ id: "42", title: "Hello" });
-
-            const client = createCollectionClient(transport, "posts");
-            const result = await client.findById("42");
-
-            expect(transport.request).toHaveBeenCalledWith(
-                "/data/posts/42",
-                { method: "GET" }
-            );
-            expect(result).toBeDefined();
-            expect(result!.id).toBe("42");
-            expect((result as Record<string, unknown>).title).toBe("Hello");
-        });
-
-        it("should return undefined for 404", async () => {
-            const { RebaseApiError } = await import("./transport");
-            (transport.request as ReturnType<typeof jest.fn>).mockRejectedValue(
-                new RebaseApiError("Not Found", { status: 404 })
-            );
-
-            const client = createCollectionClient(transport, "posts");
-            const result = await client.findById("999");
-            expect(result).toBeUndefined();
-        });
-    });
-
-    describe("create()", () => {
-        it("should return a flat row", async () => {
-            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({ id: "new-1", title: "Created" });
-
-            const client = createCollectionClient(transport, "posts");
-            const result = await client.create({ title: "Created" } as Record<string, unknown>);
-
-            expect(result.id).toBe("new-1");
-            expect((result as Record<string, unknown>).title).toBe("Created");
-        });
-    });
-
-    describe("update()", () => {
-        it("should return a flat row", async () => {
-            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({ id: "1", title: "Updated" });
-
-            const client = createCollectionClient(transport, "posts");
-            const result = await client.update("1", { title: "Updated" } as Record<string, unknown>);
-
-            expect(result.id).toBe("1");
-            expect((result as Record<string, unknown>).title).toBe("Updated");
-        });
-
-        it("should throw RebaseApiError for 404", async () => {
-            const { RebaseApiError } = await import("./transport");
-            (transport.request as ReturnType<typeof jest.fn>).mockRejectedValue(
-                new RebaseApiError("Not Found", { status: 404 })
-            );
-
-            const client = createCollectionClient(transport, "posts");
-            await expect(
-                client.update("999", { title: "Nope" } as Record<string, unknown>)
-            ).rejects.toMatchObject({ status: 404 });
-        });
-    });
-
-    describe("delete()", () => {
-        it("should throw RebaseApiError for 404", async () => {
-            const { RebaseApiError } = await import("./transport");
-            (transport.request as ReturnType<typeof jest.fn>).mockRejectedValue(
-                new RebaseApiError("Not Found", { status: 404 })
-            );
-
-            const client = createCollectionClient(transport, "posts");
-            await expect(client.delete("999")).rejects.toMatchObject({ status: 404 });
-        });
-
-        it("should propagate non-404 errors", async () => {
-            const { RebaseApiError } = await import("./transport");
-            (transport.request as ReturnType<typeof jest.fn>).mockRejectedValue(
-                new RebaseApiError("Internal Server Error", { status: 500 })
-            );
-
-            const client = createCollectionClient(transport, "posts");
-            await expect(client.delete("1")).rejects.toThrow("Internal Server Error");
-        });
-    });
-
-    /**
-     * `listen()` branches on `client.count` being present, and consumers such
-     * as EntitiesCount do the same. Asserting `typeof client.count ===
-     * "function"` on an object literal the factory just built cannot fail;
-     * what can regress is the branch downstream of it — whether the
-     * authoritative total actually reaches the subscriber, or whether the
-     * heuristic row count silently stands in for it.
-     */
-    describe("listen() total comes from count()", () => {
-        /** A WS double that hands the collection callback one page of rows. */
-        function wsDeliveringRows(rows: Record<string, unknown>[]) {
-            let emit: ((rows: Record<string, unknown>[]) => void) | undefined;
-            const ws = {
-                listenCollection: jest.fn((_params: unknown, onUpdate: any) => {
-                    emit = onUpdate;
-                    return () => undefined;
-                })
-            };
-            return { ws: ws as any,
-deliver: () => emit!(rows) };
-        }
-
-        it("reports the authoritative count, not the number of rows delivered", async () => {
-            (transport.request as ReturnType<typeof jest.fn>).mockResolvedValue({ count: 137 });
-            const { ws, deliver } = wsDeliveringRows([{ id: "1" }, { id: "2" }]);
-
-            const client = createCollectionClient(transport, "products", ws);
-            const updates: any[] = [];
-            client.listen!({ limit: 2 }, (res) => { updates.push(res); });
-            deliver();
-            await new Promise(r => setImmediate(r));
-
-            expect(updates).toHaveLength(1);
-            expect(updates[0].meta.total).toBe(137);
-            // 0 + 2 < 137, so the page is not the end of the collection.
-            expect(updates[0].meta.hasMore).toBe(true);
-        });
-
-        it("falls back to the row count when the count request fails", async () => {
-            (transport.request as ReturnType<typeof jest.fn>).mockRejectedValue(new Error("boom"));
-            const { ws, deliver } = wsDeliveringRows([{ id: "1" }, { id: "2" }]);
-
-            const client = createCollectionClient(transport, "products", ws);
-            const updates: any[] = [];
-            client.listen!({ limit: 2 }, (res) => { updates.push(res); });
-            deliver();
-            await new Promise(r => setImmediate(r));
-
-            expect(updates).toHaveLength(1);
-            expect(updates[0].meta.total).toBe(2);
-            // A full page with no authoritative total: assume there is more.
-            expect(updates[0].meta.hasMore).toBe(true);
-        });
-    });
-});