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

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

@@ -1,19 +0,0 @@
-import { b as StandardHandlerHandleOptions } from '../../shared/server.DJIkub_t.mjs';
-export { C as CompositeStandardHandlerPlugin, O as OtelHandlerPlugin, S as StandardHandler, c as StandardHandlerCodec, d as StandardHandlerCodecResolvedProcedure, h as StandardHandlerHandleResult, i as StandardHandlerInterceptor, g as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, e as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, f as StandardHandlerRoutingInterceptorOptions } from '../../shared/server.DJIkub_t.mjs';
-export { a as RPCHandlerCodec, R as RPCHandlerCodecOptions, b as RPCMatcher, c as RPCMatcherOptions } from '../../shared/server.Cj5lgPuG.mjs';
-import { C as Context } from '../../shared/server.BL22TloH.mjs';
-export { StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl } from '@standardserver/core';
-import '@orpc/client';
-import '@orpc/shared';
-import '@orpc/contract';
-import '../../shared/server.BsNNjG5J.mjs';
-
-type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
-declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
-
-export { StandardHandlerHandleOptions, resolveFriendlyStandardHandlerHandleOptions };
-export type { FriendlyStandardHandlerHandleOptions };

package/dist/adapters/standard/index.mjs

@@ -1,8 +0,0 @@
-export { C as CompositeStandardHandlerPlugin, O as OtelHandlerPlugin, R as RPCHandlerCodec, a as RPCMatcher, S as StandardHandler } from '../../shared/server.GDpX6Df8.mjs';
-export { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
-import '@orpc/client';
-import '@orpc/shared';
-import '@standardserver/core';
-import '../../shared/server.CrlKQucM.mjs';
-import '@orpc/contract';
-import '../../shared/server.BwHnWUuN.mjs';

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

@@ -1,16 +0,0 @@
-import { Value, Promisable } from '@orpc/shared';
-import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
-import { C as Context } from '../../shared/server.BL22TloH.mjs';
-import { b as StandardHandlerHandleOptions, S as StandardHandler } from '../../shared/server.DJIkub_t.mjs';
-import '@orpc/client';
-import '@orpc/contract';
-
-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>;
-
-export { createStandardPeerRequestHandler };
-export type { StandardPeerRequestHandlerOptions };

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

@@ -1,2 +0,0 @@
-export { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
-import '@orpc/shared';

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

@@ -1,61 +0,0 @@
-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 '@orpc/client';
-import '@orpc/contract';
-import '@standardserver/core';
-
-type WebsocketLike = Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send'>;
-interface WebsocketHandlerOptions<_T extends Context> {
-    /**
-     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    encodePeerMessage?: EncodePeerMessageOptions | undefined;
-    /**
-     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    decodePeerMessage?: DecodePeerMessageOptions | undefined;
-}
-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>>);
-    /**
-     * 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.
-     *
-     * @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, require consistent instance across messages for proper peer management
-     * @param data The message data received from the WebSocket, can be string, ArrayBuffer, 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<{
-        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.
-     *
-     * @param ws The WebSocket instance to clean up, must be the same instance used in `.message()` calls to properly clean up
-     */
-    close(ws: WebsocketLike): Promise<void>;
-}
-
-interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebsocketHandlerOptions<T> {
-}
-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 };

package/dist/adapters/websocket/index.mjs

@@ -1,76 +0,0 @@
-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 '@orpc/client';
-import '@standardserver/core';
-import '../../shared/server.CrlKQucM.mjs';
-import '@orpc/contract';
-import '../../shared/server.BwHnWUuN.mjs';
-
-class WebsocketHandler {
-  constructor(handler, options = {}) {
-    this.handler = handler;
-    this.encodePeerMessageOptions = options.encodePeerMessage;
-    this.decodePeerMessageOptions = options.decodePeerMessage;
-  }
-  peers = /* @__PURE__ */ new WeakMap();
-  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.
-   *
-   * @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, require consistent instance across messages for proper peer management
-   * @param data The message data received from the WebSocket, can be string, ArrayBuffer, 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 encoded = await toStringOrBytes(data);
-    const result = decodePeerMessage(encoded, this.decodePeerMessageOptions);
-    if (result.matched && isClientPeerSendMessage(result.message)) {
-      await peer.message(
-        result.message,
-        createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest))
-      );
-    }
-    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.
-   *
-   * @param ws The WebSocket instance to clean up, must be the same instance used in `.message()` calls to properly clean up
-   */
-  async close(ws) {
-    const peer = this.peers.get(ws);
-    if (peer) {
-      await peer.close();
-      this.peers.delete(ws);
-    }
-  }
-}
-
-class RPCHandler extends WebsocketHandler {
-  constructor(router, options = {}) {
-    const codec = new RPCHandlerCodec(router, options);
-    const handler = new StandardHandler(codec, options);
-    super(handler, options);
-  }
-}
-
-export { RPCHandler, WebsocketHandler };

