@rebasepro/client 0.17.3 → 0.18.0

package/dist/offline-connectivity.d.ts

@@ -10,7 +10,18 @@
  * store immediately, which is the difference between an app that freezes when
  * the wifi drops and one that does not.
  */
-/** The request never reached the server, so nothing was decided by it. */
+/**
+ * The request never reached the server, so nothing was decided by it.
+ *
+ * One question, one answer: `status === 0` is how a transport spells "there
+ * was no response at all", and the transport now wraps every `fetch` rejection
+ * into a `RebaseApiError` carrying it. This used to also sniff for the shapes
+ * a raw `fetch` rejects with — a `TypeError` in a browser, an `AbortError`, a
+ * `TimeoutError` — which is a list that has to be kept in step with three
+ * runtimes and was wrong in both directions: it missed anything they add, and
+ * it claimed a `TypeError` thrown by application code inside a callback was a
+ * network failure, which quietly served a cached answer in its place.
+ */
 export declare function isNetworkError(error: unknown): boolean;
 /**
  * Is the server still answering an earlier attempt of this same write?

package/dist/offline.d.ts

@@ -119,7 +119,14 @@ export interface OfflineApi {
     /** Subscribe to queue-size changes (for a "pending changes" badge). */
     onQueueChange(listener: (count: number) => void): () => void;
 }
-/** True when a read failed because there was neither network nor local data. */
+/**
+ * True when a read failed because there was neither network nor local data.
+ *
+ * The code is `OFFLINE`. It was `"offline"`, the one lowercase code in a
+ * surface whose every other code is `SCREAMING_SNAKE_CASE` — including the
+ * `NETWORK_ERROR` it sits next to — so `e.code === "OFFLINE"`, which is what
+ * anyone writes, never matched.
+ */
 export declare function isOfflineError(error: unknown): boolean;
 type AnyRow = Record<string, unknown>;
 type InnerFactory = (slug: string) => SDKCollectionClient<AnyRow>;
