@rebasepro/client 0.12.1-canary.gf5f1d39 → 0.13.0

package/src/transport.ts

@@ -7,6 +7,7 @@ import { rebaseReviver } from "./reviver";
 // `import { RebaseApiError } from ".../transport"` path used across the SDK.
 export { RebaseApiError } from "@rebasepro/types";
 export type { RebaseErrorInit } from "@rebasepro/types";
+import { RebaseClientError } from "@rebasepro/types";
 
 export interface RebaseClientConfig {
     /**
@@ -133,6 +134,47 @@ export const ANONYMOUS_SERVER_CLIENT_WARNING =
 export type FindParams<M extends Record<string, unknown> = Record<string, unknown>> = TypesFindParams<M>;
 export type FindResponse<T> = TypesFindResponse<T extends Record<string, unknown> ? T : Record<string, unknown>>;
 
+/**
+ * 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: Record<string, unknown>): void {
+    const reject = (field: string, op: unknown): never => {
+        throw new RebaseClientError(
+            `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)) {
+        // An entirely absent condition is the documented way to skip a filter.
+        if (condition === undefined) continue;
+        if (!Array.isArray(condition)) continue;
+
+        // Either one `[op, value]` tuple or an array of them.
+        const tuples = Array.isArray(condition[0]) ? condition as unknown[][] : [condition as unknown[]];
+        for (const tuple of tuples) {
+            if (!Array.isArray(tuple) || tuple.length !== 2) continue;
+            const [op, value] = tuple;
+            if (value === undefined) reject(field, op);
+            // `["in", [...]]` — a hole in the list is the same mistake.
+            if (Array.isArray(value) && value.some(v => v === undefined)) reject(field, op);
+        }
+    }
+}
+
 export function buildQueryString(params?: FindParams): string {
     if (!params) return "";
     const parts: string[] = [];
@@ -161,6 +203,7 @@ export function buildQueryString(params?: FindParams): string {
     }
 
     if (params.where) {
+        assertNoUndefinedFilterValues(params.where);
         const serialized = serializeFilter(params.where);
         for (const [field, value] of Object.entries(serialized)) {
             if (Array.isArray(value)) {

package/src/websocket.ts

@@ -97,6 +97,18 @@ export class RebaseWebSocketClient {
     /** Set by `close()`. Blocks any later operation from silently redialling. */
     private 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.
+     */
+    private gaveUp = false;
+
     /**
      * Whether a socket exists at all (open or still opening).
      *
@@ -249,20 +261,52 @@ export class RebaseWebSocketClient {
             }
             return;
         }
+        this.installOnlineListener();
         if (this.ws || this.reconnectTimeout) return;
+        // A caller asking for a connection is a fresh reason to try, so it also
+        // buys a fresh backoff budget. Without this, the first `subscribe`
+        // after a give-up would exhaust the counter on attempt one.
+        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.
+     */
+    private 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);
+    }
+
+    private onlineListener: (() => void) | null = null;
+
     /**
      * Authenticate the WebSocket connection
      */
     async authenticate(token: string): Promise<void> {
         return new Promise((resolve, reject) => {
-            const requestId = `auth_${Date.now()}`;
+            // Random suffix, like every other request id here. Two auth
+            // attempts started in the same millisecond produced the same id,
+            // and `pendingRequests` is a Map: the second registration replaced
+            // the first, so one caller's promise was never settled either way.
+            const requestId = `auth_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
 
             const timeout = setTimeout(() => {
                 this.pendingRequests.delete(requestId);
-                this.authPromise = null; // Clear promise so we can retry later
+                // `authPromise` belongs to `ensureAuthenticated`, which clears
+                // it when the whole attempt — retries included — settles.
+                // Clearing it here let a second attempt start while this one
+                // was still retrying.
                 reject(new Error("Authentication timeout"));
             }, 30000);
 
@@ -325,6 +369,10 @@ export class RebaseWebSocketClient {
      */
     public disconnect(permanent = false): void {
         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) {
@@ -354,7 +402,10 @@ export class RebaseWebSocketClient {
         }
 
         try {
-            this.ws = new this.WebSocketConstructor(this.websocketUrl);
+            // Captured so each handler can tell "my socket" from a later one:
+            // a close arriving after a redial must not clear the new socket.
+            const socket = new this.WebSocketConstructor(this.websocketUrl);
+            this.ws = socket;
 
             this.ws!.onopen = async () => {
                 console.debug("Connected to PostgreSQL backend");
@@ -403,6 +454,11 @@ export class RebaseWebSocketClient {
 
             this.ws!.onclose = () => {
                 console.debug("Disconnected from PostgreSQL backend");
+                // Release the dead socket. `ensureConnected` returns early
+                // while `this.ws` is set, so holding a closed one made the
+                // "give up after N attempts" state permanent: nothing could
+                // ever redial, not even a fresh `subscribe`.
+                if (this.ws === socket) this.ws = null;
                 this.isConnected = false;
                 this.isAuthenticated = false;
                 this.authPromise = null;
@@ -451,6 +507,7 @@ export class RebaseWebSocketClient {
             console.error("Max reconnection attempts reached");
             // Nothing will re-subscribe now, so stop every subscription that
             // never loaded from spinning forever.
+            this.gaveUp = true;
             this.failAllPendingSubscriptions(
                 new RebaseApiError("Connection lost", { code: "CONNECTION_LOST" })
             );
@@ -845,26 +902,39 @@ export class RebaseWebSocketClient {
         // If already authenticated or no token getter, skip
         if (this.isAuthenticated || !this.getAuthToken) return;
 
-        // If auth is in progress, wait for it
-        if (this.authPromise) {
-            await this.authPromise;
-            return;
+        // If auth is in progress, wait for it.
+        //
+        // The share has to be published *before* the first await, which is why
+        // the work lives in its own method. The guard used to be read here and
+        // the promise only assigned after `await this.getAuthToken()` — so
+        // every caller that arrived during that gap saw `null` and started an
+        // attempt of its own. A queue flushing six subscriptions on connect
+        // does exactly that, and each extra attempt raced the others through a
+        // single `pendingRequests` slot: one settled, the rest hung until their
+        // own 30s timeout, and the frames waiting behind them were never sent.
+        // Their subscriptions then reported "Subscription timed out" — the
+        // board's columns loading one at a time, or not at all.
+        if (!this.authPromise) {
+            this.authPromise = this.runAuthentication(retryCount);
+            this.authPromise.finally(() => {
+                this.authPromise = null;
+            }).catch(() => undefined);
         }
+        await this.authPromise;
+    }
 
+    private async runAuthentication(retryCount: number): Promise<void> {
         // Try to authenticate with retries
         let lastError: unknown = null;
 
         for (let attempt = 0; attempt < retryCount; attempt++) {
             try {
-                const token = await this.getAuthToken();
+                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; // Success
             } catch (error: unknown) {
-                this.authPromise = null;
                 lastError = error;
 
                 const errMsg = error instanceof Error ? error.message : String(error);