@orpc/client 1.14.6 → 2.0.0-beta.10

package/dist/adapters/websocket/index.d.mts

@@ -1,29 +1,121 @@
-import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
-import { b as ClientContext, c as ClientOptions } from '../../shared/client.i2uoJbEp.mjs';
-import { f as StandardLinkClient } from '../../shared/client.CpCa3si8.mjs';
-import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.BFAVy68H.mjs';
-import '@orpc/shared';
+import { C as ClientContext, a as ClientOptions } from '../../shared/client.8ug8I-zu.mjs';
+import { Promisable } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse } from '@standardserver/core';
+import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
+import { S as StandardLinkTransport, a as StandardLink, b as StandardLinkOptions } from '../../shared/client.Cby_-GGh.mjs';
+import { RPCLinkCodecOptions } from '../standard/index.mjs';
+import '../../shared/client.BdItY5DT.mjs';
 
-interface LinkWebsocketClientOptions {
-    websocket: Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send' | 'readyState'>;
+type WebSocketLike = Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send' | 'readyState'>;
+interface WebSocketLinkTransportAttemptInfo {
+    /**
+     * Total number of connection attempts for this transport's lifetime.
+     * Starts at 1 on the first attempt, increments on every subsequent
+     * attempt, and never resets.
+     */
+    totalAttempt: number;
+    /**
+     * Attempt number within the current (re)connect cycle.
+     * Starts at 1, increments on each consecutive failure, and resets to 1
+     * once a connection succeeds. Use this for backoff calculations.
+     */
+    attempt: number;
 }
-declare class LinkWebsocketClient<T extends ClientContext> implements StandardLinkClient<T> {
-    private readonly peer;
-    constructor(options: LinkWebsocketClientOptions);
-    call(request: StandardRequest, _options: ClientOptions<T>, _path: readonly string[], _input: unknown): Promise<StandardLazyResponse>;
+interface WebSocketLinkTransportReconnectOptions {
+    /**
+     * Whether to automatically reconnect when the connection is lost.
+     *
+     * @default false
+     */
+    enabled: boolean;
+    /**
+     * Delay before a (re)connect attempt, in milliseconds.
+     *
+     * @default info => info.attempt === 1 ? 0 : 2_000
+     */
+    delay?: undefined | ((info: WebSocketLinkTransportAttemptInfo) => number);
+    /**
+     * Maximum number of consecutive failed attempts before giving up.
+     * When exceeded, `getConnectedPeer` throws instead of retrying.
+     * Should greater than 1
+     *
+     * @default Infinity
+     */
+    maxAttempt?: undefined | number;
+    /**
+     * Whether to proactively reconnect right after the socket closes,
+     * rather than waiting for the next call to trigger reconnection.
+     * Reduces latency for the next request.
+     *
+     * @default { enabled: false }
+     */
+    onClose?: undefined | {
+        /**
+         * Whether to proactively reconnect right after the socket closes,
+         * rather than waiting for the next call to trigger reconnection.
+         * Reduces latency for the next request.
+         *
+         * @default false
+         */
+        enabled: boolean;
+        /**
+         * Delay before reconnecting after the socket closes, in milliseconds.
+         *
+         * @default 0
+         */
+        delay?: number;
+    };
+}
+interface WebSocketLinkTransportOptions<_T extends ClientContext> {
+    /**
+     * Returns a WebSocket instance for peer communication.
+     * Can be async for lazy resolution.
+     */
+    connect: (info: WebSocketLinkTransportAttemptInfo) => Promisable<WebSocketLike>;
+    /**
+     * Whether to connect immediately on initialization, instead of waiting
+     * for the first call. Reduces latency for the first request.
+     *
+     * @default false
+     */
+    connectOnInit?: undefined | boolean;
+    /**
+     * Reconnection behavior when the connection is lost.
+     *
+     * @default { enabled: false }
+     */
+    reconnect?: undefined | WebSocketLinkTransportReconnectOptions;
+    /**
+     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+     */
+    encodePeerMessage?: EncodePeerMessageOptions | undefined;
+    /**
+     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+     */
+    decodePeerMessage?: DecodePeerMessageOptions | undefined;
+}
+declare class WebSocketLinkTransport<T extends ClientContext> implements StandardLinkTransport<T> {
+    private readonly connect;
+    private readonly reconnectEnabled;
+    private readonly reconnectDelay;
+    private readonly reconnectMaxAttempt;
+    private readonly reconnectOnCloseEnabled;
+    private readonly reconnectOnCloseDelay;
+    private readonly encodePeerMessageOptions;
+    private readonly decodePeerMessageOptions;
+    constructor(options: WebSocketLinkTransportOptions<T>);
+    send(standardRequest: StandardRequest, _path: string[], _options: ClientOptions<T>): Promise<StandardLazyResponse>;
+    private totalAttempt;
+    private attempt;
+    private current;
+    private getConnectedPeer;
 }
 
-interface RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, LinkWebsocketClientOptions {
+interface RPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, WebSocketLinkTransportOptions<T>, RPCLinkCodecOptions<T> {
 }
-/**
- * The RPC Link communicates with the server using the RPC protocol over WebSocket.
- *
- * @see {@link https://orpc.dev/docs/client/rpc-link RPC Link Docs}
- * @see {@link https://orpc.dev/docs/adapters/websocket WebSocket Adapter Docs}
- */
-declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+declare class RPCLink<T extends ClientContext> extends StandardLink<T> {
     constructor(options: RPCLinkOptions<T>);
 }
 
-export { LinkWebsocketClient, RPCLink };
-export type { LinkWebsocketClientOptions, RPCLinkOptions };
+export { RPCLink, WebSocketLinkTransport };
+export type { RPCLinkOptions, WebSocketLike, WebSocketLinkTransportAttemptInfo, WebSocketLinkTransportOptions, WebSocketLinkTransportReconnectOptions };

package/dist/adapters/websocket/index.d.ts

@@ -1,29 +1,121 @@
-import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
-import { b as ClientContext, c as ClientOptions } from '../../shared/client.i2uoJbEp.js';
-import { f as StandardLinkClient } from '../../shared/client.2jUAqzYU.js';
-import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.B3pNRBih.js';
-import '@orpc/shared';
+import { C as ClientContext, a as ClientOptions } from '../../shared/client.8ug8I-zu.js';
+import { Promisable } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse } from '@standardserver/core';
+import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
+import { S as StandardLinkTransport, a as StandardLink, b as StandardLinkOptions } from '../../shared/client.CPF3hX6O.js';
+import { RPCLinkCodecOptions } from '../standard/index.js';
+import '../../shared/client.BdItY5DT.js';
 
-interface LinkWebsocketClientOptions {
-    websocket: Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send' | 'readyState'>;
+type WebSocketLike = Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send' | 'readyState'>;
+interface WebSocketLinkTransportAttemptInfo {
+    /**
+     * Total number of connection attempts for this transport's lifetime.
+     * Starts at 1 on the first attempt, increments on every subsequent
+     * attempt, and never resets.
+     */
+    totalAttempt: number;
+    /**
+     * Attempt number within the current (re)connect cycle.
+     * Starts at 1, increments on each consecutive failure, and resets to 1
+     * once a connection succeeds. Use this for backoff calculations.
+     */
+    attempt: number;
 }
-declare class LinkWebsocketClient<T extends ClientContext> implements StandardLinkClient<T> {
-    private readonly peer;
-    constructor(options: LinkWebsocketClientOptions);
-    call(request: StandardRequest, _options: ClientOptions<T>, _path: readonly string[], _input: unknown): Promise<StandardLazyResponse>;
+interface WebSocketLinkTransportReconnectOptions {
+    /**
+     * Whether to automatically reconnect when the connection is lost.
+     *
+     * @default false
+     */
+    enabled: boolean;
+    /**
+     * Delay before a (re)connect attempt, in milliseconds.
+     *
+     * @default info => info.attempt === 1 ? 0 : 2_000
+     */
+    delay?: undefined | ((info: WebSocketLinkTransportAttemptInfo) => number);
+    /**
+     * Maximum number of consecutive failed attempts before giving up.
+     * When exceeded, `getConnectedPeer` throws instead of retrying.
+     * Should greater than 1
+     *
+     * @default Infinity
+     */
+    maxAttempt?: undefined | number;
+    /**
+     * Whether to proactively reconnect right after the socket closes,
+     * rather than waiting for the next call to trigger reconnection.
+     * Reduces latency for the next request.
+     *
+     * @default { enabled: false }
+     */
+    onClose?: undefined | {
+        /**
+         * Whether to proactively reconnect right after the socket closes,
+         * rather than waiting for the next call to trigger reconnection.
+         * Reduces latency for the next request.
+         *
+         * @default false
+         */
+        enabled: boolean;
+        /**
+         * Delay before reconnecting after the socket closes, in milliseconds.
+         *
+         * @default 0
+         */
+        delay?: number;
+    };
+}
+interface WebSocketLinkTransportOptions<_T extends ClientContext> {
+    /**
+     * Returns a WebSocket instance for peer communication.
+     * Can be async for lazy resolution.
+     */
+    connect: (info: WebSocketLinkTransportAttemptInfo) => Promisable<WebSocketLike>;
+    /**
+     * Whether to connect immediately on initialization, instead of waiting
+     * for the first call. Reduces latency for the first request.
+     *
+     * @default false
+     */
+    connectOnInit?: undefined | boolean;
+    /**
+     * Reconnection behavior when the connection is lost.
+     *
+     * @default { enabled: false }
+     */
+    reconnect?: undefined | WebSocketLinkTransportReconnectOptions;
+    /**
+     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+     */
+    encodePeerMessage?: EncodePeerMessageOptions | undefined;
+    /**
+     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+     */
+    decodePeerMessage?: DecodePeerMessageOptions | undefined;
+}
+declare class WebSocketLinkTransport<T extends ClientContext> implements StandardLinkTransport<T> {
+    private readonly connect;
+    private readonly reconnectEnabled;
+    private readonly reconnectDelay;
+    private readonly reconnectMaxAttempt;
+    private readonly reconnectOnCloseEnabled;
+    private readonly reconnectOnCloseDelay;
+    private readonly encodePeerMessageOptions;
+    private readonly decodePeerMessageOptions;
+    constructor(options: WebSocketLinkTransportOptions<T>);
+    send(standardRequest: StandardRequest, _path: string[], _options: ClientOptions<T>): Promise<StandardLazyResponse>;
+    private totalAttempt;
+    private attempt;
+    private current;
+    private getConnectedPeer;
 }
 
-interface RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, LinkWebsocketClientOptions {
+interface RPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, WebSocketLinkTransportOptions<T>, RPCLinkCodecOptions<T> {
 }
-/**
- * The RPC Link communicates with the server using the RPC protocol over WebSocket.
- *
- * @see {@link https://orpc.dev/docs/client/rpc-link RPC Link Docs}
- * @see {@link https://orpc.dev/docs/adapters/websocket WebSocket Adapter Docs}
- */
-declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+declare class RPCLink<T extends ClientContext> extends StandardLink<T> {
     constructor(options: RPCLinkOptions<T>);
 }
 
-export { LinkWebsocketClient, RPCLink };
-export type { LinkWebsocketClientOptions, RPCLinkOptions };
+export { RPCLink, WebSocketLinkTransport };
+export type { RPCLinkOptions, WebSocketLike, WebSocketLinkTransportAttemptInfo, WebSocketLinkTransportOptions, WebSocketLinkTransportReconnectOptions };

package/dist/adapters/websocket/index.mjs

@@ -1,52 +1,110 @@
-import { readAsBuffer } from '@orpc/shared';
-import { ClientPeer } from '@orpc/standard-server-peer';
-import { c as StandardRPCLink } from '../../shared/client.DLhbktiD.mjs';
-import '@orpc/standard-server';
-import '../../shared/client.D9eWXdBV.mjs';
-import '@orpc/standard-server-fetch';
-import '../../shared/client.BLtwTQUg.mjs';
+import { runWithSignal, AbortError, sleep, promiseWithResolvers, toStringOrBytes } from '@orpc/shared';
+import { ClientPeer, encodePeerMessage, decodePeerMessage, isServerPeerSendMessage } from '@standardserver/peer';
+import { S as StandardLink, R as RPCLinkCodec } from '../../shared/client.BN52ep3E.mjs';
+import '@standardserver/core';
+import '@standardserver/fetch';
+import '../../shared/client.Dnfj8jnT.mjs';
+import '../../shared/client.D3TIIok6.mjs';
 
 const WEBSOCKET_CONNECTING = 0;
 const WEBSOCKET_OPEN = 1;
-class LinkWebsocketClient {
-  peer;
+class WebSocketLinkTransport {
+  connect;
+  reconnectEnabled;
+  reconnectDelay;
+  reconnectMaxAttempt;
+  reconnectOnCloseEnabled;
+  reconnectOnCloseDelay;
+  encodePeerMessageOptions;
+  decodePeerMessageOptions;
   constructor(options) {
-    this.peer = new ClientPeer(async (message) => {
-      if (options.websocket.readyState === WEBSOCKET_CONNECTING) {
-        await new Promise((resolve) => {
-          const settle = () => {
-            options.websocket.removeEventListener("open", settle);
-            options.websocket.removeEventListener("close", settle);
-            resolve();
-          };
-          options.websocket.addEventListener("open", settle, { once: true });
-          options.websocket.addEventListener("close", settle, { once: true });
+    this.connect = options.connect;
+    this.reconnectEnabled = options.reconnect?.enabled ?? false;
+    this.reconnectDelay = options.reconnect?.delay ?? ((info) => info.attempt === 1 ? 0 : 2e3);
+    this.reconnectMaxAttempt = options.reconnect?.maxAttempt ?? Infinity;
+    this.reconnectOnCloseEnabled = this.reconnectEnabled && (options.reconnect?.onClose?.enabled ?? false);
+    this.reconnectOnCloseDelay = options.reconnect?.onClose?.delay ?? 0;
+    this.encodePeerMessageOptions = options.encodePeerMessage;
+    this.decodePeerMessageOptions = options.decodePeerMessage;
+    if (options.connectOnInit) {
+      this.getConnectedPeer().catch(() => {
+      });
+    }
+  }
+  async send(standardRequest, _path, _options) {
+    const peer = await runWithSignal(
+      standardRequest.signal,
+      () => this.getConnectedPeer()
+    );
+    return peer.request(standardRequest);
+  }
+  totalAttempt = 0;
+  attempt = 0;
+  current;
+  async getConnectedPeer() {
+    const current = this.current;
+    const resolved = await current;
+    if (resolved && (!this.reconnectEnabled || resolved.websocket.readyState === WEBSOCKET_OPEN)) {
+      this.attempt = 0;
+      return resolved.peer;
+    }
+    if (current !== this.current) {
+      return this.getConnectedPeer();
+    }
+    if (this.attempt >= this.reconnectMaxAttempt) {
+      throw new AbortError(`WebSocket reconnect failed after ${this.attempt} attempt(s)`);
+    }
+    this.current = (async () => {
+      this.totalAttempt += 1;
+      this.attempt += 1;
+      const info = { totalAttempt: this.totalAttempt, attempt: this.attempt };
+      await sleep(this.reconnectDelay(info));
+      const websocket = await this.connect(info);
+      const peer = new ClientPeer(async (message) => {
+        const encoded = await encodePeerMessage(message, this.encodePeerMessageOptions);
+        return websocket.send(encoded);
+      });
+      let connectingResolvers;
+      if (websocket.readyState === WEBSOCKET_CONNECTING) {
+        connectingResolvers = promiseWithResolvers();
+        websocket.addEventListener("open", () => {
+          connectingResolvers?.resolve();
         });
       }
-      if (options.websocket.readyState !== WEBSOCKET_OPEN) {
-        throw new Error("Cannot send message, WebSocket is not open.");
+      websocket.addEventListener("message", async (event) => {
+        const message = await toStringOrBytes(event.data);
+        const result = decodePeerMessage(message, this.decodePeerMessageOptions);
+        if (result.matched && isServerPeerSendMessage(result.message)) {
+          await peer.message(result.message);
+        }
+      });
+      websocket.addEventListener("close", async (event) => {
+        connectingResolvers?.resolve();
+        if (this.reconnectOnCloseEnabled) {
+          sleep(this.reconnectOnCloseDelay).then(() => this.getConnectedPeer()).catch(() => {
+          });
+        }
+        const reason = new AbortError(`WebSocket closed (code ${event.code}: ${event.reason})`);
+        await peer.close(reason);
+      });
+      await connectingResolvers?.promise;
+      connectingResolvers = void 0;
+      return { websocket, peer };
+    })().catch((error) => {
+      if (!this.reconnectEnabled) {
+        throw error;
       }
-      return options.websocket.send(message);
-    });
-    options.websocket.addEventListener("message", async (event) => {
-      const message = event.data instanceof Blob ? await readAsBuffer(event.data) : event.data;
-      this.peer.message(message);
     });
-    options.websocket.addEventListener("close", () => {
-      this.peer.close();
-    });
-  }
-  async call(request, _options, _path, _input) {
-    const response = await this.peer.request(request);
-    return { ...response, body: () => Promise.resolve(response.body) };
+    return this.getConnectedPeer();
   }
 }
 
-class RPCLink extends StandardRPCLink {
+class RPCLink extends StandardLink {
   constructor(options) {
-    const linkClient = new LinkWebsocketClient(options);
-    super(linkClient, { ...options, url: "http://orpc" });
+    const codec = new RPCLinkCodec(options);
+    const transport = new WebSocketLinkTransport(options);
+    super(codec, transport, options);
   }
 }
 
-export { LinkWebsocketClient, RPCLink };
+export { RPCLink, WebSocketLinkTransport };