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

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

@@ -1,8 +1,8 @@
 import { ORPCError, toORPCError, RPCSerializer, COMMON_ERROR_STATUS_MAP } from '@orpc/client';
-import { sortPlugins, getOpenTelemetryConfig, runWithSpan, toArray, matchesHttpPathPrefix, intercept, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, recordSpanError, pathToHttpPath, normalizeHttpPath, value, parseEmptyableJSON, getOwn } from '@orpc/shared';
-import { flattenStandardHeader, parseStandardUrl } from '@standard-server/core';
-import { c as createProcedureClient, u as unlazy, P as Procedure } from './server.CDOFCg6A.mjs';
-import { w as walkProcedureContractsSync, g as getRouter, c as createContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.gXC5UaAH.mjs';
+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.BynNaBBA.mjs';
 
 class CompositeStandardHandlerPlugin {
   name = "~composite";
@@ -24,8 +24,8 @@ class StandardHandler {
   constructor(codec, options) {
     this.codec = codec;
     options = new CompositeStandardHandlerPlugin([
-      new OtelHandlerPlugin(),
-      ...toArray(options.plugins)
+      ...toArray(options.plugins),
+      new TracingHandlerPlugin()
     ]).init(options);
     this.routingInterceptors = options.routingInterceptors;
     this.interceptors = options.interceptors;
@@ -34,15 +34,17 @@ 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 },
       async ({ context: context2, prefix: prefix2, request: request2 }) => {
-        const span = getOpenTelemetryConfig()?.trace.getActiveSpan();
+        const span = getTracer()?.getActiveSpan();
         let step;
         const matchedOrNot = await runWithSpan("find_procedure", () => this.codec.resolveProcedure(request2, { context: context2, prefix: prefix2 }));
         if (!matchedOrNot) {
@@ -63,8 +65,10 @@ class StandardHandler {
               step = "decode_input";
               let input = await runWithSpan("decode_input", decodeInput2);
               step = void 0;
-              if (isAsyncIteratorObject(input)) {
+              if (getTracer() && isAsyncIteratorObject(input)) {
                 input = override(input, traceAsyncIterator("consume_async_iterator_object_input", input));
+              } else if (getTracer() && input instanceof ReadableStream) {
+                input = override(input, traceReadableStream("consume_octet_stream_input", input));
               }
               const client = createProcedureClient(procedure2, {
                 context: context3,
@@ -97,23 +101,80 @@ class StandardHandler {
     );
   }
 }
-class OtelHandlerPlugin {
-  name = "~opentelemetry";
+class TracingHandlerPlugin {
+  name = "~tracing";
   init(options) {
     return {
       ...options,
       routingInterceptors: [
-        // Should be placed before user-provided interceptors to help them access the current active context.
+        // Should be placed before user-provided interceptors to help them access the current active span.
         async ({ next, request }) => {
-          const otelConfig = getOpenTelemetryConfig();
-          let propagationContext;
-          if (otelConfig?.propagation) {
-            propagationContext = otelConfig.propagation.extract(otelConfig.context.active(), request.headers);
+          const tracer = getTracer();
+          if (!tracer) {
+            return next();
           }
-          return runWithSpan(
-            { name: `${request.method} ${request.url}`, context: propagationContext },
-            () => next()
-          );
+          const parent = tracer.extract?.(request.headers);
+          const [pathname] = parseStandardUrl(request.url);
+          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)
       ]
@@ -301,4 +362,4 @@ class RPCHandlerCodec {
   }
 }
 
-export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, RPCHandlerCodec as R, StandardHandler as S, RPCMatcher as a, RPC_DEFAULT_ALLOW_METHODS as b };
+export { CompositeStandardHandlerPlugin as C, RPCHandlerCodec as R, StandardHandler as S, TracingHandlerPlugin as T, RPCMatcher as a, RPC_DEFAULT_ALLOW_METHODS as b };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "2.0.0-beta.34",
+  "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.34",
-    "@orpc/contract": "2.0.0-beta.34",
-    "@orpc/shared": "2.0.0-beta.34",
+    "@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.ByvwIMbH.d.mts

@@ -1,91 +0,0 @@
-import { RPCSerializer, AnyORPCError } from '@orpc/client';
-import { Value, Promisable } from '@orpc/shared';
-import { StandardMethod, StandardLazyRequest, StandardResponse } from '@standard-server/core';
-import { A as AnyProcedure, C as Context } from './server.BsujoJoF.mjs';
-import { A as AnyRouter } from './server.BpmUhems.mjs';
-import { AnyProcedureContract } from '@orpc/contract';
-import { c as StandardHandlerHandleOptions, d as StandardHandlerCodec, e as StandardHandlerCodecResolvedProcedure } from './server.BrURRtO7.mjs';
-
-/**
- * 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?: Pick<RPCSerializer, keyof 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.CAmrY_mX.d.ts

@@ -1,91 +0,0 @@
-import { RPCSerializer, AnyORPCError } from '@orpc/client';
-import { Value, 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.D23TTT5i.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?: Pick<RPCSerializer, keyof 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 };