@rebasepro/client 0.22.0 → 0.23.0

package/dist/offline-connectivity.d.ts

@@ -30,6 +30,14 @@ export declare function isNetworkError(error: unknown): boolean;
  * server's own message says, and exactly what this SDK used not to do.
  */
 export declare function isIdempotencyInProgressError(error: unknown): boolean;
+/**
+ * Is this key held for a different request than the one just sent with it?
+ *
+ * For a create the queue already sent once, that is an answer rather than a
+ * failure: the key is live only because the first attempt got through and
+ * committed, and only its response went missing.
+ */
+export declare function isIdempotencyKeyReusedError(error: unknown): boolean;
 /** Is this failure worth another attempt later? */
 export declare function isRetryableError(error: unknown): boolean;
 /**

package/dist/offline-query.d.ts

@@ -15,7 +15,11 @@ export { DEFAULT_LIST_LIMIT as DEFAULT_PAGE_SIZE } from "@rebasepro/types";
  * which is how NULL propagates through a comparison.
  */
 export declare function compareValues(a: unknown, b: unknown): number | undefined;
-/** Equality with the wire's type erasure allowed for, but never across NULL. */
+/**
+ * Equality with a string filter value allowed to name a number, a boolean or
+ * an instant, but never across NULL. Two strings are equal only when they are
+ * the same string, as text is in Postgres.
+ */
 export declare function looseEquals(a: unknown, b: unknown): boolean;
 /** Evaluate one canonical operator against one row value. */
 export declare function matchesOperator(rowValue: unknown, op: WhereFilterOp, filterValue: unknown): boolean;
@@ -72,14 +76,14 @@ export declare function isExactlyEvaluable(params?: FindParams): boolean;
  *
  * Asked of the rows rather than of the query, because unlike a filter this one
  * *is* decidable from the data in hand: {@link compareValues} reaches the
- * collator only when it cannot read both operands as numbers, and `toComparable`
- * has already turned dates and relations into numbers and ids by then. If every
+ * collator only when neither operand is a number, and `toComparable` has
+ * already turned dates and relations into numbers and ids by then. If every
  * value on the sort column normalises to a number, the collator is unreachable
  * and the local order is the server's order.
  *
  * A text column is therefore refused — see {@link isExactlyEvaluable} for why
- * the two cannot be made to agree — and so is a column this page happens to see
- * only as strings, which is the same thing from here.
+ * the two cannot be made to agree — including one holding only digits, which
+ * Postgres orders as text ("10", "100", "9").
  *
  * Nulls are fine either way: they are ordered by an explicit rule (last
  * ascending, first descending) that matches Postgres and never reaches the

package/dist/offline-store.d.ts

