@orpc/server 0.13.0 → 0.14.0

package/dist/{chunk-FL4ZAGNE.js → chunk-MZXEMHFS.js}

@@ -45,9 +45,8 @@ function decorateMiddleware(middleware) {
 }
 
 // src/procedure-caller.ts
-import { trim, value } from "@orpc/shared";
+import { executeWithHooks, trim, value } from "@orpc/shared";
 import { ORPCError } from "@orpc/shared/error";
-import { OpenAPIDeserializer } from "@orpc/transformer";
 
 // src/procedure.ts
 import {
@@ -109,96 +108,101 @@ function isProcedure(item) {
 
 // src/procedure-caller.ts
 function createProcedureCaller(options) {
-  const loadProcedure = async () => {
-    let procedure;
-    if (isLazy(options.procedure)) {
-      procedure = (await loadLazy(options.procedure)).default;
-    } else {
-      procedure = options.procedure;
-    }
-    if (!isProcedure(procedure)) {
-      throw new ORPCError({
-        code: "NOT_FOUND",
-        message: "Not found",
-        cause: new Error(trim(`
-          This error should be caught by the typescript compiler.
-          But if you still see this error, it means that you trying to call a lazy router (expected to be a lazy procedure).
-        `))
-      });
-    }
-    return procedure;
-  };
   const caller = async (input) => {
     const path = options.path ?? [];
-    const procedure = await loadProcedure();
-    const input_ = (() => {
-      if (!(input instanceof FormData)) {
-        return input;
-      }
-      const transformer = new OpenAPIDeserializer({
-        schema: procedure.zz$p.contract.zz$cp.InputSchema
-      });
-      return transformer.deserializeAsFormData(input);
-    })();
-    const validInput = (() => {
-      const schema = procedure.zz$p.contract.zz$cp.InputSchema;
-      if (!schema) {
-        return input_;
-      }
-      try {
-        return schema.parse(input_);
-      } catch (e) {
-        throw new ORPCError({
-          message: "Validation input failed",
-          code: "BAD_REQUEST",
-          cause: e
-        });
-      }
-    })();
-    const middlewares = procedure.zz$p.middlewares ?? [];
-    let currentMidIndex = 0;
-    let currentContext = await value(options.context);
-    const next = async (nextOptions) => {
-      const mid = middlewares[currentMidIndex];
-      currentMidIndex += 1;
-      currentContext = mergeContext(currentContext, nextOptions.context);
-      if (mid) {
-        return await mid(validInput, currentContext, {
-          path,
-          procedure,
-          next,
-          output: (output2) => ({ output: output2, context: void 0 })
-        });
-      } else {
-        return {
-          output: await await procedure.zz$p.func(validInput, currentContext, {
+    const procedure = await loadProcedure(options.procedure);
+    const context = await value(options.context);
+    const execute = async () => {
+      const validInput = (() => {
+        const schema = procedure.zz$p.contract.zz$cp.InputSchema;
+        if (!schema) {
+          return input;
+        }
+        try {
+          return schema.parse(input);
+        } catch (e) {
+          throw new ORPCError({
+            message: "Validation input failed",
+            code: "BAD_REQUEST",
+            cause: e
+          });
+        }
+      })();
+      const middlewares = procedure.zz$p.middlewares ?? [];
+      let currentMidIndex = 0;
+      let currentContext = context;
+      const next = async (nextOptions) => {
+        const mid = middlewares[currentMidIndex];
+        currentMidIndex += 1;
+        currentContext = mergeContext(currentContext, nextOptions.context);
+        if (mid) {
+          return await mid(validInput, currentContext, {
             path,
-            procedure
-          }),
-          context: currentContext
-        };
-      }
+            procedure,
+            next,
+            output: (output3) => ({ output: output3, context: void 0 })
+          });
+        } else {
+          return {
+            output: await await procedure.zz$p.func(validInput, currentContext, {
+              path,
+              procedure
+            }),
+            context: currentContext
+          };
+        }
+      };
+      const output2 = (await next({})).output;
+      const validOutput = await (async () => {
+        const schema = procedure.zz$p.contract.zz$cp.OutputSchema;
+        if (!schema) {
+          return output2;
+        }
+        const result = await schema.safeParseAsync(output2);
+        if (result.error) {
+          throw new ORPCError({
+            message: "Validation output failed",
+            code: "INTERNAL_SERVER_ERROR",
+            cause: result.error
+          });
+        }
+        return result.data;
+      })();
+      return validOutput;
     };
-    const output = (await next({})).output;
-    const validOutput = await (async () => {
-      const schema = procedure.zz$p.contract.zz$cp.OutputSchema;
-      if (!schema) {
-        return output;
-      }
-      const result = await schema.safeParseAsync(output);
-      if (result.error) {
-        throw new ORPCError({
-          message: "Validation output failed",
-          code: "INTERNAL_SERVER_ERROR",
-          cause: result.error
-        });
-      }
-      return result.data;
-    })();
-    return validOutput;
+    const output = await executeWithHooks({
+      hooks: options,
+      input,
+      context,
+      meta: {
+        path,
+        procedure
+      },
+      execute
+    });
+    return output;
   };
   return caller;
 }
+async function loadProcedure(procedure) {
+  let loadedProcedure;
+  if (isLazy(procedure)) {
+    loadedProcedure = (await loadLazy(procedure)).default;
+  } else {
+    loadedProcedure = procedure;
+  }
+  if (!isProcedure(loadedProcedure)) {
+    throw new ORPCError({
+      code: "NOT_FOUND",
+      message: "Not found",
+      cause: new Error(trim(`
+          This error should be caught by the typescript compiler.
+          But if you still see this error, it means that you trying to call a lazy router (expected to be a lazy procedure).
+        `))
+    });
+  }
+  return loadedProcedure;
+}
 
 // src/lazy.ts
 var LAZY_LOADER_SYMBOL = Symbol("ORPC_LAZY_LOADER");
@@ -260,8 +264,9 @@ export {
   createFlattenLazy,
   decorateLazy,
   createProcedureCaller,
+  loadProcedure,
   Procedure,
   decorateProcedure,
   isProcedure
 };
-//# sourceMappingURL=chunk-FL4ZAGNE.js.map
+//# sourceMappingURL=chunk-MZXEMHFS.js.map

package/dist/fetch.js

@@ -2,7 +2,7 @@ import {
   createProcedureCaller,
   isLazy,
   isProcedure
-} from "./chunk-FL4ZAGNE.js";
+} from "./chunk-MZXEMHFS.js";
 
 // src/fetch/handle.ts
 import { ORPCError } from "@orpc/shared/error";
@@ -24,7 +24,7 @@ async function handleFetchRequest(options) {
 
 // src/fetch/handler.ts
 import { ORPC_HEADER, ORPC_HEADER_VALUE } from "@orpc/contract";
-import { trim, value } from "@orpc/shared";
+import { executeWithHooks, trim, value } from "@orpc/shared";
 import { ORPCError as ORPCError2 } from "@orpc/shared/error";
 import { ORPCDeserializer, ORPCSerializer } from "@orpc/transformer";
 var serializer = new ORPCSerializer();
@@ -56,10 +56,13 @@ function createORPCHandler() {
       });
     };
     try {
-      return await options.hooks?.(
+      return await executeWithHooks({
+        hooks: options,
         context,
-        { next: handler, response: (response) => response }
-      ) ?? await handler();
+        execute: handler,
+        input: options.request,
+        meta: void 0
+      });
     } catch (e) {
       const error = e instanceof ORPCError2 ? e : new ORPCError2({
         code: "INTERNAL_SERVER_ERROR",

package/dist/index.js

@@ -10,8 +10,9 @@ import {
   isLazy,
   isProcedure,
   loadLazy,
+  loadProcedure,
   mergeContext
-} from "./chunk-FL4ZAGNE.js";
+} from "./chunk-MZXEMHFS.js";
 
 // src/builder.ts
 import {
@@ -409,28 +410,25 @@ function toContractRouter(router) {
 
 // src/router-caller.ts
 function createRouterCaller(options) {
-  return createRouterCallerInternal({
-    current: options.router,
-    context: options.context,
-    path: options.basePath ?? []
-  });
+  return createRouterCallerInternal(options);
 }
 function createRouterCallerInternal(options) {
-  const procedureCaller = isLazy(options.current) || isProcedure(options.current) ? createProcedureCaller({
-    procedure: options.current,
+  const procedureCaller = isLazy(options.router) || isProcedure(options.router) ? createProcedureCaller({
+    ...options,
+    procedure: options.router,
     context: options.context,
-    path: options.path
+    path: options.basePath
   }) : {};
   const recursive = new Proxy(procedureCaller, {
     get(target, key) {
       if (typeof key !== "string") {
         return Reflect.get(target, key);
       }
-      const next = options.current[key];
+      const next = options.router[key];
       return createRouterCallerInternal({
-        current: next,
-        context: options.context,
-        path: [...options.path, key]
+        ...options,
+        router: next,
+        basePath: [...options.basePath ?? [], key]
       });
     }
   });
@@ -461,6 +459,7 @@ export {
   isLazy,
   isProcedure,
   loadLazy,
+  loadProcedure,
   mergeContext,
   os,
   toContractRouter

package/dist/src/fetch/types.d.ts

@@ -1,9 +1,5 @@
-import type { PartialOnUndefinedDeep, Promisable, Value } from '@orpc/shared';
+import type { Hooks, PartialOnUndefinedDeep, Value } from '@orpc/shared';
 import type { Router } from '../router';
-export interface FetchHandlerHooks {
-    next: () => Promise<Response>;
-    response: (response: Response) => Response;
-}
 export type FetchHandlerOptions<TRouter extends Router<any>> = {
     /**
      * The `router` used for handling the request and routing,
@@ -21,15 +17,11 @@ export type FetchHandlerOptions<TRouter extends Router<any>> = {
      * @example /api
      */
     prefix?: string;
-    /**
-     * Hooks for executing logics on lifecycle events.
-     */
-    hooks?: (context: TRouter extends Router<infer UContext> ? UContext : never, hooks: FetchHandlerHooks) => Promisable<Response>;
 } & PartialOnUndefinedDeep<{
     /**
      * The context used to handle the request.
      */
     context: Value<TRouter extends Router<infer UContext> ? UContext : never>;
-}>;
+}> & Hooks<Request, Response, TRouter extends Router<infer UContext> ? UContext : never, undefined>;
 export type FetchHandler = <TRouter extends Router<any>>(options: FetchHandlerOptions<TRouter>) => Promise<Response | undefined>;
 //# sourceMappingURL=types.d.ts.map

package/dist/src/procedure-caller.d.ts

@@ -1,20 +1,25 @@
 import type { SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { Hooks, PartialOnUndefinedDeep, Value } from '@orpc/shared';
 import type { Lazy } from './lazy';
-import { type Value } from '@orpc/shared';
-import { type ANY_LAZY_PROCEDURE, type ANY_PROCEDURE, type Procedure } from './procedure';
-export interface CreateProcedureCallerOptions<TProcedure extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE> {
-    procedure: TProcedure;
-    /**
-     * The context used when calling the procedure.
-     */
-    context: Value<TProcedure extends Procedure<infer UContext, any, any, any, any> | Lazy<Procedure<infer UContext, any, any, any, any>> ? UContext : never>;
+import type { ANY_LAZY_PROCEDURE, ANY_PROCEDURE, Procedure } from './procedure';
+export type CreateProcedureCallerOptions<T extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE> = T extends Procedure<infer UContext, any, any, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<infer UContext, any, any, infer UOutputSchema, infer UFuncOutput>> ? {
+    procedure: T;
     /**
      * This is helpful for logging and analytics.
      *
      * @internal
      */
     path?: string[];
-}
-export type ProcedureCaller<TProcedure extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE> = TProcedure extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput>> ? (...input: [input: SchemaInput<UInputSchema> | FormData] | (undefined extends SchemaInput<UInputSchema> ? [] : never)) => Promise<SchemaOutput<UOutputSchema, UFuncOutput>> : never;
+} & PartialOnUndefinedDeep<{
+    /**
+     * The context used when calling the procedure.
+     */
+    context: Value<UContext>;
+}> & Hooks<unknown, SchemaOutput<UOutputSchema, UFuncOutput>, UContext, {
+    path: string[];
+    procedure: ANY_PROCEDURE;
+}> : never;
+export type ProcedureCaller<TProcedure extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE> = TProcedure extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput>> ? (...input: [input: SchemaInput<UInputSchema>] | (undefined extends SchemaInput<UInputSchema> ? [] : never)) => Promise<SchemaOutput<UOutputSchema, UFuncOutput>> : never;
 export declare function createProcedureCaller<TProcedure extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE>(options: CreateProcedureCallerOptions<TProcedure>): ProcedureCaller<TProcedure>;
+export declare function loadProcedure(procedure: ANY_PROCEDURE | ANY_LAZY_PROCEDURE): Promise<ANY_PROCEDURE>;
 //# sourceMappingURL=procedure-caller.d.ts.map

package/dist/src/router-caller.d.ts

@@ -1,8 +1,11 @@
-import type { Value } from '@orpc/shared';
+import type { Hooks, Value } from '@orpc/shared';
 import type { ANY_LAZY_PROCEDURE, ANY_PROCEDURE } from './procedure';
 import type { Router } from './router';
 import { type ProcedureCaller } from './procedure-caller';
-export interface CreateRouterCallerOptions<TRouter extends Router<any>> {
+export interface CreateRouterCallerOptions<TRouter extends Router<any>> extends Hooks<unknown, unknown, TRouter extends Router<infer UContext> ? UContext : never, {
+    path: string[];
+    procedure: ANY_PROCEDURE;
+}> {
     router: TRouter;
     /**
      * The context used when calling the procedure.

package/dist/src/router.d.ts

@@ -13,9 +13,9 @@ export type RouterWithContract<TContext extends Context, TContract extends Contr
 };
 export declare function toContractRouter(router: ContractRouter | Router<any>): ContractRouter;
 export type InferRouterInputs<T extends Router<any>> = {
-    [K in keyof T]: T[K] extends Procedure<any, any, infer UInputSchema, any, any> ? SchemaInput<UInputSchema> : T[K] extends Router<any> ? InferRouterInputs<T[K]> : never;
+    [K in keyof T]: T[K] extends Procedure<any, any, infer UInputSchema, any, any> | Lazy<Procedure<any, any, infer UInputSchema, any, any>> ? SchemaInput<UInputSchema> : T[K] extends Router<any> ? InferRouterInputs<T[K]> : never;
 };
 export type InferRouterOutputs<T extends Router<any>> = {
-    [K in keyof T]: T[K] extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput> ? SchemaOutput<UOutputSchema, UFuncOutput> : T[K] extends Router<any> ? InferRouterOutputs<T[K]> : never;
+    [K in keyof T]: T[K] extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput>> ? SchemaOutput<UOutputSchema, UFuncOutput> : T[K] extends Router<any> ? InferRouterOutputs<T[K]> : never;
 };
 //# sourceMappingURL=router.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -35,15 +35,15 @@
   ],
   "peerDependencies": {
     "zod": ">=3.23.0",
-    "@orpc/zod": "0.13.0"
+    "@orpc/zod": "0.14.0"
   },
   "dependencies": {
-    "@orpc/transformer": "0.13.0",
-    "@orpc/contract": "0.13.0",
-    "@orpc/shared": "0.13.0"
+    "@orpc/shared": "0.14.0",
+    "@orpc/transformer": "0.14.0",
+    "@orpc/contract": "0.14.0"
   },
   "devDependencies": {
-    "@orpc/openapi": "0.13.0"
+    "@orpc/openapi": "0.14.0"
   },
   "scripts": {
     "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",