@trpc/server 10.0.0-alpha.38 → 10.0.0-alpha.39

package/src/core/internals/procedureBuilder.ts

@@ -1,5 +1,7 @@
+import { TRPCError } from '../../error/TRPCError';
+import { getCauseFromUnknown, getErrorFromUnknown } from '../../error/utils';
 import { MaybePromise } from '../../types';
-import { MiddlewareFunction } from '../middleware';
+import { MiddlewareFunction, MiddlewareResult } from '../middleware';
 import { Parser, inferParser } from '../parser';
 import {
   MutationProcedure,
@@ -8,9 +10,11 @@ import {
   QueryProcedure,
   SubscriptionProcedure,
 } from '../procedure';
+import { ProcedureType } from '../types';
 import { RootConfig } from './config';
-import { createInternalBuilder } from './internalProcedure';
-import { ResolveOptions } from './utils';
+import { ParseFn, getParseFn } from './getParseFn';
+import { mergeWithoutOverrides } from './mergeWithoutOverrides';
+import { ResolveOptions, middlewareMarker } from './utils';
 import { DefaultValue as FallbackValue, Overwrite, UnsetMarker } from './utils';
 
 type CreateProcedureReturnInput<
@@ -21,8 +25,8 @@ type CreateProcedureReturnInput<
   _meta: TPrev['_meta'];
   _ctx_in: TPrev['_ctx_in'];
   _ctx_out: Overwrite<TPrev['_ctx_out'], TNext['_ctx_out']>;
-  _input_out: FallbackValue<TNext['_input_out'], TPrev['_input_out']>;
   _input_in: FallbackValue<TNext['_input_in'], TPrev['_input_in']>;
+  _input_out: FallbackValue<TNext['_input_out'], TPrev['_input_out']>;
   _output_in: FallbackValue<TNext['_output_in'], TPrev['_output_in']>;
   _output_out: FallbackValue<TNext['_output_out'], TPrev['_output_out']>;
 }>;
@@ -38,10 +42,10 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
     _meta: TParams['_meta'];
     _ctx_in: TParams['_ctx_in'];
     _ctx_out: TParams['_ctx_out'];
-    _output_in: TParams['_output_in'];
-    _output_out: TParams['_output_out'];
     _input_in: inferParser<$TParser>['in'];
     _input_out: inferParser<$TParser>['out'];
+    _output_in: TParams['_output_in'];
+    _output_out: TParams['_output_out'];
   }>;
   /**
    * Add an output parser to the procedure.
@@ -72,7 +76,7 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
    * Extend the procedure with another procedure.
    * @warning The TypeScript inference fails when chaining concatenated procedures.
    */
-  unstable_concat<$ProcedureReturnInput extends ProcedureBuilder<any>>(
+  unstable_concat<$ProcedureReturnInput extends AnyProcedureBuilder>(
     proc: $ProcedureReturnInput,
   ): $ProcedureReturnInput extends ProcedureBuilder<infer $TParams>
     ? CreateProcedureReturnInput<TParams, $TParams>
@@ -94,24 +98,7 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
         >
       >
     : Procedure<TParams>;
-  /**
-   * Query procedure
-   */
-  query<$TOutput>(
-    resolver: (
-      opts: ResolveOptions<TParams>,
-    ) => MaybePromise<FallbackValue<TParams['_output_in'], $TOutput>>,
-  ): UnsetMarker extends TParams['_output_out']
-    ? QueryProcedure<
-        Overwrite<
-          TParams,
-          {
-            _output_in: $TOutput;
-            _output_out: $TOutput;
-          }
-        >
-      >
-    : QueryProcedure<TParams>;
+
   /**
    * Query procedure
    */
@@ -168,17 +155,266 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
         >
       >
     : SubscriptionProcedure<TParams>;
+  /**
+   * @internal
+   */
+  _def: {
+    input?: Parser;
+    output?: Parser;
+    meta?: Record<string, unknown>;
+    resolver?: ProcedureBuilderResolver;
+    middlewares: ProcedureBuilderMiddleware[];
+    mutation?: boolean;
+    query?: boolean;
+    subscription?: boolean;
+  };
 }
 
