@trpc/server 11.0.0-next.320 → 11.0.0-next.323

package/src/unstable-core-do-not-import/procedure.ts

@@ -1,3 +1,4 @@
+import type { TRPCError } from './error/TRPCError';
 import type { ProcedureCallOptions } from './procedureBuilder';
 
 export const procedureTypes = ['query', 'mutation', 'subscription'] as const;
@@ -22,7 +23,9 @@ export interface ProcedureOptions {
 interface BuiltProcedureDef {
   input: unknown;
   output: unknown;
+  experimental_caller?: true;
 }
+
 /**
  *
  * @internal
@@ -45,7 +48,13 @@ export interface Procedure<
   /**
    * @internal
    */
-  (opts: ProcedureCallOptions): Promise<unknown>;
+  (
+    opts: TDef['experimental_caller'] extends true
+      ? TDef['input']
+      : ProcedureCallOptions,
+  ): Promise<
+    TDef['experimental_caller'] extends true ? TDef['output'] : unknown
+  >;
 }
 
 export interface QueryProcedure<TDef extends BuiltProcedureDef>
@@ -72,3 +81,14 @@ export type inferProcedureParams<TProcedure> = TProcedure extends AnyProcedure
   : never;
 export type inferProcedureOutput<TProcedure> =
   inferProcedureParams<TProcedure>['_output_out'];
+
+/**
+ * @internal
+ */
+export interface ErrorHandlerOptions<TContext> {
+  error: TRPCError;
+  type: ProcedureType | 'unknown';
+  path: string | undefined;
+  input: unknown;
+  ctx: TContext | undefined;
+}

package/src/unstable-core-do-not-import/procedureBuilder.ts

@@ -45,6 +45,11 @@ type DefaultValue<TValue, TFallback> = TValue extends UnsetMarker
   ? TFallback
   : TValue;
 
