@inline-chat/realtime-sdk 0.0.2 → 0.0.3

package/dist/realtime/protocol-client.d.ts

@@ -9,6 +9,7 @@ export type ProtocolClientOptions = {
     transport: Transport;
     getConnectionInit: () => ConnectionInit | null;
     logger?: InlineSdkLogger;
+    defaultRpcTimeoutMs?: number | null;
 };
 export declare class ProtocolClient {
     readonly events: AsyncChannel<ClientEvent>;
@@ -17,7 +18,8 @@ export declare class ProtocolClient {
     state: ClientState;
     private readonly log;
     private readonly getConnectionInit;
-    private rpcContinuations;
+    private readonly defaultRpcTimeoutMs;
+    private pendingRpcRequests;
     private seq;
     private lastTimestamp;
     private sequence;
@@ -35,7 +37,7 @@ export declare class ProtocolClient {
     }): Promise<void>;
     sendRpc(method: Method, input?: RpcCall["input"]): Promise<bigint>;
     callRpc(method: Method, input?: RpcCall["input"], options?: {
-        timeoutMs?: number;
+        timeoutMs?: number | null;
     }): Promise<RpcResult["result"]>;
     private startListeners;
     private handleTransportMessage;
@@ -53,10 +55,14 @@ export declare class ProtocolClient {
     private generateId;
     private currentTimestamp;
     private completeRpcResult;
+    private ensureOpenForRpc;
     private completeRpcError;
-    private failRpcContinuation;
-    private getAndRemoveRpcContinuation;
-    private cancelAllRpcContinuations;
+    private failPendingRpcRequest;
+    private getAndRemovePendingRpcRequest;
+    private cancelAllPendingRpcRequests;
+    private resolveRpcTimeoutMs;
+    private resendPendingRpcRequests;
+    private trySendPendingRpcRequest;
 }
 export declare class ProtocolClientError extends Error {
     constructor(code: "not-authorized" | "not-connected" | "rpc-error" | "stopped" | "timeout", details?: {

package/dist/realtime/protocol-client.js

@@ -2,6 +2,7 @@ import { ClientMessage, ServerProtocolMessage } from "@inline-chat/protocol/core
 import { AsyncChannel } from "../utils/async-channel.js";
 import { PingPongService } from "./ping-pong.js";
 const emptyRpcInput = { oneofKind: undefined };
+const defaultRpcTimeoutMs = 30_000;
 export class ProtocolClient {
     events = new AsyncChannel();
     transport;
@@ -9,7 +10,8 @@ export class ProtocolClient {
     state = "connecting";
     log;
     getConnectionInit;
-    rpcContinuations = new Map();
+    defaultRpcTimeoutMs;
+    pendingRpcRequests = new Map();
     seq = 0;
     lastTimestamp = 0;
     sequence = 0;
@@ -22,6 +24,7 @@ export class ProtocolClient {
         this.transport = options.transport;
         this.log = options.logger ?? {};
         this.getConnectionInit = options.getConnectionInit;
+        this.defaultRpcTimeoutMs = normalizeRpcTimeoutMs(options.defaultRpcTimeoutMs, defaultRpcTimeoutMs);
         this.pingPong = new PingPongService({ logger: this.log });
         this.pingPong.configure(this);
         this.startListeners();
@@ -48,6 +51,7 @@ export class ProtocolClient {
         await this.transport.reconnect({ skipDelay: options?.skipDelay });
     }
     async sendRpc(method, input = emptyRpcInput) {
+        this.ensureOpenForRpc();
         const message = this.wrapMessage({
             oneofKind: "rpcCall",
             rpcCall: { method, input },
@@ -61,17 +65,20 @@ export class ProtocolClient {
             rpcCall: { method, input },
         });
         return await new Promise((resolve, reject) => {
-            const continuation = { resolve, reject };
-            this.rpcContinuations.set(message.id, continuation);
-            void this.transport.send(message).catch((error) => {
-                this.failRpcContinuation(message.id, error instanceof Error ? error : new Error("send-failed"));
-            });
-            const timeoutMs = options?.timeoutMs ?? 15_000;
-            if (timeoutMs > 0) {
-                continuation.timeout = setTimeout(() => {
-                    this.failRpcContinuation(message.id, new ProtocolClientError("timeout"));
-                }, timeoutMs);
+            const pending = {
+                message,
+                resolve,
+                reject,
+                timeoutMs: this.resolveRpcTimeoutMs(options?.timeoutMs),
+                sending: false,
+            };
+            this.pendingRpcRequests.set(message.id, pending);
+            if (pending.timeoutMs !== null) {
+                pending.timeout = setTimeout(() => {
+                    this.failPendingRpcRequest(message.id, new ProtocolClientError("timeout"));
+                }, pending.timeoutMs);
             }
+            this.trySendPendingRpcRequest(message.id);
         });
     }
     async startListeners() {
@@ -168,6 +175,7 @@ export class ProtocolClient {
         }
         this.connectionAttemptNo = 0;
         this.pingPong.start();
+        this.resendPendingRpcRequests();
     }
     async connecting() {
         this.state = "connecting";
@@ -176,7 +184,7 @@ export class ProtocolClient {
     async reset() {
         this.pingPong.stop();
         this.stopAuthenticationTimeout();
-        this.cancelAllRpcContinuations(new ProtocolClientError("stopped"));
+        this.cancelAllPendingRpcRequests(new ProtocolClientError("stopped"));
         this.state = "connecting";
     }
     startAuthenticationTimeout() {
@@ -195,8 +203,8 @@ export class ProtocolClient {
     }
     handleClientFailure() {
         this.pingPong.stop();
-        this.cancelAllRpcContinuations(new ProtocolClientError("not-connected"));
         this.stopAuthenticationTimeout();
+        this.state = "connecting";
         if (this.reconnectionTimer) {
             clearTimeout(this.reconnectionTimer);
         }
@@ -239,36 +247,80 @@ export class ProtocolClient {
         return Math.floor(Date.now() / 1000) - this.epochSeconds;
     }
     completeRpcResult(msgId, rpcResult) {
-        const continuation = this.getAndRemoveRpcContinuation(msgId);
-        continuation?.resolve(rpcResult);
+        const pending = this.getAndRemovePendingRpcRequest(msgId);
+        pending?.resolve(rpcResult);
+    }
+    ensureOpenForRpc() {
+        if (this.state !== "open") {
+            throw new ProtocolClientError("not-connected");
+        }
     }
     completeRpcError(msgId, rpcError) {
         const error = new ProtocolClientError("rpc-error", { code: rpcError.code, message: rpcError.message });
-        const continuation = this.getAndRemoveRpcContinuation(msgId);
-        continuation?.reject(error);
+        const pending = this.getAndRemovePendingRpcRequest(msgId);
+        pending?.reject(error);
     }
-    failRpcContinuation(msgId, error) {
-        const continuation = this.getAndRemoveRpcContinuation(msgId);
-        continuation?.reject(error);
+    failPendingRpcRequest(msgId, error) {
+        const pending = this.getAndRemovePendingRpcRequest(msgId);
+        pending?.reject(error);
     }
-    getAndRemoveRpcContinuation(msgId) {
-        const continuation = this.rpcContinuations.get(msgId);
-        if (!continuation)
+    getAndRemovePendingRpcRequest(msgId) {
+        const pending = this.pendingRpcRequests.get(msgId);
+        if (!pending)
             return null;
-        if (continuation.timeout)
-            clearTimeout(continuation.timeout);
-        this.rpcContinuations.delete(msgId);
-        return continuation;
-    }
-    cancelAllRpcContinuations(error) {
-        for (const continuation of this.rpcContinuations.values()) {
-            continuation.reject(error);
-            if (continuation.timeout)
-                clearTimeout(continuation.timeout);
+        if (pending.timeout)
+            clearTimeout(pending.timeout);
+        this.pendingRpcRequests.delete(msgId);
+        return pending;
+    }
+    cancelAllPendingRpcRequests(error) {
+        for (const pending of this.pendingRpcRequests.values()) {
+            pending.reject(error);
+            if (pending.timeout)
+                clearTimeout(pending.timeout);
+        }
+        this.pendingRpcRequests.clear();
+    }
+    resolveRpcTimeoutMs(timeoutMs) {
+        return normalizeRpcTimeoutMs(timeoutMs, this.defaultRpcTimeoutMs);
+    }
+    resendPendingRpcRequests() {
+        for (const msgId of this.pendingRpcRequests.keys()) {
+            this.trySendPendingRpcRequest(msgId);
         }
-        this.rpcContinuations.clear();
+    }
+    trySendPendingRpcRequest(msgId) {
+        const pending = this.pendingRpcRequests.get(msgId);
+        if (!pending)
+            return;
+        if (this.state !== "open")
+            return;
+        if (pending.sending)
+            return;
+        pending.sending = true;
+        void this.transport
+            .send(pending.message)
+            .catch((error) => {
+            this.log.warn?.("Failed to send RPC request; waiting for reconnect", error);
+            this.handleClientFailure();
+        })
+            .finally(() => {
+            pending.sending = false;
+        });
     }
 }
+const normalizeRpcTimeoutMs = (timeoutMs, fallback) => {
+    const resolved = timeoutMs === undefined ? fallback : timeoutMs;
+    if (resolved == null)
+        return null;
+    if (resolved === Number.POSITIVE_INFINITY)
+        return null;
+    if (!Number.isFinite(resolved))
+        return null;
+    if (resolved <= 0)
+        return null;
+    return Math.floor(resolved);
+};
 export class ProtocolClientError extends Error {
     constructor(code, details) {
         super(details?.message ?? code);

package/dist/sdk/inline-sdk-client.d.ts

@@ -42,13 +42,13 @@ export declare class InlineSdkClient {
         typing: boolean;
     }): Promise<void>;
     invokeRaw(method: Method, input?: RpcCall["input"], options?: {
-        timeoutMs?: number;
+        timeoutMs?: number | null;
     }): Promise<RpcResult["result"]>;
     invokeUncheckedRaw(method: Method, input?: RpcCall["input"], options?: {
-        timeoutMs?: number;
+        timeoutMs?: number | null;
     }): Promise<RpcResult["result"]>;
     invoke<M extends MappedMethod>(method: M, input: RpcInputForMethod<M>, options?: {
-        timeoutMs?: number;
+        timeoutMs?: number | null;
     }): Promise<RpcResultForMethod<M>>;
     private assertMethodInputMatch;
     private assertMethodResultMatch;

package/dist/sdk/inline-sdk-client.js

@@ -53,6 +53,7 @@ export class InlineSdkClient {
                 clientVersion: getSdkVersion(),
             }),
             logger: options.logger,
+            defaultRpcTimeoutMs: options.rpcTimeoutMs,
         });
         void this.startListeners();
     }

package/dist/sdk/types.d.ts

@@ -6,6 +6,7 @@ import type { Transport } from "../realtime/transport.js";
 export type InlineSdkClientOptions = {
     baseUrl?: string;
     token: string;
+    rpcTimeoutMs?: number | null;
     logger?: InlineSdkLogger;
     state?: InlineSdkStateStore;
     transport?: Transport;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inline-chat/realtime-sdk",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "private": false,
   "type": "module",
   "files": [