@trpc/server 11.0.0-alpha-tmp-issues-5557-types-node-wut.324 → 11.0.0-alpha-tmp-04-02-no-typesProxy.331

package/src/unstable-core-do-not-import/http/index.ts

@@ -9,7 +9,11 @@ export type {
   HTTPHeaders,
   HTTPRequest,
   HTTPResponse,
-  OnErrorFunction,
+  /**
+   * @deprecated Use `HTTPErrorHandler` instead
+   */
+  HTTPErrorHandler as OnErrorFunction,
+  HTTPErrorHandler,
   ProcedureCall,
   ResolveHTTPRequestOptionsContextFn,
   ResponseChunk,

package/src/unstable-core-do-not-import/http/types.ts

@@ -1,5 +1,5 @@
 import type { TRPCError } from '../error/TRPCError';
-import type { ProcedureType } from '../procedure';
+import type { ErrorHandlerOptions, ProcedureType } from '../procedure';
 import type {
   AnyRouter,
   inferRouterContext,
@@ -86,24 +86,23 @@ export type TRPCRequestInfo = {
 export type ResolveHTTPRequestOptionsContextFn<TRouter extends AnyRouter> =
   (opts: { info: TRPCRequestInfo }) => Promise<inferRouterContext<TRouter>>;
 
+interface HTTPErrorHandlerOptions<TRouter extends AnyRouter, TRequest>
+  extends ErrorHandlerOptions<inferRouterContext<TRouter>> {
+  req: TRequest;
+}
 /**
  * @internal
  */
-export type OnErrorFunction<TRouter extends AnyRouter, TRequest> = (opts: {
-  error: TRPCError;
-  type: ProcedureType | 'unknown';
-  path: string | undefined;
-  req: TRequest;
-  input: unknown;
-  ctx: inferRouterContext<TRouter> | undefined;
-}) => void;
+export type HTTPErrorHandler<TRouter extends AnyRouter, TRequest> = (
+  opts: HTTPErrorHandlerOptions<TRouter, TRequest>,
+) => void;
 
 /**
  * Base interface for any response handler
  * @internal
  */
 export interface BaseHandlerOptions<TRouter extends AnyRouter, TRequest> {
-  onError?: OnErrorFunction<TRouter, TRequest>;
+  onError?: HTTPErrorHandler<TRouter, TRequest>;
   /**
    * @deprecated use `allowBatching` instead, this will be removed in v12
    */

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

@@ -1,4 +1,3 @@
-import { createFlatProxy } from './createProxy';
 import {
   defaultFormatter,
   type DefaultErrorShape,
@@ -16,6 +15,7 @@ import {
 import type { DataTransformerOptions } from './transformer';
 import { defaultTransformer, getDataTransformer } from './transformer';
 import type { Unwrap, ValidateShape } from './types';
+import { $typesProxy } from './utils';
 
 type inferErrorFormatterShape<TType> = TType extends ErrorFormatter<
   any,
@@ -95,11 +95,7 @@ class TRPCBuilder<TContext extends object, TMeta extends object> {
        * These are just types, they can't be used at runtime
        * @internal
        */
-      $types: createFlatProxy((key) => {
-        throw new Error(
-          `Tried to access "$types.${key}" which is not available at runtime`,
-        );
-      }),
+      $types: $typesProxy,
     };
 
     {

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;
@@ -23,6 +24,7 @@ interface BuiltProcedureDef {
   input: unknown;
   output: unknown;
 }
+
 /**
  *
  * @internal
@@ -32,8 +34,14 @@ export interface Procedure<
   TDef extends BuiltProcedureDef,
 > {
   _def: {
-    _input_in: TDef['input'];
-    _output_out: TDef['output'];
+    /**
+     * These are just types, they can't be used at runtime
+     * @internal
+     */
+    $types: {
+      input: TDef['input'];
+      output: TDef['output'];
+    };
     procedure: true;
     type: TType;
     /**
@@ -41,11 +49,12 @@ export interface Procedure<
      * Meta is not inferrable on individual procedures, only on the router
      */
     meta: unknown;
+    experimental_caller: boolean;
   };
   /**
    * @internal
    */
-  (opts: ProcedureCallOptions): Promise<unknown>;
+  (opts: ProcedureCallOptions<unknown>): Promise<TDef['output']>;
 }
 
 export interface QueryProcedure<TDef extends BuiltProcedureDef>
@@ -63,12 +72,23 @@ export type AnySubscriptionProcedure = SubscriptionProcedure<any>;
 export type AnyProcedure = Procedure<ProcedureType, any>;
 
 export type inferProcedureInput<TProcedure extends AnyProcedure> =
-  undefined extends inferProcedureParams<TProcedure>['_input_in']
-    ? void | inferProcedureParams<TProcedure>['_input_in']
-    : inferProcedureParams<TProcedure>['_input_in'];
+  undefined extends inferProcedureParams<TProcedure>['$types']['input']
+    ? void | inferProcedureParams<TProcedure>['$types']['input']
+    : inferProcedureParams<TProcedure>['$types']['input'];
 
 export type inferProcedureParams<TProcedure> = TProcedure extends AnyProcedure
   ? TProcedure['_def']
   : never;
 export type inferProcedureOutput<TProcedure> =
-  inferProcedureParams<TProcedure>['_output_out'];
+  inferProcedureParams<TProcedure>['$types']['output'];
+
+/**
+ * @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

@@ -30,7 +30,7 @@ import type {
   Simplify,
   TypeError,
 } from './types';
-import { mergeWithoutOverrides } from './utils';
+import { $typesProxy, mergeWithoutOverrides } from './utils';
 
 type IntersectIfDefined<TType, TWith> = TType extends UnsetMarker
   ? TWith
@@ -45,6 +45,11 @@ type DefaultValue<TValue, TFallback> = TValue extends UnsetMarker
   ? TFallback
   : TValue;
 
+export type CallerOverride<TContext> = (opts: {
+  args: unknown[];
+  invoke: (opts: ProcedureCallOptions<TContext>) => 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<unknown>;
 };
 
 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,14 @@ export interface ProcedureBuilder<
       TOutputIn,
       $Output
     >,
-  ): QueryProcedure<{
-    input: DefaultValue<TInputIn, void>;
-    output: DefaultValue<TOutputOut, $Output>;
-  }>;
+  ): TCaller extends true
+    ? (
+        input: DefaultValue<TInputIn, void>,
+      ) => Promise<DefaultValue<TOutputOut, $Output>>
+    : QueryProcedure<{
+        input: DefaultValue<TInputIn, void>;
+        output: DefaultValue<TOutputOut, $Output>;
+      }>;
 
   /**
    * Mutation procedure
@@ -294,10 +323,14 @@ export interface ProcedureBuilder<
       TOutputIn,
       $Output
     >,
-  ): MutationProcedure<{
-    input: DefaultValue<TInputIn, void>;
-    output: DefaultValue<TOutputOut, $Output>;
-  }>;
+  ): TCaller extends true
+    ? (
+        input: DefaultValue<TInputIn, void>,
+      ) => Promise<DefaultValue<TOutputOut, $Output>>
+    : MutationProcedure<{
+        input: DefaultValue<TInputIn, void>;
+        output: DefaultValue<TOutputOut, $Output>;
+      }>;
 
   /**
    * Subscription procedure
@@ -312,10 +345,29 @@ export interface ProcedureBuilder<
       TOutputIn,
       $Output
     >,
-  ): SubscriptionProcedure<{
-    input: DefaultValue<TInputIn, void>;
-    output: DefaultValue<TOutputOut, inferObservableValue<$Output>>;
-  }>;
+  ): TCaller extends true
+    ? TypeError<'Not implemented'>
+    : SubscriptionProcedure<{
+        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<TContext>,
+  ): ProcedureBuilder<
+    TContext,
+    TMeta,
+    TContextOverrides,
+    TInputIn,
+    TInputOut,
+    TOutputIn,
+    TOutputOut,
+    true
+  >;
   /**
    * @internal
    */
@@ -350,7 +402,8 @@ export function createBuilder<TContext, TMeta>(
   UnsetMarker,
   UnsetMarker,
   UnsetMarker,
-  UnsetMarker
+  UnsetMarker,
+  false
 > {
   const _def: AnyProcedureBuilderDef = {
     procedure: true,
@@ -412,16 +465,21 @@ export function createBuilder<TContext, TMeta>(
         resolver,
       ) as AnySubscriptionProcedure;
     },
+    experimental_caller(caller) {
+      return createNewBuilder(_def, {
+        caller,
+      }) as any;
+    },
   };
 
   return builder;
 }
 
 function createResolver(
-  _def: AnyProcedureBuilderDef & { type: ProcedureType },
+  _defIn: AnyProcedureBuilderDef & { type: ProcedureType },
   resolver: AnyResolver,
 ) {
-  const finalBuilder = createNewBuilder(_def, {
+  const finalBuilder = createNewBuilder(_defIn, {
     resolver,
     middlewares: [
       async function resolveMiddleware(opts) {
@@ -435,15 +493,36 @@ function createResolver(
       },
     ],
   });
+  const _def: AnyProcedure['_def'] = {
+    ...finalBuilder._def,
+    type: _defIn.type,
+    experimental_caller: Boolean(finalBuilder._def.caller),
+    meta: finalBuilder._def.meta,
+    $types: $typesProxy,
+  };
+
+  const invoke = createProcedureCaller(finalBuilder._def);
+  const callerOverride = finalBuilder._def.caller;
+  if (!callerOverride) {
+    return invoke;
+  }
+  const callerWrapper = async (...args: unknown[]) => {
+    return await callerOverride({
+      args,
+      invoke,
+      _def: _def,
+    });
+  };
 
-  return createProcedureCaller(finalBuilder._def);
+  callerWrapper._def = _def;
+  return callerWrapper;
 }
 
 /**
  * @internal
  */
-export interface ProcedureCallOptions {
-  ctx: unknown;
+export interface ProcedureCallOptions<TContext> {
+  ctx: TContext;
   getRawInput: GetRawInputFn;
   input?: unknown;
   path: string;
@@ -456,7 +535,7 @@ If you want to call this function on the server, see https://trpc.io/docs/v11/se
 `.trim();
 
 function createProcedureCaller(_def: AnyProcedureBuilderDef): AnyProcedure {
-  async function procedure(opts: ProcedureCallOptions) {
+  async function procedure(opts: ProcedureCallOptions<unknown>) {
     // is direct server-side call
     if (!opts || !('getRawInput' in opts)) {
       throw new Error(codeblock);

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

@@ -1,13 +1,18 @@
 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,
+  inferProcedureOutput,
+} 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;
@@ -17,8 +22,8 @@ type DecorateProcedure<TProcedure extends AnyProcedure> = (
   input: inferProcedureInput<TProcedure>,
 ) => Promise<
   TProcedure['_def']['type'] extends 'subscription'
-    ? Observable<TProcedure['_def']['_output_out'], TRPCError>
-    : TProcedure['_def']['_output_out']
+    ? Observable<inferProcedureOutput<TProcedure>, TRPCError>
+    : inferProcedureOutput<TProcedure>
 >;
 
 /**
@@ -32,6 +37,14 @@ export type DecorateRouterRecord<TRecord extends RouterRecord> = {
     : never;
 };
 
+/**
+ * @internal
+ */
+
+export type RouterCallerErrorHandler<TContext> = (
+  opts: ErrorHandlerOptions<TContext>,
+) => void;
+
 /**
  * @internal
  */
@@ -45,6 +58,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 +207,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,
+      }),
     };
   }
 
@@ -221,7 +225,7 @@ function isProcedure(
  * @internal
  */
 export function callProcedure(
-  opts: ProcedureCallOptions & {
+  opts: ProcedureCallOptions<unknown> & {
     procedures: RouterRecord;
     allowMethodOverride?: boolean;
   },
@@ -244,34 +248,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

@@ -1,3 +1,5 @@
+import { createFlatProxy } from './createProxy';
+
 /**
  * Ensures there are no duplicate keys when building a procedure.
  * @internal
@@ -27,6 +29,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
@@ -36,3 +43,16 @@ export function omitPrototype<TObj extends Record<string, unknown>>(
 ): TObj {
   return Object.assign(Object.create(null), obj);
 }
+
+/**
+ * Prevents access to `$types` at runtime
+ * @internal
+ */
+export const $typesProxy = createFlatProxy<any>((key) => {
+  if (key === 'prototype') {
+    return undefined;
+  }
+  throw new Error(
+    `Tried to access "$types.${key}" which is not available at runtime`,
+  );
+});