@@ -215,6 +222,21 @@ export declare class OfflineManager {
      */
     private answer;
     private localFind;
+    /**
+     * A temporary id of the type this collection's ids actually have.
+     *
+     * There is no schema here to read it off — the generated `Database` types
+     * are erased at compile time, and the whole point of this path is that the
+     * server is unreachable. So it is read off the rows the local database
+     * already holds: a collection whose cached ids are numbers gets a negative
+     * number, and everything else gets a UUID.
+     *
+     * A collection with nothing cached falls back to a UUID, which is the same
+     * guess as before — but that is a first write on a device that has never
+     * read the collection, which is also the case where nothing local can tell
+     * the difference. Reading one row first is enough to fix it.
+     */
+    private mintOfflineId;
     private rawLocalRow;
     private localRow;
     private setLocalRow;

package/dist/query-contract.types.d.ts

@@ -141,4 +141,34 @@ export declare const readUnknown: (result: FindResult<ContractRow>) => any;
  * nothing here noticed.
  */
 export declare const rowStaysIndexable: (result: FindResult<ContractRow>) => Record<string, unknown>[];
+/**
+ * Four calls that `find(params)` took and the fluent builder refused.
+ *
+ * The two forms are one API with two spellings, and a caller who reaches for
+ * the chainable one should not discover it is a subset. Each of these is
+ * documented, works over HTTP, and was a compile error on a generated SDK —
+ * which is to say: on every project that took the trouble to be typed.
+ */
+/** 1. A relation path. `find({ where: { "author.name": … } })` always compiled. */
+export declare const fluentRelationPath: (qb: SDKQueryBuilderInterface<PostRow>) => SDKQueryBuilderInterface<PostRow>;
+/** 2. A JSON path into a `jsonb` column — `?metadata->>tier=eq.gold` on the wire. */
+export declare const fluentJsonPath: (qb: SDKQueryBuilderInterface<ContractRow>) => SDKQueryBuilderInterface<ContractRow>;
+/** 3. An aggregate over a to-many relation, which `FindParams.orderBy` takes. */
+export declare const fluentRelationAggregateSort: (qb: SDKQueryBuilderInterface<PostRow>) => SDKQueryBuilderInterface<PostRow>;
+/** 4. Paging past the `limit` ceiling, which the client can do and the builder could not. */
+export declare const fluentIterate: (qb: SDKQueryBuilderInterface<ContractRow>) => AsyncIterableIterator<ContractRow>;
+export declare const fluentFindAll: (qb: SDKQueryBuilderInterface<ContractRow>) => Promise<ContractRow[]>;
+/**
+ * The loosening is bounded. A path overload keyed on "anything that is not a
+ * column" would have caught a mistyped column too and typed its value as
+ * `unknown` — turning every one of the assertions above into a silent pass.
+ * These are the same refusals as before.
+ */
+export declare const fluentPathTypo: (qb: SDKQueryBuilderInterface<ContractRow>) => SDKQueryBuilderInterface<ContractRow>;
+export declare const fluentPathDoesNotLoosenValues: (qb: SDKQueryBuilderInterface<ContractRow>) => SDKQueryBuilderInterface<ContractRow>;
+export declare const fluentAggregateSortTypo: (qb: SDKQueryBuilderInterface<PostRow>) => SDKQueryBuilderInterface<PostRow>;
+/** And the object form still takes all four, unchanged. */
+export declare const paramsRelationPath: FindParams<PostRow>;
+export declare const paramsJsonPath: FindParams<ContractRow>;
+export declare const paramsRelationAggregateSort: FindParams<PostRow>;
 export {};

package/dist/realtime-channel.d.ts

@@ -57,6 +57,7 @@ export interface BroadcastEvent {
  */
 export type { ChannelHistoryEntry } from "@rebasepro/types";
 import type { ChannelHistoryEntry } from "@rebasepro/types";
+import { RebaseApiError } from "@rebasepro/types";
 /** The answer to a catch-up request. */
 export interface ChannelHistoryResult {
     messages: ChannelHistoryEntry[];
@@ -96,6 +97,7 @@ export declare class RebaseRealtimeChannel {
     private transport;
     private presenceHandlers;
     private broadcastHandlers;
+    private errorHandlers;
     private unsubscribers;
     /** Last known roster, kept so handlers always get a full picture. */
     private presences;
@@ -205,8 +207,34 @@ export declare class RebaseRealtimeChannel {
      * known, then on every change.
      */
     onPresence(handler: (state: PresenceState, diff?: PresenceDiff) => void): () => void;
-    /** Send a broadcast. The sender does not receive its own message. */
+    /**
+     * Send a broadcast. The sender does not receive its own message.
+     *
+     * Resolves when the frame is written to the socket, **not** when the server
+     * has accepted it. Channel frames are fire-and-forget by design — a
+     * collaborative app broadcasts a cursor position sixty times a second, and
+     * waiting for an acknowledgement on each would make that a round trip.
+     *
+     * A refusal therefore arrives on {@link onError}, not as a rejection here.
+     */
     broadcast(event: string, payload: unknown): Promise<void>;
+    /**
+     * Observe refusals about this channel.
+     *
+     * `CHANNEL_FORBIDDEN` when an authorizer refuses a join, a broadcast or a
+     * history read; `RATE_LIMITED` past the channel frame budget;
+     * `CHANNEL_HISTORY_WRITE_FAILED` / `CHANNEL_HISTORY_READ_FAILED` when
+     * retention cannot be served; `CHANNEL_BUS_PAYLOAD_TOO_LARGE` when a
+     * broadcast on an ephemeral channel is too big to cross the bus.
+     *
+     * These used to be dropped on the floor — there is no promise to reject on
+     * a fire-and-forget frame, so a forbidden broadcast looked exactly like a
+     * delivered one. With no handler attached they are logged as a warning,
+     * because an unobserved refusal is the failure this exists for.
+     *
+     * @returns An unsubscribe function.
+     */
+    onError(handler: (error: RebaseApiError) => void): () => void;
     /** Observe broadcasts. Pass an event name to filter. */
     onBroadcast(handler: (event: BroadcastEvent) => void): () => void;
     onBroadcast(event: string, handler: (payload: unknown) => void): () => void;

package/dist/sdk_query_builder.d.ts

@@ -1,4 +1,4 @@
-import { FindResult, LogicalCondition, SDKCollectionClient, SDKQueryBuilderInterface, WhereFilterOp, WhereValueFor, type ComputedSortField } from "@rebasepro/types";
+import { FindResult, LogicalCondition, PageWalkOptions, RelationAggregateSort, SDKCollectionClient, SDKQueryBuilderInterface, WhereFilterOp, WhereValueFor, type ComputedSortField, type FieldPath, type NonColumnFieldPath } from "@rebasepro/types";
 /**
  * SDK Query Builder — returns flat rows (`FindResult<M>`) instead of
  * Entity-wrapped results (`FindResponse<M>`).
@@ -22,6 +22,8 @@ export declare class SDKQueryBuilder<M extends Record<string, unknown> = Record<
      * client.data.users.where('age', '>=', 18).find()
      */
     where<K extends keyof M & string, Op extends WhereFilterOp>(column: K, operator: Op, value: WhereValueFor<Op, M[K]>): this;
+    /** A relation path (`author.name`) or a JSON path (`metadata->>tier`). */
+    where(column: NonColumnFieldPath, operator: WhereFilterOp, value: unknown): this;
     where(logicalCondition: LogicalCondition): this;
     /**
      * Order the results by a specific column.
@@ -31,7 +33,7 @@ export declare class SDKQueryBuilder<M extends Record<string, unknown> = Record<
      * `.orderBy("roles").orderBy("created_at", "desc")` sorts by role and
      * shows the newest first within each one.
      */
-    orderBy(column: (keyof M & string) | ComputedSortField, direction?: "asc" | "desc"): this;
+    orderBy(column: FieldPath<M> | ComputedSortField | RelationAggregateSort, direction?: "asc" | "desc"): this;
     /**
      * Limit the number of results returned.
      */
@@ -99,12 +101,29 @@ export declare class SDKQueryBuilder<M extends Record<string, unknown> = Record<
      * Execute the find query and return the results as flat rows.
      */
     find(): Promise<FindResult<M>>;
+    /**
+     * Page through everything this query matches, one row at a time.
+     *
+     * `.limit()` on the builder becomes the page size, so the ceiling on a
+     * single `find()` is not a ceiling on what the query can read.
+     */
+    iterate(options?: PageWalkOptions<M>): AsyncIterableIterator<M>;
+    /** Collect everything this query matches into one array. */
+    findAll(options?: PageWalkOptions<M> & {
+        maxRows?: number;
+    }): Promise<M[]>;
     /**
      * Count the records matching this query.
      */
     count(): Promise<number>;
     /**
      * Listen to realtime updates matching this query.
+     *
+     * The guard that used to stand here — `if (!this.collection.listen) throw`
+     * — has moved onto the client itself, which is where the same failure had
+     * to be diagnosed anyway: `client.data.posts.listen(…)`, one call short of
+     * this builder, answered `undefined is not a function`. The message is now
+     * the same either way.
      */
     listen(onUpdate: (data: FindResult<M>) => void, onError?: (error: Error) => void): () => void;
 }

package/dist/transport.d.ts

@@ -71,6 +71,30 @@ export interface RebaseClientConfig {
      * and nothing is ever warned about.
      */
     anonymous?: boolean;
+    /**
+     * The schema this client was generated against, sent as `x-rebase-schema`.
+     *
+     * `rebase generate-sdk` writes the value into `schema.meta.ts` as
+     * `SCHEMA_VERSION`; pass it here and every request carries it. Advisory —
+     * nothing is ever refused for it — but it is what lets a server say "this
+     * client was built against a schema three deploys old" instead of
+     * answering a renamed field with a bare 400.
+     *
+     * The compatibility matrix has listed this header as something the SDK
+     * sends since it was written. Nothing sent it: the constant existed, the
+     * server echoed it back on two routes, and no client ever put it on a
+     * request. This is the missing half.
+     */
+    schemaVersion?: string;
+    /**
+     * Headers added to every request, beneath any per-request `headers`.
+     *
+     * For identifying the caller, not for authenticating it — the CLI uses it
+     * to send `User-Agent: rebase-cli/<version>`, which is what a control plane
+     * needs before it can refuse a CLI that is too old by name. `Authorization`
+     * is not settable here; it always comes from the token.
+     */
+    headers?: Record<string, string>;
 }
 /**
  * Facts about the surrounding client that the transport cannot read off its own

package/package.json

@@ -1,37 +1,49 @@
 {
   "name": "@rebasepro/client",
-  "type": "module",
-  "version": "0.17.3",
+  "version": "0.18.0",
   "description": "HTTP SDK client for the Rebase custom backend",
-  "funding": {
-    "url": "https://github.com/sponsors/rebaseco"
+  "keywords": [
+    "rebase",
+    "sdk",
+    "client",
+    "postgres",
+    "backend",
+    "typescript"
+  ],
+  "homepage": "https://rebase.pro",
+  "bugs": {
+    "url": "https://github.com/rebasepro/rebase/issues"
   },
-  "author": "Rebase",
-  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/rebasepro/rebase.git",
     "directory": "packages/client"
   },
+  "funding": {
+    "url": "https://github.com/sponsors/rebasepro"
+  },
+  "license": "MIT",
+  "author": "Rebase",
+  "type": "module",
   "main": "./dist/index.es.js",
   "module": "./dist/index.es.js",
   "types": "./dist/index.d.ts",
-  "source": "src/index.ts",
   "engines": {
-    "node": ">=20"
+    "node": ">=22.22.0"
   },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "development": "./dist/index.es.js",
-      "import": "./dist/index.es.js"
+      "import": "./dist/index.es.js",
+      "default": "./dist/index.es.js"
     },
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@rebasepro/common": "0.17.3",
-    "@rebasepro/types": "0.17.3",
-    "@rebasepro/utils": "0.17.3"
+    "@rebasepro/common": "0.18.0",
+    "@rebasepro/utils": "0.18.0",
+    "@rebasepro/types": "0.18.0"
   },
   "devDependencies": {
     "@jest/globals": "^30.4.1",
@@ -48,8 +60,7 @@
     "ws": "^8.21.1"
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "gitHead": "d935eefa5aa8d1009a2398cfac2c1e4ee9aeb6b6",
   "publishConfig": {
@@ -74,13 +85,15 @@
       "^@rebasepro/common$": "<rootDir>/../common/src/index.ts",
       "^@rebasepro/types$": "<rootDir>/../types/src/index.ts",
       "^@rebasepro/utils$": "<rootDir>/../utils/src/index.ts"
-    }
+    },
+    "testTimeout": 30000
   },
   "scripts": {
     "watch": "vite build --watch",
     "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.prod.json && node ../../tooling/scripts/add-dts-extensions.mjs dist && node ../../tooling/scripts/assert-build-output.mjs",
     "test:lint": "eslint \"src/**\" --quiet",
     "test": "jest --passWithNoTests --forceExit",
+    "test:watch": "jest --watch",
     "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f"
   }
 }

package/src/admin.ts

@@ -1,90 +0,0 @@
-import type { Transport } from "./transport";
-import { AdminUser } from "@rebasepro/types";
-
-export type { AdminUser };
-
-
-export interface CreateAdminOptions {
-    adminPath?: string;
-}
-
-export function createAdmin(transport: Transport, options?: CreateAdminOptions) {
-    const opts = options || {};
-    const adminPath = opts.adminPath || "/admin";
-
-    async function listUsers() {
-        return transport.request<{ users: AdminUser[] }>(adminPath + "/users", { method: "GET" });
-    }
-
-    async function listUsersPaginated(options?: { search?: string; limit?: number; offset?: number; orderBy?: string; orderDir?: "asc" | "desc" }) {
-        const params = new URLSearchParams();
-        if (options?.limit !== undefined) params.set("limit", String(options.limit));
-        if (options?.offset !== undefined) params.set("offset", String(options.offset));
-        if (options?.search) params.set("search", options.search);
-        if (options?.orderBy) params.set("orderBy", options.orderBy);
-        if (options?.orderDir) params.set("orderDir", options.orderDir);
-        const qs = params.toString();
-        return transport.request<{ users: AdminUser[]; total: number; limit: number; offset: number }>(
-            adminPath + "/users" + (qs ? "?" + qs : ""), { method: "GET" }
-        );
-    }
-
-    async function getUser(userId: string) {
-        return transport.request<{ user: AdminUser }>(adminPath + "/users/" + encodeURIComponent(userId), { method: "GET" });
-    }
-
-    async function createUser(data: { email: string, displayName?: string, password?: string, roles?: string[] }) {
-        return transport.request<{ user: AdminUser }>(adminPath + "/users", {
-            method: "POST",
-            body: JSON.stringify(data)
-        });
-    }
-
-    async function updateUser(userId: string, data: { email?: string, displayName?: string, password?: string, roles?: string[] }) {
-        return transport.request<{ user: AdminUser }>(adminPath + "/users/" + encodeURIComponent(userId), {
-            method: "PUT",
-            body: JSON.stringify(data)
-        });
-    }
-
-    async function deleteUser(userId: string) {
-        return transport.request<{ success: boolean }>(adminPath + "/users/" + encodeURIComponent(userId), {
-            method: "DELETE"
-        });
-    }
-
-    async function resetPassword(userId: string, options?: { password?: string }) {
-        return transport.request<{ user: AdminUser; temporaryPassword?: string; invitationSent?: boolean; emailDeliveryFailed?: boolean }>(
-            adminPath + "/users/" + encodeURIComponent(userId) + "/reset-password",
-            {
-                method: "POST",
-                ...(options?.password ? { body: JSON.stringify({ password: options.password }) } : {})
-            }
-        );
-    }
-
-    async function listRoles() {
-        return transport.request<{ roles: Array<{ id: string; name: string }> }>(
-            adminPath + "/roles",
-            { method: "GET" }
-        );
-    }
-
-    async function bootstrap() {
-        return transport.request<{ success: boolean; message: string; user: { uid: string; roles: string[] } }>(adminPath + "/bootstrap", {
-            method: "POST"
-        });
-    }
-
-    return {
-        listUsers,
-        listUsersPaginated,
-        getUser,
-        createUser,
-        updateUser,
-        deleteUser,
-        resetPassword,
-        listRoles,
-        bootstrap
-    };
-}

package/src/anonymous-client-guard.test.ts

@@ -1,190 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, jest } from "@jest/globals";
-import { ANONYMOUS_SERVER_CLIENT_WARNING, createTransport } from "./transport";
-import { createRebaseClient } from "./index";
-
-/**
- * A client built off-browser with no credential is silently anonymous: RLS
- * answers it with whatever is public, which is usually nothing. A `scrape-jobs`
- * script hit this twice. These pin the *narrowness* of the guard as much as the
- * guard itself — a warning that fires on legitimate anonymous clients (browser
- * before sign-in, public reads) is noise that teaches people to ignore warnings.
- */
-
-type MockFetch = jest.Mock<(input: RequestInfo | URL, init?: RequestInit) => Promise<Partial<Response>>>;
-
-const okFetch = (): MockFetch => {
-    const fetchMock = jest.fn() as MockFetch;
-    fetchMock.mockResolvedValue({
-        ok: true,
-        status: 200,
-        text: async () => JSON.stringify({ data: [] })
-    });
-    return fetchMock;
-};
-
-const setWindow = (defined: boolean) => {
-    if (!defined) { delete (globalThis as never as { window?: unknown }).window; return; }
-    (globalThis as never as { window: unknown }).window = { location: { origin: "https://app.example.com", href: "https://app.example.com/" } };
-};
-
-const setDocument = (defined: boolean) => {
-    if (!defined) { delete (globalThis as never as { document?: unknown }).document; return; }
-    (globalThis as never as { document: unknown }).document = { cookie: "" };
-};
-
-let warn: jest.SpiedFunction<typeof console.warn>;
-
-beforeEach(() => {
-    warn = jest.spyOn(console, "warn").mockImplementation(() => undefined);
-});
-
-afterEach(() => {
-    warn.mockRestore();
-    setWindow(false);
-    setDocument(false);
-});
-
-const anonymousWarnings = () => warn.mock.calls.filter(([first]) => first === ANONYMOUS_SERVER_CLIENT_WARNING);
-
-describe("anonymous server client guard", () => {
-    it("warns when a Node-side client has no credential at all", async () => {
-        const transport = createTransport({ baseUrl: "http://localhost:3001", fetch: okFetch() as typeof globalThis.fetch });
-
-        await transport.request("/data/jobs");
-
-        expect(anonymousWarnings()).toHaveLength(1);
-        expect(anonymousWarnings()[0][0]).toContain("anonymous: true");
-    });
-
-    it("warns once per client, not once per request", async () => {
-        const transport = createTransport({ baseUrl: "http://localhost:3001", fetch: okFetch() as typeof globalThis.fetch });
-
-        await transport.request("/data/jobs");
-        await transport.request("/data/jobs");
-        await transport.request("/data/other");
-
-        expect(anonymousWarnings()).toHaveLength(1);
-    });
-
-    it("warns per client, so a second offending client is still reported", async () => {
-        const a = createTransport({ baseUrl: "http://localhost:3001", fetch: okFetch() as typeof globalThis.fetch });
-        const b = createTransport({ baseUrl: "http://localhost:3001", fetch: okFetch() as typeof globalThis.fetch });
-
-        await a.request("/data/jobs");
-        await b.request("/data/jobs");
-
-        expect(anonymousWarnings()).toHaveLength(2);
-    });
-
-    it("stays silent in a browser, where anonymous-before-sign-in is normal", async () => {
-        setWindow(true);
-        const transport = createTransport({ fetch: okFetch() as typeof globalThis.fetch });
-
-        await transport.request("/data/posts");
-
-        expect(anonymousWarnings()).toHaveLength(0);
-    });
-
-    it("stays silent when only `document` is defined, so an SSR/test shim is not mistaken for Node", async () => {
-        setDocument(true);
-        const transport = createTransport({ baseUrl: "http://localhost:3001", fetch: okFetch() as typeof globalThis.fetch });
-
-        await transport.request("/data/posts");
-
-        expect(anonymousWarnings()).toHaveLength(0);
-    });
-
-    it("stays silent when a token was passed", async () => {
-        const transport = createTransport({ baseUrl: "http://localhost:3001", token: "service-key", fetch: okFetch() as typeof globalThis.fetch });
-
-        await transport.request("/data/jobs");
-
-        expect(anonymousWarnings()).toHaveLength(0);
-    });
-
-    it("stays silent when the token arrives after construction (the reason this is checked at first request)", async () => {
-        const transport = createTransport({ baseUrl: "http://localhost:3001", fetch: okFetch() as typeof globalThis.fetch });
-        transport.setToken("service-key");
-
-        await transport.request("/data/jobs");
-
-        expect(anonymousWarnings()).toHaveLength(0);
-    });
-
-    it("stays silent when an auth token getter is installed", async () => {
-        const transport = createTransport({ baseUrl: "http://localhost:3001", fetch: okFetch() as typeof globalThis.fetch });
-        transport.setAuthTokenGetter(async () => "fetched-token");
-
-        await transport.request("/data/jobs");
-
-        expect(anonymousWarnings()).toHaveLength(0);
-    });
-
-    it("stays silent for a token getter that has nothing yet — the credential path exists", async () => {
-        const transport = createTransport({ baseUrl: "http://localhost:3001", fetch: okFetch() as typeof globalThis.fetch });
-        transport.setAuthTokenGetter(async () => null);
-
-        await transport.request("/data/jobs");
-
-        expect(anonymousWarnings()).toHaveLength(0);
-    });
-
-    it("stays silent for the cookie auth flow, where the credential is not a header", async () => {
-        const transport = createTransport(
-            { baseUrl: "http://localhost:3001", fetch: okFetch() as typeof globalThis.fetch },
-            { credentialOutOfBand: true }
-        );
-
-        await transport.request("/data/jobs");
-
-        expect(anonymousWarnings()).toHaveLength(0);
-    });
-
-    it("stays silent when the caller opted in with `anonymous: true`", async () => {
-        const transport = createTransport({ baseUrl: "http://localhost:3001", anonymous: true, fetch: okFetch() as typeof globalThis.fetch });
-
-        await transport.request("/data/jobs");
-
-        expect(anonymousWarnings()).toHaveLength(0);
-    });
-});
-
-describe("anonymous server client guard, through createRebaseClient", () => {
-    it("warns for a credential-less client built in a script", async () => {
-        const client = createRebaseClient({
-            baseUrl: "http://localhost:3001",
-            realtime: false,
-            fetch: okFetch() as typeof globalThis.fetch
-        });
-
-        await client.collection("jobs").find();
-
-        expect(anonymousWarnings()).toHaveLength(1);
-    });
-
-    it("stays silent when `auth.authFlowMode` is cookie", async () => {
-        const client = createRebaseClient({
-            baseUrl: "http://localhost:3001",
-            realtime: false,
-            fetch: okFetch() as typeof globalThis.fetch,
-            auth: { authFlowMode: "cookie", persistSession: false }
-        });
-
-        await client.collection("jobs").find();
-
-        expect(anonymousWarnings()).toHaveLength(0);
-    });
-
-    it("stays silent when the caller opted in with `anonymous: true`", async () => {
-        const client = createRebaseClient({
-            baseUrl: "http://localhost:3001",
-            realtime: false,
-            anonymous: true,
-            fetch: okFetch() as typeof globalThis.fetch
-        });
-
-        await client.collection("jobs").find();
-
-        expect(anonymousWarnings()).toHaveLength(0);
-    });
-});