@orpc/server 2.0.0-beta.49 → 2.0.0-beta.50

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

@@ -1,59 +1,61 @@
-import type { Arrayable, MaybeOptionalOptions } from '@orpc/shared';
-import type { DecodePeerMessageOptions, EncodePeerMessageOptions } from '@standard-server/peer';
-import type { Context } from '../../context.ts';
-import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from '../standard/index.ts';
+import { Context } from "../../context.js";
+import { StandardHandler } from "../standard/handler.js";
+import { FriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+import "../standard/index.js";
+import { Arrayable, MaybeOptionalOptions } from "@orpc/shared";
+import { DecodePeerMessageOptions, EncodePeerMessageOptions } from "@standard-server/peer";
 /**
  * Supports standard WebSocket instances, Bun ServerWebSocket, "ws" ServerWebSocket,
  * Cloudflare WebSocket Hibernation, and similar implementations.
  */
 export type WebSocketLike = {
-    send: (data: string | Uint8Array<ArrayBuffer>) => unknown;
+  send: (data: string | Uint8Array<ArrayBuffer>) => unknown;
 };
 export interface WebSocketHandlerOptions<_T extends Context> {
-    /**
-     * 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;
+  /**
+   * 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;
 }
 export declare class WebSocketHandler<T extends Context> {
-    private readonly handler;
-    /**
-     * `null` marks a closed socket, so late messages never create a new peer.
-     */
-    private readonly peers;
-    private readonly encodePeerMessageOptions;
-    private readonly decodePeerMessageOptions;
-    constructor(handler: StandardHandler<T>, options?: NoInfer<WebSocketHandlerOptions<T>>);
-    /**
-     * Handles a single WebSocket message.
-     *
-     * Message order matters. Call this immediately after receiving a message,
-     * before any other async work, to preserve ordering.
-     *
-     * To avoid async Blob reads, configure `ws.binaryType` to return binary data
-     * directly (for example, `arraybuffer`).
-     *
-     * @param ws The WebSocket instance. Use the same instance for all messages.
-     * @param data The received message. Binary data should already be loaded (not a `Blob`).
-     */
-    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
-        matched: boolean;
-    }>;
-    /**
-     * Cleans up peer state for a closed WebSocket.
-     * Messages passed to `.message()` for this WebSocket afterwards are ignored.
-     *
-     * @param ws The same WebSocket instance passed to `.message()`.
-     */
-    close(ws: WebSocketLike): Promise<void>;
-    /**
-     * Attaches message, close, and error event listeners to a WebSocket.
-     *
-     * Prefer this over calling `.message()` and `.close()` manually.
-     */
-    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
-}
+  private readonly handler;
+  /**
+   * `null` marks a closed socket, so late messages never create a new peer.
+   */
+  private readonly peers;
+  private readonly encodePeerMessageOptions;
+  private readonly decodePeerMessageOptions;
+  constructor(handler: StandardHandler<T>, options?: NoInfer<WebSocketHandlerOptions<T>>);
+  /**
+   * Handles a single WebSocket message.
+   *
+   * Message order matters. Call this immediately after receiving a message,
+   * before any other async work, to preserve ordering.
+   *
+   * To avoid async Blob reads, configure `ws.binaryType` to return binary data
+   * directly (for example, `arraybuffer`).
+   *
+   * @param ws The WebSocket instance. Use the same instance for all messages.
+   * @param data The received message. Binary data should already be loaded (not a `Blob`).
+   */
+  message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, "buffer" | "byteOffset" | "byteLength">>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
+    matched: boolean;
+  }>;
+  /**
+   * Cleans up peer state for a closed WebSocket.
+   * Messages passed to `.message()` for this WebSocket afterwards are ignored.
+   *
+   * @param ws The same WebSocket instance passed to `.message()`.
+   */
+  close(ws: WebSocketLike): Promise<void>;
+  /**
+   * Attaches message, close, and error event listeners to a WebSocket.
+   *
+   * Prefer this over calling `.message()` and `.close()` manually.
+   */
+  upgrade(ws: Pick<WebSocket, "send" | "addEventListener" | "removeEventListener">, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
+}

package/dist/adapters/websocket/handler.js

