@orpc/server 0.0.0-next.57a6344 → 0.0.0-next.5b2c897

package/dist/index.js

@@ -1,415 +1,355 @@
 import {
   LAZY_LOADER_SYMBOL,
   Procedure,
-  createFlattenLazy,
-  createLazy,
-  createProcedureCaller,
-  decorateLazy,
-  decorateMiddleware,
-  decorateProcedure,
+  adaptRouter,
+  addMiddleware,
+  convertPathToHttpPath,
+  createAccessibleLazyRouter,
+  createContractedProcedure,
+  createLazyProcedureFormAnyLazy,
+  createProcedureClient,
+  deepSetLazyRouterPrefix,
+  eachAllContractProcedure,
+  eachContractProcedure,
+  flatLazy,
+  getLazyRouterPrefix,
+  getRouterChild,
+  getRouterContract,
   isLazy,
   isProcedure,
-  loadLazy,
-  loadProcedure,
-  mergeContext
-} from "./chunk-VARUID7X.js";
+  lazy,
+  middlewareOutputFn,
+  setRouterContract,
+  unlazy
+} from "./chunk-XP6YRLY2.js";
 
 // src/builder.ts
-import {
-  ContractProcedure,
-  isContractProcedure as isContractProcedure2
-} from "@orpc/contract";
+import { mergeErrorMap as mergeErrorMap2, mergeMeta as mergeMeta2, mergePrefix, mergeRoute as mergeRoute2, mergeTags } from "@orpc/contract";
 
