@orpc/server 0.0.0-next.7a6598d → 0.0.0-next.7b151dd

package/dist/plugins/index.mjs

@@ -1,5 +1,7 @@
-import { value, isAsyncIteratorObject } from '@orpc/shared';
+import { runWithSpan, value, setSpanError, isAsyncIteratorObject, clone } from '@orpc/shared';
+import { flattenHeader } from '@orpc/standard-server';
 import { parseBatchRequest, toBatchResponse } from '@orpc/standard-server/batch';
+import { toFetchHeaders } from '@orpc/standard-server-fetch';
 import { ORPCError } from '@orpc/client';
 export { S as StrictGetMethodPlugin } from '../shared/server.BW-nUGgA.mjs';
 import '@orpc/contract';
@@ -25,69 +27,80 @@ class BatchHandlerPlugin {
   init(options) {
     options.rootInterceptors ??= [];
     options.rootInterceptors.unshift(async (options2) => {
-      if (options2.request.headers["x-orpc-batch"] !== "1") {
+      const xHeader = flattenHeader(options2.request.headers["x-orpc-batch"]);
+      if (xHeader === void 0) {
         return options2.next();
       }
       let isParsing = false;
       try {
-        isParsing = true;
-        const parsed = parseBatchRequest({ ...options2.request, body: await options2.request.body() });
-        isParsing = false;
-        const maxSize = await value(this.maxSize, options2);
-        if (parsed.length > maxSize) {
-          return {
-            matched: true,
-            response: {
-              status: 413,
-              headers: {},
-              body: "Batch request size exceeds the maximum allowed size"
-            }
-          };
-        }
-        const responses = parsed.map(
-          (request, index) => {
-            const mapped = this.mapRequestItem(request, options2);
-            return options2.next({ ...options2, request: { ...mapped, body: () => Promise.resolve(mapped.body) } }).then(({ response: response2, matched }) => {
-              if (matched) {
-                if (response2.body instanceof Blob || response2.body instanceof FormData || isAsyncIteratorObject(response2.body)) {
-                  return {
-                    index,
-                    status: 500,
-                    headers: {},
-                    body: "Batch responses do not support file/blob, or event-iterator. Please call this procedure separately outside of the batch request."
-                  };
-                }
-                return { ...response2, index };
+        return await runWithSpan({ name: "handle_batch_request" }, async (span) => {
+          const mode = xHeader === "buffered" ? "buffered" : "streaming";
+          isParsing = true;
+          const parsed = parseBatchRequest({ ...options2.request, body: await options2.request.body() });
+          isParsing = false;
+          span?.setAttribute("batch.mode", mode);
+          span?.setAttribute("batch.size", parsed.length);
+          const maxSize = await value(this.maxSize, options2);
+          if (parsed.length > maxSize) {
+            const message = "Batch request size exceeds the maximum allowed size";
+            setSpanError(span, message);
+            return {
+              matched: true,
+              response: {
+                status: 413,
+                headers: {},
+                body: message
               }
-              return { index, status: 404, headers: {}, body: "No procedure matched" };
-            }).catch(() => {
-              return { index, status: 500, headers: {}, body: "Internal server error" };
-            });
+            };
           }
-        );
-        await Promise.race(responses);
-        const status = await value(this.successStatus, responses, options2);
-        const headers = await value(this.headers, responses, options2);
-        const response = toBatchResponse({
-          status,
-          headers,
-          body: async function* () {
-            const promises = [...responses];
-            while (true) {
-              const handling = promises.filter((p) => p !== void 0);
-              if (handling.length === 0) {
-                return;
-              }
-              const result = await Promise.race(handling);
-              promises[result.index] = void 0;
-              yield result;
+          const responses = parsed.map(
+            (request, index) => {
+              const mapped = this.mapRequestItem(request, options2);
+              return options2.next({ ...options2, request: { ...mapped, body: () => Promise.resolve(mapped.body) } }).then(({ response: response2, matched }) => {
+                span?.addEvent(`response.${index}.${matched ? "success" : "not_matched"}`);
+                if (matched) {
+                  if (response2.body instanceof Blob || response2.body instanceof FormData || isAsyncIteratorObject(response2.body)) {
+                    return {
+                      index,
+                      status: 500,
+                      headers: {},
+                      body: "Batch responses do not support file/blob, or event-iterator. Please call this procedure separately outside of the batch request."
+                    };
+                  }
+                  return { ...response2, index };
+                }
+                return { index, status: 404, headers: {}, body: "No procedure matched" };
+              }).catch((err) => {
+                Promise.reject(err);
+                return { index, status: 500, headers: {}, body: "Internal server error" };
+              });
             }
-          }()
+          );
+          await Promise.race(responses);
+          const status = await value(this.successStatus, responses, options2);
+          const headers = await value(this.headers, responses, options2);
+          const response = await toBatchResponse({
+            status,
+            headers,
+            mode,
+            body: async function* () {
+              const promises = [...responses];
+              while (true) {
+                const handling = promises.filter((p) => p !== void 0);
+                if (handling.length === 0) {
+                  return;
+                }
+                const result = await Promise.race(handling);
+                promises[result.index] = void 0;
+                yield result;
+              }
+            }()
+          });
+          return {
+            matched: true,
+            response
+          };
         });
-        return {
-          matched: true,
-          response
-        };
       } catch (cause) {
         if (isParsing) {
           return {
@@ -123,13 +136,11 @@ class CORSPlugin {
           resHeaders["access-control-max-age"] = this.options.maxAge.toString();
         }
         if (this.options.allowMethods?.length) {
-          resHeaders["access-control-allow-methods"] = this.options.allowMethods.join(",");
+          resHeaders["access-control-allow-methods"] = flattenHeader(this.options.allowMethods);
         }
         const allowHeaders = this.options.allowHeaders ?? interceptorOptions.request.headers["access-control-request-headers"];
-        if (Array.isArray(allowHeaders) && allowHeaders.length) {
-          resHeaders["access-control-allow-headers"] = allowHeaders.join(",");
-        } else if (typeof allowHeaders === "string") {
-          resHeaders["access-control-allow-headers"] = allowHeaders;
+        if (typeof allowHeaders === "string" || allowHeaders?.length) {
+          resHeaders["access-control-allow-headers"] = flattenHeader(allowHeaders);
         }
         return {
           matched: true,
@@ -147,7 +158,7 @@ class CORSPlugin {
       if (!result.matched) {
         return result;
       }
-      const origin = Array.isArray(interceptorOptions.request.headers.origin) ? interceptorOptions.request.headers.origin.join(",") : interceptorOptions.request.headers.origin || "";
+      const origin = flattenHeader(interceptorOptions.request.headers.origin) ?? "";
       const allowedOrigin = await value(this.options.origin, origin, interceptorOptions);
       const allowedOriginArr = Array.isArray(allowedOrigin) ? allowedOrigin : [allowedOrigin];
       if (allowedOriginArr.includes("*")) {
@@ -169,13 +180,29 @@ class CORSPlugin {
         result.response.headers["access-control-allow-credentials"] = "true";
       }
       if (this.options.exposeHeaders?.length) {
-        result.response.headers["access-control-expose-headers"] = this.options.exposeHeaders.join(",");
+        result.response.headers["access-control-expose-headers"] = flattenHeader(this.options.exposeHeaders);
       }
       return result;
     });
   }
 }
 
+class RequestHeadersPlugin {
+  init(options) {
+    options.rootInterceptors ??= [];
+    options.rootInterceptors.push((interceptorOptions) => {
+      const reqHeaders = interceptorOptions.context.reqHeaders ?? toFetchHeaders(interceptorOptions.request.headers);
+      return interceptorOptions.next({
+        ...interceptorOptions,
+        context: {
+          ...interceptorOptions.context,
+          reqHeaders
+        }
+      });
+    });
+  }
+}
+
 class ResponseHeadersPlugin {
   init(options) {
     options.rootInterceptors ??= [];
@@ -191,7 +218,7 @@ class ResponseHeadersPlugin {
       if (!result.matched) {
         return result;
       }
-      const responseHeaders = result.response.headers;
+      const responseHeaders = clone(result.response.headers);
       for (const [key, value] of resHeaders) {
         if (Array.isArray(responseHeaders[key])) {
           responseHeaders[key].push(value);
@@ -201,7 +228,13 @@ class ResponseHeadersPlugin {
           responseHeaders[key] = value;
         }
       }
-      return result;
+      return {
+        ...result,
+        response: {
+          ...result.response,
+          headers: responseHeaders
+        }
+      };
     });
   }
 }
@@ -249,4 +282,4 @@ class SimpleCsrfProtectionHandlerPlugin {
   }
 }
 
-export { BatchHandlerPlugin, CORSPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };
+export { BatchHandlerPlugin, CORSPlugin, RequestHeadersPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };

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

@@ -0,0 +1,12 @@
+import { C as Context } from './server.CYNGeoCm.js';
+import { b as StandardHandleOptions } from './server.Bmh5xd4n.js';
+
+type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
+
+export { resolveFriendlyStandardHandleOptions as r };
+export type { FriendlyStandardHandleOptions as F };

package/dist/shared/server.BEFBl-Cb.d.mts

@@ -0,0 +1,12 @@
+import { C as Context } from './server.CYNGeoCm.mjs';
+import { b as StandardHandleOptions } from './server.gqRxT-yN.mjs';
+
+type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
+
+export { resolveFriendlyStandardHandleOptions as r };
+export type { FriendlyStandardHandleOptions as F };

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

@@ -0,0 +1,32 @@
+import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
+import { b as AnyRouter, C as Context, R as Router } from './server.CYNGeoCm.mjs';
+import { i as StandardMatcher, h as StandardMatchResult, e as StandardHandlerOptions, f as StandardHandler } from './server.gqRxT-yN.mjs';
+import { HTTPPath } from '@orpc/client';
+import { Value } from '@orpc/shared';
+import { T as TraverseContractProcedureCallbackOptions } from './server.DhJj-1X9.mjs';
+
+interface StandardRPCMatcherOptions {
+    /**
+     * Filter procedures. Return `false` to exclude a procedure from matching.
+     *
+     * @default true
+     */
+    filter?: Value<boolean, [options: TraverseContractProcedureCallbackOptions]>;
+}
+declare class StandardRPCMatcher implements StandardMatcher {
+    private readonly filter;
+    private readonly tree;
+    private pendingRouters;
+    constructor(options?: StandardRPCMatcherOptions);
+    init(router: AnyRouter, path?: readonly string[]): void;
+    match(_method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+interface StandardRPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, StandardRPCJsonSerializerOptions, StandardRPCMatcherOptions {
+}
+declare class StandardRPCHandler<T extends Context> extends StandardHandler<T> {
+    constructor(router: Router<any, T>, options?: StandardRPCHandlerOptions<T>);
+}
+
+export { StandardRPCHandler as a, StandardRPCMatcher as c };
+export type { StandardRPCHandlerOptions as S, StandardRPCMatcherOptions as b };

package/dist/shared/{server.YZzrREz9.d.ts → server.Bmh5xd4n.d.ts}

@@ -1,8 +1,8 @@
 import { HTTPPath, ORPCError } from '@orpc/client';
-import { Meta, InferSchemaOutput, AnySchema, ErrorFromErrorMap } from '@orpc/contract';
-import { Interceptor, ThrowableError } from '@orpc/shared';
+import { Meta } from '@orpc/contract';
+import { Interceptor } from '@orpc/shared';
 import { StandardResponse, StandardLazyRequest } from '@orpc/standard-server';
-import { C as Context, R as Router, f as AnyRouter, h as AnyProcedure, F as ProcedureClientInterceptorOptions } from './server.DPWk5pjW.js';
+import { C as Context, R as Router, b as AnyRouter, A as AnyProcedure, d as ProcedureClientInterceptorOptions } from './server.CYNGeoCm.js';
 
 interface StandardHandlerPlugin<T extends Context> {
     order?: number;
@@ -49,16 +49,16 @@ interface StandardHandlerOptions<TContext extends Context> {
     /**
      * Interceptors at the request level, helpful when you want catch errors
      */
-    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, ThrowableError>[];
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
     /**
      * Interceptors at the root level, helpful when you want override the request/response
      */
-    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, ThrowableError>[];
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
     /**
      *
      * Interceptors for procedure client.
      */
-    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, InferSchemaOutput<AnySchema>, ErrorFromErrorMap<Record<never, never>>>[];
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, Promise<unknown>>[];
 }
 declare class StandardHandler<T extends Context> {
     private readonly matcher;
@@ -70,5 +70,5 @@ declare class StandardHandler<T extends Context> {
     handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
 }
 
-export { CompositeStandardHandlerPlugin as C, StandardHandler as i };
-export type { StandardHandlerInterceptorOptions as S, StandardHandlerPlugin as a, StandardHandlerOptions as b, StandardCodec as c, StandardParams as d, StandardMatcher as e, StandardMatchResult as f, StandardHandleOptions as g, StandardHandleResult as h };
+export { CompositeStandardHandlerPlugin as C, StandardHandler as f };
+export type { StandardCodec as S, StandardParams as a, StandardHandleOptions as b, StandardHandleResult as c, StandardHandlerInterceptorOptions as d, StandardHandlerOptions as e, StandardHandlerPlugin as g, StandardMatchResult as h, StandardMatcher as i };

package/dist/shared/{server.BM1HMJGg.mjs → server.BohymmQ6.mjs}

@@ -1,9 +1,8 @@
 import { toHttpPath, StandardRPCJsonSerializer, StandardRPCSerializer } from '@orpc/client/standard';
-import { toArray, intercept, parseEmptyableJSON } from '@orpc/shared';
-import '@orpc/standard-server/batch';
 import { ORPCError, toORPCError } from '@orpc/client';
-import { S as StrictGetMethodPlugin } from './server.BW-nUGgA.mjs';
-import { c as createProcedureClient, t as traverseContractProcedures, i as isProcedure, u as unlazy, g as getRouter, a as createContractedProcedure } from './server.DG7Tamti.mjs';
+import { toArray, intercept, runWithSpan, ORPC_NAME, isAsyncIteratorObject, asyncIteratorWithSpan, setSpanError, parseEmptyableJSON, NullProtoObj, value } from '@orpc/shared';
+import { flattenHeader } from '@orpc/standard-server';
+import { c as createProcedureClient, t as traverseContractProcedures, i as isProcedure, u as unlazy, g as getRouter, a as createContractedProcedure } from './server.CQr6WNc2.mjs';
 
 class CompositeStandardHandlerPlugin {
   plugins;
@@ -40,47 +39,74 @@ class StandardHandler {
       this.rootInterceptors,
       { ...options, request, prefix },
       async (interceptorOptions) => {
-        let isDecoding = false;
-        try {
-          return await intercept(
-            this.interceptors,
-            interceptorOptions,
-            async ({ request: request2, context, prefix: prefix2 }) => {
-              const method = request2.method;
-              const url = request2.url;
-              const pathname = prefix2 ? url.pathname.replace(prefix2, "") : url.pathname;
-              const match = await this.matcher.match(method, `/${pathname.replace(/^\/|\/$/g, "")}`);
-              if (!match) {
-                return { matched: false, response: void 0 };
+        return runWithSpan(
+          { name: `${request.method} ${request.url.pathname}` },
+          async (span) => {
+            let step;
+            try {
+              return await intercept(
+                this.interceptors,
+                interceptorOptions,
+                async ({ request: request2, context, prefix: prefix2 }) => {
+                  const method = request2.method;
+                  const url = request2.url;
+                  const pathname = prefix2 ? url.pathname.replace(prefix2, "") : url.pathname;
+                  const match = await runWithSpan(
+                    { name: "find_procedure" },
+                    () => this.matcher.match(method, `/${pathname.replace(/^\/|\/$/g, "")}`)
+                  );
+                  if (!match) {
+                    return { matched: false, response: void 0 };
+                  }
+                  span?.updateName(`${ORPC_NAME}.${match.path.join("/")}`);
+                  span?.setAttribute("rpc.system", ORPC_NAME);
+                  span?.setAttribute("rpc.method", match.path.join("."));
+                  step = "decode_input";
+                  let input = await runWithSpan(
+                    { name: "decode_input" },
+                    () => this.codec.decode(request2, match.params, match.procedure)
+                  );
+                  step = void 0;
+                  if (isAsyncIteratorObject(input)) {
+                    input = asyncIteratorWithSpan(
+                      { name: "consume_event_iterator_input", signal: request2.signal },
+                      input
+                    );
+                  }
+                  const client = createProcedureClient(match.procedure, {
+                    context,
+                    path: match.path,
+                    interceptors: this.clientInterceptors
+                  });
+                  step = "call_procedure";
+                  const output = await client(input, {
+                    signal: request2.signal,
+                    lastEventId: flattenHeader(request2.headers["last-event-id"])
+                  });
+                  step = void 0;
+                  const response = this.codec.encode(output, match.procedure);
+                  return {
+                    matched: true,
+                    response
+                  };
+                }
+              );
+            } catch (e) {
+              if (step !== "call_procedure") {
+                setSpanError(span, e);
               }
-              const client = createProcedureClient(match.procedure, {
-                context,
-                path: match.path,
-                interceptors: this.clientInterceptors
-              });
-              isDecoding = true;
-              const input = await this.codec.decode(request2, match.params, match.procedure);
-              isDecoding = false;
-              const lastEventId = Array.isArray(request2.headers["last-event-id"]) ? request2.headers["last-event-id"].at(-1) : request2.headers["last-event-id"];
-              const output = await client(input, { signal: request2.signal, lastEventId });
-              const response = this.codec.encode(output, match.procedure);
+              const error = step === "decode_input" && !(e instanceof ORPCError) ? new ORPCError("BAD_REQUEST", {
+                message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
+                cause: e
+              }) : toORPCError(e);
+              const response = this.codec.encodeError(error);
               return {
                 matched: true,
                 response
               };
             }
-          );
-        } catch (e) {
-          const error = isDecoding && !(e instanceof ORPCError) ? new ORPCError("BAD_REQUEST", {
-            message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
-            cause: e
-          }) : toORPCError(e);
-          const response = this.codec.encodeError(error);
-          return {
-            matched: true,
-            response
-          };
-        }
+          }
+        );
       }
     );
   }
@@ -111,10 +137,18 @@ class StandardRPCCodec {
 }
 
 class StandardRPCMatcher {
-  tree = {};
+  filter;
+  tree = new NullProtoObj();
   pendingRouters = [];
+  constructor(options = {}) {
+    this.filter = options.filter ?? true;
+  }
   init(router, path = []) {
-    const laziedOptions = traverseContractProcedures({ router, path }, ({ path: path2, contract }) => {
+    const laziedOptions = traverseContractProcedures({ router, path }, (traverseOptions) => {
+      if (!value(this.filter, traverseOptions)) {
+        return;
+      }
+      const { path: path2, contract } = traverseOptions;
       const httpPath = toHttpPath(path2);
       if (isProcedure(contract)) {
         this.tree[httpPath] = {
@@ -173,15 +207,10 @@ class StandardRPCMatcher {
 }
 
 class StandardRPCHandler extends StandardHandler {
-  constructor(router, options) {
-    options.plugins ??= [];
-    const strictGetMethodPluginEnabled = options.strictGetMethodPluginEnabled ?? true;
-    if (strictGetMethodPluginEnabled) {
-      options.plugins.push(new StrictGetMethodPlugin());
-    }
+  constructor(router, options = {}) {
     const jsonSerializer = new StandardRPCJsonSerializer(options);
     const serializer = new StandardRPCSerializer(jsonSerializer);
-    const matcher = new StandardRPCMatcher();
+    const matcher = new StandardRPCMatcher(options);
     const codec = new StandardRPCCodec(serializer);
     super(router, matcher, codec, options);
   }