-export function createBuilder<TConfig extends RootConfig>(): ProcedureBuilder<{
+type AnyProcedureBuilder = ProcedureBuilder<any>;
+export type ProcedureBuilderDef = AnyProcedureBuilder['_def'];
+
+export type ProcedureBuilderMiddleware = MiddlewareFunction<any, any>;
+
+export type ProcedureBuilderResolver = (
+  opts: ResolveOptions<any>,
+) => Promise<unknown>;
+
+function createNewBuilder(
+  def1: ProcedureBuilderDef,
+  def2: Partial<ProcedureBuilderDef>,
+) {
+  const { middlewares = [], ...rest } = def2;
+
+  // TODO: maybe have a fn here to warn about calls
+  return createBuilder({
+    ...mergeWithoutOverrides(def1, rest),
+    middlewares: [...def1.middlewares, ...middlewares],
+  } as any);
+}
+
+export function createBuilder<TConfig extends RootConfig>(
+  initDef?: ProcedureBuilderDef,
+): ProcedureBuilder<{
   _config: TConfig;
   _ctx_in: TConfig['ctx'];
   _ctx_out: TConfig['ctx'];
-  _input_out: UnsetMarker;
   _input_in: UnsetMarker;
+  _input_out: UnsetMarker;
   _output_in: UnsetMarker;
   _output_out: UnsetMarker;
   _meta: TConfig['meta'];
 }> {
-  return createInternalBuilder() as any;
+  const _def: ProcedureBuilderDef = initDef || {
+    middlewares: [],
+  };
+
+  return {
+    _def,
+    input(input) {
+      const parser = getParseFn(input);
+      return createNewBuilder(_def, {
+        input,
+        middlewares: [createInputMiddleware(parser)],
+      }) as AnyProcedureBuilder;
+    },
+    output(output: Parser) {
+      const parseOutput = getParseFn(output);
+      return createNewBuilder(_def, {
+        output,
+        middlewares: [createOutputMiddleware(parseOutput)],
+      }) as AnyProcedureBuilder;
+    },
+    meta(meta) {
+      return createNewBuilder(_def, {
+        meta: meta as Record<string, unknown>,
+      }) as AnyProcedureBuilder;
+    },
+    /** @deprecated **/
+    resolve(resolver) {
+      return createResolver(_def, resolver);
+    },
+    unstable_concat(builder) {
+      return createNewBuilder(_def, builder._def) as any;
+    },
+    use(middleware) {
+      return createNewBuilder(_def, {
+        middlewares: [middleware],
+      }) as AnyProcedureBuilder;
+    },
+    query(resolver) {
+      return createResolver(
+        { ..._def, query: true },
+        resolver,
+      ) as QueryProcedure<any>;
+    },
+    mutation(resolver) {
+      return createResolver(
+        { ..._def, mutation: true },
+        resolver,
+      ) as MutationProcedure<any>;
+    },
+    subscription(resolver) {
+      return createResolver(
+        { ..._def, subscription: true },
+        resolver,
+      ) as SubscriptionProcedure<any>;
+    },
+  };
+}
+
+export function createInputMiddleware<T>(
+  parse: ParseFn<T>,
+): ProcedureBuilderMiddleware {
+  return async function inputMiddleware({ next, rawInput }) {
+    let input: ReturnType<typeof parse>;
+    try {
+      input = await parse(rawInput);
+    } catch (cause) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        cause: getCauseFromUnknown(cause),
+      });
+    }
+    // TODO fix this typing?
+    return next({ input } as any);
+  };
+}
+
+export function createOutputMiddleware<T>(
+  parse: ParseFn<T>,
+): ProcedureBuilderMiddleware {
+  return async function outputMiddleware({ next }) {
+    const result = await next();
+    if (!result.ok) {
+      // pass through failures without validating
+      return result;
+    }
+    try {
+      const data = await parse(result.data);
+      return {
+        ...result,
+        data,
+      };
+    } catch (cause) {
+      throw new TRPCError({
+        message: 'Output validation failed',
+        code: 'INTERNAL_SERVER_ERROR',
+        cause: getCauseFromUnknown(cause),
+      });
+    }
+  };
+}
+
+function createResolver(
+  _def: ProcedureBuilderDef,
+  resolver: (opts: ResolveOptions<any>) => MaybePromise<any>,
+) {
+  const finalBuilder = createNewBuilder(_def, {
+    resolver,
+    middlewares: [
+      async function resolveMiddleware(opts) {
+        const data = await resolver(opts);
+        return {
+          marker: middlewareMarker,
+          ok: true,
+          data,
+          ctx: opts.ctx,
+        } as const;
+      },
+    ],
+  });
+
+  return createProcedureCaller(finalBuilder._def);
+}
+
+/**
+ * @internal
+ */
+export interface ProcedureCallOptions {
+  ctx: unknown;
+  rawInput: unknown;
+  input?: unknown;
+  path: string;
+  type: ProcedureType;
+}
+
+const codeblock = `
+If you want to call this function on the server, you do the following:
+This is a client-only function.
+
+const caller = appRouter.createCaller({
+  /* ... your context */
+});
+
+const result = await caller.call('myProcedure', input);
+`.trim();
+
+function createProcedureCaller(_def: ProcedureBuilderDef): Procedure<any> {
+  const procedure = async function resolve(opts: ProcedureCallOptions) {
+    // is direct server-side call
+    if (!opts || !('rawInput' in opts)) {
+      throw new Error(codeblock);
+    }
+
+    // run the middlewares recursively with the resolver as the last one
+    const callRecursive = async (
+      callOpts: { ctx: any; index: number; input?: unknown } = {
+        index: 0,
+        ctx: opts.ctx,
+      },
+    ): Promise<MiddlewareResult<any>> => {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const middleware = _def.middlewares[callOpts.index]!;
+        const result = await middleware({
+          ctx: callOpts.ctx,
+          type: opts.type,
+          path: opts.path,
+          rawInput: opts.rawInput,
+          meta: _def.meta,
+          input: callOpts.input,
+          next: async (nextOpts?: { ctx: any; input?: any }) => {
+            return await callRecursive({
+              index: callOpts.index + 1,
+              ctx:
+                nextOpts && 'ctx' in nextOpts
+                  ? { ...callOpts.ctx, ...nextOpts.ctx }
+                  : callOpts.ctx,
+              input:
+                nextOpts && 'input' in nextOpts
+                  ? nextOpts.input
+                  : callOpts.input,
+            });
+          },
+        });
+        return result;
+      } catch (cause) {
+        return {
+          ok: false,
+          error: getErrorFromUnknown(cause),
+          marker: middlewareMarker,
+        };
+      }
+    };
+
+    // there's always at least one "next" since we wrap this.resolver in a middleware
+    const result = await callRecursive();
+
+    if (!result) {
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message:
+          'No result from middlewares - did you forget to `return next()`?',
+      });
+    }
+    if (!result.ok) {
+      // re-throw original error
+      throw result.error;
+    }
+    return result.data;
+  };
+  procedure._def = _def;
+  procedure.meta = _def.meta;
+
+  return procedure as Procedure<any>;
 }

