@orpc/server 2.0.0-beta.47 → 2.0.0-beta.48

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

@@ -0,0 +1,140 @@
+import { normalizeHttpPath, pathToHttpPath, value } from "@orpc/shared";
+import { unlazy } from "../../lazy.mjs";
+import { Procedure } from "../../procedure.mjs";
+import { resolveContractProcedure, walkProcedureContractsSync } from "../../router-utils.mjs";
+
+export const RPC_DEFAULT_ALLOW_METHODS = [
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE"
+];
+
+const NORMALIZABLE_PATHNAME_REGEX = /[^\w\-.!~*'()/]/;
+export class RPCMatcher {
+	filter;
+	allowMethodsSet;
+	allowMethodsFn;
+	rootRouter;
+	tree = new Map();
+	pendingLazyRouters = new Map();
+	
+	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 : 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);
+		}
+		
+		const loading = this.resolvePendingLazyRouters(pathname);
+		if (loading !== undefined) {
+			await loading;
+		}
+		let entry = this.tree.get(pathname);
+		if (entry === undefined && NORMALIZABLE_PATHNAME_REGEX.test(pathname)) {
+			
+			
+			
+			const normalizedPathname = normalizeHttpPath(pathname);
+			
+			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;
+		
+		
+		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);
+		
+		
+		this.pendingLazyRouters.delete(httpPathPrefix);
+	}
+	async resolveProcedure(entry) {
+		entry.procedure = await resolveContractProcedure(this.rootRouter, entry.contract, entry.path);
+		return entry.procedure;
+	}
+}

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

@@ -0,0 +1,10 @@
+import type { Promisable, Value } from "@orpc/shared";
+import type { StandardLazyRequest } from "@standard-server/core";
+import type { Context } from "../../context.mjs";
+import type { StandardHandlerHandleOptions } from "./handler.mjs";
+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]>;
+});
+export declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;

package/dist/adapters/standard/utils.mjs

@@ -0,0 +1,6 @@
+export function resolveFriendlyStandardHandlerHandleOptions(options) {
+	return {
+		...options,
+		context: options.context ?? {}
+	};
+}

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

@@ -1,11 +1 @@
-import { StandardLazyRequest, StandardResponse } from '@standard-server/core';
-import { Context } from '../../index.mjs';
-import { StandardHandler } from '../standard/index.mjs';
-import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
-import '@orpc/client';
-import '@orpc/contract';
-import '@orpc/shared';
-
-declare function createStandardPeerRequestHandler<T extends Context>(handler: StandardHandler<T>, options: FriendlyStandardHandlerHandleOptions<T>): (request: StandardLazyRequest) => Promise<StandardResponse>;
-
-export { createStandardPeerRequestHandler };
+export * from "./utils.mjs";

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

@@ -1,10 +1 @@
-import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
-
-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 };
+export * from "./utils.mjs";

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

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

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

@@ -0,0 +1,11 @@
+import { resolveFriendlyStandardHandlerHandleOptions } from "../standard/index.mjs";
+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"
+		};
+	};
+}

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

@@ -0,0 +1,55 @@
+import type { Arrayable, MaybeOptionalOptions } from "@orpc/shared";
+import type { DecodePeerMessageOptions, EncodePeerMessageOptions } from "@standard-server/peer";
+import type { Context } from "../../context.mjs";
+import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from "../standard/index.mjs";
+/**
+* Supports standard WebSocket instances, Bun ServerWebSocket, "ws" ServerWebSocket,
+* Cloudflare WebSocket Hibernation, and similar implementations.
+*/
+export type WebSocketLike = {
+	send: (data: string | Uint8Array<ArrayBuffer>) => unknown;
+};
+export 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;
+}
+export 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>>);
+	/**
+	* Handles a single WebSocket message.
+	*
+	* Message order matters. Call this immediately after receiving a message,
+	* before any other async work, to preserve ordering.
+	*
+	* To avoid async Blob reads, configure `ws.binaryType` to return binary data
+	* directly (for example, `arraybuffer`).
+	*
+	* @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: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, "buffer" | "byteOffset" | "byteLength">>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
+		matched: boolean;
+	}>;
+	/**
+	* Cleans up peer state for a closed WebSocket.
+	*
+	* @param ws The same WebSocket instance passed to `.message()`.
+	*/
+	close(ws: WebSocketLike): Promise<void>;
+	/**
+	* Attaches message, close, and error event listeners to a WebSocket.
+	*
+	* Prefer this over calling `.message()` and `.close()` manually.
+	*/
+	upgrade(ws: Pick<WebSocket, "send" | "addEventListener" | "removeEventListener">, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
+}

package/dist/adapters/websocket/handler.mjs

