@orpc/server 2.0.0-beta.11 → 2.0.0-beta.12

package/README.md

@@ -50,6 +50,7 @@ You can read the documentation [here](https://orpc.dev).
 - [@orpc/experimental-effect](https://www.npmjs.com/package/@orpc/experimental-effect): Integrate with [Effect](https://effect.website/).
 - [@orpc/nest](https://www.npmjs.com/package/@orpc/nest): Implement your contract with [NestJS](https://nestjs.com/).
 - [@orpc/bun](https://www.npmjs.com/package/@orpc/bun): Adapters for [Bun's Redis](https://bun.sh/).
+- [@orpc/cloudflare](https://www.npmjs.com/package/@orpc/cloudflare): Adapters for [Cloudflare's RateLimit and Durable Objects](https://developers.cloudflare.com/workers/).
 
 **Observability**
 

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

@@ -29,17 +29,20 @@ declare class experimental_CrosswsHandler<T extends Context> {
     private readonly decodePeerMessageOptions;
     constructor(handler: StandardHandler<T>, options?: NoInfer<experimental_CrosswsHandlerOptions<T>>);
     /**
-     * Handles a single message received from a crossws Peer.
+     * Handles a single WebSocket message.
      *
-     * @param ws The crossws Peer instance, require consistent instance across messages for proper peer management
+     * Message order matters. Call this immediately after receiving a message,
+     * before any other async work, to preserve ordering.
+     *
+     * @param ws The crossws peer instance. Use the same instance for all messages.
      */
     message(ws: CrosswsPeerLike, message: CrosswsMessageLike, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
-     * Closes the peer connection and cleans up associated resources.
+     * Cleans up peer state for a closed WebSocket.
      *
-     * @param ws The crossws Peer instance to close, require consistent instance for proper peer management
+     * @param ws The same crossws peer instance passed to `.message()`.
      */
     close(ws: CrosswsPeerLike): Promise<void>;
 }

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

@@ -29,17 +29,20 @@ declare class experimental_CrosswsHandler<T extends Context> {
     private readonly decodePeerMessageOptions;
     constructor(handler: StandardHandler<T>, options?: NoInfer<experimental_CrosswsHandlerOptions<T>>);
     /**
-     * Handles a single message received from a crossws Peer.
+     * Handles a single WebSocket message.
      *
-     * @param ws The crossws Peer instance, require consistent instance across messages for proper peer management
+     * Message order matters. Call this immediately after receiving a message,
+     * before any other async work, to preserve ordering.
+     *
+     * @param ws The crossws peer instance. Use the same instance for all messages.
      */
     message(ws: CrosswsPeerLike, message: CrosswsMessageLike, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
-     * Closes the peer connection and cleans up associated resources.
+     * Cleans up peer state for a closed WebSocket.
      *
-     * @param ws The crossws Peer instance to close, require consistent instance for proper peer management
+     * @param ws The same crossws peer instance passed to `.message()`.
      */
     close(ws: CrosswsPeerLike): Promise<void>;
 }

package/dist/adapters/crossws/index.mjs

@@ -18,9 +18,12 @@ class experimental_CrosswsHandler {
   encodePeerMessageOptions;
   decodePeerMessageOptions;
   /**
-   * Handles a single message received from a crossws Peer.
+   * Handles a single WebSocket message.
    *
-   * @param ws The crossws Peer instance, require consistent instance across messages for proper peer management
+   * Message order matters. Call this immediately after receiving a message,
+   * before any other async work, to preserve ordering.
+   *
+   * @param ws The crossws peer instance. Use the same instance for all messages.
    */
   async message(ws, message, ...rest) {
     let peer = this.peers.get(ws);
@@ -40,9 +43,9 @@ class experimental_CrosswsHandler {
     return result;
   }
   /**
-   * Closes the peer connection and cleans up associated resources.
+   * Cleans up peer state for a closed WebSocket.
    *
-   * @param ws The crossws Peer instance to close, require consistent instance for proper peer management
+   * @param ws The same crossws peer instance passed to `.message()`.
    */
   async close(ws) {
     const server = this.peers.get(ws);

package/dist/adapters/message-port/index.d.mts

@@ -41,25 +41,23 @@ declare class MessagePortHandler<T extends Context> {
     private readonly decodePeerMessageOptions;
     constructor(handler: StandardHandler<T>, options?: NoInfer<MessagePortHandlerOptions<T>>);
     /**
-     * Attaches necessary event listeners to a message port to handle incoming messages and peer management.
+     * Attaches message and close listeners to a message port.
+     *
+     * Prefer this over calling `.message()` and `.close()` manually.
      */
     upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
     /**
      * Handles a single message received from a message port.
      *
-     * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
-     *
-     * @param port The message port instance, require consistent instance across messages for proper peer management
+     * @param port The message port instance. Use the same instance for all messages.
      */
-    message(port: SupportedMessagePort, data: any, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(port: SupportedMessagePort, data: unknown, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
-     * Called when a message port is closed, to clean up any associated peer state.
-     *
-     * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
+     * Cleans up peer state for a closed message port.
      *
-     * @param port The message port instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+     * @param port The same message port instance passed to `.message()`.
      */
     close(port: SupportedMessagePort): Promise<void>;
 }

package/dist/adapters/message-port/index.d.ts

@@ -41,25 +41,23 @@ declare class MessagePortHandler<T extends Context> {
     private readonly decodePeerMessageOptions;
     constructor(handler: StandardHandler<T>, options?: NoInfer<MessagePortHandlerOptions<T>>);
     /**
-     * Attaches necessary event listeners to a message port to handle incoming messages and peer management.
+     * Attaches message and close listeners to a message port.
+     *
+     * Prefer this over calling `.message()` and `.close()` manually.
      */
     upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
     /**
      * Handles a single message received from a message port.
      *
-     * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
-     *
-     * @param port The message port instance, require consistent instance across messages for proper peer management
+     * @param port The message port instance. Use the same instance for all messages.
      */
-    message(port: SupportedMessagePort, data: any, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(port: SupportedMessagePort, data: unknown, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
-     * Called when a message port is closed, to clean up any associated peer state.
-     *
-     * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
+     * Cleans up peer state for a closed message port.
      *
-     * @param port The message port instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+     * @param port The same message port instance passed to `.message()`.
      */
     close(port: SupportedMessagePort): Promise<void>;
 }

package/dist/adapters/message-port/index.mjs

@@ -1,6 +1,6 @@
 import { onMessagePortMessage, onMessagePortClose, postMessagePortMessage } from '@orpc/client/message-port';
-import { value, isPlainObject, resolveMaybeOptionalOptions, toStringOrBytes } from '@orpc/shared';
-import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage } from '@standardserver/peer';
+import { value, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage, isPeerMessage } from '@standardserver/peer';
 import { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
 import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.GDpX6Df8.mjs';
 import '@orpc/client';
@@ -21,7 +21,9 @@ class MessagePortHandler {
   encodePeerMessageOptions;
   decodePeerMessageOptions;
   /**
-   * Attaches necessary event listeners to a message port to handle incoming messages and peer management.
+   * Attaches message and close listeners to a message port.
+   *
+   * Prefer this over calling `.message()` and `.close()` manually.
    */
   upgrade(port, ...rest) {
     onMessagePortMessage(port, (message) => this.message(port, message, ...rest));
@@ -30,51 +32,45 @@ class MessagePortHandler {
   /**
    * Handles a single message received from a message port.
    *
-   * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
-   *
-   * @param port The message port instance, require consistent instance across messages for proper peer management
+   * @param port The message port instance. Use the same instance for all messages.
    */
   async message(port, data, ...rest) {
     let peer = this.peers.get(port);
     if (!peer) {
-      this.peers.set(port, peer = new ServerPeer(async (message2) => {
-        const transfer = await value(this.transfer, message2, port);
+      this.peers.set(port, peer = new ServerPeer(async (message) => {
+        const transfer = await value(this.transfer, message, port);
         if (transfer) {
-          postMessagePortMessage(port, message2, transfer);
+          postMessagePortMessage(port, message, transfer);
         } else {
-          postMessagePortMessage(port, await encodePeerMessage(message2, this.encodePeerMessageOptions));
+          postMessagePortMessage(port, await encodePeerMessage(message, this.encodePeerMessageOptions));
         }
       }));
     }
-    if (isPlainObject(data)) {
-      await peer.message(
-        data,
-        createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest))
-      );
-      return { matched: true };
+    let peerMessage;
+    if (typeof data === "string" || data instanceof Uint8Array) {
+      const result = decodePeerMessage(data, this.decodePeerMessageOptions);
+      if (result.matched && isClientPeerSendMessage(result.message)) {
+        peerMessage = result.message;
+      }
+    } else if (isPeerMessage(data) && isClientPeerSendMessage(data)) {
+      peerMessage = data;
     }
-    const message = await toStringOrBytes(data);
-    const result = decodePeerMessage(message, this.decodePeerMessageOptions);
-    if (result.matched && isClientPeerSendMessage(result.message)) {
-      await peer.message(
-        result.message,
-        createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest))
-      );
+    if (peerMessage === void 0) {
+      return { matched: false };
     }
-    return result;
+    await peer.message(peerMessage, createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest)));
+    return { matched: true };
   }
   /**
-   * Called when a message port is closed, to clean up any associated peer state.
-   *
-   * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
+   * Cleans up peer state for a closed message port.
    *
-   * @param port The message port instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+   * @param port The same message port instance passed to `.message()`.
    */
   async close(port) {
     const peer = this.peers.get(port);
     if (peer) {
-      await peer.close();
       this.peers.delete(port);
+      await peer.close();
     }
   }
 }

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

@@ -1,4 +1,4 @@
-import { MaybeOptionalOptions } from '@orpc/shared';
+import { Arrayable, MaybeOptionalOptions } from '@orpc/shared';
 import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
 import { C as Context } from '../../shared/server.BL22TloH.mjs';
 import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DJIkub_t.mjs';
@@ -33,29 +33,30 @@ declare class WebSocketHandler<T extends Context> {
     private readonly decodePeerMessageOptions;
     constructor(handler: StandardHandler<T>, options?: NoInfer<WebSocketHandlerOptions<T>>);
     /**
-     * Handles a single message received from a WebSocket.
+     * Handles a single WebSocket message.
      *
-     * @warning AVOID calling this method, if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
+     * Message order matters. Call this immediately after receiving a message,
+     * before any other async work, to preserve ordering.
      *
-     * @param ws The WebSocket instance, require consistent instance across messages for proper peer management
-     * @param data The message data received from the WebSocket, can be string, ArrayBuffer, Blob, ...
+     * 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: string | ArrayBuffer | Blob | Exclude<ConstructorParameters<typeof Blob>[0], undefined>[0][] | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
-     * Called when a websocket is closed, to clean up any associated peer state.
-     *
-     * @warning AVOID calling this method, if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
+     * Cleans up peer state for a closed WebSocket.
      *
-     * @param ws The WebSocket instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+     * @param ws The same WebSocket instance passed to `.message()`.
      */
     close(ws: WebSocketLike): Promise<void>;
     /**
-     * Attaches websocket event listeners for message and close handling.
+     * Attaches message and close event listeners to a WebSocket.
      *
-     * Use this instead of calling `.message()` and `.close()` manually.
-     * Requires a websocket-like object that supports `addEventListener` and `removeEventListener`.
+     * Prefer this over calling `.message()` and `.close()` manually.
      */
     upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
 }

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

@@ -1,4 +1,4 @@
-import { MaybeOptionalOptions } from '@orpc/shared';
+import { Arrayable, MaybeOptionalOptions } from '@orpc/shared';
 import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
 import { C as Context } from '../../shared/server.BL22TloH.js';
 import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DBANIheG.js';
@@ -33,29 +33,30 @@ declare class WebSocketHandler<T extends Context> {
     private readonly decodePeerMessageOptions;
     constructor(handler: StandardHandler<T>, options?: NoInfer<WebSocketHandlerOptions<T>>);
     /**
-     * Handles a single message received from a WebSocket.
+     * Handles a single WebSocket message.
      *
-     * @warning AVOID calling this method, if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
+     * Message order matters. Call this immediately after receiving a message,
+     * before any other async work, to preserve ordering.
      *
-     * @param ws The WebSocket instance, require consistent instance across messages for proper peer management
-     * @param data The message data received from the WebSocket, can be string, ArrayBuffer, Blob, ...
+     * 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: string | ArrayBuffer | Blob | Exclude<ConstructorParameters<typeof Blob>[0], undefined>[0][] | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
-     * Called when a websocket is closed, to clean up any associated peer state.
-     *
-     * @warning AVOID calling this method, if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
+     * Cleans up peer state for a closed WebSocket.
      *
-     * @param ws The WebSocket instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+     * @param ws The same WebSocket instance passed to `.message()`.
      */
     close(ws: WebSocketLike): Promise<void>;
     /**
-     * Attaches websocket event listeners for message and close handling.
+     * Attaches message and close event listeners to a WebSocket.
      *
-     * Use this instead of calling `.message()` and `.close()` manually.
-     * Requires a websocket-like object that supports `addEventListener` and `removeEventListener`.
+     * Prefer this over calling `.message()` and `.close()` manually.
      */
     upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
 }

package/dist/adapters/websocket/index.mjs

@@ -1,4 +1,4 @@
-import { toStringOrBytes, resolveMaybeOptionalOptions } from '@orpc/shared';
+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.GDpX6Df8.mjs';
@@ -18,12 +18,16 @@ class WebSocketHandler {
   encodePeerMessageOptions;
   decodePeerMessageOptions;
   /**
-   * Handles a single message received from a WebSocket.
+   * Handles a single WebSocket message.
    *
-   * @warning AVOID calling this method, if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
+   * Message order matters. Call this immediately after receiving a message,
+   * before any other async work, to preserve ordering.
    *
-   * @param ws The WebSocket instance, require consistent instance across messages for proper peer management
-   * @param data The message data received from the WebSocket, can be string, ArrayBuffer, Blob, ...
+   * 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) {
     let peer = this.peers.get(ws);
@@ -33,7 +37,7 @@ class WebSocketHandler {
         await ws.send(encoded2);
       }));
     }
-    const encoded = await toStringOrBytes(data);
+    const encoded = toStringOrBytes(data);
     const result = decodePeerMessage(encoded, this.decodePeerMessageOptions);
     if (result.matched && isClientPeerSendMessage(result.message)) {
       await peer.message(
@@ -44,27 +48,27 @@ class WebSocketHandler {
     return result;
   }
   /**
-   * Called when a websocket is closed, to clean up any associated peer state.
-   *
-   * @warning AVOID calling this method, if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
+   * Cleans up peer state for a closed WebSocket.
    *
-   * @param ws The WebSocket instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+   * @param ws The same WebSocket instance passed to `.message()`.
    */
   async close(ws) {
     const peer = this.peers.get(ws);
     if (peer) {
-      await peer.close();
       this.peers.delete(ws);
+      await peer.close();
     }
   }
   /**
-   * Attaches websocket event listeners for message and close handling.
+   * Attaches message and close event listeners to a WebSocket.
    *
-   * Use this instead of calling `.message()` and `.close()` manually.
-   * Requires a websocket-like object that supports `addEventListener` and `removeEventListener`.
+   * Prefer this over calling `.message()` and `.close()` manually.
    */
   upgrade(ws, ...rest) {
-    ws.addEventListener("message", (event) => this.message(ws, event.data, ...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));
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "2.0.0-beta.11",
+  "version": "2.0.0-beta.12",
   "license": "MIT",
   "homepage": "https://orpc.dev",
   "repository": {
@@ -90,10 +90,10 @@
     "@standardserver/node": "^0.0.25",
     "@standardserver/peer": "^0.0.25",
     "cookie": "^1.1.1",
-    "@orpc/client": "2.0.0-beta.11",
-    "@orpc/contract": "2.0.0-beta.11",
-    "@orpc/shared": "2.0.0-beta.11",
-    "@orpc/interop": "2.0.0-beta.11"
+    "@orpc/client": "2.0.0-beta.12",
+    "@orpc/contract": "2.0.0-beta.12",
+    "@orpc/interop": "2.0.0-beta.12",
+    "@orpc/shared": "2.0.0-beta.12"
   },
   "devDependencies": {
     "crossws": "^0.4.6",