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

package/dist/plugins/head-method.js

@@ -1,104 +1,107 @@
-import { isAsyncIteratorObject, toArray } from '@orpc/shared';
-import { cancelStandardBody, getRequiredStandardBodyHint } from '@standard-server/core';
-import { toFetchBody } from '@standard-server/fetch';
+import { isAsyncIteratorObject, toArray } from "@orpc/shared";
+import { cancelStandardBody, getRequiredStandardBodyHint } from "@standard-server/core";
+import { toFetchBody } from "@standard-server/fetch";
+// src/plugins/head-method.ts
 const textEncoder = /* @__PURE__ */ new TextEncoder();
 /**
- * Answers `HEAD` requests with the headers of the matching `GET` procedure, like Fastify's
- * `exposeHeadRoutes`, so clients can check a resource's existence, type, and size without
- * downloading it. A procedure routed as `HEAD` itself takes precedence over the `GET` one.
- *
- * @remarks
- * - `HEAD` responses never carry a body: the plugin discards it, cancelling streams and
- *   event iterators, and keeps the headers it implies, such as `Content-Type`, and
- *   `Content-Length` when its size is known up front.
- * - `GET` procedures still need to be reachable, so with `RPCHandler`, `GET` must be in `allowMethods`.
- *
- * @see {@link https://orpc.dev/docs/plugins/head-method | HEAD Method Plugin}
- */
-export class HeadMethodHandlerPlugin {
-    name = '~head-method';
-    /**
-     * Discard the body after response compression, so `HEAD` reports the same `Content-Encoding` as `GET`.
-     */
-    after = ['~response-compression'];
-    init(options) {
-        // oxlint-disable-next-line unicorn/consistent-function-scoping
-        const bodyInterceptor = async ({ next, request }) => {
-            if (request.method !== 'HEAD') {
-                return next();
-            }
-            const result = await next();
-            if (!result.matched) {
-                return result;
-            }
-            return { ...result, response: toHeadResponse(result.response) };
-        };
-        /**
-         * Placed last, so falling back to `GET` repeats routing rather than the routing interceptors before this one.
-         */
-        // oxlint-disable-next-line unicorn/consistent-function-scoping
-        const fallbackInterceptor = async (interceptorOptions) => {
-            const { next, request } = interceptorOptions;
-            if (request.method !== 'HEAD') {
-                return next();
-            }
-            const result = await next();
-            if (result.matched) {
-                return result;
-            }
-            return next({
-                ...interceptorOptions,
-                request: { ...request, method: 'GET' },
-            });
-        };
-        return {
-            ...options,
-            routingInterceptors: [
-                bodyInterceptor,
-                ...toArray(options.routingInterceptors),
-                fallbackInterceptor,
-            ],
-        };
-    }
-}
+* Answers `HEAD` requests with the headers of the matching `GET` procedure, like Fastify's
+* `exposeHeadRoutes`, so clients can check a resource's existence, type, and size without
+* downloading it. A procedure routed as `HEAD` itself takes precedence over the `GET` one.
+*
+* @remarks
+* - `HEAD` responses never carry a body: the plugin discards it, cancelling streams and
+*   event iterators, and keeps the headers it implies, such as `Content-Type`, and
+*   `Content-Length` when its size is known up front.
+* - `GET` procedures still need to be reachable, so with `RPCHandler`, `GET` must be in `allowMethods`.
+*
+* @see {@link https://orpc.dev/docs/plugins/head-method | HEAD Method Plugin}
+*/
+var HeadMethodHandlerPlugin = class {
+	name = "~head-method";
+	/**
+	* Discard the body after response compression, so `HEAD` reports the same `Content-Encoding` as `GET`.
+	*/
+	after = ["~response-compression"];
+	init(options) {
+		const bodyInterceptor = async ({ next, request }) => {
+			if (request.method !== "HEAD") return next();
+			const result = await next();
+			if (!result.matched) return result;
+			return {
+				...result,
+				response: toHeadResponse(result.response)
+			};
+		};
+		/**
+		* Placed last, so falling back to `GET` repeats routing rather than the routing interceptors before this one.
+		*/
+		const fallbackInterceptor = async (interceptorOptions) => {
+			const { next, request } = interceptorOptions;
+			if (request.method !== "HEAD") return next();
+			const result = await next();
+			if (result.matched) return result;
+			return next({
+				...interceptorOptions,
+				request: {
+					...request,
+					method: "GET"
+				}
+			});
+		};
+		return {
+			...options,
+			routingInterceptors: [
+				bodyInterceptor,
+				...toArray(options.routingInterceptors),
+				fallbackInterceptor
+			]
+		};
+	}
+};
 /**
- * Replaces the body with an empty stream, keeping the headers adapters derive from it.
- * An empty stream rather than no body, because adapters drop `Content-Type` and `Content-Length` when the body is `undefined`,
- * and an empty `Standard-Server` hint rather than none, so they do not hint the stream as `octet-stream`.
- */
+* Replaces the body with an empty stream, keeping the headers adapters derive from it.
+* An empty stream rather than no body, because adapters drop `Content-Type` and `Content-Length` when the body is `undefined`,
+* and an empty `Standard-Server` hint rather than none, so they do not hint the stream as `octet-stream`.
+*/
 function toHeadResponse(response) {
-    const { body } = response;
-    if (body === undefined) {
-        return response;
-    }
-    if (isAsyncIteratorObject(body)) {
-        discardBody(body);
-        const headers = { ...response.headers, 'content-length': undefined };
-        headers['content-type'] ??= 'text/event-stream';
-        headers['standard-server'] = getRequiredStandardBodyHint('event-stream', headers) ?? [];
-        return { ...response, headers, body: createEmptyStream() };
-    }
-    const [encoded, headers] = toFetchBody(body, response.headers);
-    if (encoded instanceof ReadableStream) {
-        discardBody(encoded);
-    }
-    else if (encoded instanceof FormData) {
-        // The encoded body is never cancelled, since undici rejects unhandled when cancelled mid-serialization
-        headers['standard-server'] = [];
-        headers['content-type'] = new Response(encoded).headers.get('content-type');
-    }
-    else if (typeof encoded === 'string' || encoded instanceof URLSearchParams) {
-        headers['standard-server'] ??= [];
-        headers['content-length'] = textEncoder.encode(encoded.toString()).byteLength.toString();
-    }
-    return { ...response, headers, body: createEmptyStream() };
+	const { body } = response;
+	if (body === void 0) return response;
+	if (isAsyncIteratorObject(body)) {
+		discardBody(body);
+		const headers = {
+			...response.headers,
+			"content-length": void 0
+		};
+		headers["content-type"] ??= "text/event-stream";
+		headers["standard-server"] = getRequiredStandardBodyHint("event-stream", headers) ?? [];
+		return {
+			...response,
+			headers,
+			body: createEmptyStream()
+		};
+	}
+	const [encoded, headers] = toFetchBody(body, response.headers);
+	if (encoded instanceof ReadableStream) discardBody(encoded);
+	else if (encoded instanceof FormData) {
+		headers["standard-server"] = [];
+		headers["content-type"] = new Response(encoded).headers.get("content-type");
+	} else if (typeof encoded === "string" || encoded instanceof URLSearchParams) {
+		headers["standard-server"] ??= [];
+		headers["content-length"] = textEncoder.encode(encoded.toString()).byteLength.toString();
+	}
+	return {
+		...response,
+		headers,
+		body: createEmptyStream()
+	};
 }
 function createEmptyStream() {
-    return new ReadableStream({ start: (controller) => controller.close() });
+	return new ReadableStream({ start: (controller) => controller.close() });
 }
 /**
- * Nothing reads the body anymore, so a failure to cancel it has nowhere to go.
- */
+* Nothing reads the body anymore, so a failure to cancel it has nowhere to go.
+*/
 function discardBody(body) {
-    cancelStandardBody(body).catch(() => { });
+	cancelStandardBody(body).catch(() => {});
 }
+export { HeadMethodHandlerPlugin };

package/dist/plugins/index.d.ts

@@ -1,39 +1,15 @@
-export * from './batch.ts';
-export * from './cors.ts';
-export { 
-/**
- * @deprecated Use `CORSHandlerPlugin` instead.
- */
-CORSHandlerPlugin as CORSPlugin, } from './cors.ts';
-export * from './get-method-csrf-protection.ts';
-export * from './head-method.ts';
-export * from './method-override.ts';
-export * from './request-compression.ts';
-export * from './request-headers.ts';
-export { 
-/**
- * @deprecated Use `RequestHeadersHandlerPlugin` instead.
- */
-RequestHeadersHandlerPlugin as RequestHeadersPlugin, } from './request-headers.ts';
-export type { 
-/**
- * @deprecated Use `RequestHeadersHandlerPluginContext` instead.
- */
-RequestHeadersHandlerPluginContext as RequestHeadersPluginContext, } from './request-headers.ts';
-export * from './request-limit.ts';
-export * from './response-compression.ts';
-export * from './response-headers.ts';
-export { 
-/**
- * @deprecated Use `ResponseHeadersHandlerPlugin` instead.
- */
-ResponseHeadersHandlerPlugin as ResponseHeadersPlugin, } from './response-headers.ts';
-export type { 
-/**
- * @deprecated Use `ResponseHeadersHandlerPluginContext` instead.
- */
-ResponseHeadersHandlerPluginContext as ResponseHeadersPluginContext, } from './response-headers.ts';
-export * from './rethrow.ts';
-export * from './signal-sync.ts';
-export * from './timeout.ts';
-export { BATCH_HEADER, DEFAULT_BATCH_MAX_SIZE } from '@orpc/client/plugins';
+import { BATCH_CONTENT_TYPE, BatchHandlerPlugin, BatchHandlerPluginOptions } from "./batch.js";
+import { CORSHandlerPlugin, CORSHandlerPluginOptions } from "./cors.js";
+import { GetMethodCsrfProtectionHandlerPlugin } from "./get-method-csrf-protection.js";
+import { HeadMethodHandlerPlugin } from "./head-method.js";
+import { MethodOverrideHandlerPlugin, MethodOverrideHandlerPluginOptions } from "./method-override.js";
+import { RequestCompressionHandlerPlugin } from "./request-compression.js";
+import { RequestHeadersHandlerPlugin, RequestHeadersHandlerPluginContext } from "./request-headers.js";
+import { RequestLimitHandlerPlugin, RequestLimitHandlerPluginOptions } from "./request-limit.js";
+import { ResponseCompressionHandlerPlugin, ResponseCompressionHandlerPluginOptions, negotiateResponseCompressionEncoding, toCompressedHeaders } from "./response-compression.js";
+import { ResponseHeadersHandlerPlugin, ResponseHeadersHandlerPluginContext } from "./response-headers.js";
+import { RethrowHandlerPlugin, RethrowHandlerPluginOptions } from "./rethrow.js";
+import { SignalSyncHandlerPlugin } from "./signal-sync.js";
+import { TimeoutHandlerPlugin, TimeoutHandlerPluginOptions } from "./timeout.js";
+import { BATCH_HEADER, DEFAULT_BATCH_MAX_SIZE } from "@orpc/client/plugins";
+export { BATCH_CONTENT_TYPE, BATCH_HEADER, BatchHandlerPlugin, BatchHandlerPluginOptions, CORSHandlerPlugin, CORSHandlerPluginOptions, CORSHandlerPlugin as CORSPlugin, DEFAULT_BATCH_MAX_SIZE, GetMethodCsrfProtectionHandlerPlugin, HeadMethodHandlerPlugin, MethodOverrideHandlerPlugin, MethodOverrideHandlerPluginOptions, RequestCompressionHandlerPlugin, RequestHeadersHandlerPlugin, RequestHeadersHandlerPluginContext, RequestHeadersHandlerPlugin as RequestHeadersPlugin, type RequestHeadersHandlerPluginContext as RequestHeadersPluginContext, RequestLimitHandlerPlugin, RequestLimitHandlerPluginOptions, ResponseCompressionHandlerPlugin, ResponseCompressionHandlerPluginOptions, ResponseHeadersHandlerPlugin, ResponseHeadersHandlerPluginContext, ResponseHeadersHandlerPlugin as ResponseHeadersPlugin, type ResponseHeadersHandlerPluginContext as ResponseHeadersPluginContext, RethrowHandlerPlugin, RethrowHandlerPluginOptions, SignalSyncHandlerPlugin, TimeoutHandlerPlugin, TimeoutHandlerPluginOptions, negotiateResponseCompressionEncoding, toCompressedHeaders };

package/dist/plugins/index.js

@@ -1,29 +1,14 @@
-export * from './batch.js';
-export * from './cors.js';
-export { 
-/**
- * @deprecated Use `CORSHandlerPlugin` instead.
- */
-CORSHandlerPlugin as CORSPlugin, } from './cors.js';
-export * from './get-method-csrf-protection.js';
-export * from './head-method.js';
-export * from './method-override.js';
-export * from './request-compression.js';
-export * from './request-headers.js';
-export { 
-/**
- * @deprecated Use `RequestHeadersHandlerPlugin` instead.
- */
-RequestHeadersHandlerPlugin as RequestHeadersPlugin, } from './request-headers.js';
-export * from './request-limit.js';
-export * from './response-compression.js';
-export * from './response-headers.js';
-export { 
-/**
- * @deprecated Use `ResponseHeadersHandlerPlugin` instead.
- */
-ResponseHeadersHandlerPlugin as ResponseHeadersPlugin, } from './response-headers.js';
-export * from './rethrow.js';
-export * from './signal-sync.js';
-export * from './timeout.js';
-export { BATCH_HEADER, DEFAULT_BATCH_MAX_SIZE } from '@orpc/client/plugins';
+export { BATCH_CONTENT_TYPE, BatchHandlerPlugin } from "./batch.js";
+export { CORSHandlerPlugin, CORSHandlerPlugin as CORSPlugin } from "./cors.js";
+export { GetMethodCsrfProtectionHandlerPlugin } from "./get-method-csrf-protection.js";
+export { HeadMethodHandlerPlugin } from "./head-method.js";
+export { MethodOverrideHandlerPlugin } from "./method-override.js";
+export { RequestCompressionHandlerPlugin } from "./request-compression.js";
+export { RequestHeadersHandlerPlugin, RequestHeadersHandlerPlugin as RequestHeadersPlugin } from "./request-headers.js";
+export { RequestLimitHandlerPlugin } from "./request-limit.js";
+export { ResponseCompressionHandlerPlugin, negotiateResponseCompressionEncoding, toCompressedHeaders } from "./response-compression.js";
+export { ResponseHeadersHandlerPlugin, ResponseHeadersHandlerPlugin as ResponseHeadersPlugin } from "./response-headers.js";
+export { RethrowHandlerPlugin } from "./rethrow.js";
+export { SignalSyncHandlerPlugin } from "./signal-sync.js";
+export { TimeoutHandlerPlugin } from "./timeout.js";
+export { BATCH_HEADER, DEFAULT_BATCH_MAX_SIZE } from "@orpc/client/plugins";

package/dist/plugins/method-override.d.ts

@@ -1,22 +1,24 @@
-import type { StandardMethod } from '@standard-server/core';
-import type { StandardHandlerOptions, StandardHandlerPlugin } from '../adapters/standard/index.ts';
-import type { Context } from '../context.ts';
+import "../adapters/standard/index.js";
+import { StandardHandlerPlugin } from "../adapters/standard/plugin.js";
+import { StandardHandlerOptions } from "../adapters/standard/handler.js";
+import { Context } from "../context.js";
+import { StandardMethod } from "@standard-server/core";
 export interface MethodOverrideHandlerPluginOptions {
-    /**
-     * The query parameter carrying the override method.
-     *
-     * @default 'method'
-     */
-    param?: string | undefined;
-    /**
-     * The methods a POST request may be overridden to.
-     *
-     * GET and HEAD are excluded by default because they switch input decoding
-     * from the request body to the query string and widen the CSRF surface.
-     *
-     * @default ['PUT', 'PATCH', 'DELETE']
-     */
-    methods?: readonly StandardMethod[] | undefined;
+  /**
+   * The query parameter carrying the override method.
+   *
+   * @default 'method'
+   */
+  param?: string | undefined;
+  /**
+   * The methods a POST request may be overridden to.
+   *
+   * GET and HEAD are excluded by default because they switch input decoding
+   * from the request body to the query string and widen the CSRF surface.
+   *
+   * @default ['PUT', 'PATCH', 'DELETE']
+   */
+  methods?: readonly StandardMethod[] | undefined;
 }
 /**
  * Overrides the HTTP method of a POST request based on a query parameter,
@@ -26,13 +28,13 @@ export interface MethodOverrideHandlerPluginOptions {
  * @see {@link https://orpc.dev/docs/plugins/method-override | Method Override Plugin}
  */
 export declare class MethodOverrideHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    name: string;
-    /**
-     * Should override batch sub-request methods, not the original batch request.
-     */
-    before: string[];
-    private readonly param;
-    private readonly methods;
-    constructor(options?: MethodOverrideHandlerPluginOptions);
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
+  name: string;
+  /**
+   * Should override batch sub-request methods, not the original batch request.
+   */
+  before: string[];
+  private readonly param;
+  private readonly methods;
+  constructor(options?: MethodOverrideHandlerPluginOptions);
+  init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/method-override.js

@@ -1,50 +1,54 @@
-import { toArray } from '@orpc/shared';
-import { parseStandardUrl } from '@standard-server/core';
+import { toArray } from "@orpc/shared";
+import { parseStandardUrl } from "@standard-server/core";
+// src/plugins/method-override.ts
 /**
- * Overrides the HTTP method of a POST request based on a query parameter,
- * so HTML forms (which only support GET and POST) can invoke procedures
- * routed as PUT, PATCH, or DELETE.
- *
- * @see {@link https://orpc.dev/docs/plugins/method-override | Method Override Plugin}
- */
-export class MethodOverrideHandlerPlugin {
-    name = '~method-override';
-    /**
-     * Should override batch sub-request methods, not the original batch request.
-     */
-    before = ['~batch'];
-    param;
-    methods;
-    constructor(options = {}) {
-        this.param = options.param ?? 'method';
-        this.methods = new Set((options.methods ?? ['PUT', 'PATCH', 'DELETE']).map((method) => method.toUpperCase()));
-    }
-    init(options) {
-        const routingInterceptor = async ({ next, ...interceptorOptions }) => {
-            const { request } = interceptorOptions;
-            if (request.method !== 'POST') {
-                return next();
-            }
-            const [pathname, search, hash] = parseStandardUrl(request.url);
-            const params = new URLSearchParams(search);
-            const raw = params.getAll(this.param).at(-1);
-            if (raw === undefined) {
-                return next();
-            }
-            const method = raw.toUpperCase();
-            if (!this.methods.has(method)) {
-                return next();
-            }
-            params.delete(this.param);
-            const url = `${pathname}${params.size ? `?${params}` : ''}${hash ?? ''}`;
-            return next({
-                ...interceptorOptions,
-                request: { ...request, method, url },
-            });
-        };
-        return {
-            ...options,
-            routingInterceptors: [routingInterceptor, ...toArray(options.routingInterceptors)],
-        };
-    }
-}
+* Overrides the HTTP method of a POST request based on a query parameter,
+* so HTML forms (which only support GET and POST) can invoke procedures
+* routed as PUT, PATCH, or DELETE.
+*
+* @see {@link https://orpc.dev/docs/plugins/method-override | Method Override Plugin}
+*/
+var MethodOverrideHandlerPlugin = class {
+	name = "~method-override";
+	/**
+	* Should override batch sub-request methods, not the original batch request.
+	*/
+	before = ["~batch"];
+	param;
+	methods;
+	constructor(options = {}) {
+		this.param = options.param ?? "method";
+		this.methods = new Set((options.methods ?? [
+			"PUT",
+			"PATCH",
+			"DELETE"
+		]).map((method) => method.toUpperCase()));
+	}
+	init(options) {
+		const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+			const { request } = interceptorOptions;
+			if (request.method !== "POST") return next();
+			const [pathname, search, hash] = parseStandardUrl(request.url);
+			const params = new URLSearchParams(search);
+			const raw = params.getAll(this.param).at(-1);
+			if (raw === void 0) return next();
+			const method = raw.toUpperCase();
+			if (!this.methods.has(method)) return next();
+			params.delete(this.param);
+			const url = `${pathname}${params.size ? `?${params}` : ""}${hash ?? ""}`;
+			return next({
+				...interceptorOptions,
+				request: {
+					...request,
+					method,
+					url
+				}
+			});
+		};
+		return {
+			...options,
+			routingInterceptors: [routingInterceptor, ...toArray(options.routingInterceptors)]
+		};
+	}
+};
+export { MethodOverrideHandlerPlugin };

package/dist/plugins/request-compression.d.ts

@@ -1,5 +1,7 @@
-import type { StandardHandlerOptions, StandardHandlerPlugin } from '../adapters/standard/index.ts';
-import type { Context } from '../context.ts';
+import "../adapters/standard/index.js";
+import { StandardHandlerPlugin } from "../adapters/standard/plugin.js";
+import { StandardHandlerOptions } from "../adapters/standard/handler.js";
+import { Context } from "../context.js";
 /**
  * Decompresses incoming request bodies based on the Content-Encoding header,
  * supporting gzip, deflate, and deflate-raw.
@@ -7,10 +9,10 @@ import type { Context } from '../context.ts';
  * @see {@link https://orpc.dev/docs/plugins/request-compression | Request Compression Plugin}
  */
 export declare class RequestCompressionHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    name: string;
-    /**
-     * Should decompress the original batch request body instead of sub-requests.
-     */
-    after: string[];
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
+  name: string;
+  /**
+   * Should decompress the original batch request body instead of sub-requests.
+   */
+  after: string[];
+  init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}