@orpc/server 1.14.11 → 1.14.13

package/dist/adapters/standard-peer/index.d.mts

@@ -1,16 +1,18 @@
-import { Value, Promisable } from '@orpc/shared';
-import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
-import { C as Context } from '../../shared/server.CcR4kgje.mjs';
-import { b as StandardHandlerHandleOptions, S as StandardHandler } from '../../shared/server.DDFizwfU.mjs';
+import { ServerPeer, EncodedMessage, ServerPeerHandleRequestFn } from '@orpc/standard-server-peer';
+import { C as Context } from '../../shared/server.qKsRrdxW.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.B8gYOD5g.mjs';
+import { f as StandardHandler } from '../../shared/server.BqadksTP.mjs';
 import '@orpc/client';
 import '@orpc/contract';
+import '@orpc/shared';
+import '@orpc/standard-server';
 
-type StandardPeerRequestHandlerOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: Value<Promisable<T>, [request: StandardLazyRequest]>;
-} : {
-    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
-});
-declare function createStandardPeerRequestHandler<T extends Context>(handler: StandardHandler<T>, options: StandardPeerRequestHandlerOptions<T>): (request: StandardLazyRequest) => Promise<StandardResponse>;
+type HandleStandardServerPeerMessageOptions<T extends Context> = Omit<FriendlyStandardHandleOptions<T>, 'prefix'>;
+/**
+ * @deprecated Use `createServerPeerRequestHandleFn` instead.
+ */
+declare function handleStandardServerPeerMessage<T extends Context>(handler: StandardHandler<T>, peer: ServerPeer, message: EncodedMessage, options: HandleStandardServerPeerMessageOptions<T>): Promise<void>;
+declare function createServerPeerHandleRequestFn<T extends Context>(handler: StandardHandler<T>, options: HandleStandardServerPeerMessageOptions<T>): ServerPeerHandleRequestFn;
 
-export { createStandardPeerRequestHandler };
-export type { StandardPeerRequestHandlerOptions };
+export { createServerPeerHandleRequestFn, handleStandardServerPeerMessage };
+export type { HandleStandardServerPeerMessageOptions };

package/dist/adapters/standard-peer/index.d.ts

@@ -1,16 +1,18 @@
-import { Value, Promisable } from '@orpc/shared';
-import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
-import { C as Context } from '../../shared/server.CcR4kgje.js';
-import { b as StandardHandlerHandleOptions, S as StandardHandler } from '../../shared/server.BhsVw7m7.js';
+import { ServerPeer, EncodedMessage, ServerPeerHandleRequestFn } from '@orpc/standard-server-peer';
+import { C as Context } from '../../shared/server.qKsRrdxW.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.EfTOZ2Q7.js';
+import { f as StandardHandler } from '../../shared/server.7cEtMB30.js';
 import '@orpc/client';
 import '@orpc/contract';
+import '@orpc/shared';
+import '@orpc/standard-server';
 
-type StandardPeerRequestHandlerOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: Value<Promisable<T>, [request: StandardLazyRequest]>;
-} : {
-    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
-});
-declare function createStandardPeerRequestHandler<T extends Context>(handler: StandardHandler<T>, options: StandardPeerRequestHandlerOptions<T>): (request: StandardLazyRequest) => Promise<StandardResponse>;
+type HandleStandardServerPeerMessageOptions<T extends Context> = Omit<FriendlyStandardHandleOptions<T>, 'prefix'>;
+/**
+ * @deprecated Use `createServerPeerRequestHandleFn` instead.
+ */
+declare function handleStandardServerPeerMessage<T extends Context>(handler: StandardHandler<T>, peer: ServerPeer, message: EncodedMessage, options: HandleStandardServerPeerMessageOptions<T>): Promise<void>;
+declare function createServerPeerHandleRequestFn<T extends Context>(handler: StandardHandler<T>, options: HandleStandardServerPeerMessageOptions<T>): ServerPeerHandleRequestFn;
 