package/src/core/procedure.ts

@@ -1,6 +1,10 @@
 import { DefaultErrorShape } from '../error/formatter';
 import { CombinedDataTransformer } from '../transformer';
 import { RootConfig } from './internals/config';
+import {
+  ProcedureBuilderDef,
+  ProcedureCallOptions,
+} from './internals/procedureBuilder';
 import { UnsetMarker } from './internals/utils';
 
 type ClientContext = Record<string, unknown>;
@@ -46,19 +50,19 @@ export interface ProcedureParams<
   /**
    * @internal
    */
-  _output_in: TOutputIn;
+  _input_in: TInputIn;
   /**
    * @internal
    */
-  _output_out: TOutputOut;
+  _input_out: TInputOut;
   /**
    * @internal
    */
-  _input_in: TInputIn;
+  _output_in: TOutputIn;
   /**
    * @internal
    */
-  _input_out: TInputOut;
+  _output_out: TOutputOut;
 }
 
 /**
@@ -72,37 +76,40 @@ export type ProcedureArgs<TParams extends ProcedureParams> =
     : [input: TParams['_input_in'], opts?: ProcedureOptions];
 
 /**
+ *
  * @internal
  */
 export interface ProcedureBase<TParams extends ProcedureParams> {
-  _def: TParams;
+  _def: TParams & ProcedureBuilderDef;
   /**
    * @deprecated use `._def.meta` instead
    */
   meta?: TParams['_meta'];
   _procedure: true;
+  /**
+   * @internal
+   */
+  (opts: ProcedureCallOptions): Promise<unknown>;
 }
 
 export interface QueryProcedure<TParams extends ProcedureParams>
   extends ProcedureBase<TParams> {
   _query: true;
-  query(...args: ProcedureArgs<TParams>): Promise<TParams['_output_out']>;
 }
 
 export interface MutationProcedure<TParams extends ProcedureParams>
   extends ProcedureBase<TParams> {
   _mutation: true;
-  mutate(...args: ProcedureArgs<TParams>): Promise<TParams['_output_out']>;
 }
 
 export interface SubscriptionProcedure<TParams extends ProcedureParams>
   extends ProcedureBase<TParams> {
   _subscription: true;
-  subscription(
-    ...args: ProcedureArgs<TParams>
-  ): Promise<TParams['_output_out']>;
 }
