@rebasepro/client 0.25.0 → 0.26.0

package/dist/offline-store.d.ts

@@ -88,6 +88,9 @@ export interface PendingMutation {
      *
      * 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`.
+     *
+     * A queued create or update is marked too, before its first replay goes
+     * out, for the same reason: from then on the server may hold it.
      */
     sent?: {
         idempotencyKey: string;
@@ -97,6 +100,13 @@ export interface PendingMutation {
         id?: string | number;
         /** `createMany`: the conflict target the batch was sent with. */
         onConflict?: readonly string[];
+        /**
+         * A `create` replayed folded into a `replayBatchSize` run: that run's
+         * key. While the run is still whole in the queue it is sent again as
+         * that same request; otherwise each member replays alone, under its
+         * own key.
+         */
+        run?: string;
     };
     queuedAt: number;
     /**

package/dist/offline.d.ts

@@ -100,7 +100,8 @@ export interface OfflineConfig {
      * A row last seen in a `find()` or `listen()` list has no version, and an
      * edit made on top of another queued write to the same row has none
      * either; those replay without a precondition. A caller's own `ifMatch` is
-     * kept on a queued edit too.
+     * kept on a queued edit or delete too — without this option as well, when
+     * a 412 over it is a refusal like any other.
      *
      * The queue waits while this runs, so a prompt can ask the user. Without
      * it — the default — replay sends no precondition and the last writer
@@ -379,6 +380,22 @@ export declare class OfflineManager {
     private ticket;
     /** The ticket of whoever the held scope turns out to be. */
     private nextTicket;
+    private currentTicket;
+    /**
+     * Whether a write may go to the server now. Not while the scope is the last
+     * user's, unconfirmed: it would go out with no credentials, as nobody. It
+     * queues for its author instead, as it does offline.
+     */
+    private sendsWrites;
+    private readonly reachedUnconfirmedListeners;
+    /**
+     * `listener` runs when a request made while the scope is unconfirmed
+     * reached the server: the connection is back, so the session can be asked
+     * about. The client wires it to the same confirmation the status listener
+     * runs — the status may never have said the connection was gone.
+     */
+    onReachedUnconfirmed(listener: () => void): () => void;
+    private reachedUnconfirmed;
     /** Whether an operation's user is still the signed-in one. */
     private isCurrent;
     /**
@@ -587,6 +604,14 @@ export declare class OfflineManager {
      */
     private replayRun;
     private replay;
+    /**
+     * Record a queued create as sent, with the request about to go out, and
+     * persist it — before the request, so a lost answer cannot leave it
+     * unmarked. One already marked (sent online before it was queued, or by
+     * an earlier replay) keeps what it holds: that is the request the server
+     * may have stored.
+     */
+    private markCreateSent;
     /**
      * Send a queued write under its key.
      *

package/dist/realtime-channel.d.ts

@@ -259,6 +259,14 @@ export declare class RebaseRealtimeChannel {
      * A refusal therefore arrives on {@link onError}, not as a rejection here.
      */
     broadcast(event: string, payload: unknown): Promise<void>;
+    /**
+     * The socket ids this channel has broadcast from — the current one and the
+     * ones before a reconnect. A message in history from any of them is this
+     * client's own, and a sender is never sent its own messages: replayed after
+     * a reconnect whose `broadcast_ack` was lost, it was applied twice.
+     */
+    private readonly ownSenderIds;
+    private rememberOwnSender;
     /**
      * Observe refusals about this channel.
      *

package/dist/websocket.d.ts

@@ -16,6 +16,11 @@ export interface RebaseWebSocketConfig {
      * `RebaseClientConfig.impersonate`. Sent with every `AUTHENTICATE`.
      */
     impersonate?: string;
+    /**
+     * Log the connection's progress — opened, signed in, closed, redialling —
+     * with `console.debug`. Off by default. See `CreateRebaseClientOptions.debug`.
+     */
+    debug?: boolean;
 }
 export declare class RebaseWebSocketClient {
     private websocketUrl;
@@ -149,6 +154,19 @@ export declare class RebaseWebSocketClient {
     onUnauthorized?: () => Promise<boolean>;
     private refreshInProgress;
     private readonly impersonate?;
+    private readonly debug;
+    /**
+     * Connection chatter: the socket opened, signed in, closed, is redialling.
+     *
+     * Silent unless asked for, with the `debug` option or
+     * {@link debugSwitchedOn}. It used to go to `console.debug` in every
+     * browser: a public page printed "Connected to PostgreSQL backend" and
+     * "WebSocket auto-authenticated" to each visitor's console, naming the
+     * backend on every load. In Node, where `console.debug` is `console.log`,
+     * it opened a script's stdout ahead of what the script prints. Warnings and
+     * errors are not chatter and are always written.
+     */
+    private connectionDebug;
     constructor(config: RebaseWebSocketConfig);
     /**
      * Open the socket if it is not open (or opening) already.
@@ -173,6 +191,22 @@ export declare class RebaseWebSocketClient {
     private removeNetworkListeners;
     private onlineListener;
     private visibilityListener;
+    /** The session this socket's server refused, and why. Cleared when a socket opens. */
+    private refusedSession;
+    /**
+     * Whether `error` is the server refusing the session `token` signs in as —
+     * revoked, its account gone or disabled, a token that does not verify. Said
+     * once per socket and token, as a warning that names the code.
+     */
+    private noteSessionRefused;
+    /** Whether the current run of ceiling refusals has been said in the console. */
+    private socketCeilingWarned;
+    /**
+     * The server refused this socket for its per-user ceiling. Said once per
+     * run of refusals, as a warning, and reported to every registration at
+     * once as an outage — a refusal is not a blip that the next dial fixes.
+     */
+    private noteSocketCeiling;
     /**
      * Authenticate the WebSocket connection
      */

package/package.json

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