-export { createStandardPeerRequestHandler };
-export type { StandardPeerRequestHandlerOptions };
+export { createServerPeerHandleRequestFn, handleStandardServerPeerMessage };
+export type { HandleStandardServerPeerMessageOptions };

package/dist/adapters/standard-peer/index.mjs

@@ -1,2 +1,21 @@
-export { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
-import '@orpc/shared';
+import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
+
+async function handleStandardServerPeerMessage(handler, peer, message, options) {
+  const [id, request] = await peer.message(message);
+  if (!request) {
+    return;
+  }
+  const handle = createServerPeerHandleRequestFn(handler, options);
+  await peer.response(id, await handle(request));
+}
+function createServerPeerHandleRequestFn(handler, options) {
+  return async (request) => {
+    const { response } = await handler.handle(
+      { ...request, body: () => Promise.resolve(request.body) },
+      resolveFriendlyStandardHandleOptions(options)
+    );
+    return response ?? { status: 404, headers: {}, body: "No procedure matched" };
+  };
+}
+
+export { createServerPeerHandleRequestFn, handleStandardServerPeerMessage };

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

@@ -1,71 +1,56 @@
-import { Arrayable, MaybeOptionalOptions } from '@orpc/shared';
-import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
-import { C as Context } from '../../shared/server.CcR4kgje.mjs';
-import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DDFizwfU.mjs';
-import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.mjs';
-import { R as Router } from '../../shared/server.15O7oC1p.mjs';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.B4BnEWWm.mjs';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.mjs';
+import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.mjs';
+import { f as StandardHandler } from '../../shared/server.BqadksTP.mjs';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.DzE6WeuY.mjs';
 import '@orpc/client';
 import '@orpc/contract';
-import '@standardserver/core';
+import '@orpc/standard-server-peer';
+import '../../shared/server.B8gYOD5g.mjs';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+import '../../shared/server.C8_sRzQB.mjs';
 
-/**
- * Supports standard WebSocket instances, Bun ServerWebSocket, "ws" ServerWebSocket,
- * Cloudflare WebSocket Hibernation, and similar implementations.
- */
-type WebSocketLike = {
-    send: (data: string | Uint8Array<ArrayBuffer>) => unknown;
-};
-interface WebSocketHandlerOptions<_T extends Context> {
-    /**
-     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    encodePeerMessage?: EncodePeerMessageOptions | undefined;
+type MinimalWebsocket = Pick<WebSocket, 'addEventListener' | 'send'>;
+declare class WebsocketHandler<T extends Context> {
+    #private;
+    constructor(standardHandler: StandardHandler<T>);
     /**
-     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    decodePeerMessage?: DecodePeerMessageOptions | undefined;
-}
-declare class WebSocketHandler<T extends Context> {
-    private readonly handler;
-    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.
+     * Upgrades a WebSocket to enable handling
      *
-     * To avoid async Blob reads, configure `ws.binaryType` to return binary data
-     * directly (for example, `arraybuffer`).
+     * This attaches the necessary 'message' and 'close' listeners to the WebSocket
      *
-     * @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`).
+     * @warning Do not use this method if you're using `.message()` or `.close()`
      */
-    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
-        matched: boolean;
-    }>;
+    upgrade(ws: MinimalWebsocket, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): void;
     /**
-     * Cleans up peer state for a closed WebSocket.
+     * Handles a single message received from a WebSocket.
+     *
+     * @warning Avoid calling this directly if `.upgrade()` is used.
      *
-     * @param ws The same WebSocket instance passed to `.message()`.
+     * @param ws The WebSocket instance
+     * @param data The message payload, usually place in `event.data`
      */
-    close(ws: WebSocketLike): Promise<void>;
+    message(ws: MinimalWebsocket, data: string | ArrayBuffer | Blob, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): Promise<void>;
     /**
-     * Attaches message and close event listeners to a WebSocket.
+     * Closes the WebSocket peer and cleans up.
      *
-     * Prefer this over calling `.message()` and `.close()` manually.
+     * @warning Avoid calling this directly if `.upgrade()` is used.
      */
-    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
+    close(ws: MinimalWebsocket): void;
 }
 
-interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends StandardRPCHandlerOptions<T> {
 }
-declare class RPCHandler<T extends Context> extends WebSocketHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+/**
+ * RPC Handler for Websocket adapter
+ *
+ * @see {@link https://orpc.dev/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.dev/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends WebsocketHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { RPCHandler, WebSocketHandler };
-export type { RPCHandlerOptions, WebSocketHandlerOptions, WebSocketLike };
+export { RPCHandler, WebsocketHandler };
+export type { MinimalWebsocket, RPCHandlerOptions };

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

@@ -1,71 +1,56 @@
-import { Arrayable, MaybeOptionalOptions } from '@orpc/shared';
-import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
-import { C as Context } from '../../shared/server.CcR4kgje.js';
-import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.BhsVw7m7.js';
-import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.js';
-import { R as Router } from '../../shared/server.m3szVJGU.js';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.CnN50DHH.js';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.js';
+import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.js';
+import { f as StandardHandler } from '../../shared/server.7cEtMB30.js';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.D8IXzfqT.js';
 import '@orpc/client';
 import '@orpc/contract';
-import '@standardserver/core';
+import '@orpc/standard-server-peer';
+import '../../shared/server.EfTOZ2Q7.js';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+import '../../shared/server.ChyoA9XY.js';
 
-/**
- * Supports standard WebSocket instances, Bun ServerWebSocket, "ws" ServerWebSocket,
- * Cloudflare WebSocket Hibernation, and similar implementations.
- */
-type WebSocketLike = {
-    send: (data: string | Uint8Array<ArrayBuffer>) => unknown;
-};
-interface WebSocketHandlerOptions<_T extends Context> {
-    /**
-     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    encodePeerMessage?: EncodePeerMessageOptions | undefined;
+type MinimalWebsocket = Pick<WebSocket, 'addEventListener' | 'send'>;
+declare class WebsocketHandler<T extends Context> {
+    #private;
+    constructor(standardHandler: StandardHandler<T>);
     /**
-     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    decodePeerMessage?: DecodePeerMessageOptions | undefined;
-}
-declare class WebSocketHandler<T extends Context> {
-    private readonly handler;
-    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.
+     * Upgrades a WebSocket to enable handling
      *
-     * To avoid async Blob reads, configure `ws.binaryType` to return binary data
-     * directly (for example, `arraybuffer`).
+     * This attaches the necessary 'message' and 'close' listeners to the WebSocket
      *
-     * @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`).
+     * @warning Do not use this method if you're using `.message()` or `.close()`
      */
-    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
-        matched: boolean;
-    }>;
+    upgrade(ws: MinimalWebsocket, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): void;
     /**
-     * Cleans up peer state for a closed WebSocket.
+     * Handles a single message received from a WebSocket.
+     *
+     * @warning Avoid calling this directly if `.upgrade()` is used.
      *
-     * @param ws The same WebSocket instance passed to `.message()`.
+     * @param ws The WebSocket instance
+     * @param data The message payload, usually place in `event.data`
      */
-    close(ws: WebSocketLike): Promise<void>;
+    message(ws: MinimalWebsocket, data: string | ArrayBuffer | Blob, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): Promise<void>;
     /**
-     * Attaches message and close event listeners to a WebSocket.
+     * Closes the WebSocket peer and cleans up.
      *
-     * Prefer this over calling `.message()` and `.close()` manually.
+     * @warning Avoid calling this directly if `.upgrade()` is used.
      */
-    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
+    close(ws: MinimalWebsocket): void;
 }
 
-interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends StandardRPCHandlerOptions<T> {
 }
-declare class RPCHandler<T extends Context> extends WebSocketHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+/**
+ * RPC Handler for Websocket adapter
+ *
+ * @see {@link https://orpc.dev/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.dev/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends WebsocketHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { RPCHandler, WebSocketHandler };
-export type { RPCHandlerOptions, WebSocketHandlerOptions, WebSocketLike };
+export { RPCHandler, WebsocketHandler };
+export type { MinimalWebsocket, RPCHandlerOptions };

package/dist/adapters/websocket/index.mjs

@@ -1,84 +1,67 @@
-import { toStringOrBytes, resolveMaybeOptionalOptions, sequential, loadBytes } from '@orpc/shared';
-import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage } from '@standardserver/peer';
-import { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.COPVXhDG.mjs';
+import { readAsBuffer, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { ServerPeer } from '@orpc/standard-server-peer';
+import { createServerPeerHandleRequestFn } from '../standard-peer/index.mjs';
+import { b as StandardRPCHandler } from '../../shared/server.CMf4nKky.mjs';
+import '../../shared/server.DZ5BIITo.mjs';
+import '@orpc/client/standard';
 import '@orpc/client';
-import '@standardserver/core';
-import '../../shared/server.DofEOwf-.mjs';
+import '@orpc/standard-server';
+import '../../shared/server.DEBcqOjg.mjs';
 import '@orpc/contract';
-import '../../shared/server.BoiFpNT7.mjs';
 
-class WebSocketHandler {
-  constructor(handler, options = {}) {
-    this.handler = handler;
-    this.encodePeerMessageOptions = options.encodePeerMessage;
-    this.decodePeerMessageOptions = options.decodePeerMessage;
+class WebsocketHandler {
+  #peers = /* @__PURE__ */ new WeakMap();
+  #handler;
+  constructor(standardHandler) {
+    this.#handler = standardHandler;
   }
-  peers = /* @__PURE__ */ new WeakMap();
-  encodePeerMessageOptions;
-  decodePeerMessageOptions;
   /**
-   * Handles a single WebSocket message.
+   * Upgrades a WebSocket to enable handling
    *
-   * Message order matters. Call this immediately after receiving a message,
-   * before any other async work, to preserve ordering.
+   * This attaches the necessary 'message' and 'close' listeners to the WebSocket
    *
-   * To avoid async Blob reads, configure `ws.binaryType` to return binary data
-   * directly (for example, `arraybuffer`).
+   * @warning Do not use this method if you're using `.message()` or `.close()`
+   */
+  upgrade(ws, ...rest) {
+    ws.addEventListener("message", (event) => this.message(ws, event.data, ...rest));
+    ws.addEventListener("close", () => this.close(ws));
+  }
+  /**
+   * Handles a single message received from a WebSocket.
+   *
+   * @warning Avoid calling this directly if `.upgrade()` is used.
    *
-   * @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`).
+   * @param ws The WebSocket instance
+   * @param data The message payload, usually place in `event.data`
    */
   async message(ws, data, ...rest) {
-    let peer = this.peers.get(ws);
+    let peer = this.#peers.get(ws);
     if (!peer) {
-      this.peers.set(ws, peer = new ServerPeer(async (message) => {
-        const encoded2 = await encodePeerMessage(message, this.encodePeerMessageOptions);
-        await ws.send(encoded2);
-      }));
-    }
-    const encoded = toStringOrBytes(data);
-    const result = decodePeerMessage(encoded, this.decodePeerMessageOptions);
-    if (result.matched && isClientPeerSendMessage(result.message)) {
-      await peer.message(
-        result.message,
-        createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest))
-      );
+      this.#peers.set(ws, peer = new ServerPeer(ws.send.bind(ws)));
     }
