@delali/sirannon-db 0.1.7 → 0.2.0

package/dist/server/index.d.ts

@@ -1,70 +1,23 @@
-import { W as WriteConcern, g as BulkLoadDurability, h as BulkLoadResult, R as ReadConcern, E as ExecuteResult, i as ServerOptions, j as WSHandlerOptions } from '../types-D_hQW1hr.js';
-import { S as Sirannon } from '../sirannon-4SspRvP5.js';
-import '../database-DuGp0Rtr.js';
-import '../types-D4p4UyDK.js';
+import { T as TransactionStatement, Q as QueryResponse, E as ExecuteResponse, a as TransactionResponse, B as BatchResponse, L as LoadResponse, A as AckResponse } from '../protocol-6KrSq2Hy.js';
+export { b as BatchRequest, c as ErrorResponse, d as ExecuteRequest, e as LoadRequest, f as QueryRequest, g as TransactionRequest, t as toExecuteResponse } from '../protocol-6KrSq2Hy.js';
+import { S as Sirannon } from '../sirannon-DaQSyhbJ.js';
+import { B as BulkLoadDurability, S as ServerOptions, W as WSHandlerOptions } from '../server-options-1JHu8pid.js';
+import { W as WriteConcern, R as ReadConcern } from '../types-zhnRXrsb.js';
+import '../database-BY0L5Q2n.js';
+import '../types-C_D8IhpO.js';
+import '../types-CL6piSnD.js';
+import '../operation-registry-9DcvxcE5.js';
 
-interface QueryRequest {
-    sql: string;
-    params?: Record<string, unknown> | unknown[];
-    readConcern?: ReadConcern;
-}
-interface ExecuteRequest {
-    sql: string;
-    params?: Record<string, unknown> | unknown[];
-    writeConcern?: WriteConcern;
-}
-interface TransactionStatement {
-    sql: string;
-    params?: Record<string, unknown> | unknown[];
-}
-interface TransactionRequest {
-    statements: TransactionStatement[];
-    writeConcern?: WriteConcern;
-}
-/** The whole batch commits atomically in one server-side transaction with one fsync. */
-interface BatchRequest {
-    sql: string;
-    paramsBatch: (Record<string, unknown> | unknown[])[];
-    writeConcern?: WriteConcern;
-}
-interface QueryResponse {
-    rows: Record<string, unknown>[];
-}
-interface ExecuteResponse {
-    changes: number;
-    lastInsertRowId: number | string;
-}
-interface TransactionResponse {
-    results: ExecuteResponse[];
-}
-interface BatchResponse {
-    results: ExecuteResponse[];
-}
-/**
- * Loads rows with relaxed writer durability; the configured durability is
- * restored before the response is sent, and a load interrupted by a crash is
- * recovered by re-running it.
- */
-interface LoadRequest {
-    sql: string;
-    paramsBatch: (Record<string, unknown> | unknown[])[];
-    durability?: BulkLoadDurability;
-    checkpoint?: boolean;
-}
-type LoadResponse = BulkLoadResult;
-interface ErrorResponse {
-    error: {
-        code: string;
-        message: string;
-        details?: Record<string, unknown>;
-    };
-}
-type WSClientMessage = WSSubscribeMessage | WSUnsubscribeMessage | WSQueryMessage | WSExecuteMessage | WSTransactionMessage | WSBatchMessage | WSLoadMessage;
+type WSClientMessage = WSSubscribeMessage | WSUnsubscribeMessage | WSAckMessage | WSQueryMessage | WSExecuteMessage | WSTransactionMessage | WSBatchMessage | WSLoadMessage;
 interface WSSubscribeMessage {
     type: 'subscribe';
     id: string;
-    table: string;
+    table?: string;
+    tables?: string[];
     filter?: Record<string, unknown>;
+    name?: string;
+    args?: Record<string, unknown>;
+    registryDigest?: string;
     /**
      * Highest `seq` the client has already processed. When present, the server
      * replays every retained change with a greater seq before delivering live
@@ -79,22 +32,43 @@ interface WSSubscribeMessage {
      * resync rather than replay foreign rows against it.
      */
     epoch?: string;
+    deviceId?: string;
+    schemaVersion?: number;
+    /**
+     * Declares that this device stages pulled changes durably and
+     * acknowledges staged sequences. The server then packs several events
+     * into each `changes` frame and paces the delivery window continuously
+     * instead of per transaction. Meaningful only with `deviceId`.
+     */
+    stagedStream?: boolean;
 }
 interface WSUnsubscribeMessage {
     type: 'unsubscribe';
     id: string;
 }