-// src/procedure-builder.ts
-import {
-  DecoratedContractProcedure as DecoratedContractProcedure2
-} from "@orpc/contract";
-
-// src/router-builder.ts
-import { DecoratedContractProcedure } from "@orpc/contract";
-var LAZY_ROUTER_PREFIX_SYMBOL = Symbol("ORPC_LAZY_ROUTER_PREFIX");
-var RouterBuilder = class _RouterBuilder {
-  constructor(zz$rb) {
-    this.zz$rb = zz$rb;
-    if (zz$rb.prefix && zz$rb.prefix.includes("{")) {
-      throw new Error('Prefix cannot contain "{" for dynamic routing');
-    }
-  }
-  prefix(prefix) {
-    return new _RouterBuilder({
-      ...this.zz$rb,
-      prefix: `${this.zz$rb.prefix ?? ""}${prefix}`
-    });
-  }
-  tags(...tags) {
-    if (!tags.length)
-      return this;
-    return new _RouterBuilder({
-      ...this.zz$rb,
-      tags: [...this.zz$rb.tags ?? [], ...tags]
-    });
-  }
-  use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _RouterBuilder({
-      ...this.zz$rb,
-      middlewares: [...this.zz$rb.middlewares || [], middleware_]
-    });
-  }
-  router(router) {
-    const handled = adaptRouter({
-      routerOrChild: router,
-      middlewares: this.zz$rb.middlewares,
-      tags: this.zz$rb.tags,
-      prefix: this.zz$rb.prefix
-    });
-    return handled;
+// src/config.ts
+var DEFAULT_CONFIG = {
+  initialInputValidationIndex: 0,
+  initialOutputValidationIndex: 0
+};
+function fallbackConfig(key, value) {
+  if (value === void 0) {
+    return DEFAULT_CONFIG[key];
   }
-  lazy(loader) {
-    const lazy = adaptLazyRouter({
-      current: createLazy(loader),
-      middlewares: this.zz$rb.middlewares,
-      tags: this.zz$rb.tags,
-      prefix: this.zz$rb.prefix
+  return value;
+}
+
+// src/middleware-decorated.ts
+function decorateMiddleware(middleware) {
+  const decorated = middleware;
+  decorated.mapInput = (mapInput) => {
+    const mapped = decorateMiddleware(
+      (options, input, ...rest) => middleware(options, mapInput(input), ...rest)
+    );
+    return mapped;
+  };
+  decorated.concat = (concatMiddleware, mapInput) => {
+    const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
+    const concatted = decorateMiddleware((options, input, output, ...rest) => {
+      const next = async (...[nextOptions]) => {
+        return mapped({ ...options, context: { ...nextOptions?.context, ...options.context } }, input, output, ...rest);
+      };
+      const merged = middleware({ ...options, next }, input, output, ...rest);
+      return merged;
     });
-    return lazy;
-  }
-};
-function adaptRouter(options) {
-  if (isProcedure(options.routerOrChild)) {
-    return adaptProcedure({
-      ...options,
-      procedure: options.routerOrChild
+    return concatted;
+  };
+  return decorated;
+}
+
+// src/procedure-decorated.ts
+import { mergeErrorMap, mergeMeta, mergeRoute } from "@orpc/contract";
+var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
+  errors(errors) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
     });
   }
-  if (isLazy(options.routerOrChild)) {
-    return adaptLazyRouter({
-      ...options,
-      current: options.routerOrChild
+  meta(meta) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      meta: mergeMeta(this["~orpc"].meta, meta)
     });
   }
-  const handled = {};
-  for (const key in options.routerOrChild) {
-    handled[key] = adaptRouter({
-      ...options,
-      routerOrChild: options.routerOrChild[key]
+  route(route) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      route: mergeRoute(this["~orpc"].route, route)
     });
   }
-  return handled;
-}
-function adaptLazyRouter(options) {
-  const loader = async () => {
-    const current = (await loadLazy(options.current)).default;
-    return {
-      default: adaptRouter({
-        ...options,
-        routerOrChild: current
-      })
-    };
-  };
-  let lazyRouterPrefix = options.prefix;
-  if (LAZY_ROUTER_PREFIX_SYMBOL in options.current && typeof options.current[LAZY_ROUTER_PREFIX_SYMBOL] === "string") {
-    lazyRouterPrefix = `${options.current[LAZY_ROUTER_PREFIX_SYMBOL]}${lazyRouterPrefix ?? ""}`;
-  }
-  const decoratedLazy = Object.assign(decorateLazy(createLazy(loader)), {
-    [LAZY_ROUTER_PREFIX_SYMBOL]: lazyRouterPrefix
-  });
-  const recursive = new Proxy(decoratedLazy, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      return adaptLazyRouter({
-        ...options,
-        current: createLazy(async () => {
-          const current = (await loadLazy(options.current)).default;
-          return { default: current[key] };
-        })
-      });
-    }
-  });
-  return recursive;
-}
-function adaptProcedure(options) {
-  const builderMiddlewares = options.middlewares ?? [];
-  const procedureMiddlewares = options.procedure.zz$p.middlewares ?? [];
-  const middlewares = [
-    ...builderMiddlewares,
-    ...procedureMiddlewares.filter(
-      (item) => !builderMiddlewares.includes(item)
-    )
-  ];
-  let contract = DecoratedContractProcedure.decorate(
-    options.procedure.zz$p.contract
-  ).pushTag(...options.tags ?? []);
-  if (options.prefix) {
-    contract = contract.prefix(options.prefix);
-  }
-  return decorateProcedure({
-    zz$p: {
-      ...options.procedure.zz$p,
-      contract,
-      middlewares
-    }
-  });
-}
-
-// src/procedure-implementer.ts
-var ProcedureImplementer = class _ProcedureImplementer {
-  constructor(zz$pi) {
-    this.zz$pi = zz$pi;
-  }
   use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _ProcedureImplementer({
-      ...this.zz$pi,
-      middlewares: [...this.zz$pi.middlewares ?? [], middleware_]
+    const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
     });
   }
