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

package/dist/adapters/standard/rpc-handler-codec.js

@@ -1,51 +1,50 @@
-import { COMMON_ERROR_STATUS_MAP, RPCSerializer } from '@orpc/client';
-import { getOwn, parseEmptyableJSON, value } from '@orpc/shared';
-import { parseStandardUrl } from '@standard-server/core';
-import { DEFAULT_ERROR_STATUS, DEFAULT_SUCCESS_STATUS } from '../../constants.js';
-import { RPCMatcher } from './rpc-matcher.js';
-export class RPCHandlerCodec {
-    matcher;
-    serializer;
-    errorStatusMap;
-    outputStatus;
-    constructor(router, options = {}) {
-        this.matcher = new RPCMatcher(router, options);
-        this.serializer = options.serializer ?? new RPCSerializer();
-        this.errorStatusMap = options.errorStatusMap ?? COMMON_ERROR_STATUS_MAP;
-        this.outputStatus = options.outputStatus ?? DEFAULT_SUCCESS_STATUS;
-    }
-    async resolveProcedure(request, options) {
-        const [pathname, query] = parseStandardUrl(request.url);
-        const matched = await this.matcher.match(request.method, pathname, options.prefix);
-        if (!matched) {
-            return undefined;
-        }
-        return {
-            procedure: matched.procedure,
-            path: matched.path,
-            decodeInput: async () => {
-                if (request.method === 'GET') {
-                    const dataString = new URLSearchParams(query).getAll('data').at(-1);
-                    return this.serializer.deserialize(parseEmptyableJSON(dataString));
-                }
-                const body = await request.resolveBody();
-                return this.serializer.deserialize(body);
-            },
-        };
-    }
-    encodeOutput(output, procedure, path, options) {
-        return {
-            headers: {},
-            status: value(this.outputStatus, output, procedure, path, options),
-            body: this.serializer.serialize(output),
-        };
-    }
-    encodeError(error, _procedure, _path, _options) {
-        const status = getOwn(this.errorStatusMap, error.code) ?? DEFAULT_ERROR_STATUS;
-        return {
-            headers: {},
-            status,
-            body: this.serializer.serialize(error.toJSON()),
-        };
-    }
-}
+import "../../constants.js";
+import { RPCMatcher } from "./rpc-matcher.js";
+import { getOwn, parseEmptyableJSON, value } from "@orpc/shared";
+import { COMMON_ERROR_STATUS_MAP, RPCSerializer } from "@orpc/client";
+import { parseStandardUrl } from "@standard-server/core";
+// src/adapters/standard/rpc-handler-codec.ts
+var RPCHandlerCodec = class {
+	matcher;
+	serializer;
+	errorStatusMap;
+	outputStatus;
+	constructor(router, options = {}) {
+		this.matcher = new RPCMatcher(router, options);
+		this.serializer = options.serializer ?? new RPCSerializer();
+		this.errorStatusMap = options.errorStatusMap ?? COMMON_ERROR_STATUS_MAP;
+		this.outputStatus = options.outputStatus ?? 200;
+	}
+	async resolveProcedure(request, options) {
+		const [pathname, query] = parseStandardUrl(request.url);
+		const matched = await this.matcher.match(request.method, pathname, options.prefix);
+		if (!matched) return;
+		return {
+			procedure: matched.procedure,
+			path: matched.path,
+			decodeInput: async () => {
+				if (request.method === "GET") {
+					const dataString = new URLSearchParams(query).getAll("data").at(-1);
+					return this.serializer.deserialize(parseEmptyableJSON(dataString));
+				}
+				const body = await request.resolveBody();
+				return this.serializer.deserialize(body);
+			}
+		};
+	}
+	encodeOutput(output, procedure, path, options) {
+		return {
+			headers: {},
+			status: value(this.outputStatus, output, procedure, path, options),
+			body: this.serializer.serialize(output)
+		};
+	}
+	encodeError(error, _procedure, _path, _options) {
+		return {
+			headers: {},
+			status: getOwn(this.errorStatusMap, error.code) ?? 400,
+			body: this.serializer.serialize(error.toJSON())
+		};
+	}
+};
+export { RPCHandlerCodec };

