@orpc/server 0.28.0 → 0.30.0

package/dist/{chunk-V3I7RIRY.js → chunk-2HRHHZJD.js}

@@ -4,7 +4,7 @@ import {
   getRouterChild,
   isProcedure,
   unlazy
-} from "./chunk-DNG2IB3R.js";
+} from "./chunk-SA7HGGVY.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);
@@ -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-2HRHHZJD.js.map

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

@@ -36,9 +36,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 +83,35 @@ function flatLazy(lazied) {
   return lazy(flattenLoader);
 }
 
+// src/middleware.ts
+function middlewareOutputFn(output) {
+  return { output, context: void 0 };
+}
+
 // 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,24 +154,44 @@ async function validateOutput(procedure, output) {
   }
   return result.value;
 }
-async function executeMiddlewareChain(opt) {
-  const middlewares = opt.procedure["~orpc"].middlewares ?? [];
-  let currentMidIndex = 0;
+function executeMiddlewareChain(middlewares, opt, input) {
+  let currentIndex = 0;
   let currentContext = opt.context;
-  const next = async (nextOptions) => {
-    const mid = middlewares[currentMidIndex];
-    currentMidIndex += 1;
+  const executeMiddlewareChain2 = async (nextOptions) => {
+    const mid = middlewares[currentIndex];
+    currentIndex += 1;
     currentContext = mergeContext(currentContext, nextOptions.context);
     if (mid) {
-      return await mid({ ...opt, context: currentContext, next }, opt.input, (output) => ({ output, context: void 0 }));
+      return await mid({ ...opt, context: currentContext, next: executeMiddlewareChain2 }, input, middlewareOutputFn);
     }
-    const result = {
-      output: await opt.procedure["~orpc"].handler({ ...opt, context: currentContext }),
-      context: currentContext
-    };
-    return result;
+    return opt.next({ context: currentContext });
+  };
+  return executeMiddlewareChain2({});
+}
+async function executeProcedureInternal(procedure, options) {
+  const executeHandler = async (context, input) => {
+    return await procedure["~orpc"].handler({ ...options, context, input });
+  };
+  const executePostMiddlewares = async (context, input) => {
+    const validatedInput = await validateInput(procedure, input);
+    const result2 = await executeMiddlewareChain(procedure["~orpc"].postMiddlewares, {
+      ...options,
+      context,
+      next: async ({ context: context2 }) => {
+        return middlewareOutputFn(
+          await executeHandler(context2, validatedInput)
+        );
+      }
+    }, validatedInput);
+    const validatedOutput = await validateOutput(procedure, result2.output);
+    return { ...result2, output: validatedOutput };
   };
-  return (await next({})).output;
+  const result = await executeMiddlewareChain(procedure["~orpc"].preMiddlewares, {
+    ...options,
+    context: options.context,
+    next: ({ context }) => executePostMiddlewares(context, options.input)
+  }, options.input);
+  return result.output;
 }
 
 // src/router.ts
@@ -221,7 +235,8 @@ export {
   isLazy,
   unlazy,
   flatLazy,
+  middlewareOutputFn,
   createProcedureClient,
   getRouterChild
 };
-//# sourceMappingURL=chunk-DNG2IB3R.js.map
+//# sourceMappingURL=chunk-SA7HGGVY.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-2HRHHZJD.js";
+import "./chunk-SA7HGGVY.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-V3I7RIRY.js";
-import "./chunk-DNG2IB3R.js";
+} from "./chunk-2HRHHZJD.js";
+import "./chunk-SA7HGGVY.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
 };