@orpc/server 2.0.0-beta.35 → 2.0.0-beta.36

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

@@ -2,7 +2,7 @@ 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 { StandardPeerRequestHandlerOptions } from '../standard-peer/index.mjs';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
 import { Router } from '../../index.mjs';
 import { RPCHandlerCodecOptions } from '../standard/index.mjs';
 import '@orpc/client';
@@ -44,7 +44,7 @@ declare class WebSocketHandler<T extends Context> {
      * @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<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
@@ -58,7 +58,7 @@ declare class WebSocketHandler<T extends Context> {
      *
      * Prefer this over calling `.message()` and `.close()` manually.
      */
-    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
+    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
 }
 
 interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {

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

@@ -2,7 +2,7 @@ import { Arrayable, MaybeOptionalOptions } from '@orpc/shared';
 import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standard-server/peer';
 import { Context } from '../../index.js';
 import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
-import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.js';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
 import { Router } from '../../index.js';
 import { RPCHandlerCodecOptions } from '../standard/index.js';
 import '@orpc/client';
@@ -44,7 +44,7 @@ declare class WebSocketHandler<T extends Context> {
      * @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<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
@@ -58,7 +58,7 @@ declare class WebSocketHandler<T extends Context> {
      *
      * Prefer this over calling `.message()` and `.close()` manually.
      */
-    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
+    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
 }
 
 interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {

package/dist/adapters/websocket/index.mjs

@@ -1,12 +1,13 @@
 import { toStringOrBytes, resolveMaybeOptionalOptions, sequential, loadBytes } from '@orpc/shared';
 import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage } from '@standard-server/peer';
-import { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.sNWd6DAG.mjs';
+import { createStandardPeerRequestHandler } from '../standard-peer/index.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.vUIzQiOP.mjs';
+import '../../shared/server.W91HSRkE.mjs';
 import '@orpc/client';
 import '@standard-server/core';
 import '../../shared/server.Djb_ebJT.mjs';
 import '@orpc/contract';
-import '../../shared/server.BYnwk7Xz.mjs';
+import '../../shared/server.BynNaBBA.mjs';
 
 class WebSocketHandler {
   constructor(handler, options = {}) {

package/dist/index.mjs

@@ -5,8 +5,8 @@ export { AsyncIteratorClass, asyncIteratorToStream, asyncIteratorToUnproxiedData
 import { L as Lazy, P as Procedure, c as createProcedureClient } from './shared/server.Djb_ebJT.mjs';
 export { u as unlazy } from './shared/server.Djb_ebJT.mjs';
 import { D as DecoratedProcedure } from './shared/server.24nXyhbl.mjs';
-import { b as augmentRouter, d as augmentImplementedRouter, e as withHiddenRouterContract, f as createGuardedProcedureLazy, g as getRouter } from './shared/server.BYnwk7Xz.mjs';
-export { a as DEFAULT_ERROR_STATUS, D as DEFAULT_SUCCESS_STATUS, h as call, c as createContractProcedure, i as getHiddenRouterContract, u as unlazyRouter, j as walkProcedureContractsAsync, w as walkProcedureContractsSync } from './shared/server.BYnwk7Xz.mjs';
+import { b as augmentRouter, d as augmentImplementedRouter, e as withHiddenRouterContract, f as createGuardedProcedureLazy, g as getRouter } from './shared/server.BynNaBBA.mjs';
+export { a as DEFAULT_ERROR_STATUS, D as DEFAULT_SUCCESS_STATUS, h as call, c as createContractProcedure, i as getHiddenRouterContract, u as unlazyRouter, j as walkProcedureContractsAsync, w as walkProcedureContractsSync } from './shared/server.BynNaBBA.mjs';
 import { RECURSIVE_CLIENT_UNWRAP_KEYS } from '@orpc/client';
 export { COMMON_ERROR_STATUS_MAP, ORPCError, RPCJsonSerializer, RPCSerializer, cloneORPCError, isDefinedError, safe, toORPCError } from '@orpc/client';
 export { ErrorEvent, getEventMeta, unwrapEvent, withEventMeta } from '@standard-server/core';
@@ -388,13 +388,11 @@ function createRouterImplementerInternal(contract, config, middlewares) {
     });
   }
   const implementer = {};
-  for (const key in contract) {
-    const child = contract[key];
+  for (const [key, child] of Object.entries(contract)) {
     implementer[key] = createRouterImplementerInternal(child, config, middlewares);
   }
   const shared = bindMethods(SharedRouterImplementer.create(contract, config, middlewares));
-  for (const key in shared) {
-    const method = shared[key];
+  for (const [key, method] of Object.entries(shared)) {
     if (key in implementer) {
       const child = implementer[key];
       implementer[key] = new Proxy(method, {

package/dist/plugins/index.d.mts

@@ -2,7 +2,7 @@ import { Value, Promisable, ThrowableError } from '@orpc/shared';
 import { StandardLazyRequest, StandardHeaders, StandardMethod } from '@standard-server/core';
 import { Context } from '../index.mjs';
 import { StandardHandlerPlugin, StandardHandlerRoutingInterceptorOptions, StandardHandlerOptions, StandardHandlerInterceptorOptions } from '../adapters/standard/index.mjs';
-export { R as RequestLimitHandlerPlugin, a as RequestLimitHandlerPluginOptions } from '../shared/server.CAiLRqPf.mjs';
+export { R as RequestLimitHandlerPlugin, a as RequestLimitHandlerPluginOptions } from '../shared/server.C7xllBNN.mjs';
 import '@orpc/client';
 import '@orpc/contract';
 

package/dist/plugins/index.d.ts

@@ -2,7 +2,7 @@ import { Value, Promisable, ThrowableError } from '@orpc/shared';
 import { StandardLazyRequest, StandardHeaders, StandardMethod } from '@standard-server/core';
 import { Context } from '../index.js';
 import { StandardHandlerPlugin, StandardHandlerRoutingInterceptorOptions, StandardHandlerOptions, StandardHandlerInterceptorOptions } from '../adapters/standard/index.js';
-export { R as RequestLimitHandlerPlugin, a as RequestLimitHandlerPluginOptions } from '../shared/server.b2-J4t6T.js';
+export { R as RequestLimitHandlerPlugin, a as RequestLimitHandlerPluginOptions } from '../shared/server.D0dr-F8u.js';
 import '@orpc/client';
 import '@orpc/contract';
 

package/dist/shared/{server.R0uHWfBo.d.mts → server.B5K1CViq.d.mts}

@@ -1,5 +1,5 @@
 import { AnyORPCError } from '@orpc/client';
-import { OrderablePlugin, Interceptor, Promisable } from '@orpc/shared';
+import { OrderablePlugin, Value, Promisable, Interceptor } from '@orpc/shared';
 import { StandardLazyRequest, StandardResponse } from '@standard-server/core';
 import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.BsujoJoF.mjs';
 import { Schema, ErrorMap } from '@orpc/contract';
@@ -36,6 +36,17 @@ declare class CompositeStandardHandlerPlugin<T extends Context> implements Stand
 
 interface StandardHandlerHandleOptions<T extends Context> {
     prefix?: `/${string}` | undefined;
+    /**
+     * The initial context, or a function (sync or async) that receives the request and returns it.
+     * The function only runs once the request passes the prefix check.
+     */
+    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+}
+/**
+ * `StandardHandlerHandleOptions` after the context has been resolved,
+ * this is what interceptors and codecs receive.
+ */
+interface ResolvedStandardHandlerHandleOptions<T extends Context> extends Omit<StandardHandlerHandleOptions<T>, 'context'> {
     context: T;
 }
 type StandardHandlerHandleResult = {
@@ -45,11 +56,11 @@ type StandardHandlerHandleResult = {
     matched: false;
     response?: undefined;
 };
-interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, StandardHandlerHandleOptions<T> {
+interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, ResolvedStandardHandlerHandleOptions<T> {
     request: StandardLazyRequest;
 }
 type StandardHandlerInterceptor<T extends Context> = Interceptor<StandardHandlerInterceptorOptions<T>, Promise<StandardResponse>>;
-interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
+interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends ResolvedStandardHandlerHandleOptions<T> {
     request: StandardLazyRequest;
 }
 type StandardHandlerRoutingInterceptor<T extends Context> = Interceptor<StandardHandlerRoutingInterceptorOptions<T>, Promise<StandardHandlerHandleResult>>;
@@ -82,7 +93,7 @@ declare class StandardHandler<T extends Context> {
     private readonly interceptors;
     private readonly clientInterceptors;
     constructor(codec: StandardHandlerCodec<T>, options: StandardHandlerOptions<T>);
-    handle(request: StandardLazyRequest, { context, prefix }: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
+    handle(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
 }
 declare class TracingHandlerPlugin implements StandardHandlerPlugin<any> {
     name: string;
@@ -95,10 +106,10 @@ interface StandardHandlerCodecResolvedProcedure {
     decodeInput: () => Promise<unknown>;
 }
 interface StandardHandlerCodec<T extends Context> {
-    resolveProcedure(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promisable<StandardHandlerCodecResolvedProcedure | undefined>;
-    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-    encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    resolveProcedure(request: StandardLazyRequest, options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardHandlerCodecResolvedProcedure | undefined>;
+    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
 }
 
-export { CompositeStandardHandlerPlugin as C, TracingHandlerPlugin as T, StandardHandler as b };
-export type { StandardHandlerPlugin as S, StandardHandlerOptions as a, StandardHandlerHandleOptions as c, StandardHandlerCodec as d, StandardHandlerCodecResolvedProcedure as e, StandardHandlerRoutingInterceptorOptions as f, StandardHandlerInterceptorOptions as g, StandardHandlerHandleResult as h, StandardHandlerInterceptor as i, StandardHandlerRoutingInterceptor as j };
+export { CompositeStandardHandlerPlugin as C, StandardHandler as S, TracingHandlerPlugin as T };
+export type { ResolvedStandardHandlerHandleOptions as R, StandardHandlerHandleOptions as a, StandardHandlerPlugin as b, StandardHandlerOptions as c, StandardHandlerRoutingInterceptorOptions as d, StandardHandlerInterceptorOptions as e, StandardHandlerCodec as f, StandardHandlerCodecResolvedProcedure as g, StandardHandlerHandleResult as h, StandardHandlerInterceptor as i, StandardHandlerRoutingInterceptor as j };

package/dist/shared/{server.BYnwk7Xz.mjs → server.BynNaBBA.mjs}

@@ -93,8 +93,8 @@ function augmentRouter(router, options) {
     return router;
   }
   const enhanced = {};
-  for (const key in router) {
-    enhanced[key] = augmentRouter(router[key], options);
+  for (const [key, child] of Object.entries(router)) {
+    enhanced[key] = augmentRouter(child, options);
   }
   return enhanced;
 }
@@ -125,8 +125,8 @@ function augmentImplementedRouter(router, options) {
     return router;
   }
   const enhanced = {};
-  for (const key in router) {
-    enhanced[key] = augmentImplementedRouter(router[key], options);
+  for (const [key, child] of Object.entries(router)) {
+    enhanced[key] = augmentImplementedRouter(child, options);
   }
   return enhanced;
 }
@@ -177,8 +177,7 @@ function walkProcedureContractsSyncInternal(router, callback, path, lazyResults)
   if (!isTypescriptObject(router)) {
     return;
   }
-  for (const key in router) {
-    const value = router[key];
+  for (const [key, value] of Object.entries(router)) {
     path.push(key);
     if (value instanceof Lazy) {
       lazyResults.push({ router: value, path: path.slice() });
@@ -200,8 +199,7 @@ async function walkProcedureContractsAsync(router, callback, path = []) {
   if (!isTypescriptObject(router)) {
     return;
   }
-  for (const key in router) {
-    const value = router[key];
+  for (const [key, value] of Object.entries(router)) {
     if (value instanceof Lazy) {
       const { default: router2 } = await unlazy(value);
       await walkProcedureContractsAsync(router2, callback, [...path, key]);
@@ -218,7 +216,7 @@ async function unlazyRouter(router) {
     return router;
   }
   const unlazied = {};
-  for (const key in router) {
+  for (const key of Object.keys(router)) {
     const item = router[key];
     const { default: unlaziedRouter } = await unlazy(item);
     unlazied[key] = await unlazyRouter(unlaziedRouter);

package/dist/shared/{server.CAiLRqPf.d.mts → server.C7xllBNN.d.mts}

@@ -1,5 +1,5 @@
 import { C as Context } from './server.BsujoJoF.mjs';
-import { S as StandardHandlerPlugin, a as StandardHandlerOptions } from './server.R0uHWfBo.mjs';
+import { b as StandardHandlerPlugin, c as StandardHandlerOptions } from './server.B5K1CViq.mjs';
 
 interface RequestLimitHandlerPluginOptions {
     /**

package/dist/shared/server.CFqSIFnT.d.mts

@@ -0,0 +1,14 @@
+import { Value, Promisable } from '@orpc/shared';
+import { StandardLazyRequest } from '@standard-server/core';
+import { C as Context } from './server.BsujoJoF.mjs';
+import { a as StandardHandlerHandleOptions } from './server.B5K1CViq.mjs';
+
+type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
+    context?: Value<Promisable<T>, [request: StandardLazyRequest]>;
+} : {
+    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+});
+declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
+
+export { resolveFriendlyStandardHandlerHandleOptions as r };
+export type { FriendlyStandardHandlerHandleOptions as F };

package/dist/shared/{server.DEeCcNd6.d.ts → server.Cxranw-8.d.ts}

@@ -1,5 +1,5 @@
 import { AnyORPCError } from '@orpc/client';
-import { OrderablePlugin, Interceptor, Promisable } from '@orpc/shared';
+import { OrderablePlugin, Value, Promisable, Interceptor } from '@orpc/shared';
 import { StandardLazyRequest, StandardResponse } from '@standard-server/core';
 import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.BsujoJoF.js';
 import { Schema, ErrorMap } from '@orpc/contract';
@@ -36,6 +36,17 @@ declare class CompositeStandardHandlerPlugin<T extends Context> implements Stand
 
 interface StandardHandlerHandleOptions<T extends Context> {
     prefix?: `/${string}` | undefined;
+    /**
+     * The initial context, or a function (sync or async) that receives the request and returns it.
+     * The function only runs once the request passes the prefix check.
+     */
+    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+}
+/**
+ * `StandardHandlerHandleOptions` after the context has been resolved,
+ * this is what interceptors and codecs receive.
+ */
+interface ResolvedStandardHandlerHandleOptions<T extends Context> extends Omit<StandardHandlerHandleOptions<T>, 'context'> {
     context: T;
 }
 type StandardHandlerHandleResult = {
@@ -45,11 +56,11 @@ type StandardHandlerHandleResult = {
     matched: false;
     response?: undefined;
 };
-interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, StandardHandlerHandleOptions<T> {
+interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, ResolvedStandardHandlerHandleOptions<T> {
     request: StandardLazyRequest;
 }
 type StandardHandlerInterceptor<T extends Context> = Interceptor<StandardHandlerInterceptorOptions<T>, Promise<StandardResponse>>;
-interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
+interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends ResolvedStandardHandlerHandleOptions<T> {
     request: StandardLazyRequest;
 }
 type StandardHandlerRoutingInterceptor<T extends Context> = Interceptor<StandardHandlerRoutingInterceptorOptions<T>, Promise<StandardHandlerHandleResult>>;
@@ -82,7 +93,7 @@ declare class StandardHandler<T extends Context> {
     private readonly interceptors;
     private readonly clientInterceptors;
     constructor(codec: StandardHandlerCodec<T>, options: StandardHandlerOptions<T>);
-    handle(request: StandardLazyRequest, { context, prefix }: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
+    handle(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
 }
 declare class TracingHandlerPlugin implements StandardHandlerPlugin<any> {
     name: string;
@@ -95,10 +106,10 @@ interface StandardHandlerCodecResolvedProcedure {
     decodeInput: () => Promise<unknown>;
 }
 interface StandardHandlerCodec<T extends Context> {
-    resolveProcedure(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promisable<StandardHandlerCodecResolvedProcedure | undefined>;
-    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-    encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    resolveProcedure(request: StandardLazyRequest, options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardHandlerCodecResolvedProcedure | undefined>;
+    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
 }
 
-export { CompositeStandardHandlerPlugin as C, TracingHandlerPlugin as T, StandardHandler as b };
-export type { StandardHandlerPlugin as S, StandardHandlerOptions as a, StandardHandlerHandleOptions as c, StandardHandlerCodec as d, StandardHandlerCodecResolvedProcedure as e, StandardHandlerRoutingInterceptorOptions as f, StandardHandlerInterceptorOptions as g, StandardHandlerHandleResult as h, StandardHandlerInterceptor as i, StandardHandlerRoutingInterceptor as j };
+export { CompositeStandardHandlerPlugin as C, StandardHandler as S, TracingHandlerPlugin as T };
+export type { ResolvedStandardHandlerHandleOptions as R, StandardHandlerHandleOptions as a, StandardHandlerPlugin as b, StandardHandlerOptions as c, StandardHandlerRoutingInterceptorOptions as d, StandardHandlerInterceptorOptions as e, StandardHandlerCodec as f, StandardHandlerCodecResolvedProcedure as g, StandardHandlerHandleResult as h, StandardHandlerInterceptor as i, StandardHandlerRoutingInterceptor as j };

package/dist/shared/{server.b2-J4t6T.d.ts → server.D0dr-F8u.d.ts}

@@ -1,5 +1,5 @@
 import { C as Context } from './server.BsujoJoF.js';
-import { S as StandardHandlerPlugin, a as StandardHandlerOptions } from './server.DEeCcNd6.js';
+import { b as StandardHandlerPlugin, c as StandardHandlerOptions } from './server.Cxranw-8.js';
 
 interface RequestLimitHandlerPluginOptions {
     /**

package/dist/shared/server.RRVK1xTV.d.ts

@@ -0,0 +1,14 @@
+import { Value, Promisable } from '@orpc/shared';
+import { StandardLazyRequest } from '@standard-server/core';
+import { C as Context } from './server.BsujoJoF.js';
+import { a as StandardHandlerHandleOptions } from './server.Cxranw-8.js';
+
+type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
+    context?: Value<Promisable<T>, [request: StandardLazyRequest]>;
+} : {
+    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+});
+declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
+
+export { resolveFriendlyStandardHandlerHandleOptions as r };
+export type { FriendlyStandardHandlerHandleOptions as F };

package/dist/shared/{server.sNWd6DAG.mjs → server.vUIzQiOP.mjs}

@@ -1,8 +1,8 @@
 import { ORPCError, toORPCError, RPCSerializer, COMMON_ERROR_STATUS_MAP } from '@orpc/client';
-import { sortPlugins, toArray, matchesHttpPathPrefix, intercept, getTracer, runWithSpan, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, traceReadableStream, recordSpanError, pathToHttpPath, normalizeHttpPath, value, parseEmptyableJSON, getOwn } from '@orpc/shared';
-import { flattenStandardHeader, parseStandardUrl } from '@standard-server/core';
+import { sortPlugins, toArray, matchesHttpPathPrefix, value, intercept, getTracer, runWithSpan, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, traceReadableStream, recordSpanError, toTracingException, wrapAsyncIterator, wrapReadableStream, pathToHttpPath, normalizeHttpPath, parseEmptyableJSON, getOwn } from '@orpc/shared';
+import { flattenStandardHeader, parseStandardUrl, ErrorEvent } from '@standard-server/core';
 import { c as createProcedureClient, u as unlazy, P as Procedure } from './server.Djb_ebJT.mjs';
-import { w as walkProcedureContractsSync, g as getRouter, c as createContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.BYnwk7Xz.mjs';
+import { w as walkProcedureContractsSync, g as getRouter, c as createContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.BynNaBBA.mjs';
 
 class CompositeStandardHandlerPlugin {
   name = "~composite";
@@ -24,8 +24,8 @@ class StandardHandler {
   constructor(codec, options) {
     this.codec = codec;
     options = new CompositeStandardHandlerPlugin([
-      new TracingHandlerPlugin(),
-      ...toArray(options.plugins)
+      ...toArray(options.plugins),
+      new TracingHandlerPlugin()
     ]).init(options);
     this.routingInterceptors = options.routingInterceptors;
     this.interceptors = options.interceptors;
@@ -34,10 +34,12 @@ class StandardHandler {
   routingInterceptors;
   interceptors;
   clientInterceptors;
-  async handle(request, { context, prefix }) {
+  async handle(request, options) {
+    const { prefix } = options;
     if (prefix && !matchesHttpPathPrefix(request.url, prefix)) {
       return { matched: false, response: void 0 };
     }
+    const context = await value(options.context, request);
     return intercept(
       this.routingInterceptors,
       { context, prefix, request },
@@ -108,12 +110,71 @@ class TracingHandlerPlugin {
         // Should be placed before user-provided interceptors to help them access the current active span.
         async ({ next, request }) => {
           const tracer = getTracer();
-          const parent = tracer?.extract?.(request.headers);
+          if (!tracer) {
+            return next();
+          }
+          const parent = tracer.extract?.(request.headers);
           const [pathname] = parseStandardUrl(request.url);
-          return runWithSpan(
-            { name: `${request.method} ${pathname}`, parent },
-            () => next()
-          );
+          const span = tracer.startSpan(`${request.method} ${pathname}`, parent);
+          let result;
+          try {
+            result = await tracer.withActiveSpan(span, next);
+          } catch (e) {
+            span.recordException("error", toTracingException(e));
+            span.end();
+            throw e;
+          }
+          if (!result.matched) {
+            span.end();
+            return result;
+          }
+          const body = result.response.body;
+          if (isAsyncIteratorObject(body)) {
+            return {
+              ...result,
+              response: {
+                ...result.response,
+                /**
+                 * @remarks
+                 * **Warning**: Remember use `override` for remaining special properties
+                 */
+                body: override(body, wrapAsyncIterator(body, {
+                  runWith: (fn) => tracer.withActiveSpan(span, fn),
+                  onError(error) {
+                    if (!(error instanceof ErrorEvent)) {
+                      span.recordException("error", toTracingException(error));
+                    }
+                  },
+                  onFinish() {
+                    span.end();
+                  }
+                }))
+              }
+            };
+          }
+          if (body instanceof ReadableStream) {
+            return {
+              ...result,
+              response: {
+                ...result.response,
+                /**
+                 * @remarks
+                 * **Warning**: Remember use `override` for remaining special properties
+                 */
+                body: override(body, wrapReadableStream(body, {
+                  runWith: (fn) => tracer.withActiveSpan(span, fn),
+                  onError(error) {
+                    span.recordException("error", toTracingException(error));
+                  },
+                  onFinish() {
+                    span.end();
+                  }
+                }))
+              }
+            };
+          }
+          span.end();
+          return result;
         },
         ...toArray(options.routingInterceptors)
       ]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "2.0.0-beta.35",
+  "version": "2.0.0-beta.36",
   "description": "Build typesafe APIs with oRPC: RPC and OpenAPI support, middleware, and adapters for Node.js, Bun, Deno, Fetch, Fastify, WebSocket, AWS Lambda, and more",
   "license": "MIT",
   "funding": [
@@ -117,9 +117,9 @@
     }
   },
   "dependencies": {
-    "@orpc/client": "2.0.0-beta.35",
-    "@orpc/contract": "2.0.0-beta.35",
-    "@orpc/shared": "2.0.0-beta.35",
+    "@orpc/client": "2.0.0-beta.36",
+    "@orpc/contract": "2.0.0-beta.36",
+    "@orpc/shared": "2.0.0-beta.36",
     "@standard-server/aws-lambda": "~0.9.0",
     "@standard-server/core": "~0.9.0",
     "@standard-server/fastify": "~0.9.0",

package/dist/shared/server.BGMO5dst.d.ts

@@ -1,91 +0,0 @@
-import { RPCSerializer, AnyORPCError } from '@orpc/client';
-import { Value, Public, Promisable } from '@orpc/shared';
-import { StandardMethod, StandardLazyRequest, StandardResponse } from '@standard-server/core';
-import { A as AnyProcedure, C as Context } from './server.BsujoJoF.js';
-import { A as AnyRouter } from './server.CRwPbhLO.js';
-import { AnyProcedureContract } from '@orpc/contract';
-import { c as StandardHandlerHandleOptions, d as StandardHandlerCodec, e as StandardHandlerCodecResolvedProcedure } from './server.DEeCcNd6.js';
-
-/**
- * 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}
- */
-declare const RPC_DEFAULT_ALLOW_METHODS: readonly StandardMethod[];
-interface RPCMatcherOptions {
-    /**
-     * Filter which procedures are exposed for matching. Return `false` to exclude.
-     *
-     * @default true
-     */
-    filter?: Value<boolean, [procedure: AnyProcedureContract | AnyProcedure, path: string[]]>;
-    /**
-     * 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);
-}
-declare class RPCMatcher {
-    private readonly filter;
-    private readonly allowMethodsSet;
-    private readonly allowMethodsFn;
-    private readonly rootRouter;
-    private readonly tree;
-    private readonly pendingLazyRouters;
-    constructor(router: AnyRouter, options?: RPCMatcherOptions);
-    private index;
-    match(method: StandardMethod, pathname: `/${string}`, prefix: `/${string}` | undefined): Promise<{
-        path: string[];
-        procedure: AnyProcedure;
-    } | undefined>;
-    private resolvePendingLazyRouters;
-    private loadPendingLazyRouters;
-    private loadPendingLazyRouter;
-    private indexPendingLazyRouter;
-    private resolveProcedure;
-}
-
-interface RPCHandlerCodecOptions<T extends Context> extends RPCMatcherOptions {
-    /**
-     * Override the default RPC serializer.
-     */
-    serializer?: Public<RPCSerializer>;
-    /**
-     * Resolve HTTP status for encoded successful outputs.
-     *
-     * Value should be in the `2xx` range and must be less than `400`.
-     * Return `undefined` or `null` to fallback to default
-     *
-     * @default DEFAULT_SUCCESS_STATUS (200)
-     */
-    outputStatus?: Value<number | undefined | null, [output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>]>;
-    /**
-     * Mapping ORPCError Code -> HTTP Status Code
-     * The status code should be in the `4xx` or `5xx` range (must be greater than or equal to `400`).
-     *
-     * @default COMMON_ERROR_STATUS_MAP
-     */
-    errorStatusMap?: Record<string, number> | undefined;
-}
-declare class RPCHandlerCodec<T extends Context> implements StandardHandlerCodec<T> {
-    private readonly matcher;
-    private readonly serializer;
-    private readonly errorStatusMap;
-    private readonly outputStatus;
-    constructor(router: AnyRouter, options?: RPCHandlerCodecOptions<T>);
-    resolveProcedure(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerCodecResolvedProcedure | undefined>;
-    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-    encodeError(error: AnyORPCError, _procedure: AnyProcedure, _path: string[], _options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-}
-
-export { RPCHandlerCodec as a, RPCMatcher as b, RPC_DEFAULT_ALLOW_METHODS as d };
-export type { RPCHandlerCodecOptions as R, RPCMatcherOptions as c };

package/dist/shared/server.CX4vUnDk.mjs

@@ -1,11 +0,0 @@
-import { value } from '@orpc/shared';
-
-function createStandardPeerRequestHandler(handler, options) {
-  return async (request) => {
-    const context = await value(options.context ?? {}, request);
-    const { response } = await handler.handle(request, { ...options, context });
-    return response ?? { status: 404, headers: {}, body: "No procedure matched" };
-  };
-}
-
-export { createStandardPeerRequestHandler as c };