@rebasepro/client 0.12.1-canary.gf5f1d39 → 0.13.0

package/dist/auth.d.ts

@@ -1,10 +1,6 @@
 import { Transport } from "./transport";
-import type { AuthChangeEvent, RebaseSession, AuthTokens, DeviceSession, User } from "@rebasepro/types";
+import type { AuthChangeEvent, RebaseSession, DeviceSession, User } from "@rebasepro/types";
 export type { RebaseSession, AuthTokens, AuthChangeEvent, DeviceSession } from "@rebasepro/types";
-/** @deprecated Use `User` from `@rebasepro/types` instead. */
-export type RebaseUser = User;
-/** @deprecated Use `AuthTokens` from `@rebasepro/types` instead. */
-export type RebaseTokens = AuthTokens;
 /** Minimal, non-sensitive user profile returned by {@link findUserByEmail}. */
 export interface PublicUserProfile {
     uid: string;
@@ -128,6 +124,7 @@ export declare function createAuth(transport: Transport, options?: CreateAuthOpt
         refreshToken: string;
     }>;
     signOut: () => Promise<void>;
+    stopAutoRefresh: () => void;
     refreshSession: () => Promise<RebaseSession>;
     handleUnauthorized: () => Promise<boolean>;
     getUser: () => Promise<User>;
@@ -180,6 +177,7 @@ export declare function createAuth(transport: Transport, options?: CreateAuthOpt
     getAuthConfig: () => Promise<AuthConfig>;
     getSession: () => RebaseSession | null;
     onAuthStateChange: (callback: (event: AuthChangeEvent, session: RebaseSession | null) => void) => () => boolean;
+    canRestoreSession: () => boolean;
     isInitialized: () => Promise<void>;
 };
 export interface CookieStorageOptions {

package/dist/index.d.ts

@@ -21,9 +21,7 @@ export type { PaginationErrorCode } from "@rebasepro/common";
 export { QueryBuilder, or, and, cond } from "@rebasepro/common";
 export { createCookieStorage, createMemoryStorage } from "./auth";
 export type { AuthConfig, AuthStorage, CookieStorageOptions, CreateAuthOptions } from "./auth";
-export type { RebaseSession, AuthTokens, AuthChangeEvent, DeviceSession } from "@rebasepro/types";
-/** @deprecated Import `User` / `AuthTokens` from `@rebasepro/types` instead. */
-export type { RebaseUser, RebaseTokens } from "./auth";
+export type { User, RebaseSession, AuthTokens, AuthChangeEvent, DeviceSession } from "@rebasepro/types";
 export type { CreateAdminOptions } from "./admin";
 export type { AdminUser } from "./admin";
 export type { CreateCronOptions } from "./cron";
@@ -120,11 +118,17 @@ export type CreateRebaseClientResult<DB = Record<string, unknown>> = Omit<Rebase
         channel: (name: string, options?: ChannelOptions) => RebaseRealtimeChannel;
     };
     /**
-     * Release the realtime socket and its reconnect timer.
+     * Release everything this client holds that can keep a process alive: the
+     * realtime socket and its reconnect timer, channel presence heartbeats, the
+     * offline manager, and the scheduled token refresh.
      *
-     * An open socket keeps the Node event loop alive, so a script that does not
-     * call this will not exit on its own. Safe when realtime was never started
-     * (`realtime: false`), and safe to call twice.
+     * Each of those keeps the Node event loop alive on its own, so a script
+     * that does not call this will not exit — and, until the refresh timer was
+     * included, one that *did* call it still would not if it had signed in.
+     *
+     * Safe when realtime was never started (`realtime: false`), safe when
+     * signed out, and safe to call twice. It does not sign the user out: a
+     * persisted session survives for the next client to restore.
      */
     close: () => void;
     storage: StorageSource;

package/dist/index.es.js

@@ -1,4 +1,4 @@
-import { DEFAULT_STORAGE_SOURCE_KEY, EntityReference, EntityRelation, GeoPoint, PUBLIC_STORAGE_PREFIX, RebaseApiError, RebaseApiError as RebaseApiError$1, RebaseClientError, Vector, isPublicStoragePath, toCanonicalOp } from "@rebasepro/types";
+import { DEFAULT_STORAGE_SOURCE_KEY, EntityReference, EntityRelation, GeoPoint, PUBLIC_STORAGE_PREFIX, RebaseApiError, RebaseApiError as RebaseApiError$1, RebaseClientError, RebaseClientError as RebaseClientError$1, Vector, isPublicStoragePath, toCanonicalOp } from "@rebasepro/types";
 import { COMPOSITE_ID_SEPARATOR, QueryBuilder, RebasePaginationError, and, buildCompositeId, collectAllPages, cond, or, paginateFind, serializeFilter, serializeLogicalCondition, serializeOrderBy } from "@rebasepro/common";
 import { toSnakeCase } from "@rebasepro/utils";
 //#region src/reviver.ts
@@ -49,6 +49,38 @@ function isServerLikeEnvironment() {
 * greppable — this is the string a user will paste into a search.
 */
 var ANONYMOUS_SERVER_CLIENT_WARNING = "[rebase] This client was created outside a browser with no credential — no `token`, no auth token getter, and no cookie auth flow — so every request runs as an anonymous caller. Row-level security will return only publicly readable rows, which is usually nothing and occasionally the wrong thing. Inside a cron or function handler, use the `client` you were handed instead of building a new one: its data plane is already admin-scoped. In a standalone script or job, pass the service key as `token`. If you really do want anonymous access, pass `anonymous: true` to silence this.";
+/**
+* Refuse a filter whose *value* is missing.
+*
+* `where: { status: ["==", undefined] }` used to serialize to the literal
+* string, so `status=eq.undefined` went out on the wire and the server dutifully
+* looked for rows whose status is the four-letter word "undefined". The caller
+* saw an empty page, not an error — the classic shape of a variable that was
+* never set.
+*
+* Dropping the condition instead would be worse than sending it: the query
+* would come back *unfiltered*, which for an ownership or tenant filter means
+* returning rows the caller never asked to see. So this is a hard error, and
+* both correct spellings are named in the message: omit the key to skip the
+* filter, or use `["is-null", null]` to match SQL NULL (which still
+* serializes — `null` is a value, `undefined` is the absence of one).
+*/
+function assertNoUndefinedFilterValues(where) {
+	const reject = (field, op) => {
+		throw new RebaseClientError$1(`Filter on "${field}" has an undefined value (["${String(op)}", undefined]). Omit "${field}" from \`where\` to skip the filter, or use ["is-null", null] to match SQL NULL.`);
+	};
+	for (const [field, condition] of Object.entries(where)) {
+		if (condition === void 0) continue;
+		if (!Array.isArray(condition)) continue;
+		const tuples = Array.isArray(condition[0]) ? condition : [condition];
+		for (const tuple of tuples) {
+			if (!Array.isArray(tuple) || tuple.length !== 2) continue;
+			const [op, value] = tuple;
+			if (value === void 0) reject(field, op);
+			if (Array.isArray(value) && value.some((v) => v === void 0)) reject(field, op);
+		}
+	}
+}
 function buildQueryString(params) {
 	if (!params) return "";
 	const parts = [];
@@ -67,6 +99,7 @@ function buildQueryString(params) {
 		parts.push(`${root.type}=${encodeURIComponent(`(${serialized})`)}`);
 	}
 	if (params.where) {
+		assertNoUndefinedFilterValues(params.where);
 		const serialized = serializeFilter(params.where);
 		for (const [field, value] of Object.entries(serialized)) if (Array.isArray(value)) for (const v of value) parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(v)}`);
 		else parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(value)}`);
@@ -418,6 +451,29 @@ function createAuth(transport, options) {
 			attemptScheduledRefresh(0);
 		}, delay);
 	}
