@orpc/server 0.0.0-next.4220427 → 0.0.0-next.43889a7

package/dist/{chunk-V3I7RIRY.js → chunk-26GHKV43.js}

@@ -4,7 +4,7 @@ import {
   getRouterChild,
   isProcedure,
   unlazy
-} from "./chunk-DNG2IB3R.js";
+} from "./chunk-LDIL7OEP.js";
 
 // src/adapters/fetch/super-json.ts
 var super_json_exports = {};
@@ -238,7 +238,7 @@ var ORPCProcedureMatcher = class {
 // src/adapters/fetch/orpc-handler.ts
 import { ORPCError as ORPCError2 } from "@orpc/contract";
 import { executeWithHooks, trim as trim2 } from "@orpc/shared";
-var ORPCHandler = class {
+var RPCHandler = class {
   constructor(router, options) {
     this.options = options;
     this.procedureMatcher = options?.procedureMatcher ?? new ORPCProcedureMatcher(router);
@@ -247,7 +247,7 @@ var ORPCHandler = class {
   procedureMatcher;
   payloadCodec;
   async handle(request, ...[options]) {
-    const context = options?.context;
+    const context = options?.context ?? {};
     const execute = async () => {
       const url = new URL(request.url);
       const pathname = `/${trim2(url.pathname.replace(options?.prefix ?? "", ""), "/")}`;
@@ -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-V3I7RIRY.js.map
+//# sourceMappingURL=chunk-26GHKV43.js.map

package/dist/{chunk-DNG2IB3R.js → chunk-LDIL7OEP.js}

@@ -4,18 +4,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/utils.ts
-function mergeContext(a, b) {
-  if (!a)
-    return b;
-  if (!b)
-    return a;
-  return {
-    ...a,
-    ...b
-  };
-}
-
 // src/procedure.ts
 import { isContractProcedure } from "@orpc/contract";
 var Procedure = class {
@@ -36,9 +24,6 @@ function isProcedure(item) {
 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) {
@@ -86,38 +71,35 @@ function flatLazy(lazied) {
   return lazy(flattenLoader);
 }
 
+// src/middleware.ts
+function middlewareOutputFn(output) {
+  return { output, context: {} };
+}
+
 // src/procedure-client.ts
 import { ORPCError as ORPCError2, validateORPCError, ValidationError } from "@orpc/contract";
 import { executeWithHooks, toError, value } from "@orpc/shared";
-function createProcedureClient(options) {
+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 meta = {
+    const path = options?.path ?? [];
+    const { default: procedure } = await unlazy(lazyableProcedure);
+    const context = await value(options?.context ?? {}, callerOptions?.context);
+    const errors = createORPCErrorConstructorMap(procedure["~orpc"].contract["~orpc"].errorMap);
+    const executeOptions = {
+      input,
+      context,
+      errors,
       path,
       procedure,
       signal: callerOptions?.signal
     };
-    const executeWithValidation = async () => {
-      const validInput = await validateInput(procedure, input);
-      const output = await executeMiddlewareChain({
-        context,
-        input: validInput,
-        path,
-        procedure,
-        signal: callerOptions?.signal,
-        errors: createORPCErrorConstructorMap(procedure["~orpc"].contract["~orpc"].errorMap)
-      });
-      return validateOutput(procedure, output);
-    };
     try {
       const output = await executeWithHooks({
         hooks: options,
         input,
         context,
-        meta,
-        execute: executeWithValidation
+        meta: executeOptions,
+        execute: () => executeProcedureInternal(procedure, executeOptions)
       });
       return output;
     } catch (e) {
@@ -160,21 +142,29 @@ async function validateOutput(procedure, output) {
   }
   return result.value;
 }
-async function executeMiddlewareChain(opt) {
-  const middlewares = opt.procedure["~orpc"].middlewares ?? [];
-  let currentMidIndex = 0;
-  let currentContext = opt.context;
-  const next = async (nextOptions) => {
-    const mid = middlewares[currentMidIndex];
-    currentMidIndex += 1;
-    currentContext = mergeContext(currentContext, nextOptions.context);
-    if (mid) {
-      return await mid({ ...opt, context: currentContext, next }, opt.input, (output) => ({ output, context: void 0 }));
+async function executeProcedureInternal(procedure, options) {
+  const middlewares = procedure["~orpc"].middlewares;
+  const inputValidationIndex = Math.min(Math.max(0, procedure["~orpc"].inputValidationIndex), middlewares.length);
+  const outputValidationIndex = Math.min(Math.max(0, procedure["~orpc"].outputValidationIndex), middlewares.length);
+  let currentIndex = 0;
+  let currentContext = options.context;
+  let currentInput = options.input;
+  const next = async (...[nextOptions]) => {
+    const index = currentIndex;
+    currentIndex += 1;
+    currentContext = { ...currentContext, ...nextOptions?.context };
+    if (index === inputValidationIndex) {
+      currentInput = await validateInput(procedure, currentInput);
+    }
+    const mid = middlewares[index];
+    const result = mid ? await mid({ ...options, context: currentContext, next }, currentInput, middlewareOutputFn) : { output: await procedure["~orpc"].handler({ ...options, context: currentContext, input: currentInput }), context: currentContext };
+    if (index === outputValidationIndex) {
+      const validatedOutput = await validateOutput(procedure, result.output);
+      return {
+        ...result,
+        output: validatedOutput
+      };
     }
-    const result = {
-      output: await opt.procedure["~orpc"].handler({ ...opt, context: currentContext }),
-      context: currentContext
-    };
     return result;
   };
   return (await next({})).output;
@@ -212,7 +202,6 @@ function getRouterChild(router, ...path) {
 
 export {
   __export,
-  mergeContext,
   Procedure,
   isProcedure,
   createORPCErrorConstructorMap,
@@ -221,7 +210,8 @@ export {
   isLazy,
   unlazy,
   flatLazy,
+  middlewareOutputFn,
   createProcedureClient,
   getRouterChild
 };
-//# sourceMappingURL=chunk-DNG2IB3R.js.map
+//# sourceMappingURL=chunk-LDIL7OEP.js.map

package/dist/fetch.js

@@ -1,15 +1,15 @@
 import "./chunk-WUOGVGWG.js";
 import {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports
-} from "./chunk-V3I7RIRY.js";
-import "./chunk-DNG2IB3R.js";
+} from "./chunk-26GHKV43.js";
+import "./chunk-LDIL7OEP.js";
 export {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports as SuperJSON
 };
 //# sourceMappingURL=fetch.js.map

package/dist/hono.js

@@ -1,17 +1,17 @@
 import "./chunk-WUOGVGWG.js";
 import {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports
-} from "./chunk-V3I7RIRY.js";
-import "./chunk-DNG2IB3R.js";
+} from "./chunk-26GHKV43.js";
+import "./chunk-LDIL7OEP.js";
 
 // src/adapters/hono/middleware.ts
 import { value } from "@orpc/shared";
 function createMiddleware(handler, ...[options]) {
   return async (c, next) => {
-    const context = await value(options?.context, c);
+    const context = await value(options?.context ?? {}, c);
     const { matched, response } = await handler.handle(c.req.raw, { ...options, context });
     if (matched) {
       c.res = response;
@@ -21,9 +21,9 @@ function createMiddleware(handler, ...[options]) {
   };
 }
 export {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports as SuperJSON,
   createMiddleware
 };