+interface WSAckMessage {
+    type: 'ack';
+    id: string;
+    deviceId: string;
+    seq: string;
+}
 interface WSQueryMessage {
     type: 'query';
     id: string;
-    sql: string;
+    sql?: string;
     params?: Record<string, unknown> | unknown[];
+    name?: string;
+    args?: Record<string, unknown>;
+    readConcern?: ReadConcern;
 }
 interface WSExecuteMessage {
     type: 'execute';
     id: string;
-    sql: string;
+    sql?: string;
     params?: Record<string, unknown> | unknown[];
+    name?: string;
+    args?: Record<string, unknown>;
+    writeConcern?: WriteConcern;
 }
 /**
  * Runs every statement in one server-side transaction and replies once with
@@ -122,10 +96,34 @@ interface WSLoadMessage {
     durability?: BulkLoadDurability;
     checkpoint?: boolean;
 }
-type WSServerMessage = WSSubscribedMessage | WSUnsubscribedMessage | WSChangeMessage | WSResultMessage | WSErrorMessage;
+type WSServerMessage = WSSubscribedMessage | WSUnsubscribedMessage | WSChangeMessage | WSChangesMessage | WSLiveMessage | WSResultMessage | WSErrorMessage;
+type WSLiveOp = {
+    op: 'insert';
+    index: number;
+    row: unknown;
+} | {
+    op: 'update';
+    index: number;
+    row: unknown;
+} | {
+    op: 'delete';
+    index: number;
+};
+interface WSLiveMessage {
+    type: 'live';
+    id: string;
+    ops?: WSLiveOp[];
+    rows?: unknown[];
+    revalidating?: boolean;
+}
 interface WSSubscribedMessage {
     type: 'subscribed';
     id: string;
+    /**
+     * How far a device may run ahead of its acknowledged cursor before the
+     * server holds delivery. Present only for a device subscription.
+     */
+    maxUnacknowledgedChanges?: number;
     /**
      * The seq the subscription is live from. A client that has not yet seen any
      * change adopts this as its resume cursor, so a reconnect during an idle
@@ -144,27 +142,44 @@ interface WSSubscribedMessage {
      * database forces a resync instead of a silent replay of unrelated rows.
      */
     epoch?: string;
+    rows?: unknown[];
 }
 interface WSUnsubscribedMessage {
     type: 'unsubscribed';
     id: string;
 }
+interface WSWireChangeEvent {
+    type: 'insert' | 'update' | 'delete';
+    table: string;
+    row: Record<string, unknown>;
+    oldRow?: Record<string, unknown>;
+    seq: string;
+    timestamp: number;
+    hlc?: string;
+    origin?: string;
+    rowId?: string;
+    txId?: string;
+    txEnd?: boolean;
+}
 interface WSChangeMessage {
     type: 'change';
     id: string;
-    event: {
-        type: 'insert' | 'update' | 'delete';
-        table: string;
-        row: Record<string, unknown>;
-        oldRow?: Record<string, unknown>;
-        seq: string;
-        timestamp: number;
-    };
+    event: WSWireChangeEvent;
+}
+/**
+ * Several change events in one frame, in ascending seq order. Sent only on
+ * a device subscription that requested `stagedStream`; the events carry the
+ * same fields as a `change` frame's event.
+ */
+interface WSChangesMessage {
+    type: 'changes';
+    id: string;
+    events: WSWireChangeEvent[];
 }
 interface WSResultMessage {
     type: 'result';
     id: string;
-    data: QueryResponse | ExecuteResponse | TransactionResponse | BatchResponse | LoadResponse;
+    data: QueryResponse | ExecuteResponse | TransactionResponse | BatchResponse | LoadResponse | AckResponse;
 }
 interface WSErrorMessage {
     type: 'error';
@@ -174,23 +189,26 @@ interface WSErrorMessage {
         message: string;
     };
 }
-declare function toExecuteResponse(result: ExecuteResult): ExecuteResponse;
 