+
 export type Procedure<TParams extends ProcedureParams> =
   | QueryProcedure<TParams>
   | MutationProcedure<TParams>
   | SubscriptionProcedure<TParams>;
+
+export type AnyProcedure = Procedure<any>;

package/src/core/router.ts

@@ -9,21 +9,21 @@ import {
 } from '../error/formatter';
 import { getHTTPStatusCodeFromError } from '../http/internals/getHTTPStatusCode';
 import { TRPCErrorShape, TRPC_ERROR_CODES_BY_KEY } from '../rpc';
+import { createProxy } from '../shared';
 import { CombinedDataTransformer, defaultTransformer } from '../transformer';
 import { RootConfig } from './internals/config';
-import {
-  InternalProcedure,
-  InternalProcedureCallOptions,
-} from './internals/internalProcedure';
 import { mergeWithoutOverrides } from './internals/mergeWithoutOverrides';
 import { omitPrototype } from './internals/omitPrototype';
+import { ProcedureCallOptions } from './internals/procedureBuilder';
 import {
+  AnyProcedure,
   MutationProcedure,
   Procedure,
+  ProcedureArgs,
   QueryProcedure,
   SubscriptionProcedure,
 } from './procedure';
-import { ProcedureType } from './types';
+import { ProcedureType, procedureTypes } from './types';
 
 type ProcedureRecord = Record<string, Procedure<any>>;
 
@@ -122,11 +122,24 @@ type inferHandlerFn<TProcedures extends Record<string, Procedure<any>>> = <
   ...args: inferHandlerInput<TProcedure>
 ) => Promise<inferProcedureOutput<TProcedure>>;
 
+type DecorateProcedure<TProcedure extends Procedure<any>> = (
+  input: ProcedureArgs<TProcedure['_def']>[0],
+) => Promise<TProcedure['_def']['_output_out']>;
+
+type assertProcedure<T> = T extends Procedure<any> ? T : never;
+
 /**
- * This only exists b/c of interop mode
  * @internal
  */
+type DecoratedProcedureRecord<TProcedures extends ProcedureRouterRecord> = {
+  [TKey in keyof TProcedures]: TProcedures[TKey] extends AnyRouter
+    ? DecoratedProcedureRecord<TProcedures[TKey]['_def']['record']>
+    : DecorateProcedure<assertProcedure<TProcedures[TKey]>>;
+};
 
