@orpc/server 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/index.mjs

@@ -1,15 +1,15 @@
 import { mergeErrorMap, resolveMetaPlugins, getHiddenMetaPlugins, ProcedureContract } from '@orpc/contract';
-export { ValidationError, defineMeta, eventIterator, reconcileORPCError, type } from '@orpc/contract';
-import { toArray, bindMethods, getOrBind, isTypescriptObject, resolveMaybeOptionalOptions } from '@orpc/shared';
-export { AsyncIteratorClass, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
-import { L as Lazy, P as Procedure, c as createProcedureClient } from './shared/server.CrlKQucM.mjs';
-export { a as createORPCErrorConstructorMap, u as unlazy } from './shared/server.CrlKQucM.mjs';
-import { D as DecoratedProcedure } from './shared/server.CjOb6ItT.mjs';
-import { b as augmentRouter, d as augmentImplementedRouter, e as withHiddenRouterContract, f as createGuardedProcedureLazy, g as getRouter } from './shared/server.BwHnWUuN.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.BwHnWUuN.mjs';
+export { ValidationError, asyncIteratorObject, defineMeta, error, eventIterator, reconcileORPCError, type } from '@orpc/contract';
+import { toArray, bindMethods, isTypescriptObject, resolveMaybeOptionalOptions } from '@orpc/shared';
+export { AsyncIteratorClass, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, streamToAsyncIteratorObject, streamToAsyncIteratorObject as streamToEventIterator } from '@orpc/shared';
+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.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, isInferableError, safe, toORPCError } from '@orpc/client';
-export { ErrorEvent, getEventMeta, unwrapEvent, withEventMeta } from '@standardserver/core';
+export { COMMON_ERROR_STATUS_MAP, ORPCError, RPCJsonSerializer, RPCSerializer, cloneORPCError, isDefinedError, safe, toORPCError } from '@orpc/client';
+export { ErrorEvent, getEventMeta, unwrapEvent, withEventMeta } from '@standard-server/core';
 
 function decorateMiddleware(middleware) {
   const decorated = ((...args) => middleware(...args));
@@ -86,9 +86,19 @@ function decorateMiddleware(middleware) {
 
 class Builder {
   "~orpc";
+  /**
+   * Private constructor to prevent direct instantiation.
+   * Use the static `create` method to initialize a new instance with a safe initial definition.
+   */
   constructor(definition) {
     this["~orpc"] = definition;
   }
+  /**
+   * Creates a fresh builder with an empty definition.
+   * Prefer the exported `os` instance over calling this directly.
+   *
+   * @see {@link https://orpc.dev/docs/procedure | Procedure}
+   */
   static create() {
     return new Builder({
       errorMap: {},
@@ -96,9 +106,32 @@ class Builder {
       orderedMiddlewares: []
     });
   }
+  /**
+   * Declares the initial context type that must be provided when executing
+   * procedures built from this builder.
+   *
+   * @see {@link https://orpc.dev/docs/context#initial-context | Context - Initial Context}
+   */
   $context() {
     return this;
   }
+  /**
+   * Overrides the procedure configuration, such as disabling runtime
+   * input/output validation.
+   *
+   * @see {@link https://orpc.dev/docs/recipes/validation-customization | Validation Customization}
+   */
+  $config(config) {
+    return new Builder({
+      ...this["~orpc"],
+      ...config
+    });
+  }
+  /**
+   * Applies metadata plugins to procedures built from this builder.
+   *
+   * @see {@link https://orpc.dev/docs/metadata | Metadata}
+   */
   meta(...plugins) {
     const [meta, metaPlugins] = resolveMetaPlugins(
       this["~orpc"].meta,
@@ -111,6 +144,12 @@ class Builder {
       metaPlugins
     });
   }
+  /**
+   * Defines typesafe errors that procedures built from this builder can throw
+   * via the `errors` utility in handlers and middleware.
+   *
+   * @see {@link https://orpc.dev/docs/error-handling#typesafe-errors | Error Handling - Typesafe Errors}
+   */
   errors(errors) {
     let builder = new Builder({
       ...this["~orpc"],
@@ -122,6 +161,12 @@ class Builder {
     }
     return builder;
   }
+  /**
+   * Applies a middleware that runs before the handler of every procedure
+   * built from this builder.
+   *
+   * @see {@link https://orpc.dev/docs/middleware | Middleware}
+   */
   use(middleware) {
     let builder = new Builder({
       ...this["~orpc"],
@@ -137,6 +182,12 @@ class Builder {
     }
     return builder;
   }
+  /**
+   * Creates a standalone middleware that can be composed and applied to any
+   * compatible builder or procedure with `.use`.
+   *
+   * @see {@link https://orpc.dev/docs/middleware | Middleware}
+   */
   middleware(middleware) {
     const allMiddlewares = [
       ...this["~orpc"].orderedMiddlewares.map(({ middleware: middleware2 }) => middleware2),
@@ -156,6 +207,11 @@ class Builder {
     };
     return current;
   }
+  /**
+   * Defines the input schema used to validate and type the procedure input.
+   *
+   * @see {@link https://orpc.dev/docs/procedure#inputoutput-validation | Procedure - Input/Output Validation}
+   */
   input(schema) {
     let builder = new Builder({
       ...this["~orpc"],
@@ -167,6 +223,11 @@ class Builder {
     }
     return builder;
   }
+  /**
+   * Defines the output schema used to validate and type the procedure output.
+   *
+   * @see {@link https://orpc.dev/docs/procedure#inputoutput-validation | Procedure - Input/Output Validation}
+   */
   output(schema) {
     let builder = new Builder({
       ...this["~orpc"],
@@ -178,6 +239,12 @@ class Builder {
     }
     return builder;
   }
+  /**
+   * Defines the function that implements the procedure and completes the
+   * chain, returning a callable procedure.
+   *
+   * @see {@link https://orpc.dev/docs/procedure | Procedure}
+   */
   handler(handler) {
     let procedure = new DecoratedProcedure({
       ...this["~orpc"],
@@ -189,14 +256,24 @@ class Builder {
     }
     return procedure;
   }
+  /**
+   * Applies the builder's middleware, errors, and metadata to every procedure
+   * in the given router.
+   *
+   * @see {@link https://orpc.dev/docs/router#extending-router | Router - Extending Router}
+   */
   router(router) {
     return augmentRouter(router, {
-      middlewares: this["~orpc"].orderedMiddlewares.map(({ middleware }) => middleware),
-      meta: this["~orpc"].meta,
-      metaPlugins: this["~orpc"].metaPlugins,
-      errorMap: this["~orpc"].errorMap
+      ...this["~orpc"],
+      middlewares: this["~orpc"].orderedMiddlewares.map(({ middleware }) => middleware)
     });
   }
+  /**
+   * Like `.router`, but loads the router lazily on first access, which helps
+   * reduce startup time for large applications.
+   *
+   * @see {@link https://orpc.dev/docs/router#lazy-router | Router - Lazy Router}
+   */
   lazy(loader) {
     return new Lazy({
       loader: async () => {
@@ -230,15 +307,7 @@ class ProcedureImplementer {
   "handler"(handler) {
     return new ImplementedProcedure({
       ...this["~orpc"],
-      handler,
-      /**
-       * When enabled, errors returned (not thrown) by the handler are passed through as-is,
-       * rather than being transformed into inferrable errors.
-       *
-       * This is intended for the contract-first approach, where the procedure adheres to an
-       * external contract and returned errors should not affect the inferred contract types.
-       */
-      opaqueReturnedErrors: true
+      handler
     });
   }
 }
@@ -256,15 +325,20 @@ class ImplementedProcedure extends Procedure {
 }
 
 class SharedRouterImplementer {
-  constructor(contract, middlewares) {
+  constructor(contract, config, middlewares) {
     this.contract = contract;
+    this.config = config;
     this.middlewares = middlewares;
   }
-  static create(contract, middlewares = []) {
-    return new SharedRouterImplementer(contract, middlewares);
+  static create(contract, config, middlewares = []) {
+    return new SharedRouterImplementer(
+      contract,
+      config,
+      middlewares
+    );
   }
   use(middleware) {
-    return createRouterImplementerInternal(this.contract, [...this.middlewares, middleware]);
+    return createRouterImplementerInternal(this.contract, this.config, [...this.middlewares, middleware]);
   }
   middleware(middleware) {
     const allMiddlewares = [
@@ -280,6 +354,7 @@ class SharedRouterImplementer {
   router(router) {
     if (this.middlewares.length) {
       router = augmentImplementedRouter(router, {
+        ...this.config,
         middlewares: this.middlewares
       });
     }
@@ -292,6 +367,7 @@ class SharedRouterImplementer {
         const { default: router } = await originalLoader();
         return {
           default: augmentImplementedRouter(router, {
+            ...this.config,
             middlewares: this.middlewares
           })
         };
@@ -300,29 +376,28 @@ class SharedRouterImplementer {
     return new Lazy({ loader, meta: {} });
   }
 }
-function createRouterImplementer(contract) {
-  return createRouterImplementerInternal(contract, []);
+function createRouterImplementer(contract, config) {
+  return createRouterImplementerInternal(contract, config, []);
 }
-function createRouterImplementerInternal(contract, middlewares) {
+function createRouterImplementerInternal(contract, config, middlewares) {
   if (contract instanceof ProcedureContract) {
     return new ProcedureImplementer({
+      ...config,
       ...contract["~orpc"],
       orderedMiddlewares: middlewares.map((middleware) => ({ middleware }))
     });
   }
   const implementer = {};
-  for (const key in contract) {
-    const child = contract[key];
-    implementer[key] = createRouterImplementerInternal(child, middlewares);
+  for (const [key, child] of Object.entries(contract)) {
+    implementer[key] = createRouterImplementerInternal(child, config, middlewares);
   }
-  const shared = bindMethods(SharedRouterImplementer.create(contract, middlewares));
-  for (const key in shared) {
-    const method = shared[key];
+  const shared = bindMethods(SharedRouterImplementer.create(contract, config, middlewares));
+  for (const [key, method] of Object.entries(shared)) {
     if (key in implementer) {
       const child = implementer[key];
       implementer[key] = new Proxy(method, {
         get(_, p) {
-          return getOrBind(child, p);
+          return Reflect.get(child, p);
         }
       });
     } else {
@@ -332,22 +407,24 @@ function createRouterImplementerInternal(contract, middlewares) {
   return implementer;
 }
 
-function implement(contract) {
-  const routerImplementer = createRouterImplementer(contract);
+function implement(contract, config = {}) {
+  const routerImplementer = createRouterImplementer(contract, config);
   const implementer = new Proxy(routerImplementer, {
     get(_, p) {
       let method;
       if (p === "$context") {
         method = () => implementer;
+      } else if (p === "$config") {
+        method = (incoming) => implement(contract, { ...config, ...incoming });
       }
-      const value = getOrBind(routerImplementer, p);
+      const value = Reflect.get(routerImplementer, p);
       if (method) {
         if (!isTypescriptObject(value)) {
           return method;
         }
         return new Proxy(method, {
           get(_2, p2) {
-            return getOrBind(value, p2);
+            return Reflect.get(value, p2);
           }
         });
       }
@@ -363,19 +440,24 @@ function createRouterClient(router, ...rest) {
     return createProcedureClient(router, options);
   }
   const procedureCaller = router instanceof Lazy ? createProcedureClient(createGuardedProcedureLazy(router), options) : {};
+  const cache = /* @__PURE__ */ new Map();
   const recursive = new Proxy(procedureCaller, {
     get(target, key) {
       if (typeof key !== "string" || router instanceof Lazy && RECURSIVE_CLIENT_UNWRAP_KEYS.has(key)) {
-        return getOrBind(target, key);
+        return Reflect.get(target, key);
       }
-      const next = getRouter(router, [key]);
-      if (!next) {
-        return getOrBind(target, key);
+      let nextClient = cache.get(key);
+      if (nextClient === void 0) {
+        const next = getRouter(router, [key]);
+        if (!next) {
+          return Reflect.get(target, key);
+        }
+        nextClient = createRouterClient(next, {
+          ...options,
+          path: [...toArray(options.path), key]
+        });
+        cache.set(key, nextClient);
       }
-      const nextClient = createRouterClient(next, {
-        ...options,
-        path: [...toArray(options.path), key]
-      });
       return nextClient;
     }
   });