package/dist/adapters/standard/rpc-matcher.d.ts

@@ -1,8 +1,8 @@
-import type { AnyProcedureContract } from '@orpc/contract';
-import type { Value } from '@orpc/shared';
-import type { StandardMethod } from '@standard-server/core';
-import type { AnyProcedure } from '../../procedure.ts';
-import type { AnyRouter } from '../../router.ts';
+import { AnyProcedure } from "../../procedure.js";
+import { AnyRouter } from "../../router.js";
+import { AnyProcedureContract } from "@orpc/contract";
+import { Value } from "@orpc/shared";
+import { StandardMethod } from "@standard-server/core";
 /**
  * Methods that can invoke procedures by default. Browsers cannot trigger them
  * cross-site without a CORS preflight or an HTML form, unlike `GET`, which a plain
@@ -14,40 +14,40 @@ import type { AnyRouter } from '../../router.ts';
  */
 export declare const RPC_DEFAULT_ALLOW_METHODS: readonly StandardMethod[];
 export interface RPCMatcherOptions {
-    /**
-     * Filter which procedures are exposed for matching. Return `false` to exclude.
-     *
-     * @default true
-     */
-    filter?: Value<boolean, [procedure: AnyProcedureContract | AnyProcedure, path: string[]]> | undefined;
-    /**
-     * Restricts which HTTP methods can invoke procedures, either with a list of allowed
-     * methods or decided per request via a function. Requests using a disallowed method
-     * are treated as unmatched. `GET` is excluded by default because it is exposed to
-     * Cross-Site Request Forgery (CSRF) attacks.
-     *
-     * @default RPC_DEFAULT_ALLOW_METHODS (['POST', 'PUT', 'PATCH', 'DELETE'])
-     * @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
-     */
-    allowMethods?: readonly StandardMethod[] | ((method: StandardMethod, procedure: AnyProcedure, path: string[]) => boolean) | undefined;
+  /**
+   * Filter which procedures are exposed for matching. Return `false` to exclude.
+   *
+   * @default true
+   */
+  filter?: Value<boolean, [procedure: AnyProcedureContract | AnyProcedure, path: string[]]> | undefined;
+  /**
+   * Restricts which HTTP methods can invoke procedures, either with a list of allowed
+   * methods or decided per request via a function. Requests using a disallowed method
+   * are treated as unmatched. `GET` is excluded by default because it is exposed to
+   * Cross-Site Request Forgery (CSRF) attacks.
+   *
+   * @default RPC_DEFAULT_ALLOW_METHODS (['POST', 'PUT', 'PATCH', 'DELETE'])
+   * @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
+   */
+  allowMethods?: readonly StandardMethod[] | ((method: StandardMethod, procedure: AnyProcedure, path: string[]) => boolean) | undefined;
 }
 export declare class RPCMatcher {
-    private readonly filter;
-    private readonly allowMethodsSet;
-    private readonly allowMethodsFn;
-    private readonly rootRouter;
-    private readonly tree;
-    private readonly pendingLazyRouters;
-    /** segment count of the deepest pending key, never lowered so it stays an upper bound */
-    private maxPendingLazyRouterDepth;
-    constructor(router: AnyRouter, options?: RPCMatcherOptions);
-    private index;
-    match(method: StandardMethod, pathname: `/${string}`, prefix: `/${string}` | undefined): Promise<{
-        path: string[];
-        procedure: AnyProcedure;
-    } | undefined>;
-    private resolvePendingLazyRouters;
-    private loadPendingLazyRouter;
-    private indexPendingLazyRouter;
-    private resolveProcedure;
-}
+  private readonly filter;
+  private readonly allowMethodsSet;
+  private readonly allowMethodsFn;
+  private readonly rootRouter;
+  private readonly tree;
+  private readonly pendingLazyRouters;
+  /** segment count of the deepest pending key, never lowered so it stays an upper bound */
+  private maxPendingLazyRouterDepth;
+  constructor(router: AnyRouter, options?: RPCMatcherOptions);
+  private index;
+  match(method: StandardMethod, pathname: `/${string}`, prefix: `/${string}` | undefined): Promise<{
+    path: string[];
+    procedure: AnyProcedure;
+  } | undefined>;
+  private resolvePendingLazyRouters;
+  private loadPendingLazyRouter;
+  private indexPendingLazyRouter;
+  private resolveProcedure;
+}

