@orpc/server 2.0.0-beta.4 → 2.0.0-beta.40

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

@@ -1,16 +1,22 @@
-import { 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';
-import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.mjs';
-import { R as Router } from '../../shared/server.BsNNjG5J.mjs';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.Cj5lgPuG.mjs';
+import { Arrayable, MaybeOptionalOptions } from '@orpc/shared';
+import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standard-server/peer';
+import { Context } from '../../index.mjs';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
+import { Router } from '../../index.mjs';
+import { RPCHandlerCodecOptions } from '../standard/index.mjs';
 import '@orpc/client';
 import '@orpc/contract';
-import '@standardserver/core';
+import '@standard-server/core';
 
-type WebsocketLike = Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send'>;
-interface WebsocketHandlerOptions<_T extends Context> {
+/**
+ * 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..
      */
@@ -20,42 +26,52 @@ interface WebsocketHandlerOptions<_T extends Context> {
      */
     decodePeerMessage?: DecodePeerMessageOptions | undefined;
 }
-declare class WebsocketHandler<T extends Context> {
+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>>);
+    constructor(handler: StandardHandler<T>, options?: NoInfer<WebSocketHandlerOptions<T>>);
     /**
-     * Attaches necessary event listeners to a WebSocket to handle incoming messages and peer management.
-     */
-    upgrade(ws: WebsocketLike, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
-    /**
-     * Handles a single message received from a WebSocket.
+     * Handles a single WebSocket message.
+     *
+     * Message order matters. Call this immediately after receiving a message,
+     * before any other async work, to preserve ordering.
      *
-     * @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.
+     * To avoid async Blob reads, configure `ws.binaryType` to return binary data
+     * directly (for example, `arraybuffer`).
      *
-     * @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, ...
+     * @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<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
-     * Called when a websocket is closed, to clean up any associated peer state.
+     * Cleans up peer state for a closed WebSocket.
      *
-     * @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.
+     * @param ws The same WebSocket instance passed to `.message()`.
+     */
+    close(ws: WebSocketLike): Promise<void>;
+    /**
+     * Attaches message and close event listeners to a WebSocket.
      *
-     * @param ws The WebSocket instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+     * Prefer this over calling `.message()` and `.close()` manually.
      */
-    close(ws: WebsocketLike): Promise<void>;
+    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
 }
 
-interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebsocketHandlerOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {
 }
-declare class RPCHandler<T extends Context> extends WebsocketHandler<T> {
+/**
+ * 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}
+ */
+declare class RPCHandler<T extends Context> extends WebSocketHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { RPCHandler, WebsocketHandler };
-export type { RPCHandlerOptions, WebsocketHandlerOptions, WebsocketLike };
+export { RPCHandler, WebSocketHandler };
+export type { RPCHandlerOptions, WebSocketHandlerOptions, WebSocketLike };

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

@@ -1,16 +1,22 @@
-import { 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';
-import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.js';
-import { R as Router } from '../../shared/server.Pa0F03f_.js';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.d_2NS3g5.js';
+import { Arrayable, MaybeOptionalOptions } from '@orpc/shared';
+import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standard-server/peer';
+import { Context } from '../../index.js';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
+import { Router } from '../../index.js';
+import { RPCHandlerCodecOptions } from '../standard/index.js';
 import '@orpc/client';
 import '@orpc/contract';
-import '@standardserver/core';
+import '@standard-server/core';
 
-type WebsocketLike = Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send'>;
-interface WebsocketHandlerOptions<_T extends Context> {
+/**
+ * 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..
      */
@@ -20,42 +26,52 @@ interface WebsocketHandlerOptions<_T extends Context> {
      */
     decodePeerMessage?: DecodePeerMessageOptions | undefined;
 }
-declare class WebsocketHandler<T extends Context> {
+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>>);
+    constructor(handler: StandardHandler<T>, options?: NoInfer<WebSocketHandlerOptions<T>>);
     /**
-     * Attaches necessary event listeners to a WebSocket to handle incoming messages and peer management.
-     */
-    upgrade(ws: WebsocketLike, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
-    /**
-     * Handles a single message received from a WebSocket.
+     * Handles a single WebSocket message.
+     *
+     * Message order matters. Call this immediately after receiving a message,
+     * before any other async work, to preserve ordering.
      *
-     * @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.
+     * To avoid async Blob reads, configure `ws.binaryType` to return binary data
+     * directly (for example, `arraybuffer`).
      *
-     * @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, ...
+     * @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<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
-     * Called when a websocket is closed, to clean up any associated peer state.
+     * Cleans up peer state for a closed WebSocket.
      *
-     * @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.
+     * @param ws The same WebSocket instance passed to `.message()`.
+     */
+    close(ws: WebSocketLike): Promise<void>;
+    /**
+     * Attaches message and close event listeners to a WebSocket.
      *
-     * @param ws The WebSocket instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+     * Prefer this over calling `.message()` and `.close()` manually.
      */
-    close(ws: WebsocketLike): Promise<void>;
+    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
 }
 
-interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebsocketHandlerOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {
 }
-declare class RPCHandler<T extends Context> extends WebsocketHandler<T> {
+/**
+ * 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}
+ */
+declare class RPCHandler<T extends Context> extends WebSocketHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { RPCHandler, WebsocketHandler };
-export type { RPCHandlerOptions, WebsocketHandlerOptions, WebsocketLike };
+export { RPCHandler, WebSocketHandler };
+export type { RPCHandlerOptions, WebSocketHandlerOptions, WebSocketLike };

package/dist/adapters/websocket/index.mjs

@@ -1,14 +1,15 @@
-import { toStringOrBytes, resolveMaybeOptionalOptions } 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';
+import { toStringOrBytes, resolveMaybeOptionalOptions, sequential, loadBytes } from '@orpc/shared';
+import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage } from '@standard-server/peer';
+import { createStandardPeerRequestHandler } from '../standard-peer/index.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.C0lFtoHU.mjs';
+import '../../shared/server.W91HSRkE.mjs';
 import '@orpc/client';
-import '@standardserver/core';
-import '../../shared/server.CrlKQucM.mjs';
+import '@standard-server/core';
+import '../../shared/server.Djb_ebJT.mjs';
 import '@orpc/contract';
-import '../../shared/server.BwHnWUuN.mjs';
+import '../../shared/server.BynNaBBA.mjs';
 
-class WebsocketHandler {
+class WebSocketHandler {
   constructor(handler, options = {}) {
     this.handler = handler;
     this.encodePeerMessageOptions = options.encodePeerMessage;
@@ -18,28 +19,26 @@ class WebsocketHandler {
   encodePeerMessageOptions;
   decodePeerMessageOptions;
   /**
-   * Attaches necessary event listeners to a WebSocket to handle incoming messages and peer management.
-   */
-  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.
+   * Handles a single WebSocket message.
+   *
+   * Message order matters. Call this immediately after receiving a message,
+   * before any other async work, to preserve ordering.
    *
-   * @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.
+   * To avoid async Blob reads, configure `ws.binaryType` to return binary data
+   * directly (for example, `arraybuffer`).
    *
-   * @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, ...
+   * @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);
     if (!peer) {
       this.peers.set(ws, peer = new ServerPeer(async (message) => {
-        return ws.send(await encodePeerMessage(message, this.encodePeerMessageOptions));
+        const encoded2 = await encodePeerMessage(message, this.encodePeerMessageOptions);
+        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(
@@ -50,22 +49,32 @@ class WebsocketHandler {
     return result;
   }
   /**
-   * Called when a websocket is closed, to clean up any associated peer state.
+   * Cleans up peer state for a closed WebSocket.
    *
-   * @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.
-   *
-   * @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 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);
@@ -73,4 +82,4 @@ class RPCHandler extends WebsocketHandler {
   }
 }
 
-export { RPCHandler, WebsocketHandler };
+export { RPCHandler, WebSocketHandler };

package/dist/extensions/callable.d.mts

@@ -1,10 +1,10 @@
-import { AnyORPCError, ClientContext } from '@orpc/client';
+import { 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.BL22TloH.mjs';
+import { Context, ProcedureClientOptions, Procedure, ProcedureClient } from '../index.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>;
+declare module '@orpc/server' {
+    interface DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+        callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TClientContext>>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
     }
 }

package/dist/extensions/callable.d.ts

@@ -1,10 +1,10 @@
-import { AnyORPCError, ClientContext } from '@orpc/client';
+import { 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.BL22TloH.js';
+import { Context, ProcedureClientOptions, Procedure, ProcedureClient } from '../index.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>;
+declare module '@orpc/server' {
+    interface DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+        callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TClientContext>>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
     }
 }

package/dist/extensions/callable.mjs

@@ -1,5 +1,5 @@
-import { c as createProcedureClient } from '../shared/server.CrlKQucM.mjs';
-import { D as DecoratedProcedure } from '../shared/server.CjOb6ItT.mjs';
+import { c as createProcedureClient } from '../shared/server.Djb_ebJT.mjs';
+import { D as DecoratedProcedure } from '../shared/server.24nXyhbl.mjs';
 import '@orpc/client';
 import '@orpc/contract';
 import '@orpc/shared';

package/dist/helpers/index.d.mts

@@ -1,4 +1,4 @@
-import { ParseOptions, SerializeOptions } from 'cookie';
+import { ParseOptions, SetCookie, StringifyOptions } from 'cookie';
 
 /**
  * Encodes a Uint8Array to base64url format
@@ -11,6 +11,8 @@ import { ParseOptions, SerializeOptions } from 'cookie';
  * const decoded = decodeBase64url(encoded)
  * expect(new TextDecoder().decode(decoded)).toEqual(text)
  * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/base64url | Base64Url Helpers}
  */
 declare function encodeBase64url(data: Uint8Array): string;
 /**
@@ -24,10 +26,12 @@ declare function encodeBase64url(data: Uint8Array): string;
  * const decoded = decodeBase64url(encoded)
  * expect(new TextDecoder().decode(decoded)).toEqual(text)
  * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/base64url | Base64Url Helpers}
  */
 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).
      *
@@ -36,7 +40,7 @@ interface SetCookieOptions extends SerializeOptions {
     path?: string;
 }
 /**
- * Sets a cookie in the response headers,
+ * Sets a cookie in the response headers.
  *
  * Does nothing if `headers` is `undefined`.
  *
@@ -46,9 +50,10 @@ 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')
  * ```
  *
+ * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
  */
 declare function setCookie(headers: Headers | undefined, name: string, value: string, options?: SetCookieOptions): void;
 interface GetCookieOptions extends ParseOptions {
@@ -66,10 +71,14 @@ interface GetCookieOptions extends ParseOptions {
  *
  * expect(sessionId).toEqual('abc123')
  * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
  */
 declare function getCookie(headers: Headers | undefined, name: string, options?: GetCookieOptions): string | undefined;
 /**
  * Deletes a cookie by marking it expired.
+ *
+ * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
  */
 declare function deleteCookie(headers: Headers | undefined, name: string, options?: Omit<SetCookieOptions, 'maxAge'>): void;
 
@@ -83,6 +92,8 @@ declare function deleteCookie(headers: Headers | undefined, name: string, option
  * const decrypted = await decrypt(encrypted, "test-secret-key")
  * expect(decrypted).toBe("Hello, World!")
  * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/encryption | Encryption Helpers}
  */
 declare function encrypt(value: string, secret: string): Promise<string>;
 /**
@@ -95,6 +106,8 @@ declare function encrypt(value: string, secret: string): Promise<string>;
  * const decrypted = await decrypt(encrypted, "test-secret-key")
  * expect(decrypted).toBe("Hello, World!")
  * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/encryption | Encryption Helpers}
  */
 declare function decrypt(encrypted: string | undefined | null, secret: string): Promise<string | undefined>;
 
@@ -105,12 +118,13 @@ declare function decrypt(encrypted: string | undefined | null, secret: string):
  * the integrity and authenticity of the data. The signature is appended to
  * the original value, separated by a dot, using base64url encoding (no padding).
  *
- *
  * @example
  * ```ts
  * const signedValue = await sign("user123", "my-secret-key")
  * expect(signedValue).toEqual("user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA")
  * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
  */
 declare function sign(value: string, secret: string): Promise<string>;
 /**
@@ -120,13 +134,14 @@ declare function sign(value: string, secret: string): Promise<string>;
  * secret key. If the signature is valid, it returns the original value. If the
  * signature is invalid or the format is incorrect, it returns undefined.
  *
- *
  * @example
  * ```ts
  * const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
  * const originalValue = await unsign(signedValue, "my-secret-key")
  * expect(originalValue).toEqual("user123")
  * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
  */
 declare function unsign(signedValue: string | undefined | null, secret: string): Promise<string | undefined>;
 /**
@@ -142,6 +157,8 @@ declare function unsign(signedValue: string | undefined | null, secret: string):
  * const value = getSignedValue(signedValue)
  * expect(value).toEqual("user123")
  * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
  */
 declare function getSignedValue(signedValue: string | undefined | null): string | undefined;
 

package/dist/helpers/index.d.ts

@@ -1,4 +1,4 @@
-import { ParseOptions, SerializeOptions } from 'cookie';
+import { ParseOptions, SetCookie, StringifyOptions } from 'cookie';
 
 /**
  * Encodes a Uint8Array to base64url format
@@ -11,6 +11,8 @@ import { ParseOptions, SerializeOptions } from 'cookie';
  * const decoded = decodeBase64url(encoded)
  * expect(new TextDecoder().decode(decoded)).toEqual(text)
  * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/base64url | Base64Url Helpers}
  */
 declare function encodeBase64url(data: Uint8Array): string;
 /**
@@ -24,10 +26,12 @@ declare function encodeBase64url(data: Uint8Array): string;
  * const decoded = decodeBase64url(encoded)
  * expect(new TextDecoder().decode(decoded)).toEqual(text)
  * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/base64url | Base64Url Helpers}
  */
 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).
      *
@@ -36,7 +40,7 @@ interface SetCookieOptions extends SerializeOptions {
     path?: string;
 }
 /**
- * Sets a cookie in the response headers,
+ * Sets a cookie in the response headers.
  *
  * Does nothing if `headers` is `undefined`.
  *
@@ -46,9 +50,10 @@ 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')
  * ```
  *
+ * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
  */
 declare function setCookie(headers: Headers | undefined, name: string, value: string, options?: SetCookieOptions): void;
 interface GetCookieOptions extends ParseOptions {
@@ -66,10 +71,14 @@ interface GetCookieOptions extends ParseOptions {
  *
  * expect(sessionId).toEqual('abc123')
  * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
  */
 declare function getCookie(headers: Headers | undefined, name: string, options?: GetCookieOptions): string | undefined;
 /**
  * Deletes a cookie by marking it expired.
+ *
+ * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
  */
 declare function deleteCookie(headers: Headers | undefined, name: string, options?: Omit<SetCookieOptions, 'maxAge'>): void;
 
@@ -83,6 +92,8 @@ declare function deleteCookie(headers: Headers | undefined, name: string, option
  * const decrypted = await decrypt(encrypted, "test-secret-key")
  * expect(decrypted).toBe("Hello, World!")
  * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/encryption | Encryption Helpers}
  */
 declare function encrypt(value: string, secret: string): Promise<string>;
 /**
@@ -95,6 +106,8 @@ declare function encrypt(value: string, secret: string): Promise<string>;
  * const decrypted = await decrypt(encrypted, "test-secret-key")
  * expect(decrypted).toBe("Hello, World!")
  * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/encryption | Encryption Helpers}
  */
 declare function decrypt(encrypted: string | undefined | null, secret: string): Promise<string | undefined>;
 
@@ -105,12 +118,13 @@ declare function decrypt(encrypted: string | undefined | null, secret: string):
  * the integrity and authenticity of the data. The signature is appended to
  * the original value, separated by a dot, using base64url encoding (no padding).
  *
- *
  * @example
  * ```ts
  * const signedValue = await sign("user123", "my-secret-key")
  * expect(signedValue).toEqual("user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA")
  * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
  */
 declare function sign(value: string, secret: string): Promise<string>;
 /**
@@ -120,13 +134,14 @@ declare function sign(value: string, secret: string): Promise<string>;
  * secret key. If the signature is valid, it returns the original value. If the
  * signature is invalid or the format is incorrect, it returns undefined.
  *
- *
  * @example
  * ```ts
  * const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
  * const originalValue = await unsign(signedValue, "my-secret-key")
  * expect(originalValue).toEqual("user123")
  * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
  */
 declare function unsign(signedValue: string | undefined | null, secret: string): Promise<string | undefined>;
 /**
@@ -142,6 +157,8 @@ declare function unsign(signedValue: string | undefined | null, secret: string):
  * const value = getSignedValue(signedValue)
  * expect(value).toEqual("user123")
  * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
  */
 declare function getSignedValue(signedValue: string | undefined | null): string | undefined;