@orpc/server 1.14.9 → 1.14.11

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

@@ -1,56 +1,71 @@
-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.ChUyt5-i.mjs';
+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 '@orpc/client';
 import '@orpc/contract';
-import '@orpc/standard-server-peer';
-import '../../shared/server.B8gYOD5g.mjs';
-import '@orpc/standard-server';
-import '@orpc/client/standard';
-import '../../shared/server.C8_sRzQB.mjs';
+import '@standardserver/core';
 
-type MinimalWebsocket = Pick<WebSocket, 'addEventListener' | 'send'>;
-declare class WebsocketHandler<T extends Context> {
-    #private;
-    constructor(standardHandler: StandardHandler<T>);
+/**
+ * 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;
     /**
-     * Upgrades a WebSocket to enable handling
+     * 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.
      *
-     * 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()`
+     * @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`).
      */
-    upgrade(ws: MinimalWebsocket, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): void;
+    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+        matched: boolean;
+    }>;
     /**
-     * Handles a single message received from a WebSocket.
-     *
-     * @warning Avoid calling this directly if `.upgrade()` is used.
+     * Cleans up peer state for a closed WebSocket.
      *
-     * @param ws The WebSocket instance
-     * @param data The message payload, usually place in `event.data`
+     * @param ws The same WebSocket instance passed to `.message()`.
      */
-    message(ws: MinimalWebsocket, data: string | ArrayBuffer | Blob, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): Promise<void>;
+    close(ws: WebSocketLike): Promise<void>;
     /**
-     * Closes the WebSocket peer and cleans up.
+     * Attaches message and close event listeners to a WebSocket.
      *
-     * @warning Avoid calling this directly if `.upgrade()` is used.
+     * Prefer this over calling `.message()` and `.close()` manually.
      */
-    close(ws: MinimalWebsocket): void;
+    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
 }
 
-interface RPCHandlerOptions<T extends Context> extends StandardRPCHandlerOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<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>>);
+declare class RPCHandler<T extends Context> extends WebSocketHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { RPCHandler, WebsocketHandler };
-export type { MinimalWebsocket, RPCHandlerOptions };
+export { RPCHandler, WebSocketHandler };
+export type { RPCHandlerOptions, WebSocketHandlerOptions, WebSocketLike };

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

@@ -1,56 +1,71 @@
-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.yoEB3Fx4.js';
+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 '@orpc/client';
 import '@orpc/contract';
-import '@orpc/standard-server-peer';
-import '../../shared/server.EfTOZ2Q7.js';
-import '@orpc/standard-server';
-import '@orpc/client/standard';
-import '../../shared/server.ChyoA9XY.js';
+import '@standardserver/core';
 
-type MinimalWebsocket = Pick<WebSocket, 'addEventListener' | 'send'>;
-declare class WebsocketHandler<T extends Context> {
-    #private;
-    constructor(standardHandler: StandardHandler<T>);
+/**
+ * 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;
     /**
-     * Upgrades a WebSocket to enable handling
+     * 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.
      *
-     * 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()`
+     * @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`).
      */
-    upgrade(ws: MinimalWebsocket, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): void;
+    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+        matched: boolean;
+    }>;
     /**
-     * Handles a single message received from a WebSocket.
-     *
-     * @warning Avoid calling this directly if `.upgrade()` is used.
+     * Cleans up peer state for a closed WebSocket.
      *
-     * @param ws The WebSocket instance
-     * @param data The message payload, usually place in `event.data`
+     * @param ws The same WebSocket instance passed to `.message()`.
      */
-    message(ws: MinimalWebsocket, data: string | ArrayBuffer | Blob, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): Promise<void>;
+    close(ws: WebSocketLike): Promise<void>;
     /**
-     * Closes the WebSocket peer and cleans up.
+     * Attaches message and close event listeners to a WebSocket.
      *
-     * @warning Avoid calling this directly if `.upgrade()` is used.
+     * Prefer this over calling `.message()` and `.close()` manually.
      */
-    close(ws: MinimalWebsocket): void;
+    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
 }
 
-interface RPCHandlerOptions<T extends Context> extends StandardRPCHandlerOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<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>>);
+declare class RPCHandler<T extends Context> extends WebSocketHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { RPCHandler, WebsocketHandler };
-export type { MinimalWebsocket, RPCHandlerOptions };
+export { RPCHandler, WebSocketHandler };
+export type { RPCHandlerOptions, WebSocketHandlerOptions, WebSocketLike };

package/dist/adapters/websocket/index.mjs

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

package/dist/extensions/callable.d.mts

