@orpc/server 0.14.0 → 0.16.0

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

@@ -108,26 +108,32 @@ function isProcedure(item) {
 
 // src/procedure-caller.ts
 function createProcedureCaller(options) {
-  const caller = async (input) => {
+  const caller = async (...args) => {
+    const [input, callerOptions] = args;
     const path = options.path ?? [];
     const procedure = await loadProcedure(options.procedure);
     const context = await value(options.context);
     const execute = async () => {
-      const validInput = (() => {
+      const validInput = await (async () => {
         const schema = procedure.zz$p.contract.zz$cp.InputSchema;
         if (!schema) {
           return input;
         }
-        try {
-          return schema.parse(input);
-        } catch (e) {
+        const result = await schema["~standard"].validate(input);
+        if (result.issues) {
           throw new ORPCError({
             message: "Validation input failed",
             code: "BAD_REQUEST",
-            cause: e
+            issues: result.issues
           });
         }
+        return result.value;
       })();
+      const meta = {
+        path,
+        procedure,
+        signal: callerOptions?.signal
+      };
       const middlewares = procedure.zz$p.middlewares ?? [];
       let currentMidIndex = 0;
       let currentContext = context;
@@ -137,17 +143,13 @@ function createProcedureCaller(options) {
         currentContext = mergeContext(currentContext, nextOptions.context);
         if (mid) {
           return await mid(validInput, currentContext, {
-            path,
-            procedure,
+            ...meta,
             next,
             output: (output3) => ({ output: output3, context: void 0 })
           });
         } else {
           return {
-            output: await await procedure.zz$p.func(validInput, currentContext, {
-              path,
-              procedure
-            }),
+            output: await await procedure.zz$p.func(validInput, currentContext, meta),
             context: currentContext
           };
         }
@@ -158,15 +160,14 @@ function createProcedureCaller(options) {
         if (!schema) {
           return output2;
         }
-        const result = await schema.safeParseAsync(output2);
-        if (result.error) {
+        const result = await schema["~standard"].validate(output2);
+        if (result.issues) {
           throw new ORPCError({
             message: "Validation output failed",
-            code: "INTERNAL_SERVER_ERROR",
-            cause: result.error
+            code: "INTERNAL_SERVER_ERROR"
           });
         }
-        return result.data;
+        return result.value;
       })();
       return validOutput;
     };
@@ -269,4 +270,4 @@ export {
   decorateProcedure,
   isProcedure
 };
-//# sourceMappingURL=chunk-MZXEMHFS.js.map
+//# sourceMappingURL=chunk-Z2PQ6UAM.js.map

package/dist/fetch.js

@@ -2,7 +2,7 @@ import {
   createProcedureCaller,
   isLazy,
   isProcedure
-} from "./chunk-MZXEMHFS.js";
+} from "./chunk-Z2PQ6UAM.js";
 
 // src/fetch/handle.ts
 import { ORPCError } from "@orpc/shared/error";
@@ -48,7 +48,7 @@ function createORPCHandler() {
         procedure: match.procedure,
         path: match.path
       });
-      const output = await caller(input);
+      const output = await caller(input, { signal: options.signal });
       const { body, headers } = serializer.serialize(output);
       return new Response(body, {
         status: 200,
@@ -61,7 +61,9 @@ function createORPCHandler() {
         context,
         execute: handler,
         input: options.request,
-        meta: void 0
+        meta: {
+          signal: options.signal
+        }
       });
     } catch (e) {
       const error = e instanceof ORPCError2 ? e : new ORPCError2({

package/dist/index.js

@@ -12,7 +12,7 @@ import {
   loadLazy,
   loadProcedure,
   mergeContext
-} from "./chunk-MZXEMHFS.js";
+} from "./chunk-Z2PQ6UAM.js";
 
 // src/builder.ts
 import {

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

@@ -1,5 +1,6 @@
 import type { Hooks, PartialOnUndefinedDeep, Value } from '@orpc/shared';
 import type { Router } from '../router';
+import type { CallerOptions } from '../types';
 export type FetchHandlerOptions<TRouter extends Router<any>> = {
     /**
      * The `router` used for handling the request and routing,
@@ -22,6 +23,6 @@ export type FetchHandlerOptions<TRouter extends Router<any>> = {
      * 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>;
+}> & CallerOptions & Hooks<Request, Response, TRouter extends Router<infer UContext> ? UContext : never, CallerOptions>;
 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

@@ -2,6 +2,7 @@ import type { SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { Hooks, PartialOnUndefinedDeep, Value } from '@orpc/shared';
 import type { Lazy } from './lazy';
 import type { ANY_LAZY_PROCEDURE, ANY_PROCEDURE, Procedure } from './procedure';
+import type { Caller } from './types';
 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;
     /**
@@ -19,7 +20,7 @@ export type CreateProcedureCallerOptions<T extends ANY_PROCEDURE | ANY_LAZY_PROC
     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 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>> ? Caller<SchemaInput<UInputSchema>, 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-implementer.d.ts

@@ -12,10 +12,10 @@ export declare class RouterImplementer<TContext extends Context, TContract exten
     constructor(zz$ri: {
         contract: TContract;
     });
-    router(router: RouterWithContract<TContext, TContract>): HandledRouter<RouterWithContract<TContext, TContract>>;
-    lazy(loader: () => Promise<{
-        default: RouterWithContract<TContext, TContract>;
-    }>): DecoratedLazy<RouterWithContract<TContext, TContract>>;
+    router<U extends RouterWithContract<TContext, TContract>>(router: U): HandledRouter<U>;
+    lazy<U extends RouterWithContract<TContext, TContract>>(loader: () => Promise<{
+        default: U;
+    }>): DecoratedLazy<U>;
 }
 export type ChainedRouterImplementer<TContext extends Context, TContract extends ContractRouter, TExtraContext extends Context> = {
     [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? ProcedureImplementer<TContext, TExtraContext, UInputSchema, UOutputSchema> : TContract[K] extends ContractRouter ? ChainedRouterImplementer<TContext, TContract[K], TExtraContext> : never;

package/dist/src/router.d.ts

@@ -9,7 +9,7 @@ export type HandledRouter<TRouter extends Router<any>> = {
     [K in keyof TRouter]: TRouter[K] extends Procedure<infer UContext, infer UExtraContext, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> ? DecoratedProcedure<UContext, UExtraContext, UInputSchema, UOutputSchema, UFuncOutput> : TRouter[K] extends ANY_LAZY ? DecoratedLazy<TRouter[K]> : TRouter[K] extends Router<any> ? HandledRouter<TRouter[K]> : never;
 };
 export type RouterWithContract<TContext extends Context, TContract extends ContractRouter> = {
-    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? Procedure<TContext, any, UInputSchema, UOutputSchema, any> | Lazy<Procedure<TContext, any, UInputSchema, UOutputSchema, any>> : TContract[K] extends ContractRouter ? RouterWithContract<TContext, TContract[K]> | Lazy<RouterWithContract<TContext, TContract[K]>> : never;
+    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? Procedure<TContext, any, UInputSchema, UOutputSchema, any> | Lazy<Procedure<TContext, any, UInputSchema, UOutputSchema, any>> : TContract[K] extends ContractRouter ? RouterWithContract<TContext, TContract[K]> : never;
 };
 export declare function toContractRouter(router: ContractRouter | Router<any>): ContractRouter;
 export type InferRouterInputs<T extends Router<any>> = {

package/dist/src/types.d.ts

@@ -1,7 +1,13 @@
 import type { WELL_DEFINED_PROCEDURE } from './procedure';
 export type Context = Record<string, unknown> | undefined;
 export type MergeContext<TA extends Context, TB extends Context> = TA extends undefined ? TB : TB extends undefined ? TA : TA & TB;
-export interface Meta {
+export interface CallerOptions {
+    signal?: AbortSignal;
+}
+export interface Caller<TInput, TOutput> {
+    (...opts: [input: TInput, options?: CallerOptions] | (undefined extends TInput ? [] : never)): Promise<TOutput>;
+}
+export interface Meta extends CallerOptions {
     path: string[];
     procedure: WELL_DEFINED_PROCEDURE;
 }

package/package.json

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