@orpc/server 0.27.0 → 0.29.0

package/dist/{chunk-3BAPJGK6.js → chunk-VY6NXNQT.js}

@@ -4,7 +4,7 @@ import {
   getRouterChild,
   isProcedure,
   unlazy
-} from "./chunk-E7GUWVR4.js";
+} from "./chunk-XDC42C3C.js";
 
 // src/adapters/fetch/super-json.ts
 var super_json_exports = {};
@@ -130,8 +130,8 @@ function deserialize({
 }
 
 // src/adapters/fetch/orpc-payload-codec.ts
+import { ORPCError } from "@orpc/contract";
 import { findDeepMatches, set } from "@orpc/shared";
-import { ORPCError } from "@orpc/shared/error";
 var ORPCPayloadCodec = class {
   /**
    * If method is GET, the payload will be encoded as query string.
@@ -236,9 +236,9 @@ var ORPCProcedureMatcher = class {
 };
 
 // src/adapters/fetch/orpc-handler.ts
+import { ORPCError as ORPCError2 } from "@orpc/contract";
 import { executeWithHooks, trim as trim2 } from "@orpc/shared";
-import { ORPCError as ORPCError2 } from "@orpc/shared/error";
-var ORPCHandler = class {
+var RPCHandler = class {
   constructor(router, options) {
     this.options = options;
     this.procedureMatcher = options?.procedureMatcher ?? new ORPCProcedureMatcher(router);
@@ -256,9 +256,8 @@ var ORPCHandler = class {
         return { matched: false, response: void 0 };
       }
       const input = await this.payloadCodec.decode(request);
-      const client = createProcedureClient({
+      const client = createProcedureClient(match.procedure, {
         context,
-        procedure: match.procedure,
         path: match.path
       });
       const output = await client(input, { signal: request.signal });
@@ -297,6 +296,6 @@ export {
   super_json_exports,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
-  ORPCHandler
+  RPCHandler
 };
-//# sourceMappingURL=chunk-3BAPJGK6.js.map
+//# sourceMappingURL=chunk-VY6NXNQT.js.map

package/dist/{chunk-E7GUWVR4.js → chunk-XDC42C3C.js}

@@ -32,6 +32,33 @@ function isProcedure(item) {
   return (typeof item === "object" || typeof item === "function") && item !== null && "~type" in item && item["~type"] === "Procedure" && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "contract" in item["~orpc"] && isContractProcedure(item["~orpc"].contract) && "handler" in item["~orpc"] && typeof item["~orpc"].handler === "function";
 }
 
+// src/error.ts
+import { ORPCError } from "@orpc/contract";
+function createORPCErrorConstructorMap(errors) {
+  const constructors = {};
+  if (!errors) {
+    return constructors;
+  }
+  for (const code in errors) {
+    const config = errors[code];
+    if (!config) {
+      continue;
+    }
+    const constructor = (...[options]) => {
+      return new ORPCError({
+        code,
+        defined: true,
+        status: config.status,
+        message: options?.message ?? config.message,
+        data: options?.data,
+        cause: options?.cause
+      });
+    };
+    constructors[code] = constructor;
+  }
+  return constructors;
+}
+
 // src/lazy.ts
 var LAZY_LOADER_SYMBOL = Symbol("ORPC_LAZY_LOADER");
 function lazy(loader) {
@@ -60,13 +87,13 @@ function flatLazy(lazied) {
 }
 
 // src/procedure-client.ts
-import { executeWithHooks, value } from "@orpc/shared";
-import { ORPCError } from "@orpc/shared/error";
-function createProcedureClient(options) {
+import { ORPCError as ORPCError2, validateORPCError, ValidationError } from "@orpc/contract";
+import { executeWithHooks, toError, value } from "@orpc/shared";
+function createProcedureClient(lazyableProcedure, ...[options]) {
   return async (...[input, callerOptions]) => {
-    const path = options.path ?? [];
-    const { default: procedure } = await unlazy(options.procedure);
-    const context = await value(options.context);
+    const path = options?.path ?? [];
+    const { default: procedure } = await unlazy(lazyableProcedure);
+    const context = await value(options?.context, callerOptions?.context);
     const meta = {
       path,
       procedure,
@@ -79,17 +106,27 @@ function createProcedureClient(options) {
         input: validInput,
         path,
         procedure,
-        signal: callerOptions?.signal
+        signal: callerOptions?.signal,
+        errors: createORPCErrorConstructorMap(procedure["~orpc"].contract["~orpc"].errorMap)
       });
       return validateOutput(procedure, output);
     };
-    return executeWithHooks({
-      hooks: options,
-      input,
-      context,
-      meta,
-      execute: executeWithValidation
-    });
+    try {
+      const output = await executeWithHooks({
+        hooks: options,
+        input,
+        context,
+        meta,
+        execute: executeWithValidation
+      });
+      return output;
+    } catch (e) {
+      if (!(e instanceof ORPCError2)) {
+        throw toError(e);
+      }
+      const validated = await validateORPCError(procedure["~orpc"].contract["~orpc"].errorMap, e);
+      throw validated;
+    }
   };
 }
 async function validateInput(procedure, input) {
@@ -98,10 +135,13 @@ async function validateInput(procedure, input) {
     return input;
   const result = await schema["~standard"].validate(input);
   if (result.issues) {
-    throw new ORPCError({
+    throw new ORPCError2({
       message: "Input validation failed",
       code: "BAD_REQUEST",
-      issues: result.issues
+      data: {
+        issues: result.issues
+      },
+      cause: new ValidationError({ message: "Input validation failed", issues: result.issues })
     });
   }
   return result.value;
@@ -112,10 +152,10 @@ async function validateOutput(procedure, output) {
     return output;
   const result = await schema["~standard"].validate(output);
   if (result.issues) {
-    throw new ORPCError({
+    throw new ORPCError2({
       message: "Output validation failed",
       code: "INTERNAL_SERVER_ERROR",
-      issues: result.issues
+      cause: new ValidationError({ message: "Output validation failed", issues: result.issues })
     });
   }
   return result.value;
@@ -175,6 +215,7 @@ export {
   mergeContext,
   Procedure,
   isProcedure,
+  createORPCErrorConstructorMap,
   LAZY_LOADER_SYMBOL,
   lazy,
   isLazy,
@@ -183,4 +224,4 @@ export {
   createProcedureClient,
   getRouterChild
 };
-//# sourceMappingURL=chunk-E7GUWVR4.js.map
+//# sourceMappingURL=chunk-XDC42C3C.js.map

package/dist/fetch.js

@@ -1,15 +1,15 @@
 import "./chunk-WUOGVGWG.js";
 import {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports
-} from "./chunk-3BAPJGK6.js";
-import "./chunk-E7GUWVR4.js";
+} from "./chunk-VY6NXNQT.js";
+import "./chunk-XDC42C3C.js";
 export {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports as SuperJSON
 };
 //# sourceMappingURL=fetch.js.map

package/dist/hono.js

@@ -1,11 +1,11 @@
 import "./chunk-WUOGVGWG.js";
 import {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports
-} from "./chunk-3BAPJGK6.js";
-import "./chunk-E7GUWVR4.js";
+} from "./chunk-VY6NXNQT.js";
+import "./chunk-XDC42C3C.js";
 
 // src/adapters/hono/middleware.ts
 import { value } from "@orpc/shared";
@@ -21,9 +21,9 @@ function createMiddleware(handler, ...[options]) {
   };
 }
 export {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports as SuperJSON,
   createMiddleware
 };

package/dist/index.js

@@ -1,6 +1,7 @@
 import {
   LAZY_LOADER_SYMBOL,
   Procedure,
+  createORPCErrorConstructorMap,
   createProcedureClient,
   flatLazy,
   getRouterChild,
@@ -9,14 +10,14 @@ import {
   lazy,
   mergeContext,
   unlazy
-} from "./chunk-E7GUWVR4.js";
+} from "./chunk-XDC42C3C.js";
 
 // src/builder.ts
 import { ContractProcedure } from "@orpc/contract";
 
 // src/implementer-chainable.ts
 import { isContractProcedure } from "@orpc/contract";
-import { createCallableObject } from "@orpc/shared";
+import { createCallableObject as createCallableObject2 } from "@orpc/shared";
 
 // src/middleware-decorated.ts
 function decorateMiddleware(middleware) {
@@ -43,58 +44,72 @@ function decorateMiddleware(middleware) {
 
 // src/procedure-decorated.ts
 import { DecoratedContractProcedure } from "@orpc/contract";
-function decorateProcedure(procedure) {
-  const caller = createProcedureClient({
-    procedure,
-    context: void 0
-  });
-  const decorated = caller;
-  decorated["~type"] = procedure["~type"];
-  decorated["~orpc"] = procedure["~orpc"];
-  decorated.prefix = (prefix) => {
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).prefix(prefix)
-    }));
-  };
-  decorated.route = (route) => {
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).route(route)
-    }));
-  };
-  decorated.use = (middleware, mapInput) => {
+import { createCallableObject } from "@orpc/shared";
+var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
+  static decorate(procedure) {
+    if (procedure instanceof _DecoratedProcedure) {
+      return procedure;
+    }
+    return new _DecoratedProcedure(procedure["~orpc"]);
+  }
+  prefix(prefix) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).prefix(prefix)
+    });
+  }
+  route(route) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).route(route)
+    });
+  }
+  use(middleware, mapInput) {
     const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      middlewares: [...procedure["~orpc"].middlewares ?? [], middleware_]
-    }));
-  };
-  decorated.unshiftTag = (...tags) => {
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).unshiftTag(...tags)
-    }));
-  };
-  decorated.unshiftMiddleware = (...middlewares) => {
-    if (procedure["~orpc"].middlewares?.length) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      middlewares: [...this["~orpc"].middlewares ?? [], middleware_]
+    });
+  }
+  unshiftTag(...tags) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).unshiftTag(...tags)
+    });
+  }
+  unshiftMiddleware(...middlewares) {
+    const castedMiddlewares = middlewares;
+    if (this["~orpc"].middlewares?.length) {
       let min = 0;
-      for (let i = 0; i < procedure["~orpc"].middlewares.length; i++) {
-        const index = middlewares.indexOf(procedure["~orpc"].middlewares[i], min);
+      for (let i = 0; i < this["~orpc"].middlewares.length; i++) {
+        const index = castedMiddlewares.indexOf(this["~orpc"].middlewares[i], min);
         if (index === -1) {
-          middlewares.push(...procedure["~orpc"].middlewares.slice(i));
+          castedMiddlewares.push(...this["~orpc"].middlewares.slice(i));
           break;
         }
         min = index + 1;
       }
     }
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      middlewares
-    }));
-  };
-  return decorated;
-}
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      middlewares: castedMiddlewares
+    });
+  }
+  /**
+   * Make this procedure callable (works like a function while still being a procedure).
+   * **Note**: this only takes effect when this method is called at the end of the chain.
+   */
+  callable(...rest) {
+    return createCallableObject(this, createProcedureClient(this, ...rest));
+  }
+  /**
+   * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
+   * **Note**: this only takes effect when this method is called at the end of the chain.
+   */
+  actionable(...rest) {
+    return this.callable(...rest);
+  }
+};
 
 // src/procedure-implementer.ts
 var ProcedureImplementer = class _ProcedureImplementer {
@@ -111,11 +126,11 @@ var ProcedureImplementer = class _ProcedureImplementer {
     });
   }
   handler(handler) {
-    return decorateProcedure(new Procedure({
+    return new DecoratedProcedure({
       middlewares: this["~orpc"].middlewares,
       contract: this["~orpc"].contract,
       handler
-    }));
+    });
   }
 };
 