+	/**
+	* Stop the scheduled token refresh, leaving the session itself alone.
+	*
+	* This is teardown, not sign-out. `scheduleRefresh` arms an ordinary
+	* `setTimeout` up to a token lifetime away, and it is not `unref`'d — so on
+	* Node it holds the event loop open by itself. `client.close()` promised
+	* that "a script that does not call this will not exit on its own", which
+	* was true, while the converse it plainly implies was not: a signed-in
+	* client that closed its socket still hung, because this timer outlived it.
+	* Any script, cron handler or job that signs in hit that.
+	*
+	* Deliberately does NOT clear the session, touch storage, or emit
+	* SIGNED_OUT. Closing a client is not the user signing out — `signOut()`
+	* POSTs /logout and revokes the whole sign-in, which is the wrong hammer
+	* (see `abandonSessionLocally`) — and a persisted session must still be
+	* there for the next client to restore.
+	*/
+	function stopAutoRefresh() {
+		if (refreshTimeout) {
+			clearTimeout(refreshTimeout);
+			refreshTimeout = null;
+		}
+	}
 	function handleAuthResponse(data, event) {
 		const user = mapRawUser(data.user);
 		const session = {
@@ -888,6 +944,7 @@ function createAuth(transport, options) {
 		signInWithSlack,
 		signInWithSpotify,
 		signOut,
+		stopAutoRefresh,
 		refreshSession,
 		handleUnauthorized,
 		getUser,
@@ -907,6 +964,7 @@ function createAuth(transport, options) {
 		getAuthConfig,
 		getSession,
 		onAuthStateChange,
+		canRestoreSession: () => persistSession || authFlowMode === "cookie",
 		isInitialized: () => isInitialized
 	};
 }
@@ -1272,7 +1330,8 @@ function createCollectionClient(transport, slug, ws) {
 			const qs = buildQueryString({
 				...params,
 				limit: void 0,
-				offset: void 0
+				offset: void 0,
+				include: void 0
 			});
 			return (await transport.request(basePath + "/count" + qs, { method: "GET" })).count ?? 0;
 		},
@@ -1418,7 +1477,8 @@ function createCollectionClient(transport, slug, ws) {
 function createFunctionsClient(transport) {
 	return { async invoke(name, payload, options) {
 		const method = options?.method ?? "POST";
-		const subPath = options?.path ? `/${options.path.replace(/^\//, "")}` : "";
+		const rawPath = options?.path;
+		const subPath = rawPath ? /^[?#]/.test(rawPath) ? rawPath : `/${rawPath.replace(/^\//, "")}` : "";
 		const routePath = `/functions/${encodeURIComponent(name)}${subPath}`;
 		const init = { method };
 		if (payload !== void 0 && method !== "GET") init.body = JSON.stringify(payload);
@@ -1632,7 +1692,7 @@ function extractMessageError(message) {
 * Fire-and-forget (the server sends no response envelope), and exempt from the
 * client-side auth gate — a public channel is usable without an account.
 */
-var CHANNEL_MESSAGE_TYPES = new Set([
+var CHANNEL_MESSAGE_TYPES = /* @__PURE__ */ new Set([
 	"join_channel",
 	"leave_channel",
 	"broadcast",
@@ -1661,6 +1721,17 @@ var RebaseWebSocketClient = class {
 	/** Set by `close()`. Blocks any later operation from silently redialling. */
 	closedByCaller = false;
 	/**
+	* Set when the backoff budget ran out, cleared by anything that earns a
+	* fresh one.
+	*
+	* Unlike {@link closedByCaller} this is not final — nobody *asked* for the
+	* socket to stay down. Five attempts with exponential backoff is about a
+	* minute, which a laptop lid, a wifi handover or a backend rollout all
+	* exceed routinely; treating that as permanent meant realtime silently
+	* stopped for the rest of the page's life, with a reload the only cure.
+	*/
+	gaveUp = false;
+	/**
 	* Whether a socket exists at all (open or still opening).
 	*
 	* Lets callers distinguish "authenticate the live socket" from "there is
@@ -1733,18 +1804,37 @@ var RebaseWebSocketClient = class {
 			}
 			return;
 		}
+		this.installOnlineListener();
 		if (this.ws || this.reconnectTimeout) return;
+		if (this.gaveUp) {
+			this.gaveUp = false;
+			this.reconnectAttempts = 0;
+		}
 		this.initWebSocket();
 	}
 	/**
+	* The browser says the network is back — the usual reason the budget ran
+	* out in the first place. Registered lazily so a Node client, or a page
+	* that never subscribes, adds no listener.
+	*/
+	installOnlineListener() {
+		if (this.onlineListener || typeof window === "undefined" || typeof window.addEventListener !== "function") return;
+		this.onlineListener = () => {
+			if (this.closedByCaller || !this.gaveUp) return;
+			console.debug("Network is back — retrying the realtime connection");
+			this.ensureConnected();
+		};
+		window.addEventListener("online", this.onlineListener);
+	}
+	onlineListener = null;
+	/**
 	* Authenticate the WebSocket connection
 	*/
 	async authenticate(token) {
 		return new Promise((resolve, reject) => {
-			const requestId = `auth_${Date.now()}`;
+			const requestId = `auth_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
 			const timeout = setTimeout(() => {
 				this.pendingRequests.delete(requestId);
-				this.authPromise = null;
 				reject(/* @__PURE__ */ new Error("Authentication timeout"));
 			}, 3e4);
 			this.pendingRequests.set(requestId, {
@@ -1794,6 +1884,10 @@ var RebaseWebSocketClient = class {
 	*/
 	disconnect(permanent = false) {
 		if (permanent) this.closedByCaller = true;
+		if (permanent && this.onlineListener && typeof window !== "undefined") {
+			window.removeEventListener("online", this.onlineListener);
+			this.onlineListener = null;
+		}
 		this.isAuthenticated = false;
 		this.authPromise = null;
 		if (this.reconnectTimeout) {
@@ -1818,7 +1912,8 @@ var RebaseWebSocketClient = class {
 			this.ws = null;
 		}
 		try {
-			this.ws = new this.WebSocketConstructor(this.websocketUrl);
+			const socket = new this.WebSocketConstructor(this.websocketUrl);
+			this.ws = socket;
 			this.ws.onopen = async () => {
 				console.debug("Connected to PostgreSQL backend");
 				const wasReconnect = this.reconnectAttempts > 0;
@@ -1848,6 +1943,7 @@ var RebaseWebSocketClient = class {
 			};
 			this.ws.onclose = () => {
 				console.debug("Disconnected from PostgreSQL backend");
+				if (this.ws === socket) this.ws = null;
 				this.isConnected = false;
 				this.isAuthenticated = false;
 				this.authPromise = null;
@@ -1883,6 +1979,7 @@ var RebaseWebSocketClient = class {
 	attemptReconnect() {
 		if (this.reconnectAttempts >= this.maxReconnectAttempts) {
 			console.error("Max reconnection attempts reached");
+			this.gaveUp = true;
 			this.failAllPendingSubscriptions(new RebaseApiError$1("Connection lost", { code: "CONNECTION_LOST" }));
 			return;
 		}
@@ -2125,21 +2222,23 @@ var RebaseWebSocketClient = class {
 	}
 	async ensureAuthenticated(retryCount = 3) {
 		if (this.isAuthenticated || !this.getAuthToken) return;
-		if (this.authPromise) {
-			await this.authPromise;
-			return;
+		if (!this.authPromise) {
+			this.authPromise = this.runAuthentication(retryCount);
+			this.authPromise.finally(() => {
+				this.authPromise = null;
+			}).catch(() => void 0);
 		}
+		await this.authPromise;
+	}
+	async runAuthentication(retryCount) {
 		let lastError = null;
 		for (let attempt = 0; attempt < retryCount; attempt++) try {
 			const token = await this.getAuthToken();
 			if (!token) throw new Error("user not logged in");
-			this.authPromise = this.authenticate(token);
-			await this.authPromise;
-			this.authPromise = null;
+			await this.authenticate(token);
 			console.debug("WebSocket authenticated on demand");
 			return;
 		} catch (error) {
-			this.authPromise = null;
 			lastError = error;
 			const errMsg = error instanceof Error ? error.message : String(error);
 			if (errMsg.includes("not logged in") || errMsg.includes("Session expired")) {
@@ -2425,7 +2524,7 @@ var RebaseWebSocketClient = class {
 			if (this.deepEqual(normCached, normIncoming)) return cachedRow;
 			else {
 				const mismatches = {};
-				const allKeys = new Set([...Object.keys(normCached), ...Object.keys(normIncoming)]);
+				const allKeys = /* @__PURE__ */ new Set([...Object.keys(normCached), ...Object.keys(normIncoming)]);
 				for (const key of allKeys) if (!this.deepEqual(normCached[key], normIncoming[key])) mismatches[key] = {
 					cached: normCached[key],
 					incoming: normIncoming[key]
@@ -3228,7 +3327,7 @@ function isNetworkError(error) {
 * bug the same payload will hit again than a blip, and retrying it forever
 * jams every write behind it.
 */
-var RETRYABLE_STATUSES = new Set([
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([
 	408,
 	425,
 	429,
@@ -5278,23 +5377,25 @@ channel: (name, options) => {
 			return existing;
 		} },
 		/**
-		* Release the realtime socket and its reconnect timer.
+		* Release every handle that can keep a process alive — see the
+		* `close` docblock on the client interface.
 		*
-		* Until this returns, the open socket keeps the Node event loop alive
-		* and the process will not exit on its own. Safe to call when realtime
-		* was never started, and safe to call twice.
+		* Safe to call when realtime was never started, safe when signed out,
+		* and safe to call twice.
 		*/
 		close: () => {
 			for (const channel of realtimeChannels.values()) channel.leave();
 			realtimeChannels.clear();
 			ws?.disconnect(true);
 			offlineManager?.dispose();
+			auth.stopAutoRefresh();
 		},
 		setToken: transport.setToken,
 		setAuthTokenGetter: transport.setAuthTokenGetter,
 		setOnUnauthorized: transport.setOnUnauthorized,
 		resolveToken: transport.resolveToken,
 		baseUrl: transport.baseUrl,
+		apiPath: transport.apiPath,
 		collection,
 		call: async (endpoint, payload) => {
 			const prefix = endpoint.startsWith("/") ? "" : "/";