-declare class SirannonServer {
+declare class SirannonServer<Identity = unknown> {
     private app;
     private listenSocket;
     private readonly host;
     private readonly port;
     private readonly cors;
-    private readonly onRequestHook;
+    private readonly authenticateHook;
+    private readonly acceptSql;
+    private readonly operations;
+    private readonly registryDigest;
     private readonly resolveExecutionTarget;
     private readonly getReplicationStatus;
     private readonly getClusterStatus;
+    private readonly authorizeClusterStatus;
     private readonly sirannon;
     private readonly wsHandler;
     private readonly maxBodyBytes;
     private readonly maxWsBackpressureBytes;
-    constructor(sirannon: Sirannon, options?: ServerOptions);
+    constructor(sirannon: Sirannon, options?: ServerOptions<Identity>);
     listen(): Promise<void>;
     close(): Promise<void>;
     get listeningPort(): number;
@@ -198,9 +216,10 @@ declare class SirannonServer {
     private registerWebSocketRoute;
     private withCors;
     private wrapDbRoute;
+    private wrapOperationRoute;
     private wrapDbGetRoute;
 }
-declare function createServer(sirannon: Sirannon, options?: ServerOptions): SirannonServer;
+declare function createServer<Identity = unknown>(sirannon: Sirannon, options?: ServerOptions<Identity>): SirannonServer<Identity>;
 
 /**
  * Result of writing a frame to a WebSocket connection.
@@ -218,15 +237,18 @@ interface WSConnection {
     close(code?: number, reason?: string): void;
 }
 
-declare class WSHandler {
+declare class WSHandler<Identity = unknown> {
     private readonly sirannon;
     private readonly maxPayloadLength;
     private readonly resolveExecutionTarget;
     private readonly connections;
     private readonly cdc;
+    private readonly maxUnacknowledgedChanges;
+    private readonly acceptSql;
+    private readonly operations;
     private closed;
-    constructor(sirannon: Sirannon, options?: WSHandlerOptions);
-    handleOpen(conn: WSConnection, databaseId: string): Promise<void>;
+    constructor(sirannon: Sirannon, options?: WSHandlerOptions<Identity>);
+    handleOpen(conn: WSConnection, databaseId: string, identity?: unknown): Promise<void>;
     /**
      * Tears down a connection whose outbound buffer overflowed. Closing lets the
      * client reject in-flight requests and reconnect; guarding on `overloaded`
@@ -234,20 +256,22 @@ declare class WSHandler {
      */
     handleOverload(conn: WSConnection): void;
     handleMessage(conn: WSConnection, data: string): void;
+    handleSocketDrain(conn: WSConnection): void;
     handleClose(conn: WSConnection): void;
     get connectionCount(): number;
     close(): Promise<void>;
     private operationContext;
-    private handleSubscribe;
-    private subscribeLive;
-    private subscribeResuming;
+    private namedContext;
+    private liveDeps;
+    private subscribeDeps;
     private handleUnsubscribe;
     private resolveTarget;
     private send;
     private sendError;
     private sendSirannonError;
     private sendChange;
+    private sendText;
 }
-declare function createWSHandler(sirannon: Sirannon, options?: WSHandlerOptions): WSHandler;
+declare function createWSHandler<Identity = unknown>(sirannon: Sirannon, options?: WSHandlerOptions<Identity>): WSHandler<Identity>;
 
-export { type BatchRequest, type BatchResponse, type ErrorResponse, type ExecuteRequest, type ExecuteResponse, type LoadRequest, type LoadResponse, type QueryRequest, type QueryResponse, SirannonServer, type TransactionRequest, type TransactionResponse, type TransactionStatement, type WSBatchMessage, type WSChangeMessage, type WSClientMessage, type WSConnection, type WSErrorMessage, type WSExecuteMessage, WSHandler, type WSLoadMessage, type WSQueryMessage, type WSResultMessage, type WSServerMessage, type WSSubscribeMessage, type WSSubscribedMessage, type WSTransactionMessage, type WSUnsubscribeMessage, type WSUnsubscribedMessage, createServer, createWSHandler, toExecuteResponse };
+export { BatchResponse, ExecuteResponse, LoadResponse, QueryResponse, SirannonServer, TransactionResponse, TransactionStatement, type WSBatchMessage, type WSChangeMessage, type WSClientMessage, type WSConnection, type WSErrorMessage, type WSExecuteMessage, WSHandler, type WSLoadMessage, type WSQueryMessage, type WSResultMessage, type WSServerMessage, type WSSubscribeMessage, type WSSubscribedMessage, type WSTransactionMessage, type WSUnsubscribeMessage, type WSUnsubscribedMessage, createServer, createWSHandler };