@@ -153,31 +168,10 @@ function getLazyRouterPrefix(obj) {
   return obj[LAZY_ROUTER_PREFIX_SYMBOL];
 }
 
-// src/lazy-utils.ts
-function createLazyProcedureFormAnyLazy(lazied) {
-  const lazyProcedure = lazy(async () => {
-    const { default: maybeProcedure } = await unlazy(flatLazy(lazied));
-    if (!isProcedure(maybeProcedure)) {
-      throw new Error(`
-            Expected a lazy<procedure> but got lazy<unknown>.
-            This should be caught by TypeScript compilation.
-            Please report this issue if this makes you feel uncomfortable.
-        `);
-    }
-    return { default: maybeProcedure };
-  });
-  return lazyProcedure;
-}
-
 // src/lazy-decorated.ts
 function decorateLazy(lazied) {
   const flattenLazy = flatLazy(lazied);
-  const procedureProcedureClient = createProcedureClient({
-    procedure: createLazyProcedureFormAnyLazy(flattenLazy),
-    context: void 0
-  });
-  Object.assign(procedureProcedureClient, flattenLazy);
-  const recursive = new Proxy(procedureProcedureClient, {
+  const recursive = new Proxy(flattenLazy, {
     get(target, key) {
       if (typeof key !== "string") {
         return Reflect.get(target, key);
@@ -244,7 +238,7 @@ function adapt(item, options) {
     return adaptedLazy;
   }
   if (isProcedure(item)) {
-    let decorated = decorateProcedure(item);
+    let decorated = DecoratedProcedure.decorate(item);
     if (options.tags?.length) {
       decorated = decorated.unshiftTag(...options.tags);
     }
@@ -312,7 +306,7 @@ function createChainableImplementer(contract, middlewares) {
       if (!next) {
         return method.bind(routerImplementer);
       }
-      return createCallableObject(next, method.bind(routerImplementer));
+      return createCallableObject2(next, method.bind(routerImplementer));
     }
   });
   return merged;
@@ -346,6 +340,12 @@ var ProcedureBuilder = class _ProcedureBuilder {
       contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).output(schema, example)
     });
   }
+  errors(errors) {
+    return new _ProcedureBuilder({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).errors(errors)
+    });
+  }
   use(middleware, mapInput) {
     if (!mapInput) {
       return new ProcedureImplementer({
@@ -359,11 +359,11 @@ var ProcedureBuilder = class _ProcedureBuilder {
     }).use(middleware, mapInput);
   }
   handler(handler) {
-    return decorateProcedure(new Procedure({
+    return new DecoratedProcedure({
       middlewares: this["~orpc"].middlewares,
       contract: this["~orpc"].contract,
       handler
-    }));
+    });
   }
 };
 
@@ -392,7 +392,8 @@ var Builder = class _Builder {
       contract: new ContractProcedure({
         route,
         InputSchema: void 0,
-        OutputSchema: void 0
+        OutputSchema: void 0,
+        errorMap: void 0
       })
     });
   }
@@ -402,7 +403,8 @@ var Builder = class _Builder {
       contract: new ContractProcedure({
         OutputSchema: void 0,
         InputSchema: schema,
-        inputExample: example
+        inputExample: example,
+        errorMap: void 0
       })
     });
   }