@@ -1,85 +1,75 @@
-import { loadBytes, resolveMaybeOptionalOptions, sequential, toStringOrBytes } from '@orpc/shared';
-import { decodePeerMessage, encodePeerMessage, isClientPeerSendMessage, ServerPeer, } from '@standard-server/peer';
-import { createStandardPeerRequestHandler } from '../standard-peer/index.js';
-export class WebSocketHandler {
-    handler;
-    /**
-     * `null` marks a closed socket, so late messages never create a new peer.
-     */
-    peers = new WeakMap();
-    encodePeerMessageOptions;
-    decodePeerMessageOptions;
-    constructor(handler, options = {}) {
-        this.handler = handler;
-        this.encodePeerMessageOptions = options.encodePeerMessage;
-        this.decodePeerMessageOptions = options.decodePeerMessage;
-    }
-    /**
-     * Handles a single WebSocket message.
-     *
-     * Message order matters. Call this immediately after receiving a message,
-     * before any other async work, to preserve ordering.
-     *
-     * To avoid async Blob reads, configure `ws.binaryType` to return binary data
-     * directly (for example, `arraybuffer`).
-     *
-     * @param ws The WebSocket instance. Use the same instance for all messages.
-     * @param data The received message. Binary data should already be loaded (not a `Blob`).
-     */
-    async message(ws, data, ...rest) {
-        /**
-         * Message order is important: loading -> decode -> .message.
-         * This flow must stay synchronous, or we need to use `sequential` helper
-         */
-        const encoded = toStringOrBytes(data);
-        const result = decodePeerMessage(encoded, this.decodePeerMessageOptions);
-        let peer = this.peers.get(ws);
-        // Closed (e.g. a Blob finished loading after close): a new peer here would leak and never be aborted.
-        if (peer === null) {
-            return result;
-        }
-        if (!peer) {
-            this.peers.set(ws, (peer = new ServerPeer(async (message) => {
-                const encoded = await encodePeerMessage(message, this.encodePeerMessageOptions);
-                await ws.send(encoded);
-            })));
-        }
-        if (result.matched && isClientPeerSendMessage(result.message)) {
-            await peer.message(result.message, createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest)));
-        }
-        return result;
-    }
-    /**
-     * Cleans up peer state for a closed WebSocket.
-     * Messages passed to `.message()` for this WebSocket afterwards are ignored.
-     *
-     * @param ws The same WebSocket instance passed to `.message()`.
-     */
-    async close(ws) {
-        const peer = this.peers.get(ws);
-        this.peers.set(ws, null);
-        await peer?.close();
-    }
-    /**
-     * Attaches message, close, and error event listeners to a WebSocket.
-     *
-     * Prefer this over calling `.message()` and `.close()` manually.
-     */
-    upgrade(ws, ...rest) {
-        /**
-         * Message order is important: loading -> decode -> .message.
-         * This flow must stay synchronous, or we need to use `sequential` helper
-         */
-        ws.addEventListener('message', sequential(async (event) => {
-            // For better compatibility avoid control or depend on websocket.binaryType
-            const data = event.data instanceof Blob ? await loadBytes(event.data) : event.data;
-            // Not awaited: `this.message` runs business logic that may be slow,
-            // and awaiting it would block decoding of subsequent messages.
-            void this.message(ws, data, ...rest);
-        }));
-        ws.addEventListener('close', () => this.close(ws));
-        // EventEmitter-based implementations like `ws` throw an unhandled `error` event,
-        // so a single malformed frame would crash the process. `close` always follows and handles cleanup.
-        ws.addEventListener('error', () => { });
-    }
-}
+import { createStandardPeerRequestHandler } from "../standard-peer/utils.js";
+import { loadBytes, resolveMaybeOptionalOptions, sequential, toStringOrBytes } from "@orpc/shared";
+import { ServerPeer, decodePeerMessage, encodePeerMessage, isClientPeerSendMessage } from "@standard-server/peer";
+// src/adapters/websocket/handler.ts
+var WebSocketHandler = class {
+	handler;
+	/**
+	* `null` marks a closed socket, so late messages never create a new peer.
+	*/
+	peers = /* @__PURE__ */ new WeakMap();
+	encodePeerMessageOptions;
+	decodePeerMessageOptions;
+	constructor(handler, options = {}) {
+		this.handler = handler;
+		this.encodePeerMessageOptions = options.encodePeerMessage;
+		this.decodePeerMessageOptions = options.decodePeerMessage;
+	}
+	/**
+	* Handles a single WebSocket message.
+	*
+	* Message order matters. Call this immediately after receiving a message,
+	* before any other async work, to preserve ordering.
+	*
+	* To avoid async Blob reads, configure `ws.binaryType` to return binary data
+	* directly (for example, `arraybuffer`).
+	*
+	* @param ws The WebSocket instance. Use the same instance for all messages.
+	* @param data The received message. Binary data should already be loaded (not a `Blob`).
+	*/
+	async message(ws, data, ...rest) {
+		/**
+		* Message order is important: loading -> decode -> .message.
+		* This flow must stay synchronous, or we need to use `sequential` helper
+		*/
+		const encoded = toStringOrBytes(data);
+		const result = decodePeerMessage(encoded, this.decodePeerMessageOptions);
+		let peer = this.peers.get(ws);
+		if (peer === null) return result;
+		if (!peer) this.peers.set(ws, peer = new ServerPeer(async (message) => {
+			const encoded = await encodePeerMessage(message, this.encodePeerMessageOptions);
+			await ws.send(encoded);
+		}));
+		if (result.matched && isClientPeerSendMessage(result.message)) await peer.message(result.message, createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest)));
+		return result;
+	}
+	/**
+	* Cleans up peer state for a closed WebSocket.
+	* Messages passed to `.message()` for this WebSocket afterwards are ignored.
+	*
+	* @param ws The same WebSocket instance passed to `.message()`.
+	*/
+	async close(ws) {
+		const peer = this.peers.get(ws);
+		this.peers.set(ws, null);
+		await peer?.close();
+	}
+	/**
+	* Attaches message, close, and error event listeners to a WebSocket.
+	*
+	* Prefer this over calling `.message()` and `.close()` manually.
+	*/
+	upgrade(ws, ...rest) {
+		/**
+		* Message order is important: loading -> decode -> .message.
+		* This flow must stay synchronous, or we need to use `sequential` helper
+		*/
+		ws.addEventListener("message", sequential(async (event) => {
+			const data = event.data instanceof Blob ? await loadBytes(event.data) : event.data;
+			this.message(ws, data, ...rest);
+		}));
+		ws.addEventListener("close", () => this.close(ws));
+		ws.addEventListener("error", () => {});
+	}
+};
+export { WebSocketHandler };

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