+export type CallerOverride = (opts: {
+  args: unknown[];
+  invoke: (opts: ProcedureCallOptions) => Promise<unknown>;
+  _def: AnyProcedure['_def'];
+}) => Promise<unknown>;
 type ProcedureBuilderDef<TMeta> = {
   procedure: true;
   inputs: Parser[];
@@ -52,9 +57,20 @@ type ProcedureBuilderDef<TMeta> = {
   meta?: TMeta;
   resolver?: ProcedureBuilderResolver;
   middlewares: AnyMiddlewareFunction[];
+  /**
+   * @deprecated use `type` instead
+   */
   mutation?: boolean;
+  /**
+   * @deprecated use `type` instead
+   */
   query?: boolean;
+  /**
+   * @deprecated use `type` instead
+   */
   subscription?: boolean;
+  type?: ProcedureType;
+  caller?: CallerOverride;
 };
 
 type AnyProcedureBuilderDef = ProcedureBuilderDef<any>;
@@ -98,6 +114,7 @@ export type AnyProcedureBuilder = ProcedureBuilder<
   any,
   any,
   any,
+  any,
   any
 >;
 
@@ -114,7 +131,8 @@ export type inferProcedureBuilderResolverOptions<
   infer _TInputIn,
   infer TInputOut,
   infer _TOutputIn,
-  infer _TOutputOut
+  infer _TOutputOut,
+  infer _TCaller
 >
   ? ProcedureResolverOptions<
       TContext,
@@ -144,6 +162,7 @@ export interface ProcedureBuilder<
   TInputOut,
   TOutputIn,
   TOutputOut,
+  TCaller extends boolean,
 > {
   /**
    * Add an input parser to the procedure.
@@ -168,7 +187,8 @@ export interface ProcedureBuilder<
     IntersectIfDefined<TInputIn, inferParser<$Parser>['in']>,
     IntersectIfDefined<TInputOut, inferParser<$Parser>['out']>,
     TOutputIn,
-    TOutputOut
+    TOutputOut,
+    TCaller
   >;
   /**
    * Add an output parser to the procedure.
@@ -183,7 +203,8 @@ export interface ProcedureBuilder<
     TInputIn,
     TInputOut,
     IntersectIfDefined<TOutputIn, inferParser<$Parser>['in']>,
-    IntersectIfDefined<TOutputOut, inferParser<$Parser>['out']>
+    IntersectIfDefined<TOutputOut, inferParser<$Parser>['out']>,
+    TCaller
   >;
   /**
    * Add a meta data to the procedure.
@@ -198,7 +219,8 @@ export interface ProcedureBuilder<
     TInputIn,
     TInputOut,
     TOutputIn,
-    TOutputOut
+    TOutputOut,
+    TCaller
   >;
   /**
    * Add a middleware to the procedure.
@@ -226,7 +248,8 @@ export interface ProcedureBuilder<
     TInputIn,
     TInputOut,
     TOutputIn,
-    TOutputOut
+    TOutputOut,
+    TCaller
   >;
 
   /**
@@ -250,7 +273,8 @@ export interface ProcedureBuilder<
             $InputIn,
             $InputOut,
             $OutputIn,
-            $OutputOut
+            $OutputOut,
+            TCaller
           >
         : TypeError<'Meta mismatch'>
       : TypeError<'Context mismatch'>,
@@ -261,7 +285,8 @@ export interface ProcedureBuilder<
     IntersectIfDefined<TInputIn, $InputIn>,
     IntersectIfDefined<TInputIn, $InputOut>,
     IntersectIfDefined<TOutputIn, $OutputIn>,
-    IntersectIfDefined<TOutputOut, $OutputOut>
+    IntersectIfDefined<TOutputOut, $OutputOut>,
+    TCaller
   >;
   /**
    * Query procedure
@@ -276,10 +301,18 @@ export interface ProcedureBuilder<
       TOutputIn,
       $Output
     >,
-  ): QueryProcedure<{
-    input: DefaultValue<TInputIn, void>;
-    output: DefaultValue<TOutputOut, $Output>;
-  }>;
+  ): QueryProcedure<
+    TCaller extends true
+      ? {
+          experimental_caller: true;
+          input: DefaultValue<TInputIn, void>;
+          output: DefaultValue<TOutputOut, $Output>;
+        }
+      : {
+          input: DefaultValue<TInputIn, void>;
+          output: DefaultValue<TOutputOut, $Output>;
+        }
+  >;
 
   /**
    * Mutation procedure
@@ -294,10 +327,18 @@ export interface ProcedureBuilder<
       TOutputIn,
       $Output
     >,
-  ): MutationProcedure<{
-    input: DefaultValue<TInputIn, void>;
-    output: DefaultValue<TOutputOut, $Output>;
-  }>;
+  ): MutationProcedure<
+    TCaller extends true
+      ? {
+          experimental_caller: true;
+          input: DefaultValue<TInputIn, void>;
+          output: DefaultValue<TOutputOut, $Output>;
+        }
+      : {
+          input: DefaultValue<TInputIn, void>;
+          output: DefaultValue<TOutputOut, $Output>;
+        }
+  >;
 
   /**
    * Subscription procedure
@@ -312,10 +353,35 @@ export interface ProcedureBuilder<
       TOutputIn,
       $Output
     >,
-  ): SubscriptionProcedure<{
-    input: DefaultValue<TInputIn, void>;
-    output: DefaultValue<TOutputOut, inferObservableValue<$Output>>;
-  }>;
+  ): SubscriptionProcedure<
+    TCaller extends true
+      ? {
+          experimental_caller: true;
+          input: DefaultValue<TInputIn, void>;
+          output: DefaultValue<TOutputOut, inferObservableValue<$Output>>;
+        }
+      : {
+          input: DefaultValue<TInputIn, void>;
+          output: DefaultValue<TOutputOut, inferObservableValue<$Output>>;
+        }
+  >;
+
+  /**
+   * Overrides the way a procedure is invoked
+   * Do not use this unless you know what you're doing - this is an experimental API
+   */
+  experimental_caller(
+    caller: CallerOverride,
+  ): ProcedureBuilder<
+    TContext,
+    TMeta,
+    TContextOverrides,
+    TInputIn,
+    TInputOut,
+    TOutputIn,
+    TOutputOut,
+    true
+  >;
   /**
    * @internal
    */
@@ -350,7 +416,8 @@ export function createBuilder<TContext, TMeta>(
   UnsetMarker,
   UnsetMarker,
   UnsetMarker,
-  UnsetMarker
+  UnsetMarker,
+  false
 > {
   const _def: AnyProcedureBuilderDef = {
     procedure: true,
@@ -412,6 +479,11 @@ export function createBuilder<TContext, TMeta>(
         resolver,
       ) as AnySubscriptionProcedure;
     },
+    experimental_caller(caller) {
+      return createNewBuilder(_def, {
+        caller,
+      }) as any;
+    },
   };
 
   return builder;
@@ -422,6 +494,7 @@ function createResolver(
   resolver: AnyResolver,
 ) {
   const finalBuilder = createNewBuilder(_def, {
+    type: _def.type,
     resolver,
     middlewares: [
       async function resolveMiddleware(opts) {
@@ -435,8 +508,21 @@ function createResolver(
       },
     ],
   });
+  const invoke = createProcedureCaller(finalBuilder._def);
+  const callerOverride = finalBuilder._def.caller;
+  if (!callerOverride) {
+    return invoke;
+  }
+  const callerWrapper = (...args: unknown[]) => {
+    return callerOverride({
+      args,
+      invoke,
+      _def: finalBuilder._def as unknown as AnyProcedure['_def'],
+    });
+  };
 
-  return createProcedureCaller(finalBuilder._def);
+  callerWrapper._def = finalBuilder._def;
+  return callerWrapper;
 }
 
 /**

package/src/unstable-core-do-not-import/router.ts

@@ -1,13 +1,17 @@
 import type { Observable } from '../observable';
 import { createRecursiveProxy } from './createProxy';
 import { defaultFormatter } from './error/formatter';
-import { TRPCError } from './error/TRPCError';
-import type { AnyProcedure, inferProcedureInput } from './procedure';
+import { getTRPCErrorFromUnknown, TRPCError } from './error/TRPCError';
+import type {
+  AnyProcedure,
+  ErrorHandlerOptions,
+  inferProcedureInput,
+} from './procedure';
 import type { ProcedureCallOptions } from './procedureBuilder';
 import type { AnyRootTypes, RootConfig } from './rootConfig';
 import { defaultTransformer } from './transformer';
 import type { MaybePromise, ValueOf } from './types';
-import { mergeWithoutOverrides, omitPrototype } from './utils';
+import { isFunction, mergeWithoutOverrides, omitPrototype } from './utils';
 
 export interface RouterRecord {
   [key: string]: AnyProcedure | RouterRecord;
@@ -32,6 +36,14 @@ export type DecorateRouterRecord<TRecord extends RouterRecord> = {
     : never;
 };
 
+/**
+ * @internal
+ */
+
+export type RouterCallerErrorHandler<TContext> = (
+  opts: ErrorHandlerOptions<TContext>,
+) => void;
+
 /**
  * @internal
  */
@@ -45,6 +57,9 @@ export type RouterCaller<
    * e.g. wrapped in `React.cache` to avoid unnecessary computations
    */
   ctx: TRoot['ctx'] | (() => MaybePromise<TRoot['ctx']>),
+  options?: {
+    onError?: RouterCallerErrorHandler<TRoot['ctx']>;
+  },
 ) => DecorateRouterRecord<TRecord>;
 
 export interface Router<
@@ -191,21 +206,9 @@ export function createRouterFactory<TRoot extends AnyRootTypes>(
     return {
       ...record,
       _def,
-      createCaller(ctx: TRoot['ctx']) {
-        const proxy = createRecursiveProxy(({ path, args }) => {
-          const fullPath = path.join('.');
-          const procedure = _def.procedures[fullPath] as AnyProcedure;
-
-          return procedure({
-            path: fullPath,
-            getRawInput: async () => args[0],
-            ctx,
-            type: procedure._def.type,
-          });
-        });
-
-        return proxy as ReturnType<RouterCaller<any, any>>;
-      },
+      createCaller: createCallerFactory<TRoot>()({
+        _def,
+      }),
     };
   }
 
@@ -244,34 +247,44 @@ export function callProcedure(
 
 export function createCallerFactory<TRoot extends AnyRootTypes>() {
   return function createCallerInner<TRecord extends RouterRecord>(
-    router: Router<TRoot, TRecord>,
+    router: Pick<Router<TRoot, TRecord>, '_def'>,
   ): RouterCaller<TRoot, TRecord> {
     const _def = router._def;
     type Context = TRoot['ctx'];
 
-    return function createCaller(maybeContext) {
-      const proxy = createRecursiveProxy(({ path, args }) => {
+    return function createCaller(
+      ctxOrCallback,
+      options?: {
+        onError?: RouterCallerErrorHandler<Context>;
+      },
+    ) {
+      const proxy = createRecursiveProxy(async ({ path, args }) => {
         const fullPath = path.join('.');
 
         const procedure = _def.procedures[fullPath] as AnyProcedure;
 
-        const callProc = (ctx: Context) =>
-          procedure({
+        let ctx: Context | undefined = undefined;
+        try {
+          ctx = isFunction(ctxOrCallback)
+            ? await Promise.resolve(ctxOrCallback())
+            : ctxOrCallback;
+
+          return await procedure({
             path: fullPath,
             getRawInput: async () => args[0],
             ctx,
             type: procedure._def.type,
           });
-
-        if (typeof maybeContext === 'function') {
-          const context = (maybeContext as () => MaybePromise<Context>)();
-          if (context instanceof Promise) {
-            return context.then(callProc);
-          }
-          return callProc(context);
+        } catch (cause) {
+          options?.onError?.({
+            ctx,
+            error: getTRPCErrorFromUnknown(cause),
+            input: args[0],
+            path: fullPath,
+            type: procedure._def.type,
+          });
+          throw cause;
         }
-
-        return callProc(maybeContext);
       });
 
       return proxy as ReturnType<RouterCaller<any, any>>;

package/src/unstable-core-do-not-import/utils.ts

@@ -27,6 +27,11 @@ export function isObject(value: unknown): value is Record<string, unknown> {
   return !!value && !Array.isArray(value) && typeof value === 'object';
 }
 
+type AnyFn = (...args: any[]) => unknown;
+export function isFunction(fn: unknown): fn is AnyFn {
+  return typeof fn === 'function';
+}
+
 /**
  * Create an object without inheriting anything from `Object.prototype`
  * @internal