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

package/dist/plugins/index.d.mts

@@ -1,197 +0,0 @@
-import { Value, Promisable, ThrowableError } from '@orpc/shared';
-import { StandardLazyRequest, StandardHeaders } from '@standardserver/core';
-import { C as Context } from '../shared/server.BL22TloH.mjs';
-import { e as StandardHandlerPlugin, f as StandardHandlerRoutingInterceptorOptions, a as StandardHandlerOptions, g as StandardHandlerInterceptorOptions } from '../shared/server.DJIkub_t.mjs';
-import '@orpc/client';
-import '@orpc/contract';
-
-interface BatchHandlerPluginOptions<T extends Context> {
-    /**
-     * The max size of the batch allowed.
-     *
-     * @default 10
-     */
-    maxSize?: Value<Promisable<number>, [options: StandardHandlerRoutingInterceptorOptions<T>]>;
-    /**
-     * Map each subrequest in the batch before it is processed.
-     *
-     * @default merges the batch request headers into the subrequest and remove `orpc-batch` header to prevent nested batching
-     */
-    mapSubrequest?: (subrequest: StandardLazyRequest, batchOptions: StandardHandlerRoutingInterceptorOptions<T>) => StandardLazyRequest;
-    /**
-     * Success batch response status code.
-     *
-     * @default 207
-     */
-    successStatus?: Value<Promisable<number>, [batchOptions: StandardHandlerRoutingInterceptorOptions<T>]>;
-    /**
-     * Success batch response headers.
-     *
-     * @default {}
-     */
-    headers?: Value<Promisable<StandardHeaders>, [batchOptions: StandardHandlerRoutingInterceptorOptions<T>]>;
-}
-declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    name: string;
-    /**
-     * Run batch interceptors before OpenTelemetry interceptors
-     * so each subrequest gets its own span instead of sharing one batch-level span.
-     */
-    after: string[];
-    private readonly maxSize;
-    private readonly mapSubrequest;
-    private readonly successStatus;
-    private readonly headers;
-    constructor(options?: BatchHandlerPluginOptions<T>);
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
-
-interface CORSHandlerPluginOptions<T extends Context> {
-    /**
-     * Configures the `Access-Control-Allow-Origin` header.
-     * Can be a string, an array of allowed origins, or a function that returns the allowed origin(s).
-     *
-     * @default (origin) => origin
-     */
-    origin?: Value<Promisable<string | readonly string[] | null | undefined>, [origin: string, options: StandardHandlerRoutingInterceptorOptions<T>]>;
-    /**
-     * Configures the `Timing-Allow-Origin` header.
-     * Can be a string, an array of allowed origins, or a function that returns the allowed origin(s).
-     *
-     * @default undefined
-     */
-    timingOrigin?: Value<Promisable<string | readonly string[] | null | undefined>, [origin: string, options: StandardHandlerRoutingInterceptorOptions<T>]>;
-    /**
-     * Configures the `Access-Control-Allow-Methods` header for preflight requests.
-     *
-     * @default ['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH']
-     */
-    allowMethods?: readonly string[];
-    /**
-     * Configures the `Access-Control-Allow-Headers` header for preflight requests.
-     * Falls back to the request's `Access-Control-Request-Headers` if not set.
-     *
-     * @default undefined
-     */
-    allowHeaders?: readonly string[];
-    /**
-     * Configures the `Access-Control-Max-Age` header (in seconds) for preflight requests.
-     *
-     * @default undefined
-     */
-    maxAge?: number;
-    /**
-     * Configures the `Access-Control-Allow-Credentials` header.
-     *
-     * @default undefined
-     */
-    credentials?: boolean;
-    /**
-     * Configures the `Access-Control-Expose-Headers` header.
-     *
-     * @default undefined
-     */
-    exposeHeaders?: readonly string[];
-}
-/**
- * CORSHandlerPlugin is a plugin for oRPC that allows you to configure CORS for your API.
- *
- * @see {@link https://orpc.dev/docs/plugins/cors CORS Plugin Docs}
- */
-declare class CORSHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    private readonly options;
-    name: string;
-    /**
-     * - Do not create spans for CORS preflight requests.
-     * - Run CORS interceptors before batch interceptors so headers are applied to
-     *  the actual response rather than sub-responses.
-     */
-    after: string[];
-    constructor(options?: CORSHandlerPluginOptions<T>);
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
-
-/**
- * Adds basic Cross-Site Request Forgery (CSRF) protection to your oRPC application.
- * When a request includes cookies, it helps ensure the request originates from JavaScript
- * (for example, fetch/XHR) rather than from standard HTML forms or direct browser navigation.
- *
- * @info This plugin is enabled by default for `RPCHandler` over HTTP.
- */
-declare class CSRFGuardHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    name: string;
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
-
-interface RequestHeadersHandlerPluginContext {
-    /**
-     * Request headers as a Headers instance. This is injected by the Request Headers Plugin.
-     */
-    reqHeaders?: Headers | undefined;
-}
-/**
- * The Request Headers Plugin injects a `reqHeaders` instance into the context,
- * allowing access to request headers in oRPC.
- *
- * @see {@link https://orpc.dev/docs/plugins/request-headers Request Headers Plugin Docs}
- */
-declare class RequestHeadersHandlerPlugin<T extends RequestHeadersHandlerPluginContext> implements StandardHandlerPlugin<T> {
-    name: string;
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
-
-interface ResponseHeadersHandlerPluginContext {
-    /**
-     * Response headers as a Headers instance. This is injected by the Response Headers Plugin.
-     * When set before the response is sent, these headers will be included in the response. If not set, no additional headers will be added.
-     */
-    resHeaders?: Headers | undefined;
-}
-/**
- * The Response Headers Plugin allows you to set response headers in oRPC.
- * It injects a resHeaders instance into the context, enabling you to modify response headers easily.
- *
- * @see {@link https://orpc.dev/docs/plugins/response-headers Response Headers Plugin Docs}
- */
-declare class ResponseHeadersHandlerPlugin<T extends ResponseHeadersHandlerPluginContext> implements StandardHandlerPlugin<T> {
-    name: string;
-    /**
-     * Interceptors should run after batch interceptors so headers are applied to each sub-response.
-     */
-    before: string[];
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
-
-interface RethrowHandlerPluginOptions<T extends Context> {
-    /**
-     * Decide which errors should be rethrown.
-     *
-     * @example
-     * ```ts
-     * const rethrowPlugin = new RethrowHandlerPlugin({
-     *   filter: (error) => {
-     *     // Rethrow all non-ORPCError errors
-     *     return !(error instanceof ORPCError)
-     *   }
-     * })
-     * ```
-     */
-    filter: (error: ThrowableError, options: StandardHandlerInterceptorOptions<T>) => boolean;
-}
-/**
- * The plugin can bypass oRPC's built-in error handling
- * and rethrow matching errors directly to your framework's error handling mechanism
- * (e.g., NestJS exception filters, Express error middleware).
- *
- * @see {@link https://orpc.dev/docs/plugins/rethrow Rethrow Plugin Documentation}
- */
-declare class RethrowHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    name: string;
-    private readonly filter;
-    private readonly CONTEXT_SYMBOL;
-    constructor(options: RethrowHandlerPluginOptions<T>);
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
-
-export { BatchHandlerPlugin, CORSHandlerPlugin, CSRFGuardHandlerPlugin, RequestHeadersHandlerPlugin, ResponseHeadersHandlerPlugin, RethrowHandlerPlugin };
-export type { BatchHandlerPluginOptions, CORSHandlerPluginOptions, RequestHeadersHandlerPluginContext, ResponseHeadersHandlerPluginContext, RethrowHandlerPluginOptions };

package/dist/plugins/index.mjs

@@ -1,357 +0,0 @@
-import { toArray, value } from '@orpc/shared';
-import { flattenStandardHeader, parseStandardUrl, mergeStandardHeaders } from '@standardserver/core';
-import { isClientPeerSendMessage, ServerPeer, encodePeerMessage } from '@standardserver/peer';
-export { C as CSRFGuardHandlerPlugin } from '../shared/server.D_QauotT.mjs';
-import { toFetchHeaders, toStandardHeaders } from '@standardserver/fetch';
-import '@orpc/client';
-
-class BatchHandlerPlugin {
-  name = "~batch";
-  /**
-   * Run batch interceptors before OpenTelemetry interceptors
-   * so each subrequest gets its own span instead of sharing one batch-level span.
-   */
-  after = ["~opentelemetry"];
-  maxSize;
-  mapSubrequest;
-  successStatus;
-  headers;
-  constructor(options = {}) {
-    this.maxSize = options.maxSize ?? 10;
-    this.mapSubrequest = options.mapSubrequest ?? ((subRequest, { request: batchRequest }) => ({
-      ...subRequest,
-      headers: {
-        ...batchRequest.headers,
-        ...subRequest.headers,
-        "orpc-batch": void 0
-        // useful in case batch plugin is used multiple times
-      }
-    }));
-    this.successStatus = options.successStatus ?? 207;
-    this.headers = options.headers ?? {};
-  }
-  init(options) {
-    const routingInterceptor = async (interceptorOptions) => {
-      const batchHeader = flattenStandardHeader(interceptorOptions.request.headers["orpc-batch"]);
-      if (batchHeader === void 0) {
-        return interceptorOptions.next();
-      }
-      const mode = batchHeader === "buffered" ? "buffered" : "streaming";
-      let messages;
-      try {
-        if (interceptorOptions.request.method === "GET") {
-          const [, search] = parseStandardUrl(interceptorOptions.request.url);
-          const params = new URLSearchParams(search);
-          const data = params.getAll("data").at(-1);
-          if (!data) {
-            return {
-              matched: true,
-              response: { status: 400, headers: {}, body: "Missing data parameter for batch request" }
-            };
-          }
-          const mightBeMessages = JSON.parse(data);
-          if (!Array.isArray(mightBeMessages) || mightBeMessages.some((m) => !isClientPeerSendMessage(m))) {
-            return {
-              matched: true,
-              response: { status: 400, headers: {}, body: "Invalid batch request data parameter" }
-            };
-          }
-          messages = mightBeMessages;
-        } else {
-          const mightBeMessages = await interceptorOptions.request.resolveBody();
-          if (!Array.isArray(mightBeMessages)) {
-            return {
-              matched: true,
-              response: { status: 400, headers: {}, body: "Invalid batch request body" }
-            };
-          }
-          messages = mightBeMessages;
-        }
-      } catch {
-        return {
-          matched: true,
-          response: { status: 400, headers: {}, body: "Invalid batch request" }
-        };
-      }
-      const maxSize = await value(this.maxSize, interceptorOptions);
-      if (messages.length > maxSize) {
-        return {
-          matched: true,
-          response: { status: 413, headers: {}, body: "Batch request size exceeds the maximum allowed size" }
-        };
-      }
-      const handleIndividualRequest = async (request) => {
-        try {
-          request = this.mapSubrequest(request, interceptorOptions);
-          const { matched, response } = await interceptorOptions.next({ ...interceptorOptions, request });
-          if (!matched) {
-            return { status: 404, headers: {}, body: "No procedure matched" };
-          }
-          return response;
-        } catch (err) {
-          Promise.reject(err);
-          return { status: 500, headers: {}, body: "Internal server error" };
-        }
-      };
-      const status = await value(this.successStatus, interceptorOptions);
-      const headers = await value(this.headers, interceptorOptions);
-      if (mode === "buffered") {
-        const responseMessages = [];
-        const peer2 = new ServerPeer(async (message) => {
-          responseMessages.push(message);
-        });
-        await Promise.all(messages.map((msg) => peer2.message(msg, handleIndividualRequest)));
-        await peer2.close();
-        if (responseMessages.some((msg) => msg.binary !== void 0)) {
-          const chunks = [];
-          for (const message of responseMessages) {
-            const encoded = await encodePeerMessage(message);
-            const bytes = typeof encoded === "string" ? new TextEncoder().encode(encoded) : encoded;
-            const lengthBuffer = new ArrayBuffer(4);
-            new DataView(lengthBuffer).setUint32(0, bytes.byteLength, false);
-            chunks.push(new Uint8Array(lengthBuffer));
-            chunks.push(bytes);
-          }
-          return {
-            matched: true,
-            response: {
-              status,
-              headers,
-              body: new Blob(chunks, { type: "application/octet-stream" })
-            }
-          };
-        }
-        return {
-          matched: true,
-          response: { status, headers, body: responseMessages }
-        };
-      }
-      let streamController;
-      const stream = new ReadableStream({
-        start(controller) {
-          streamController = controller;
-        }
-      });
-      const peer = new ServerPeer(async (message) => {
-        const encoded = await encodePeerMessage(message);
-        const bytes = typeof encoded === "string" ? new TextEncoder().encode(encoded) : encoded;
-        const lengthBuffer = new ArrayBuffer(4);
-        new DataView(lengthBuffer).setUint32(0, bytes.byteLength, false);
-        streamController.enqueue(new Uint8Array(lengthBuffer));
-        streamController.enqueue(bytes);
-      });
-      Promise.all(messages.map((msg) => peer.message(msg, handleIndividualRequest))).then(async () => {
-        streamController.close();
-        await peer.close();
-      }).catch(async (error) => {
-        streamController.error(error);
-        await peer.close(error);
-      });
-      return {
-        matched: true,
-        response: { status, headers, body: stream }
-      };
-    };
-    return {
-      ...options,
-      routingInterceptors: [routingInterceptor, ...toArray(options.routingInterceptors)]
-    };
-  }
-}
-
-class CORSHandlerPlugin {
-  options;
-  name = "~cors";
-  /**
-   * - Do not create spans for CORS preflight requests.
-   * - Run CORS interceptors before batch interceptors so headers are applied to
-   *  the actual response rather than sub-responses.
-   */
-  after = ["~opentelemetry", "~batch"];
-  constructor(options = {}) {
-    const defaults = {
-      origin: (origin) => origin,
-      allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"]
-    };
-    this.options = {
-      ...defaults,
-      ...options
-    };
-  }
-  init(options) {
-    const corsHeadersInterceptor = async (interceptorOptions) => {
-      const result = await interceptorOptions.next();
-      if (!result.matched) {
-        return result;
-      }
-      const resHeaders = { ...result.response.headers };
-      const origin = flattenStandardHeader(interceptorOptions.request.headers.origin) ?? "";
-      const allowedOrigins = toArray(await value(this.options.origin, origin, interceptorOptions));
-      if (allowedOrigins.includes("*")) {
-        resHeaders["access-control-allow-origin"] = "*";
-      } else {
-        if (allowedOrigins.includes(origin)) {
-          resHeaders["access-control-allow-origin"] = origin;
-        }
-        resHeaders.vary = interceptorOptions.request.headers.vary ?? "origin";
-      }
-      const allowedTimingOrigins = toArray(await value(this.options.timingOrigin, origin, interceptorOptions));
-      if (allowedTimingOrigins.includes("*")) {
-        resHeaders["timing-allow-origin"] = "*";
-      } else if (allowedTimingOrigins.includes(origin)) {
-        resHeaders["timing-allow-origin"] = origin;
-      }
-      if (this.options.credentials) {
-        resHeaders["access-control-allow-credentials"] = "true";
-      }
-      if (this.options.exposeHeaders?.length) {
-        resHeaders["access-control-expose-headers"] = flattenStandardHeader(this.options.exposeHeaders);
-      }
-      return { ...result, response: { ...result.response, headers: resHeaders } };
-    };
-    const preflightInterceptor = async (interceptorOptions) => {
-      if (interceptorOptions.request.method === "OPTIONS") {
-        const resHeaders = {};
-        if (this.options.maxAge !== void 0) {
-          resHeaders["access-control-max-age"] = this.options.maxAge.toString();
-        }
-        if (this.options.allowMethods?.length) {
-          resHeaders["access-control-allow-methods"] = flattenStandardHeader(this.options.allowMethods);
-        }
-        const allowHeaders = this.options.allowHeaders ?? interceptorOptions.request.headers["access-control-request-headers"];
-        if (typeof allowHeaders === "string" || allowHeaders?.length) {
-          resHeaders["access-control-allow-headers"] = flattenStandardHeader(allowHeaders);
-        }
-        return {
-          matched: true,
-          response: {
-            status: 204,
-            headers: resHeaders,
-            body: void 0
-          }
-        };
-      }
-      return interceptorOptions.next();
-    };
-    return {
-      ...options,
-      routingInterceptors: [
-        corsHeadersInterceptor,
-        preflightInterceptor,
-        ...toArray(options.routingInterceptors)
-      ]
-    };
-  }
-}
-
-class RequestHeadersHandlerPlugin {
-  name = "~request-headers";
-  init(options) {
-    return {
-      ...options,
-      interceptors: [
-        (interceptorOptions) => {
-          const reqHeaders = interceptorOptions.context.reqHeaders ?? toFetchHeaders(interceptorOptions.request.headers);
-          return interceptorOptions.next({
-            ...interceptorOptions,
-            context: {
-              ...interceptorOptions.context,
-              reqHeaders
-            }
-          });
-        },
-        ...toArray(options.interceptors)
-      ]
-    };
-  }
-}
-
-class ResponseHeadersHandlerPlugin {
-  name = "~response-headers";
-  /**
-   * Interceptors should run after batch interceptors so headers are applied to each sub-response.
-   */
-  before = ["~batch"];
-  init(options) {
-    return {
-      ...options,
-      routingInterceptors: [
-        async (interceptorOptions) => {
-          const resHeaders = new Headers(interceptorOptions.context.resHeaders);
-          const result = await interceptorOptions.next({
-            ...interceptorOptions,
-            context: {
-              ...interceptorOptions.context,
-              resHeaders
-            }
-          });
-          if (!result.response) {
-            return result;
-          }
-          return {
-            ...result,
-            response: {
-              ...result.response,
-              headers: mergeStandardHeaders(result.response.headers, toStandardHeaders(resHeaders))
-            }
-          };
-        },
-        ...toArray(options.routingInterceptors)
-      ]
-    };
-  }
-}
-
-class RethrowHandlerPlugin {
-  name = "~rethrow";
-  filter;
-  CONTEXT_SYMBOL = Symbol("ORPC_RETHROW_HANDLER_PLUGIN_CONTEXT");
-  constructor(options) {
-    this.filter = options.filter;
-  }
-  init(options) {
-    const routingInterceptor = async (options2) => {
-      const pluginContext = {};
-      const result = await options2.next({
-        ...options2,
-        context: {
-          ...options2.context,
-          [this.CONTEXT_SYMBOL]: pluginContext
-        }
-      });
-      if (pluginContext.error) {
-        throw pluginContext.error.value;
-      }
-      return result;
-    };
-    const interceptor = async (options2) => {
-      const pluginContext = options2.context[this.CONTEXT_SYMBOL];
-      if (!pluginContext) {
-        throw new TypeError("[RethrowHandlerPlugin] Rethrow handler context has been corrupted or modified by another plugin or interceptor");
-      }
-      try {
-        return await options2.next();
-      } catch (error) {
-        if (this.filter(error, options2)) {
-          pluginContext.error = { value: error };
-        }
-        throw error;
-      }
-    };
-    return {
-      ...options,
-      routingInterceptors: [
-        ...toArray(options.routingInterceptors),
-        routingInterceptor
-        // rethrow as early as possible and keep it close to `interceptor` to avoid a corrupted or modified context
-      ],
-      interceptors: [
-        interceptor,
-        // catch as many errors as possible
-        ...toArray(options.interceptors)
-      ]
-    };
-  }
-}
-
-export { BatchHandlerPlugin, CORSHandlerPlugin, RequestHeadersHandlerPlugin, ResponseHeadersHandlerPlugin, RethrowHandlerPlugin };