@@ -0,0 +1,55 @@
+import { loadBytes, resolveMaybeOptionalOptions, sequential, toStringOrBytes } from "@orpc/shared";
+import { decodePeerMessage, encodePeerMessage, isClientPeerSendMessage, ServerPeer } from "@standard-server/peer";
+import { createStandardPeerRequestHandler } from "../standard-peer/index.mjs";
+export class WebSocketHandler {
+	handler;
+	peers = new WeakMap();
+	encodePeerMessageOptions;
+	decodePeerMessageOptions;
+	constructor(handler, options = {}) {
+		this.handler = handler;
+		this.encodePeerMessageOptions = options.encodePeerMessage;
+		this.decodePeerMessageOptions = options.decodePeerMessage;
+	}
+	
+	async message(ws, data, ...rest) {
+		let peer = this.peers.get(ws);
+		if (!peer) {
+			this.peers.set(ws, peer = new ServerPeer(async (message) => {
+				const encoded = await encodePeerMessage(message, this.encodePeerMessageOptions);
+				await ws.send(encoded);
+			}));
+		}
+		
+		const encoded = 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;
+	}
+	
+	async close(ws) {
+		const peer = this.peers.get(ws);
+		if (peer) {
+			
+			this.peers.delete(ws);
+			await peer.close();
+		}
+	}
+	
+	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));
+		
+		
+		ws.addEventListener("error", () => {});
+	}
+}

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

@@ -1,77 +1,2 @@
-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 '@standard-server/core';
-
-/**
- * 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..
-     */
-    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>>);
-    /**
-     * Handles a single WebSocket message.
-     *
-     * Message order matters. Call this immediately after receiving a message,
-     * before any other async work, to preserve ordering.
-     *
-     * To avoid async Blob reads, configure `ws.binaryType` to return binary data
-     * directly (for example, `arraybuffer`).
-     *
-     * @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: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
-        matched: boolean;
-    }>;
-    /**
-     * Cleans up peer state for a closed WebSocket.
-     *
-     * @param ws The same WebSocket instance passed to `.message()`.
-     */
-    close(ws: WebSocketLike): Promise<void>;
-    /**
-     * Attaches message, close, and error event listeners to a WebSocket.
-     *
-     * Prefer this over calling `.message()` and `.close()` manually.
-     */
-    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
-}
-
-interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<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 * from "./handler.mjs";
+export * from "./rpc-handler.mjs";

package/dist/adapters/websocket/index.mjs

@@ -1,87 +1,2 @@
-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.Chq5FpXf.mjs';
-import '../../shared/server.W91HSRkE.mjs';
-import '@orpc/client';
-import '@standard-server/core';
-import '../../shared/server.BB464y-6.mjs';
-import '@orpc/contract';
-import '../../shared/server.CYbIpHbH.mjs';
-
-class WebSocketHandler {
-  constructor(handler, options = {}) {
-    this.handler = handler;
-    this.encodePeerMessageOptions = options.encodePeerMessage;
-    this.decodePeerMessageOptions = options.decodePeerMessage;
-  }
-  peers = /* @__PURE__ */ new WeakMap();
-  encodePeerMessageOptions;
-  decodePeerMessageOptions;
-  /**
-   * Handles a single WebSocket message.
-   *
-   * Message order matters. Call this immediately after receiving a message,
-   * before any other async work, to preserve ordering.
-   *
-   * To avoid async Blob reads, configure `ws.binaryType` to return binary data
-   * directly (for example, `arraybuffer`).
-   *
-   * @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) => {
-        const encoded2 = await encodePeerMessage(message, this.encodePeerMessageOptions);
-        await ws.send(encoded2);
-      }));
-    }
-    const encoded = 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;
-  }
-  /**
-   * Cleans up peer state for a closed WebSocket.
-   *
-   * @param ws The same WebSocket instance passed to `.message()`.
-   */
-  async close(ws) {
-    const peer = this.peers.get(ws);
-    if (peer) {
-      this.peers.delete(ws);
-      await peer.close();
-    }
-  }
-  /**
-   * Attaches message, close, and error 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));
-    ws.addEventListener("error", () => {
-    });
-  }
-}
-
-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 };
+export * from "./handler.mjs";
+export * from "./rpc-handler.mjs";

package/dist/adapters/websocket/rpc-handler.d.mts

@@ -0,0 +1,15 @@
+import type { Context } from "../../context.mjs";
+import type { Router } from "../../router.mjs";
+import type { RPCHandlerCodecOptions, StandardHandlerOptions } from "../standard/index.mjs";
+import type { WebSocketHandlerOptions } from "./handler.mjs";
+import { WebSocketHandler } from "./handler.mjs";
+export interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<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}
+*/
+export declare class RPCHandler<T extends Context> extends WebSocketHandler<T> {
+	constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}

package/dist/adapters/websocket/rpc-handler.mjs

@@ -0,0 +1,10 @@
+import { RPCHandlerCodec, StandardHandler } from "../standard/index.mjs";
+import { WebSocketHandler } from "./handler.mjs";
+
+export class RPCHandler extends WebSocketHandler {
+	constructor(router, options = {}) {
+		const codec = new RPCHandlerCodec(router, options);
+		const handler = new StandardHandler(codec, options);
+		super(handler, options);
+	}
+}