-    return result;
+    const message = data instanceof Blob ? await readAsBuffer(data) : data;
+    await peer.message(
+      message,
+      createServerPeerHandleRequestFn(this.#handler, resolveMaybeOptionalOptions(rest))
+    );
   }
   /**
-   * Cleans up peer state for a closed WebSocket.
+   * Closes the WebSocket peer and cleans up.
    *
-   * @param ws The same WebSocket instance passed to `.message()`.
+   * @warning Avoid calling this directly if `.upgrade()` is used.
    */
-  async close(ws) {
-    const peer = this.peers.get(ws);
+  close(ws) {
+    const peer = this.#peers.get(ws);
     if (peer) {
-      this.peers.delete(ws);
-      await peer.close();
+      peer.close();
     }
   }
-  /**
-   * Attaches message and close event listeners to a WebSocket.
-   *
-   * Prefer this over calling `.message()` and `.close()` manually.
-   */
-  upgrade(ws, ...rest) {
-    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));
-  }
 }
 
-class RPCHandler extends WebSocketHandler {
+class RPCHandler extends WebsocketHandler {
   constructor(router, options = {}) {
-    const codec = new RPCHandlerCodec(router, options);
-    const handler = new StandardHandler(codec, options);
-    super(handler, options);
+    super(new StandardRPCHandler(router, options));
   }
 }
 
-export { RPCHandler, WebSocketHandler };
+export { RPCHandler, WebsocketHandler };

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

@@ -0,0 +1,31 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { WebSocket } from 'ws';
+import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.mjs';
+import { f as StandardHandler } from '../../shared/server.BqadksTP.mjs';
+import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.mjs';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.DzE6WeuY.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/standard-server-peer';
+import '../../shared/server.B8gYOD5g.mjs';
+import '@orpc/client/standard';
+import '../../shared/server.C8_sRzQB.mjs';
+
+declare class WsHandler<T extends Context> {
+    private readonly standardHandler;
+    constructor(standardHandler: StandardHandler<T>);
+    upgrade(ws: Pick<WebSocket, 'addEventListener' | 'send'>, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): Promise<void>;
+}
+
+/**
+ * RPC Handler for ws (node ws) adapter
+ *
+ * @see {@link https://orpc.dev/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.dev/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends WsHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { RPCHandler, WsHandler };

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

@@ -0,0 +1,31 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { WebSocket } from 'ws';
+import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.js';
+import { f as StandardHandler } from '../../shared/server.7cEtMB30.js';
+import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.js';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.D8IXzfqT.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/standard-server-peer';
+import '../../shared/server.EfTOZ2Q7.js';
+import '@orpc/client/standard';
+import '../../shared/server.ChyoA9XY.js';
+
+declare class WsHandler<T extends Context> {
+    private readonly standardHandler;
+    constructor(standardHandler: StandardHandler<T>);
+    upgrade(ws: Pick<WebSocket, 'addEventListener' | 'send'>, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): Promise<void>;
+}
+
+/**
+ * RPC Handler for ws (node ws) adapter
+ *
+ * @see {@link https://orpc.dev/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.dev/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends WsHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { RPCHandler, WsHandler };

package/dist/adapters/ws/index.mjs

@@ -0,0 +1,41 @@
+import { readAsBuffer, resolveMaybeOptionalOptions, logError } from '@orpc/shared';
+import { ServerPeer } from '@orpc/standard-server-peer';
+import { createServerPeerHandleRequestFn } from '../standard-peer/index.mjs';
+import { b as StandardRPCHandler } from '../../shared/server.CMf4nKky.mjs';
+import '../../shared/server.DZ5BIITo.mjs';
+import '@orpc/client/standard';
+import '@orpc/client';
+import '@orpc/standard-server';
+import '../../shared/server.DEBcqOjg.mjs';
+import '@orpc/contract';
+
+class WsHandler {
+  constructor(standardHandler) {
+    this.standardHandler = standardHandler;
+  }
+  async upgrade(ws, ...rest) {
+    const peer = new ServerPeer(ws.send.bind(ws));
+    ws.addEventListener("message", async (event) => {
+      const message = Array.isArray(event.data) ? await readAsBuffer(new Blob(event.data)) : event.data;
+      try {
+        await peer.message(
+          message,
+          createServerPeerHandleRequestFn(this.standardHandler, resolveMaybeOptionalOptions(rest))
+        );
+      } catch (error) {
+        logError(error);
+      }
+    });
+    ws.addEventListener("close", () => {
+      peer.close();
+    });
+  }
+}
+
+class RPCHandler extends WsHandler {
+  constructor(router, options = {}) {
+    super(new StandardRPCHandler(router, options));
+  }
+}
+
+export { RPCHandler, WsHandler };

package/dist/helpers/index.d.mts

@@ -1,4 +1,4 @@
-import { ParseOptions, SetCookie, StringifyOptions } from 'cookie';
+import { SerializeOptions, ParseOptions } from 'cookie';
 
 /**
  * Encodes a Uint8Array to base64url format
@@ -25,9 +25,9 @@ declare function encodeBase64url(data: Uint8Array): string;
  * expect(new TextDecoder().decode(decoded)).toEqual(text)
  * ```
  */
-declare function decodeBase64url(base64url: string | undefined | null): Uint8Array<ArrayBuffer> | undefined;
+declare function decodeBase64url(base64url: string | undefined | null): Uint8Array | undefined;
 
-interface SetCookieOptions extends Omit<SetCookie, 'name' | 'value'>, StringifyOptions {
+interface SetCookieOptions extends SerializeOptions {
     /**
      * Specifies the value for the [`Path` `Set-Cookie` attribute](https://tools.ietf.org/html/rfc6265#section-5.2.4).
      *
@@ -46,7 +46,7 @@ interface SetCookieOptions extends Omit<SetCookie, 'name' | 'value'>, StringifyO
  *
  * setCookie(headers, 'sessionId', 'abc123', { httpOnly: true, maxAge: 3600 })
  *
- * expect(headers.get('Set-Cookie')).toBe('sessionId=abc123; Max-Age=3600; Path=/; HttpOnly')
+ * expect(headers.get('Set-Cookie')).toBe('sessionId=abc123; HttpOnly; Max-Age=3600')
  * ```
  *
  */

package/dist/helpers/index.d.ts

@@ -1,4 +1,4 @@
-import { ParseOptions, SetCookie, StringifyOptions } from 'cookie';
+import { SerializeOptions, ParseOptions } from 'cookie';
 
 /**
  * Encodes a Uint8Array to base64url format
@@ -25,9 +25,9 @@ declare function encodeBase64url(data: Uint8Array): string;
  * expect(new TextDecoder().decode(decoded)).toEqual(text)
  * ```
  */
-declare function decodeBase64url(base64url: string | undefined | null): Uint8Array<ArrayBuffer> | undefined;
+declare function decodeBase64url(base64url: string | undefined | null): Uint8Array | undefined;
 
-interface SetCookieOptions extends Omit<SetCookie, 'name' | 'value'>, StringifyOptions {
+interface SetCookieOptions extends SerializeOptions {
     /**
      * Specifies the value for the [`Path` `Set-Cookie` attribute](https://tools.ietf.org/html/rfc6265#section-5.2.4).
      *
@@ -46,7 +46,7 @@ interface SetCookieOptions extends Omit<SetCookie, 'name' | 'value'>, StringifyO
  *
  * setCookie(headers, 'sessionId', 'abc123', { httpOnly: true, maxAge: 3600 })
  *
- * expect(headers.get('Set-Cookie')).toBe('sessionId=abc123; Max-Age=3600; Path=/; HttpOnly')
+ * expect(headers.get('Set-Cookie')).toBe('sessionId=abc123; HttpOnly; Max-Age=3600')
  * ```
  *
  */