@@ -0,0 +1,10 @@
+import { AnyORPCError, ClientContext } from '@orpc/client';
+import { AnySchema, ErrorMap } from '@orpc/contract';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, P as ProcedureClientOptions, a as Procedure, b as ProcedureClient } from '../shared/server.CcR4kgje.mjs';
+
+declare module "../index" {
+    interface DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> {
+        callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError, TClientContext>>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
+    }
+}

package/dist/extensions/callable.d.ts

@@ -0,0 +1,10 @@
+import { AnyORPCError, ClientContext } from '@orpc/client';
+import { AnySchema, ErrorMap } from '@orpc/contract';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, P as ProcedureClientOptions, a as Procedure, b as ProcedureClient } from '../shared/server.CcR4kgje.js';
+
+declare module "../index" {
+    interface DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> {
+        callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError, TClientContext>>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
+    }
+}

package/dist/extensions/callable.mjs

@@ -0,0 +1,11 @@
+import { c as createProcedureClient } from '../shared/server.DofEOwf-.mjs';
+import { D as DecoratedProcedure } from '../shared/server.DBs0rrf9.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/shared';
+
+DecoratedProcedure.prototype.callable = function callable(...rest) {
+  const callable2 = createProcedureClient(this, ...rest);
+  callable2["~orpc"] = this["~orpc"];
+  return callable2;
+};

package/dist/helpers/index.d.mts

@@ -1,4 +1,4 @@
-import { SerializeOptions, ParseOptions } from 'cookie';
+import { ParseOptions, SetCookie, StringifyOptions } 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 | undefined;
+declare function decodeBase64url(base64url: string | undefined | null): Uint8Array<ArrayBuffer> | undefined;
 
-interface SetCookieOptions extends SerializeOptions {
+interface SetCookieOptions extends Omit<SetCookie, 'name' | 'value'>, StringifyOptions {
     /**
      * 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 SerializeOptions {
  *
  * setCookie(headers, 'sessionId', 'abc123', { httpOnly: true, maxAge: 3600 })
  *
- * expect(headers.get('Set-Cookie')).toBe('sessionId=abc123; HttpOnly; Max-Age=3600')
+ * expect(headers.get('Set-Cookie')).toBe('sessionId=abc123; Max-Age=3600; Path=/; HttpOnly')
  * ```
  *
  */

package/dist/helpers/index.d.ts

@@ -1,4 +1,4 @@
-import { SerializeOptions, ParseOptions } from 'cookie';
+import { ParseOptions, SetCookie, StringifyOptions } 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 | undefined;
+declare function decodeBase64url(base64url: string | undefined | null): Uint8Array<ArrayBuffer> | undefined;
 
-interface SetCookieOptions extends SerializeOptions {
+interface SetCookieOptions extends Omit<SetCookie, 'name' | 'value'>, StringifyOptions {
     /**
      * 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 SerializeOptions {
  *
  * setCookie(headers, 'sessionId', 'abc123', { httpOnly: true, maxAge: 3600 })
  *
- * expect(headers.get('Set-Cookie')).toBe('sessionId=abc123; HttpOnly; Max-Age=3600')
+ * expect(headers.get('Set-Cookie')).toBe('sessionId=abc123; Max-Age=3600; Path=/; HttpOnly')
  * ```
  *
  */

package/dist/helpers/index.mjs

@@ -1,4 +1,4 @@
-import { serialize, parse } from 'cookie';
+import { parseCookie, stringifySetCookie } from 'cookie';
 
 function encodeBase64url(data) {
   const chunkSize = 8192;
@@ -34,10 +34,17 @@ function setCookie(headers, name, value, options = {}) {
   if (headers === void 0) {
     return;
   }
-  const cookieString = serialize(name, value, {
+  const cookieString = stringifySetCookie({
+    // Force path to '/' by default so the cookie is available across the
+    // entire app, not just under the directory of the request that set it
+    // (which is what browsers do per RFC 6265 §5.1.4 when Path is omitted).
     path: "/",
-    ...options
-  });
+    ...options,
+    name,
+    // prioritize
+    value
+    // prioritize
+  }, options);
   headers.append("Set-Cookie", cookieString);
 }
 function getCookie(headers, name, options = {}) {
@@ -48,12 +55,13 @@ function getCookie(headers, name, options = {}) {
   if (cookieHeader === null) {
     return void 0;
   }
-  return parse(cookieHeader, options)[name];
+  return parseCookie(cookieHeader, options)[name];
 }
 function deleteCookie(headers, name, options = {}) {
   return setCookie(headers, name, "", {
     ...options,
     maxAge: 0
+    // prioritize
   });
 }