package/dist/adapters/standard/rpc-matcher.js

@@ -1,152 +1,106 @@
-import { normalizeHttpPath, pathToHttpPath, value } from '@orpc/shared';
-import { unlazy } from '../../lazy.js';
-import { Procedure } from '../../procedure.js';
-import { resolveContractProcedure, walkProcedureContractsSync } from '../../router-utils.js';
+import { unlazy } from "../../lazy.js";
+import { Procedure } from "../../procedure.js";
+import { resolveContractProcedure, walkProcedureContractsSync } from "../../router-utils.js";
+import { normalizeHttpPath, pathToHttpPath, stripHttpPathPrefix, value } from "@orpc/shared";
+// src/adapters/standard/rpc-matcher.ts
 /**
- * Methods that can invoke procedures by default. Browsers cannot trigger them
- * cross-site without a CORS preflight or an HTML form, unlike `GET`, which a plain
- * `<a>` click or redirect can trigger with `SameSite=Lax` cookies attached. Other
- * methods (`HEAD`, `OPTIONS`, `QUERY`, ...) have safe semantics that should not
- * invoke a procedure that can modify data.
- *
- * @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
- */
-export const RPC_DEFAULT_ALLOW_METHODS = [
-    'POST',
-    'PUT',
-    'PATCH',
-    'DELETE',
+* Methods that can invoke procedures by default. Browsers cannot trigger them
+* cross-site without a CORS preflight or an HTML form, unlike `GET`, which a plain
+* `<a>` click or redirect can trigger with `SameSite=Lax` cookies attached. Other
+* methods (`HEAD`, `OPTIONS`, `QUERY`, ...) have safe semantics that should not
+* invoke a procedure that can modify data.
+*
+* @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
+*/
+const RPC_DEFAULT_ALLOW_METHODS = [
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE"
 ];
-// `%` or a char `encodeURIComponent` encodes, meaning normalization may change the pathname
 const NORMALIZABLE_PATHNAME_REGEX = /[^\w\-.!~*'()/]/;
-export class RPCMatcher {
-    filter;
-    allowMethodsSet;
-    allowMethodsFn;
-    rootRouter;
-    tree = new Map();
-    pendingLazyRouters = new Map();
-    /** segment count of the deepest pending key, never lowered so it stays an upper bound */
-    maxPendingLazyRouterDepth = 0;
-    constructor(router, options = {}) {
-        this.filter = options.filter ?? true;
-        const allowMethods = options.allowMethods ?? RPC_DEFAULT_ALLOW_METHODS;
-        if (typeof allowMethods !== 'function') {
-            this.allowMethodsSet = new Set(allowMethods);
-        }
-        else {
-            this.allowMethodsFn = allowMethods;
-        }
-        this.rootRouter = router;
-        this.index(router);
-    }
-    index(router, path = []) {
-        const lazyResults = walkProcedureContractsSync(router, (procedure, procedurePath) => {
-            if (!value(this.filter, procedure, procedurePath)) {
-                return;
-            }
-            this.tree.set(pathToHttpPath(procedurePath), {
-                path: procedurePath,
-                contract: procedure,
-                // contract-first entries have no implementation yet, resolveProcedure fills it in on demand
-                procedure: procedure instanceof Procedure ? procedure : undefined,
-            });
-        }, path);
-        for (const result of lazyResults) {
-            this.pendingLazyRouters.set(pathToHttpPath(result.path), result);
-            this.maxPendingLazyRouterDepth = Math.max(this.maxPendingLazyRouterDepth, result.path.length);
-        }
-    }
-    async match(method, pathname, prefix) {
-        if (this.allowMethodsSet && !this.allowMethodsSet.has(method)) {
-            return undefined;
-        }
-        if (prefix) {
-            if (!pathname.startsWith(prefix)) {
-                return undefined;
-            }
-            const charAfterPrefix = pathname[prefix.length];
-            if (charAfterPrefix === '/') {
-                pathname = pathname.slice(prefix.length);
-            }
-            else if (charAfterPrefix === undefined) {
-                pathname = '/';
-            }
-            else if (prefix[prefix.length - 1] === '/') {
-                pathname = pathname.slice(prefix.length - 1);
-            }
-            else {
-                return undefined;
-            }
-        }
-        if (pathname.length > 1 && pathname.endsWith('/')) {
-            pathname = pathname.slice(0, -1);
-        }
-        // most requests `await undefined` so conditionally await it to save a microtask turn
-        const loading = this.resolvePendingLazyRouters(pathname);
-        if (loading !== undefined) {
-            await loading;
-        }
-        let entry = this.tree.get(pathname);
-        if (entry === undefined && NORMALIZABLE_PATHNAME_REGEX.test(pathname)) {
-            // Retry with a normalized path: users may percent-encode characters that we store
-            // unencoded ("a%62c" vs "abc"), or leave raw characters that we store encoded
-            // ("a^b" vs "a%5Eb"), so normalization handles both without duplicate entries.
-            const normalizedPathname = normalizeHttpPath(pathname);
-            // most requests `await undefined` so conditionally await it to save a microtask turn
-            const normalizedLoading = this.resolvePendingLazyRouters(normalizedPathname);
-            if (normalizedLoading !== undefined) {
-                await normalizedLoading;
-            }
-            entry = this.tree.get(normalizedPathname);
-        }
-        if (entry === undefined) {
-            return undefined;
-        }
-        const procedure = entry.procedure ?? (await this.resolveProcedure(entry));
-        if (this.allowMethodsFn && !this.allowMethodsFn(method, procedure, entry.path)) {
-            return undefined;
-        }
-        return {
-            path: entry.path,
-            procedure,
-        };
-    }
-    resolvePendingLazyRouters(pathname) {
-        if (this.pendingLazyRouters.size === 0) {
-            return;
-        }
-        let slashIndex = 0;
-        // a pending key has as many segments as its path, so deeper prefixes can never match,
-        // and scanning them would cost quadratic time on slash-heavy pathnames
-        for (let depth = 1; slashIndex !== -1 && depth <= this.maxPendingLazyRouterDepth; depth++) {
-            const nextSlashIndex = pathname.indexOf('/', slashIndex + 1);
-            const httpPathPrefix = nextSlashIndex === -1 ? pathname : pathname.slice(0, nextSlashIndex);
-            const pending = this.pendingLazyRouters.get(httpPathPrefix);
-            if (pending !== undefined) {
-                return this.loadPendingLazyRouter(httpPathPrefix, pending).then(() => this.resolvePendingLazyRouters(pathname));
-            }
-            slashIndex = nextSlashIndex;
-        }
-    }
-    loadPendingLazyRouter(httpPathPrefix, pending) {
-        if (pending.loading === undefined) {
-            pending.loading = this.indexPendingLazyRouter(httpPathPrefix, pending).catch((error) => {
-                pending.loading = undefined;
-                throw error;
-            });
-        }
-        return pending.loading;
-    }
-    async indexPendingLazyRouter(httpPathPrefix, pending) {
-        const { default: router } = await unlazy(pending.router);
-        this.index(router, pending.path);
-        // removed only once indexed, so a concurrent match never observes this router as
-        // neither pending nor indexed
-        this.pendingLazyRouters.delete(httpPathPrefix);
-    }
-    async resolveProcedure(entry) {
-        entry.procedure = await resolveContractProcedure(this.rootRouter, entry.contract, entry.path);
-        return entry.procedure;
-    }
-}
+var RPCMatcher = class {
+	filter;
+	allowMethodsSet;
+	allowMethodsFn;
+	rootRouter;
+	tree = /* @__PURE__ */ new Map();
+	pendingLazyRouters = /* @__PURE__ */ new Map();
+	/** segment count of the deepest pending key, never lowered so it stays an upper bound */
+	maxPendingLazyRouterDepth = 0;
+	constructor(router, options = {}) {
+		this.filter = options.filter ?? true;
+		const allowMethods = options.allowMethods ?? RPC_DEFAULT_ALLOW_METHODS;
+		if (typeof allowMethods !== "function") this.allowMethodsSet = new Set(allowMethods);
+		else this.allowMethodsFn = allowMethods;
+		this.rootRouter = router;
+		this.index(router);
+	}
+	index(router, path = []) {
+		const lazyResults = walkProcedureContractsSync(router, (procedure, procedurePath) => {
+			if (!value(this.filter, procedure, procedurePath)) return;
+			this.tree.set(pathToHttpPath(procedurePath), {
+				path: procedurePath,
+				contract: procedure,
+				procedure: procedure instanceof Procedure ? procedure : void 0
+			});
+		}, path);
+		for (const result of lazyResults) {
+			this.pendingLazyRouters.set(pathToHttpPath(result.path), result);
+			this.maxPendingLazyRouterDepth = Math.max(this.maxPendingLazyRouterDepth, result.path.length);
+		}
+	}
+	async match(method, pathname, prefix) {
+		if (this.allowMethodsSet && !this.allowMethodsSet.has(method)) return;
+		if (prefix) {
+			const stripped = stripHttpPathPrefix(pathname, prefix);
+			if (stripped === void 0) return;
+			pathname = stripped;
+		}
+		if (pathname.length > 1 && pathname.endsWith("/")) pathname = pathname.slice(0, -1);
+		const loading = this.resolvePendingLazyRouters(pathname);
+		if (loading !== void 0) await loading;
+		let entry = this.tree.get(pathname);
+		if (entry === void 0 && NORMALIZABLE_PATHNAME_REGEX.test(pathname)) {
+			const normalizedPathname = normalizeHttpPath(pathname);
+			const normalizedLoading = this.resolvePendingLazyRouters(normalizedPathname);
+			if (normalizedLoading !== void 0) await normalizedLoading;
+			entry = this.tree.get(normalizedPathname);
+		}
+		if (entry === void 0) return;
+		const procedure = entry.procedure ?? await this.resolveProcedure(entry);
+		if (this.allowMethodsFn && !this.allowMethodsFn(method, procedure, entry.path)) return;
+		return {
+			path: entry.path,
+			procedure
+		};
+	}
+	resolvePendingLazyRouters(pathname) {
+		if (this.pendingLazyRouters.size === 0) return;
+		let slashIndex = 0;
+		for (let depth = 1; slashIndex !== -1 && depth <= this.maxPendingLazyRouterDepth; depth++) {
+			const nextSlashIndex = pathname.indexOf("/", slashIndex + 1);
+			const httpPathPrefix = nextSlashIndex === -1 ? pathname : pathname.slice(0, nextSlashIndex);
+			const pending = this.pendingLazyRouters.get(httpPathPrefix);
+			if (pending !== void 0) return this.loadPendingLazyRouter(httpPathPrefix, pending).then(() => this.resolvePendingLazyRouters(pathname));
+			slashIndex = nextSlashIndex;
+		}
+	}
+	loadPendingLazyRouter(httpPathPrefix, pending) {
+		if (pending.loading === void 0) pending.loading = this.indexPendingLazyRouter(httpPathPrefix, pending).catch((error) => {
+			pending.loading = void 0;
+			throw error;
+		});
+		return pending.loading;
+	}
+	async indexPendingLazyRouter(httpPathPrefix, pending) {
+		const { default: router } = await unlazy(pending.router);
+		this.index(router, pending.path);
+		this.pendingLazyRouters.delete(httpPathPrefix);
+	}
+	async resolveProcedure(entry) {
+		entry.procedure = await resolveContractProcedure(this.rootRouter, entry.contract, entry.path);
+		return entry.procedure;
+	}
+};
+export { RPCMatcher, RPC_DEFAULT_ALLOW_METHODS };

package/dist/adapters/standard/utils.d.ts

@@ -1,10 +1,10 @@
-import type { Promisable, Value } from '@orpc/shared';
-import type { StandardLazyRequest } from '@standard-server/core';
-import type { Context } from '../../context.ts';
-import type { StandardHandlerHandleOptions } from './handler.ts';
-export type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
-    context?: Value<Promisable<T>, [request: StandardLazyRequest]> | undefined;
+import { Context } from "../../context.js";
+import { StandardHandlerHandleOptions } from "./handler.js";
+import { Promisable, Value } from "@orpc/shared";
+import { StandardLazyRequest } from "@standard-server/core";
+export type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, "context"> & (object extends T ? {
+  context?: Value<Promisable<T>, [request: StandardLazyRequest]> | undefined;
 } : {
-    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+  context: Value<Promisable<T>, [request: StandardLazyRequest]>;
 });
-export declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
+export declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;

package/dist/adapters/standard/utils.js

@@ -1,6 +1,8 @@
-export function resolveFriendlyStandardHandlerHandleOptions(options) {
-    return {
-        ...options,
-        context: options.context ?? {}, // Context only optional if all fields are optional
-    };
+// src/adapters/standard/utils.ts
+function resolveFriendlyStandardHandlerHandleOptions(options) {
+	return {
+		...options,
+		context: options.context ?? {}
+	};
 }
+export { resolveFriendlyStandardHandlerHandleOptions };

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

@@ -1 +1,2 @@
-export * from './utils.ts';
+import { createStandardPeerRequestHandler } from "./utils.js";
+export { createStandardPeerRequestHandler };

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

@@ -1 +1 @@
-export * from './utils.js';
+export { createStandardPeerRequestHandler } from "./utils.js";

package/dist/adapters/standard-peer/utils.d.ts

@@ -1,4 +1,6 @@
-import type { StandardLazyRequest, StandardResponse } from '@standard-server/core';
-import type { Context } from '../../context.ts';
-import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from '../standard/index.ts';
-export declare function createStandardPeerRequestHandler<T extends Context>(handler: StandardHandler<T>, options: FriendlyStandardHandlerHandleOptions<T>): (request: StandardLazyRequest) => Promise<StandardResponse>;
+import { Context } from "../../context.js";
+import { StandardHandler } from "../standard/handler.js";
+import { FriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+import "../standard/index.js";
+import { StandardLazyRequest, StandardResponse } from "@standard-server/core";
+export declare function createStandardPeerRequestHandler<T extends Context>(handler: StandardHandler<T>, options: FriendlyStandardHandlerHandleOptions<T>): (request: StandardLazyRequest) => Promise<StandardResponse>;

package/dist/adapters/standard-peer/utils.js

@@ -1,7 +1,13 @@
-import { resolveFriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-export function createStandardPeerRequestHandler(handler, options) {
-    return async (request) => {
-        const { response } = await handler.handle(request, resolveFriendlyStandardHandlerHandleOptions(options));
-        return response ?? { status: 404, headers: {}, body: 'No procedure matched' };
-    };
+import { resolveFriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+// src/adapters/standard-peer/utils.ts
+function createStandardPeerRequestHandler(handler, options) {
+	return async (request) => {
+		const { response } = await handler.handle(request, resolveFriendlyStandardHandlerHandleOptions(options));
+		return response ?? {
+			status: 404,
+			headers: {},
+			body: "No procedure matched"
+		};
+	};
 }
+export { createStandardPeerRequestHandler };