-  func(func) {
-    return decorateProcedure({
-      zz$p: {
-        middlewares: this.zz$pi.middlewares,
-        contract: this.zz$pi.contract,
-        func
-      }
+  /**
+   * Make this procedure callable (works like a function while still being a procedure).
+   */
+  callable(...rest) {
+    return Object.assign(createProcedureClient(this, ...rest), {
+      "~type": "Procedure",
+      "~orpc": this["~orpc"]
     });
   }
-  lazy(loader) {
-    return new RouterBuilder(this.zz$pi).lazy(loader);
+  /**
+   * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
+   */
+  actionable(...rest) {
+    return this.callable(...rest);
   }
 };
 
-// src/procedure-builder.ts
-var ProcedureBuilder = class _ProcedureBuilder {
-  constructor(zz$pb) {
-    this.zz$pb = zz$pb;
+// src/builder.ts
+var Builder = class _Builder {
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
   }
   /**
-   * Self chainable
+   * Reset config
    */
-  route(opts) {
-    return new _ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure2.decorate(this.zz$pb.contract).route(
-        opts
-      )
+  $config(config) {
+    const inputValidationCount = this["~orpc"].inputValidationIndex - fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex);
+    const outputValidationCount = this["~orpc"].outputValidationIndex - fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex);
+    return new _Builder({
+      ...this["~orpc"],
+      config,
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", config.initialInputValidationIndex) + inputValidationCount,
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config.initialOutputValidationIndex) + outputValidationCount
     });
   }
-  input(schema, example) {
-    return new _ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure2.decorate(this.zz$pb.contract).input(
-        schema,
-        example
-      )
+  /**
+   * Reset initial context
+   */
+  $context() {
+    return new _Builder({
+      ...this["~orpc"],
+      middlewares: [],
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex)
     });
   }
-  output(schema, example) {
-    return new _ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure2.decorate(this.zz$pb.contract).output(
-        schema,
-        example
-      )
+  /**
+   * Reset initial meta
+   */
+  $meta(initialMeta) {
+    return new _Builder({
+      ...this["~orpc"],
+      meta: initialMeta
     });
   }
-  use(middleware, mapInput) {
-    if (!mapInput) {
-      return new ProcedureImplementer({
-        contract: this.zz$pb.contract,
-        middlewares: this.zz$pb.middlewares
-      }).use(middleware);
-    }
-    return new ProcedureImplementer({
-      contract: this.zz$pb.contract,
-      middlewares: this.zz$pb.middlewares
-    }).use(middleware, mapInput);
-  }
   /**
-   * Convert to Procedure
+   * Reset initial route
    */
-  func(func) {
-    return decorateProcedure({
-      zz$p: {
-        middlewares: this.zz$pb.middlewares,
-        contract: this.zz$pb.contract,
-        func
-      }
+  $route(initialRoute) {
+    return new _Builder({
+      ...this["~orpc"],
+      route: initialRoute
     });
   }
-};
-
-// src/router-implementer.ts
-import { isContractProcedure } from "@orpc/contract";
-var ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_ROUTER_CONTRACT");
-var RouterImplementer = class {
-  constructor(zz$ri) {
-    this.zz$ri = zz$ri;
+  middleware(middleware) {
+    return decorateMiddleware(middleware);
   }
-  router(router) {
-    return Object.assign(new RouterBuilder({}).router(router), {
-      [ROUTER_CONTRACT_SYMBOL]: this.zz$ri.contract
+  errors(errors) {
+    return new _Builder({
+      ...this["~orpc"],
+      errorMap: mergeErrorMap2(this["~orpc"].errorMap, errors)
     });
   }
-  lazy(loader) {
-    const lazy = createLazy(loader);
-    const decorated = decorateLazy(lazy);
-    return Object.assign(decorated, {
-      [ROUTER_CONTRACT_SYMBOL]: this.zz$ri.contract
+  use(middleware, mapInput) {
+    const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+    return new _Builder({
+      ...this["~orpc"],
+      middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
     });
   }
-};
-function chainRouterImplementer(contract, middlewares) {
-  const result = {};
-  for (const key in contract) {
-    const item = contract[key];
-    if (isContractProcedure(item)) {
-      result[key] = new ProcedureImplementer({
-        contract: item,
-        middlewares
-      });
-    } else {
-      result[key] = chainRouterImplementer(item, middlewares);
-    }
-  }
-  const implementer = new RouterImplementer({ contract });
-  return Object.assign(implementer, result);
-}
-
-// src/builder.ts
-var Builder = class _Builder {
-  constructor(zz$b = {}) {
-    this.zz$b = zz$b;
-  }
-  /**
-   * Self chainable
-   */
-  context() {
-    return this;
-  }
-  use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+  meta(meta) {
     return new _Builder({
-      ...this.zz$b,
-      middlewares: [...this.zz$b.middlewares || [], middleware_]
+      ...this["~orpc"],
+      meta: mergeMeta2(this["~orpc"].meta, meta)
     });
   }
-  /**
-   * Convert to ContractProcedureBuilder
-   */
   route(route) {
-    return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
-      contract: new ContractProcedure({
-        route,
-        InputSchema: void 0,
-        OutputSchema: void 0
-      })
+    return new _Builder({
+      ...this["~orpc"],
+      route: mergeRoute2(this["~orpc"].route, route)
     });
   }
-  input(schema, example) {
-    return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
-      contract: new ContractProcedure({
-        OutputSchema: void 0,
-        InputSchema: schema,
-        inputExample: example
-      })
+  input(schema) {
+    return new _Builder({
+      ...this["~orpc"],
+      inputSchema: schema,
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex) + this["~orpc"].middlewares.length
     });
   }
-  output(schema, example) {
-    return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
-      contract: new ContractProcedure({
-        InputSchema: void 0,
-        OutputSchema: schema,
-        outputExample: example
-      })
+  output(schema) {
+    return new _Builder({
+      ...this["~orpc"],
+      outputSchema: schema,
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex) + this["~orpc"].middlewares.length
     });
   }
-  /**
-   * Convert to Procedure
-   */
-  func(func) {
-    return decorateProcedure({
-      zz$p: {
-        middlewares: this.zz$b.middlewares,
-        contract: new ContractProcedure({
-          InputSchema: void 0,
-          OutputSchema: void 0
-        }),
-        func
-      }
+  handler(handler) {
+    return new DecoratedProcedure({
+      ...this["~orpc"],
+      handler
     });
   }
-  /**
-   * Convert to ProcedureImplementer | RouterBuilder
-   */
-  contract(contract) {
-    if (isContractProcedure2(contract)) {
-      return new ProcedureImplementer({
-        contract,
-        middlewares: this.zz$b.middlewares
-      });
-    }
-    return chainRouterImplementer(
-      contract,
-      this.zz$b.middlewares
-    );
-  }
-  /**
-   * Create ExtendedMiddleware
-   */
-  // TODO: TOutput always any, infer not work at all, because TOutput used inside middleware params,
-  // solution (maybe): create new generic for .output() method
-  middleware(middleware) {
-    return decorateMiddleware(middleware);
-  }
   prefix(prefix) {
-    return new RouterBuilder({
-      ...this.zz$b,
-      prefix
+    return new _Builder({
+      ...this["~orpc"],
+      prefix: mergePrefix(this["~orpc"].prefix, prefix)
     });
   }
-  tags(...tags) {
-    return new RouterBuilder({
-      ...this.zz$b,
-      tags
+  tag(...tags) {
+    return new _Builder({
+      ...this["~orpc"],
+      tags: mergeTags(this["~orpc"].tags, tags)
     });
   }
-  /**
-   * Create DecoratedRouter
-   */
   router(router) {
-    return new RouterBuilder(this.zz$b).router(router);
+    return adaptRouter(router, this["~orpc"]);
   }
   lazy(loader) {
-    return new RouterBuilder(this.zz$b).lazy(loader);
+    return adaptRouter(flatLazy(lazy(loader)), this["~orpc"]);
   }
 };
+var os = new Builder({
+  config: {},
+  route: {},
+  meta: {},
+  errorMap: {},
+  inputSchema: void 0,
+  outputSchema: void 0,
+  inputValidationIndex: fallbackConfig("initialInputValidationIndex"),
+  outputValidationIndex: fallbackConfig("initialOutputValidationIndex"),
+  middlewares: []
+});
+
+// src/context.ts
+function mergeContext(context, other) {
+  return { ...context, ...other };
+}
+
+// src/implementer.ts
+import { isContractProcedure } from "@orpc/contract";
+function implementerInternal(contract, config, middlewares) {
+  if (isContractProcedure(contract)) {
+    const impl2 = new Builder({
+      ...contract["~orpc"],
+      config,
+      middlewares,
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", config?.initialInputValidationIndex) + middlewares.length,
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config?.initialOutputValidationIndex) + middlewares.length
+    });
+    return impl2;
+  }
+  const impl = new Proxy(contract, {
+    get: (target, key) => {
+      let method;
+      if (key === "middleware") {
+        method = (mid) => decorateMiddleware(mid);
+      } else if (key === "use") {
+        method = (mid) => {
+          return implementerInternal(
+            contract,
+            config,
+            addMiddleware(middlewares, mid)
+          );
+        };
+      } else if (key === "router") {
+        method = (router) => {
+          const adapted = adaptRouter(router, {
+            middlewares,
+            errorMap: {}
+          });
+          return setRouterContract(adapted, contract);
+        };
+      } else if (key === "lazy") {
+        method = (loader) => {
+          const adapted = adaptRouter(flatLazy(lazy(loader)), {
+            middlewares,
+            errorMap: {}
+          });
+          return setRouterContract(adapted, contract);
+        };
+      }
+      const next = Reflect.get(target, key);
+      if (!next || typeof next !== "function" && typeof next !== "object") {
+        return method ?? next;
+      }
+      const nextImpl = implementerInternal(next, config, middlewares);
+      if (method) {
+        return new Proxy(method, {
+          get(_, key2) {
+            return Reflect.get(nextImpl, key2);
+          }
+        });
+      }
+      return nextImpl;
+    }
+  });
+  return impl;
+}
+function implement(contract, config = {}) {
+  const implInternal = implementerInternal(contract, config, []);
+  const impl = new Proxy(implInternal, {
+    get: (target, key) => {
+      let method;
+      if (key === "$context") {
+        method = () => impl;
+      } else if (key === "$config") {
+        method = (config2) => implement(contract, config2);
+      }
+      const next = Reflect.get(target, key);
+      if (!next || typeof next !== "function" && typeof next !== "object") {
+        return method ?? next;
+      }
+      if (method) {
+        return new Proxy(method, {
+          get(_, key2) {
+            return Reflect.get(next, key2);
+          }
+        });
+      }
+      return next;
+    }
+  });
+  return impl;
+}
 
-// src/router-caller.ts
-function createRouterCaller(options) {
-  return createRouterCallerInternal(options);
+// src/procedure-utils.ts
+function call(procedure, input, ...rest) {
+  return createProcedureClient(procedure, ...rest)(input);
 }
-function createRouterCallerInternal(options) {
-  const procedureCaller = isLazy(options.router) || isProcedure(options.router) ? createProcedureCaller({
-    ...options,
-    procedure: options.router,
-    context: options.context,
-    path: options.basePath
-  }) : {};
+
+// src/router-client.ts
+function createRouterClient(router, ...rest) {
+  if (isProcedure(router)) {
+    const caller = createProcedureClient(router, ...rest);
+    return caller;
+  }
+  const procedureCaller = isLazy(router) ? createProcedureClient(createLazyProcedureFormAnyLazy(router), ...rest) : {};
   const recursive = new Proxy(procedureCaller, {
     get(target, key) {
       if (typeof key !== "string") {
         return Reflect.get(target, key);
       }
-      const next = options.router[key];
-      return createRouterCallerInternal({
+      const next = getRouterChild(router, key);
+      if (!next) {
+        return Reflect.get(target, key);
+      }
+      const [options] = rest;
+      return createRouterClient(next, {
         ...options,
-        router: next,
-        basePath: [...options.basePath ?? [], key]
+        path: [...options?.path ?? [], key]
       });
     }
   });
@@ -417,31 +357,48 @@ function createRouterCallerInternal(options) {
 }
 
 // src/index.ts
-export * from "@orpc/shared/error";
-var os = new Builder();
+import { isDefinedError, ORPCError, safe, type, ValidationError } from "@orpc/contract";
+import { onError, onFinish, onStart, onSuccess } from "@orpc/shared";
 export {
   Builder,
+  DecoratedProcedure,
   LAZY_LOADER_SYMBOL,
-  LAZY_ROUTER_PREFIX_SYMBOL,
+  ORPCError,
   Procedure,
-  ProcedureBuilder,
-  ProcedureImplementer,
-  ROUTER_CONTRACT_SYMBOL,
-  RouterBuilder,
-  RouterImplementer,
-  chainRouterImplementer,
-  createFlattenLazy,
-  createLazy,
-  createProcedureCaller,
-  createRouterCaller,
-  decorateLazy,
+  ValidationError,
+  adaptRouter,
+  call,
+  convertPathToHttpPath,
+  createAccessibleLazyRouter,
+  createContractedProcedure,
+  createLazyProcedureFormAnyLazy,
+  createProcedureClient,
+  createRouterClient,
   decorateMiddleware,
-  decorateProcedure,
+  deepSetLazyRouterPrefix,
+  eachAllContractProcedure,
+  eachContractProcedure,
+  fallbackConfig,
+  flatLazy,
+  getLazyRouterPrefix,
+  getRouterChild,
+  getRouterContract,
+  implement,
+  implementerInternal,
+  isDefinedError,
   isLazy,
   isProcedure,
-  loadLazy,
-  loadProcedure,
+  lazy,
   mergeContext,
-  os
+  middlewareOutputFn,
+  onError,
+  onFinish,
+  onStart,
+  onSuccess,
+  os,
+  safe,
+  setRouterContract,
+  type,
+  unlazy
 };
 //# sourceMappingURL=index.js.map