+/**
+ * @internal
+ */
 type RouterCaller<TDef extends AnyRouterDef> = (ctx: TDef['_ctx']) => {
   /**
    * @deprecated
@@ -140,7 +153,7 @@ type RouterCaller<TDef extends AnyRouterDef> = (ctx: TDef['_ctx']) => {
    * @deprecated
    */
   subscription: inferHandlerFn<TDef['subscriptions']>;
-};
+} & DecoratedProcedureRecord<TDef['record']>;
 
 export interface Router<TDef extends AnyRouterDef> {
   _def: RouterDef<
@@ -153,8 +166,6 @@ export interface Router<TDef extends AnyRouterDef> {
   errorFormatter: TDef['errorFormatter'];
   /** @deprecated **/
   transformer: TDef['transformer'];
-
-  // FIXME rename me and deprecate
   createCaller: RouterCaller<TDef>;
   // FIXME rename me and deprecate
   getErrorShape(opts: {
@@ -183,13 +194,12 @@ export type RouterBuildOptions<TContext> = Partial<
 
 export type AnyRouter = Router<any>;
 
-function createRouterProxy(callback: (...args: [string, ...unknown[]]) => any) {
-  return new Proxy({} as any, {
-    get(_, path: string) {
-      return (...args: unknown[]) => callback(path, ...args);
-    },
-  });
+function isRouter(
+  procedureOrRouter: AnyProcedure | AnyRouter,
+): procedureOrRouter is AnyRouter {
+  return 'router' in procedureOrRouter._def;
 }
+
 const emptyRouter = {
   _ctx: null as any,
   _errorShape: null as any,
@@ -226,9 +236,8 @@ export function createRouterFactory<TConfig extends RootConfig>(
       for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})) {
         const newPath = `${path}${key}`;
 
-        if (typeof procedureOrRouter === 'object') {
-          const router = procedureOrRouter as AnyRouter;
-          recursiveGetPaths(router._def.procedures, `${newPath}.`);
+        if (isRouter(procedureOrRouter)) {
+          recursiveGetPaths(procedureOrRouter._def.procedures, `${newPath}.`);
           continue;
         }
 
@@ -268,74 +277,46 @@ export function createRouterFactory<TConfig extends RootConfig>(
         .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
     };
 
-    function callProcedure(opts: InternalProcedureCallOptions) {
-      const { type, path } = opts;
-
-      if (!(path in _def.procedures) || !_def.procedures[path]['_def'][type]) {
-        throw new TRPCError({
-          code: 'NOT_FOUND',
-          message: `No "${type}"-procedure on path "${path}"`,
-        });
-      }
-
-      const procedure = _def.procedures[path] as InternalProcedure;
-
-      return procedure(opts);
-    }
     const router: AnyRouter = {
       ...opts,
       _def,
       transformer: _def.transformer,
       errorFormatter: _def.errorFormatter,
       createCaller(ctx) {
-        return {
-          query: (path, ...args) =>
-            callProcedure({
-              path,
-              rawInput: args[0],
-              ctx,
-              type: 'query',
-            }) as any,
-          mutation: (path, ...args) =>
-            callProcedure({
-              path,
-              rawInput: args[0],
+        const proxy = createProxy(({ path, args }) => {
+          // interop mode
+          if (
+            path.length === 1 &&
+            procedureTypes.includes(path[0] as ProcedureType)
+          ) {
+            return callProcedure({
+              procedures: _def.procedures,
+              path: args[0] as string,
+              rawInput: args[1],
               ctx,
-              type: 'mutation',
-            }) as any,
-          subscription: (path, ...args) =>
-            callProcedure({
-              path,
-              rawInput: args[0],
-              ctx,
-              type: 'subscription',
-            }) as any,
+              type: path[0] as ProcedureType,
+            });
+          }
 
-          queries: createRouterProxy((path, rawInput) =>
-            callProcedure({
-              path,
-              rawInput,
-              ctx,
-              type: 'query',
-            }),
-          ),
-          mutations: createRouterProxy((path, rawInput) =>
-            callProcedure({
-              path,
-              rawInput,
-              ctx,
-              type: 'mutation',
-            }),
-          ),
-          subscriptions: createRouterProxy((path, rawInput) =>
-            callProcedure({
-              path,
-              rawInput,
-              ctx,
-              type: 'subscription',
-            }),
-          ),
-        };
+          const fullPath = path.join('.');
+          const procedure = _def.procedures[fullPath] as AnyProcedure;
+
+          let type: ProcedureType = 'query';
+          if (procedure._def.mutation) {
+            type = 'mutation';
+          } else if (procedure._def.subscription) {
+            type = 'subscription';
+          }
+
+          return procedure({
+            path: fullPath,
+            rawInput: args[0],
+            ctx,
+            type,
+          });
+        });
+
+        return proxy as ReturnType<RouterCaller<any>>;
       },
       getErrorShape(opts) {
         const { path, error } = opts;
@@ -363,3 +344,23 @@ export function createRouterFactory<TConfig extends RootConfig>(
     return router as any;
   };
 }
+
+/**
+ * @internal
+ */
+export function callProcedure(
+  opts: ProcedureCallOptions & { procedures: ProcedureRouterRecord },
+) {
+  const { type, path } = opts;
+
+  if (!(path in opts.procedures) || !opts.procedures[path]?._def[type]) {
+    throw new TRPCError({
+      code: 'NOT_FOUND',
+      message: `No "${type}"-procedure on path "${path}"`,
+    });
+  }
+
+  const procedure = opts.procedures[path] as AnyProcedure;
+
+  return procedure(opts);
+}

package/src/core/types.ts

@@ -17,10 +17,11 @@ export type inferRouterError<TRouter extends AnyRouter> =
 export type inferRouterMeta<TRouter extends AnyRouter> =
   inferRouterDef<TRouter>['_meta'];
 
+export const procedureTypes = ['query', 'mutation', 'subscription'] as const;
 /**
  * @public
  */
-export type ProcedureType = 'query' | 'mutation' | 'subscription';
+export type ProcedureType = typeof procedureTypes[number];
 
 export type inferHandlerInput<TProcedure extends Procedure<any>> =
   ProcedureArgs<inferProcedureParams<TProcedure>>;
@@ -52,3 +53,6 @@ export type inferSubscriptionOutput<
 > = inferObservableValue<
   inferProcedureOutput<TRouter['_def']['subscriptions'][TPath]>
 >;
+
+export type inferProcedureClientError<T extends Procedure<any>> =
+  inferProcedureParams<T>['_config']['errorShape'];