package/dist/extensions/callable.d.mts

@@ -1,10 +0,0 @@
-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.BL22TloH.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.mjs

@@ -1,11 +0,0 @@
-import { c as createProcedureClient } from '../shared/server.CrlKQucM.mjs';
-import { D as DecoratedProcedure } from '../shared/server.CjOb6ItT.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,149 +0,0 @@
-import { ParseOptions, SerializeOptions } from 'cookie';
-
-/**
- * Encodes a Uint8Array to base64url format
- * Base64url is URL-safe and doesn't use padding
- *
- * @example
- * ```ts
- * const text = "Hello World"
- * const encoded = encodeBase64url(new TextEncoder().encode(text))
- * const decoded = decodeBase64url(encoded)
- * expect(new TextDecoder().decode(decoded)).toEqual(text)
- * ```
- */
-declare function encodeBase64url(data: Uint8Array): string;
-/**
- * Decodes a base64url string to Uint8Array
- * Returns undefined if the input is invalid
- *
- * @example
- * ```ts
- * const text = "Hello World"
- * const encoded = encodeBase64url(new TextEncoder().encode(text))
- * const decoded = decodeBase64url(encoded)
- * expect(new TextDecoder().decode(decoded)).toEqual(text)
- * ```
- */
-declare function decodeBase64url(base64url: string | undefined | null): Uint8Array<ArrayBuffer> | undefined;
-
-interface SetCookieOptions extends SerializeOptions {
-    /**
-     * Specifies the value for the [`Path` `Set-Cookie` attribute](https://tools.ietf.org/html/rfc6265#section-5.2.4).
-     *
-     * @default '/'
-     */
-    path?: string;
-}
-/**
- * Sets a cookie in the response headers,
- *
- * Does nothing if `headers` is `undefined`.
- *
- * @example
- * ```ts
- * const headers = new Headers()
- *
- * setCookie(headers, 'sessionId', 'abc123', { httpOnly: true, maxAge: 3600 })
- *
- * expect(headers.get('Set-Cookie')).toBe('sessionId=abc123; HttpOnly; Max-Age=3600')
- * ```
- *
- */
-declare function setCookie(headers: Headers | undefined, name: string, value: string, options?: SetCookieOptions): void;
-interface GetCookieOptions extends ParseOptions {
-}
-/**
- * Gets a cookie value from request headers
- *
- * Returns `undefined` if the cookie is not found or headers are `undefined`.
- *
- * @example
- * ```ts
- * const headers = new Headers({ 'Cookie': 'sessionId=abc123; theme=dark' })
- *
- * const sessionId = getCookie(headers, 'sessionId')
- *
- * expect(sessionId).toEqual('abc123')
- * ```
- */
-declare function getCookie(headers: Headers | undefined, name: string, options?: GetCookieOptions): string | undefined;
-/**
- * Deletes a cookie by marking it expired.
- */
-declare function deleteCookie(headers: Headers | undefined, name: string, options?: Omit<SetCookieOptions, 'maxAge'>): void;
-
-/**
- * Encrypts a string using AES-GCM with a secret key.
- * The output is base64url encoded to be URL-safe.
- *
- * @example
- * ```ts
- * const encrypted = await encrypt("Hello, World!", "test-secret-key")
- * const decrypted = await decrypt(encrypted, "test-secret-key")
- * expect(decrypted).toBe("Hello, World!")
- * ```
- */
-declare function encrypt(value: string, secret: string): Promise<string>;
-/**
- * Decrypts a base64url encoded string using AES-GCM with a secret key.
- * Returns the original string if decryption is successful, or undefined if it fails.
- *
- * @example
- * ```ts
- * const encrypted = await encrypt("Hello, World!", "test-secret-key")
- * const decrypted = await decrypt(encrypted, "test-secret-key")
- * expect(decrypted).toBe("Hello, World!")
- * ```
- */
-declare function decrypt(encrypted: string | undefined | null, secret: string): Promise<string | undefined>;
-
-/**
- * Signs a string value using HMAC-SHA256 with a secret key.
- *
- * This function creates a cryptographic signature that can be used to verify
- * 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")
- * ```
- */
-declare function sign(value: string, secret: string): Promise<string>;
-/**
- * Verifies and extracts the original value from a signed string.
- *
- * This function validates the signature of a previously signed value using the same
- * 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")
- * ```
- */
-declare function unsign(signedValue: string | undefined | null, secret: string): Promise<string | undefined>;
-/**
- * Extracts the value part from a signed string without verification.
- *
- * This function simply extracts the original value from a signed string
- * without performing any signature verification. It's useful when you need
- * to access the value quickly without the overhead of cryptographic verification.
- *
- * @example
- * ```ts
- * const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
- * const value = getSignedValue(signedValue)
- * expect(value).toEqual("user123")
- * ```
- */
-declare function getSignedValue(signedValue: string | undefined | null): string | undefined;
-
-export { decodeBase64url, decrypt, deleteCookie, encodeBase64url, encrypt, getCookie, getSignedValue, setCookie, sign, unsign };
-export type { GetCookieOptions, SetCookieOptions };