@@ -68,6 +68,28 @@ export interface PendingMutation {
     /** The payload: a row for create/update, an array of rows for createMany. */
     data?: Record<string, unknown> | Record<string, unknown>[];
     upsert?: boolean;
+    /**
+     * The request as it was already sent once, for a write tried online
+     * that failed on the network before it was queued. Nothing says whether
+     * it reached the server — only the answer may have been lost — so replay
+     * keeps its key. For a create, sent with the rows as queued (their minted
+     * ids, which later offline writes may reference), the server either takes
+     * them, or, having committed the first attempt, refuses the key as held
+     * for a different request, and this request is sent again for its stored
+     * answer. Replaying under a fresh key wrote the rows a second time.
+     *
+     * An `update` or `delete` carries only the key: its queued request is the
+     * one it sent, since nothing is merged into an op that has `sent`.
+     */
+    sent?: {
+        idempotencyKey: string;
+        /** `create`: the row it was called with; `createMany`: the rows. */
+        data?: Record<string, unknown> | Record<string, unknown>[];
+        /** `create`: the `id` argument it was called with. */
+        id?: string | number;
+        /** `createMany`: the conflict target the batch was sent with. */
+        onConflict?: readonly string[];
+    };
     queuedAt: number;
     /** How many times replay has been attempted (diagnostics for a stuck queue). */
     attempts?: number;

package/dist/offline.d.ts

@@ -221,6 +221,19 @@ export declare class OfflineManager {
      * query the server has never answered here.
      */
     private answer;
+    /**
+     * Answer a projected query (`fields`, `distinct`) from the server's own
+     * answer to it.
+     *
+     * The server's rows are the answer. The local database contributes only
+     * what it knows better: a row with unsynced writes shows them, narrowed to
+     * the columns the server sent, or drops out if it was deleted here or
+     * edited out of a filter this side can evaluate; and rows created here
+     * join the first page when there is somewhere to put them. A distinct
+     * query, or an order on a column the projection does not carry, leaves
+     * them out, and the result says it is partial.
+     */
+    private projectedAnswer;
     private localFind;
     /**
      * A temporary id of the type this collection's ids actually have.
@@ -256,6 +269,12 @@ export declare class OfflineManager {
      * Rows that came back unchanged keep their identity and revision, so a
      * refetch that changed nothing does not re-render every live query that
      * touches them — or rewrite them all to disk.
+     *
+     * A `projection` (see {@link isProjection}) only refreshes the columns it
+     * carries on rows already held, and never creates one. It is not a row:
+     * stored as one, it replaced the full row every other query reads and
+     * wrote the narrowed copy to disk, so a list lost its columns because a
+     * dropdown elsewhere asked for titles.
      */
     private ingest;
     /**
@@ -292,6 +311,17 @@ export declare class OfflineManager {
     }>;
     private flush;
     private replay;
+    /**
+     * Send a queued write under its key.
+     *
+     * A write the queue sent once already, before it was queued, carries that
+     * attempt's key and is sent under it again, as queued. If the server holds
+     * the key for a different request, the difference is the ids minted here
+     * — so the first attempt committed and only its answer was lost, and
+     * sending that request again returns the stored answer instead of a
+     * second copy of the rows.
+     */
+    private sendQueuedWrite;
     /**
      * Take the server's version of a row the client created offline.
      *

package/dist/realtime-channel.d.ts

@@ -133,6 +133,27 @@ export declare class RebaseRealtimeChannel {
      */
     private pendingLive;
     private catchUpInFlight;
+    /**
+     * Whether {@link lastSeq} is a position this client reached, rather than
+     * the zero of a handle that has not caught up yet.
+     *
+     * A client joining for the first time asks for whatever is retained, so
+     * history pruned before it ever joined is not something it missed. Only a
+     * client with a position can have a hole in what it saw.
+     */
+    private positioned;
+    /** The page size the catch-up in flight asked for, reused for its later pages. */
+    private catchUpLimit;
+    /**
+     * `latestSeq` of an empty page that left this client behind, while a
+     * second request confirms it.
+     *
+     * The server reads the retained messages and then the cursor, so a message
+     * committed between the two shows up in `latestSeq` and not in the page.
+     * The second request returns it if it exists; only a second empty page
+     * means the messages up to this seq are gone.
+     */
+    private emptyTailSeq;
     /**
      * Deadline for a catch-up response.
      *
@@ -234,6 +255,12 @@ export declare class RebaseRealtimeChannel {
      * retention cannot be served; `CHANNEL_BUS_PAYLOAD_TOO_LARGE` when a
      * broadcast on an ephemeral channel is too big to cross the bus.
      *
+     * `CHANNEL_HISTORY_GAP` is raised by the client: a catch-up found that the
+     * server no longer retains messages this client never received, so its
+     * state has a hole a replay cannot fill. `details` is `{ from, to }`, the
+     * inclusive range of sequence numbers missed. Resync the channel's state
+     * from its source of truth.
+     *
      * 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,
@@ -271,6 +298,9 @@ export declare class RebaseRealtimeChannel {
     private stopHeartbeat;
     /** Fold an incoming frame into the roster and fan it out. */
     private handle;
+    /** Tell the app that retention dropped messages it never received. */
+    private reportHistoryGap;
+    private emitError;
     /** Deliver everything held back during a catch-up, in sequence order. */
     private flushPendingLive;
     private deliver;

package/dist/transport.d.ts

@@ -126,6 +126,23 @@ export declare const ANONYMOUS_SERVER_CLIENT_WARNING: string;
  */
 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).
+ */
+export declare function assertNoUndefinedFilterValues(where: Record<string, unknown>): void;
 export declare function buildQueryString(params?: FindParams): string;
 /**
  * The query string for `GET /<collection>/aggregate`.

package/dist/websocket.d.ts

@@ -50,6 +50,17 @@ export declare class RebaseWebSocketClient {
     private pendingRequests;
     private reconnectAttempts;
     private maxReconnectAttempts;
+    /**
+     * Whether a socket of this client has ever opened — what makes the next
+     * open a *reconnect*, whose server has forgotten every subscription and
+     * channel membership and must be told them again.
+     *
+     * Not `reconnectAttempts > 0`: that counter is a backoff budget, and a
+     * fresh one (after giving up, or after a sign-out dropped the socket)
+     * starts at zero, so the socket that finally came back looked like a first
+     * connect and nothing was re-sent.
+     */
+    private hadConnection;
     private isConnected;
     private messageQueue;
     private requestTimeoutMs;
@@ -95,6 +106,21 @@ export declare class RebaseWebSocketClient {
     disconnect(permanent?: boolean): void;
     private initWebSocket;
     private processMessageQueue;
+    /**
+     * Whether a frame that waited in the queue should go out on the socket
+     * that just opened. Only a subscribe can be refused, and one is exactly
+     * when sending it would give the server a subscription this side will not
+     * read:
+     *
+     * - Its registration is gone, or has been given a new id, while it waited.
+     *   A listener that unmounted before the socket opened (a StrictMode double
+     *   mount does exactly this) sends no `unsubscribe`, because there was no
+     *   socket to send it on, so the server would keep that one forever.
+     * - This open is a reconnect. `resubscribeAll` sends every registration
+     *   under a fresh id right after the queue drains, so the queued copy would
+     *   be the second of two. It is handed back to that pass instead.
+     */
+    private shouldSendQueued;
     private attemptReconnect;
     private isAuthError;
     private handleAuthFailure;
@@ -191,6 +217,14 @@ export declare class RebaseWebSocketClient {
      * firing mid-reconnect would tear down healthy subscriptions.
      */
     private suspendSubscribeWatchdogs;
+    /**
+     * Drop every registration's cached rows, keeping the registrations.
+     *
+     * A registration without rows counts as not loaded, so the next listener
+     * to attach asks the server (or waits for the resubscribe) instead of
+     * being handed what is cached.
+     */
+    private forgetCachedData;
     /**
      * Arm watchdogs for subscribes that were requested while offline and have
      * just been flushed to the socket. Their timers were deliberately not set at

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rebasepro/client",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "HTTP SDK client for the Rebase custom backend",
   "keywords": [
     "rebase",
@@ -41,9 +41,9 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@rebasepro/common": "0.22.0",
-    "@rebasepro/types": "0.22.0",
-    "@rebasepro/utils": "0.22.0"
+    "@rebasepro/common": "0.23.0",
+    "@rebasepro/utils": "0.23.0",
+    "@rebasepro/types": "0.23.0"
   },
   "devDependencies": {
     "@jest/globals": "^30.4.1",