@@ -1,2 +1,3 @@
-export * from './handler.ts';
-export * from './rpc-handler.ts';
+import { WebSocketHandler, WebSocketHandlerOptions, WebSocketLike } from "./handler.js";
+import { RPCHandler, RPCHandlerOptions } from "./rpc-handler.js";
+export { RPCHandler, RPCHandlerOptions, WebSocketHandler, WebSocketHandlerOptions, WebSocketLike };

package/dist/adapters/websocket/index.js

@@ -1,2 +1,2 @@
-export * from './handler.js';
-export * from './rpc-handler.js';
+export { WebSocketHandler } from "./handler.js";
+export { RPCHandler } from "./rpc-handler.js";

package/dist/adapters/websocket/rpc-handler.d.ts

@@ -1,10 +1,10 @@
-import type { Context } from '../../context.ts';
-import type { Router } from '../../router.ts';
-import type { RPCHandlerCodecOptions, StandardHandlerOptions } from '../standard/index.ts';
-import type { WebSocketHandlerOptions } from './handler.ts';
-import { WebSocketHandler } from './handler.ts';
-export interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {
-}
+import { Context } from "../../context.js";
+import { StandardHandlerOptions } from "../standard/handler.js";
+import { Router } from "../../router.js";
+import { RPCHandlerCodecOptions } from "../standard/rpc-handler-codec.js";
+import "../standard/index.js";
+import { WebSocketHandler, WebSocketHandlerOptions } from "./handler.js";
+export interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {}
 /**
  * Serves an oRPC router over the RPC protocol on a standard WebSocket
  * connection (Deno, Bun, Cloudflare Durable Objects, and more).
@@ -12,5 +12,5 @@ export interface RPCHandlerOptions<T extends Context> extends StandardHandlerOpt
  * @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
  */
 export declare class RPCHandler<T extends Context> extends WebSocketHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
+  constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}

package/dist/adapters/websocket/rpc-handler.js

@@ -1,15 +1,18 @@
-import { RPCHandlerCodec, StandardHandler } from '../standard/index.js';
-import { WebSocketHandler } from './handler.js';
+import { RPCHandlerCodec } from "../standard/rpc-handler-codec.js";
+import { StandardHandler } from "../standard/handler.js";
+import { WebSocketHandler } from "./handler.js";
+// src/adapters/websocket/rpc-handler.ts
 /**
- * Serves an oRPC router over the RPC protocol on a standard WebSocket
- * connection (Deno, Bun, Cloudflare Durable Objects, and more).
- *
- * @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
- */
-export class RPCHandler extends WebSocketHandler {
-    constructor(router, options = {}) {
-        const codec = new RPCHandlerCodec(router, options);
-        const handler = new StandardHandler(codec, options);
-        super(handler, options);
-    }
-}
+* Serves an oRPC router over the RPC protocol on a standard WebSocket
+* connection (Deno, Bun, Cloudflare Durable Objects, and more).
+*
+* @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
+*/
+var RPCHandler = class extends WebSocketHandler {
+	constructor(router, options = {}) {
+		const codec = new RPCHandlerCodec(router, options);
+		const handler = new StandardHandler(codec, options);
+		super(handler, options);
+	}
+};
+export { RPCHandler };