package/dist/helpers/index.mjs

@@ -1,198 +0,0 @@
-import { parse, serialize } from 'cookie';
-
-function encodeBase64url(data) {
-  const chunkSize = 8192;
-  let binaryString = "";
-  for (let i = 0; i < data.length; i += chunkSize) {
-    const chunk = data.subarray(i, i + chunkSize);
-    binaryString += String.fromCharCode(...chunk);
-  }
-  const base64 = btoa(binaryString);
-  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
-}
-function decodeBase64url(base64url) {
-  try {
-    if (typeof base64url !== "string") {
-      return void 0;
-    }
-    let base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
-    while (base64.length % 4) {
-      base64 += "=";
-    }
-    const binaryString = atob(base64);
-    const bytes = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-      bytes[i] = binaryString.charCodeAt(i);
-    }
-    return bytes;
-  } catch {
-    return void 0;
-  }
-}
-
-function setCookie(headers, name, value, options = {}) {
-  if (headers === void 0) {
-    return;
-  }
-  const cookieString = serialize(name, value, {
-    path: "/",
-    ...options
-  });
-  headers.append("Set-Cookie", cookieString);
-}
-function getCookie(headers, name, options = {}) {
-  if (headers === void 0) {
-    return void 0;
-  }
-  const cookieHeader = headers.get("cookie");
-  if (cookieHeader === null) {
-    return void 0;
-  }
-  return parse(cookieHeader, options)[name];
-}
-function deleteCookie(headers, name, options = {}) {
-  return setCookie(headers, name, "", {
-    ...options,
-    maxAge: 0
-  });
-}
-
-const PBKDF2_CONFIG = {
-  name: "PBKDF2",
-  iterations: 6e4,
-  // Recommended minimum iterations per current OWASP guidelines
-  hash: "SHA-256"
-};
-const AES_GCM_CONFIG = {
-  name: "AES-GCM",
-  length: 256
-};
-const CRYPTO_CONSTANTS = {
-  SALT_LENGTH: 16,
-  IV_LENGTH: 12
-};
-async function encrypt(value, secret) {
-  const encoder = new TextEncoder();
-  const data = encoder.encode(value);
-  const salt = crypto.getRandomValues(new Uint8Array(CRYPTO_CONSTANTS.SALT_LENGTH));
-  const keyMaterial = await crypto.subtle.importKey(
-    "raw",
-    encoder.encode(secret),
-    PBKDF2_CONFIG.name,
-    false,
-    ["deriveKey"]
-  );
-  const key = await crypto.subtle.deriveKey(
-    { ...PBKDF2_CONFIG, salt },
-    keyMaterial,
-    AES_GCM_CONFIG,
-    false,
-    ["encrypt"]
-  );
-  const iv = crypto.getRandomValues(new Uint8Array(CRYPTO_CONSTANTS.IV_LENGTH));
-  const encrypted = await crypto.subtle.encrypt(
-    { name: AES_GCM_CONFIG.name, iv },
-    key,
-    data
-  );
-  const result = new Uint8Array(salt.length + iv.length + encrypted.byteLength);
-  result.set(salt, 0);
-  result.set(iv, salt.length);
-  result.set(new Uint8Array(encrypted), salt.length + iv.length);
-  return encodeBase64url(result);
-}
-async function decrypt(encrypted, secret) {
-  try {
-    const data = decodeBase64url(encrypted);
-    if (data === void 0) {
-      return void 0;
-    }
-    const encoder = new TextEncoder();
-    const decoder = new TextDecoder();
-    const salt = data.slice(0, CRYPTO_CONSTANTS.SALT_LENGTH);
-    const iv = data.slice(CRYPTO_CONSTANTS.SALT_LENGTH, CRYPTO_CONSTANTS.SALT_LENGTH + CRYPTO_CONSTANTS.IV_LENGTH);
-    const encryptedData = data.slice(CRYPTO_CONSTANTS.SALT_LENGTH + CRYPTO_CONSTANTS.IV_LENGTH);
-    const keyMaterial = await crypto.subtle.importKey(
-      "raw",
-      encoder.encode(secret),
-      PBKDF2_CONFIG.name,
-      false,
-      ["deriveKey"]
-    );
-    const key = await crypto.subtle.deriveKey(
-      { ...PBKDF2_CONFIG, salt },
-      keyMaterial,
-      AES_GCM_CONFIG,
-      false,
-      ["decrypt"]
-    );
-    const decrypted = await crypto.subtle.decrypt(
-      { name: AES_GCM_CONFIG.name, iv },
-      key,
-      encryptedData
-    );
-    return decoder.decode(decrypted);
-  } catch {
-    return void 0;
-  }
-}
-
-const ALGORITHM = { name: "HMAC", hash: "SHA-256" };
-async function sign(value, secret) {
-  const encoder = new TextEncoder();
-  const key = await crypto.subtle.importKey(
-    "raw",
-    encoder.encode(secret),
-    ALGORITHM,
-    false,
-    ["sign"]
-  );
-  const signature = await crypto.subtle.sign(
-    ALGORITHM,
-    key,
-    encoder.encode(value)
-  );
-  return `${value}.${encodeBase64url(new Uint8Array(signature))}`;
-}
-async function unsign(signedValue, secret) {
-  if (typeof signedValue !== "string") {
-    return void 0;
-  }
-  const lastDotIndex = signedValue.lastIndexOf(".");
-  if (lastDotIndex === -1) {
-    return void 0;
-  }
-  const value = signedValue.slice(0, lastDotIndex);
-  const signatureBase64url = signedValue.slice(lastDotIndex + 1);
-  const signature = decodeBase64url(signatureBase64url);
-  if (signature === void 0) {
-    return void 0;
-  }
-  const encoder = new TextEncoder();
-  const key = await crypto.subtle.importKey(
-    "raw",
-    encoder.encode(secret),
-    ALGORITHM,
-    false,
-    ["verify"]
-  );
-  const isValid = await crypto.subtle.verify(
-    ALGORITHM,
-    key,
-    signature,
-    encoder.encode(value)
-  );
-  return isValid ? value : void 0;
-}
-function getSignedValue(signedValue) {
-  if (typeof signedValue !== "string") {
-    return void 0;
-  }
-  const lastDotIndex = signedValue.lastIndexOf(".");
-  if (lastDotIndex === -1) {
-    return void 0;
-  }
-  return signedValue.slice(0, lastDotIndex);
-}
-
-export { decodeBase64url, decrypt, deleteCookie, encodeBase64url, encrypt, getCookie, getSignedValue, setCookie, sign, unsign };