@@ -412,19 +414,31 @@ var Builder = class _Builder {
       contract: new ContractProcedure({
         InputSchema: void 0,
         OutputSchema: schema,
-        outputExample: example
+        outputExample: example,
+        errorMap: void 0
+      })
+    });
+  }
+  errors(errors) {
+    return new ProcedureBuilder({
+      middlewares: this["~orpc"].middlewares,
+      contract: new ContractProcedure({
+        InputSchema: void 0,
+        OutputSchema: void 0,
+        errorMap: errors
       })
     });
   }
   handler(handler) {
-    return decorateProcedure(new Procedure({
+    return new DecoratedProcedure({
       middlewares: this["~orpc"].middlewares,
       contract: new ContractProcedure({
         InputSchema: void 0,
-        OutputSchema: void 0
+        OutputSchema: void 0,
+        errorMap: void 0
       }),
       handler
-    }));
+    });
   }
   prefix(prefix) {
     return new RouterBuilder({
@@ -449,36 +463,47 @@ var Builder = class _Builder {
   }
 };
 
+// src/procedure-utils.ts
+function call(procedure, input, ...rest) {
+  return createProcedureClient(procedure, ...rest)(input);
+}
+
+// src/lazy-utils.ts
+function createLazyProcedureFormAnyLazy(lazied) {
+  const lazyProcedure = lazy(async () => {
+    const { default: maybeProcedure } = await unlazy(flatLazy(lazied));
+    if (!isProcedure(maybeProcedure)) {
+      throw new Error(`
+            Expected a lazy<procedure> but got lazy<unknown>.
+            This should be caught by TypeScript compilation.
+            Please report this issue if this makes you feel uncomfortable.
+        `);
+    }
+    return { default: maybeProcedure };
+  });
+  return lazyProcedure;
+}
+
 // src/router-client.ts
-function createRouterClient(options) {
-  if (isProcedure(options.router)) {
-    const caller = createProcedureClient({
-      ...options,
-      procedure: options.router,
-      context: options.context,
-      path: options.path
-    });
+function createRouterClient(router, ...rest) {
+  if (isProcedure(router)) {
+    const caller = createProcedureClient(router, ...rest);
     return caller;
   }
-  const procedureCaller = isLazy(options.router) ? createProcedureClient({
-    ...options,
-    procedure: createLazyProcedureFormAnyLazy(options.router),
-    context: options.context,
-    path: options.path
-  }) : {};
+  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 = getRouterChild(options.router, key);
+      const next = getRouterChild(router, key);
       if (!next) {
         return Reflect.get(target, key);
       }
-      return createRouterClient({
+      const [options] = rest;
+      return createRouterClient(next, {
         ...options,
-        router: next,
-        path: [...options.path ?? [], key]
+        path: [...options?.path ?? [], key]
       });
     }
   });
@@ -486,35 +511,39 @@ function createRouterClient(options) {
 }
 
 // src/index.ts
-import { configGlobal, fallbackToGlobalConfig } from "@orpc/contract";
-export * from "@orpc/shared/error";
+import { configGlobal, fallbackToGlobalConfig, isDefinedError, ORPCError, safe } from "@orpc/contract";
 var os = new Builder({});
 export {
   Builder,
+  DecoratedProcedure,
   LAZY_LOADER_SYMBOL,
+  ORPCError,
   Procedure,
   ProcedureBuilder,
   ProcedureImplementer,
   RouterBuilder,
   RouterImplementer,
+  call,
   configGlobal,
   createChainableImplementer,
+  createORPCErrorConstructorMap,
   createProcedureClient,
   createRouterClient,
   decorateLazy,
   decorateMiddleware,
-  decorateProcedure,
   deepSetLazyRouterPrefix,
   fallbackToGlobalConfig,
   flatLazy,
   getLazyRouterPrefix,
   getRouterChild,
   getRouterContract,
+  isDefinedError,
   isLazy,
   isProcedure,
   lazy,
   mergeContext,
   os,
+  safe,
   setRouterContract,
   unlazy
 };

package/dist/next.js

@@ -1,11 +1,11 @@
 import "./chunk-WUOGVGWG.js";
 import {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports
-} from "./chunk-3BAPJGK6.js";
-import "./chunk-E7GUWVR4.js";
+} from "./chunk-VY6NXNQT.js";
+import "./chunk-XDC42C3C.js";
 
 // src/adapters/next/serve.ts
 import { value } from "@orpc/shared";
@@ -27,9 +27,9 @@ function serve(handler, ...[options]) {
   };
 }
 export {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports as SuperJSON,
   serve
 };

package/dist/node.js

@@ -1,7 +1,7 @@
 import {
-  ORPCHandler
-} from "./chunk-3BAPJGK6.js";
-import "./chunk-E7GUWVR4.js";
+  RPCHandler
+} from "./chunk-VY6NXNQT.js";
+import "./chunk-XDC42C3C.js";
 
 // src/adapters/node/request-listener.ts
 function createRequest(req, res) {
@@ -61,10 +61,10 @@ async function sendResponse(res, response) {
 }
 
 // src/adapters/node/orpc-handler.ts
-var ORPCHandler2 = class {
+var RPCHandler2 = class {
   orpcFetchHandler;
   constructor(router, options) {
-    this.orpcFetchHandler = new ORPCHandler(router, options);
+    this.orpcFetchHandler = new RPCHandler(router, options);
   }
   async handle(req, res, ...[options]) {
     const request = createRequest(req, res);
@@ -79,7 +79,7 @@ var ORPCHandler2 = class {
   }
 };
 export {
-  ORPCHandler2 as ORPCHandler,
+  RPCHandler2 as RPCHandler,
   createHeaders,
   createRequest,
   sendResponse