@trpc/server 10.43.0 → 11.0.0-next.91

package/src/core/internals/procedureBuilder.ts

@@ -11,66 +11,51 @@ import { inferParser, Parser } from '../parser';
 import {
   AnyMutationProcedure,
   AnyProcedure,
+  AnyProcedureParams,
   AnyQueryProcedure,
   AnySubscriptionProcedure,
-  Procedure,
+  MutationProcedure,
   ProcedureParams,
+  QueryProcedure,
+  SubscriptionProcedure,
 } from '../procedure';
 import { ProcedureType } from '../types';
+import { AnyProcedureBuilderParams } from './builderTypes';
 import { AnyRootConfig } from './config';
 import { getParseFn } from './getParseFn';
 import { mergeWithoutOverrides } from './mergeWithoutOverrides';
 import {
-  DefaultValue as FallbackValue,
+  DefaultValue,
+  GetRawInputFn,
   middlewareMarker,
   Overwrite,
-  OverwriteKnown,
   ResolveOptions,
   UnsetMarker,
 } from './utils';
 
 type CreateProcedureReturnInput<
-  TPrev extends ProcedureParams,
-  TNext extends ProcedureParams,
+  TPrev extends ProcedureParams<AnyProcedureParams>,
+  TNext extends ProcedureParams<AnyProcedureParams>,
 > = ProcedureBuilder<{
   _config: TPrev['_config'];
   _meta: TPrev['_meta'];
   _ctx_out: Overwrite<TPrev['_ctx_out'], TNext['_ctx_out']>;
-  _input_in: FallbackValue<TNext['_input_in'], TPrev['_input_in']>;
+  _input_in: DefaultValue<TNext['_input_in'], TPrev['_input_in']>;
   _input_out: UnsetMarker extends TNext['_input_out']
     ? TPrev['_input_out']
     : Overwrite<TPrev['_input_out'], TNext['_input_out']>;
-  _output_in: FallbackValue<TNext['_output_in'], TPrev['_output_in']>;
-  _output_out: FallbackValue<TNext['_output_out'], TPrev['_output_out']>;
+  _output_in: DefaultValue<TNext['_output_in'], TPrev['_output_in']>;
+  _output_out: DefaultValue<TNext['_output_out'], TPrev['_output_out']>;
 }>;
 
-/**
- * @internal
- */
-export interface BuildProcedure<
-  TType extends ProcedureType,
-  TParams extends ProcedureParams,
-  TOutput,
-> extends Procedure<
-    TType,
-    UnsetMarker extends TParams['_output_out']
-      ? OverwriteKnown<
-          TParams,
-          {
-            _output_in: TOutput;
-            _output_out: TOutput;
-          }
-        >
-      : TParams
-  > {}
-
 type OverwriteIfDefined<TType, TWith> = UnsetMarker extends TType
   ? TWith
   : Simplify<TType & TWith>;
 
 type ErrorMessage<TMessage extends string> = TMessage;
 
-export type ProcedureBuilderDef<TParams extends ProcedureParams> = {
+export type ProcedureBuilderDef<TParams extends AnyProcedureBuilderParams> = {
+  procedure: true;
   inputs: Parser[];
   output?: Parser;
   meta?: TParams['_meta'];
@@ -83,7 +68,7 @@ export type ProcedureBuilderDef<TParams extends ProcedureParams> = {
 
 export type AnyProcedureBuilderDef = ProcedureBuilderDef<any>;
 
-export interface ProcedureBuilder<TParams extends ProcedureParams> {
+export interface ProcedureBuilder<TParams extends AnyProcedureBuilderParams> {
   /**
    * Add an input parser to the procedure.
    */
@@ -136,28 +121,22 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
   /**
    * Add a middleware to the procedure.
    */
-  use<$Params extends ProcedureParams>(
+  use<$Params extends ProcedureParams<AnyProcedureParams>>(
     fn:
       | MiddlewareBuilder<TParams, $Params>
       | MiddlewareFunction<TParams, $Params>,
   ): CreateProcedureReturnInput<TParams, $Params>;
-  /**
-   * Extend the procedure with another procedure.
-   * @warning The TypeScript inference fails when chaining concatenated procedures.
-   */
-  unstable_concat<$ProcedureBuilder extends AnyProcedureBuilder>(
-    proc: $ProcedureBuilder,
-  ): $ProcedureBuilder extends ProcedureBuilder<infer $TParams>
-    ? CreateProcedureReturnInput<TParams, $TParams>
-    : never;
   /**
    * Query procedure
    */
   query<$Output>(
     resolver: (
       opts: ResolveOptions<TParams>,
-    ) => MaybePromise<FallbackValue<TParams['_output_in'], $Output>>,
-  ): BuildProcedure<'query', TParams, $Output>;
+    ) => MaybePromise<DefaultValue<TParams['_output_in'], $Output>>,
+  ): QueryProcedure<{
+    input: DefaultValue<TParams['_input_in'], void>;
+    output: DefaultValue<TParams['_output_out'], $Output>;
+  }>;
 
   /**
    * Mutation procedure
@@ -165,8 +144,11 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
   mutation<$Output>(
     resolver: (
       opts: ResolveOptions<TParams>,
-    ) => MaybePromise<FallbackValue<TParams['_output_in'], $Output>>,
-  ): BuildProcedure<'mutation', TParams, $Output>;
+    ) => MaybePromise<DefaultValue<TParams['_output_in'], $Output>>,
+  ): MutationProcedure<{
+    input: DefaultValue<TParams['_input_in'], void>;
+    output: DefaultValue<TParams['_output_out'], $Output>;
+  }>;
 
   /**
    * Mutation procedure
@@ -174,8 +156,11 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
   subscription<$Output>(
     resolver: (
       opts: ResolveOptions<TParams>,
-    ) => MaybePromise<FallbackValue<TParams['_output_in'], $Output>>,
-  ): BuildProcedure<'subscription', TParams, $Output>;
+    ) => MaybePromise<DefaultValue<TParams['_output_in'], $Output>>,
+  ): SubscriptionProcedure<{
+    input: DefaultValue<TParams['_input_in'], void>;
+    output: DefaultValue<TParams['_output_out'], $Output>;
+  }>;
   /**
    * @internal
    */
@@ -217,6 +202,7 @@ export function createBuilder<TConfig extends AnyRootConfig>(
   _meta: TConfig['$types']['meta'];
 }> {
   const _def: AnyProcedureBuilderDef = {
+    procedure: true,
     inputs: [],
     middlewares: [],
     ...initDef,
@@ -243,13 +229,6 @@ export function createBuilder<TConfig extends AnyRootConfig>(
         meta: meta as Record<string, unknown>,
       }) as AnyProcedureBuilder;
     },
-    /**
-     * @deprecated
-     * This functionality is deprecated and will be removed in the next major version.
-     */
-    unstable_concat(builder) {
-      return createNewBuilder(_def, builder._def) as any;
-    },
     use(middlewareBuilderOrFn) {
       // Distinguish between a middleware builder and a middleware function
       const middlewares =
@@ -263,19 +242,19 @@ export function createBuilder<TConfig extends AnyRootConfig>(
     },
     query(resolver) {
       return createResolver(
-        { ..._def, query: true },
+        { ..._def, type: 'query' },
         resolver,
       ) as AnyQueryProcedure;
     },
     mutation(resolver) {
       return createResolver(
-        { ..._def, mutation: true },
+        { ..._def, type: 'mutation' },
         resolver,
       ) as AnyMutationProcedure;
     },
     subscription(resolver) {
       return createResolver(
-        { ..._def, subscription: true },
+        { ..._def, type: 'subscription' },
         resolver,
       ) as AnySubscriptionProcedure;
     },
@@ -283,7 +262,7 @@ export function createBuilder<TConfig extends AnyRootConfig>(
 }
 
 function createResolver(
-  _def: AnyProcedureBuilderDef,
+  _def: AnyProcedureBuilderDef & { type: ProcedureType },
   resolver: (opts: ResolveOptions<any>) => MaybePromise<any>,
 ) {
   const finalBuilder = createNewBuilder(_def, {
@@ -309,7 +288,7 @@ function createResolver(
  */
 export interface ProcedureCallOptions {
   ctx: unknown;
-  rawInput: unknown;
+  getRawInput: GetRawInputFn;
   input?: unknown;
   path: string;
   type: ProcedureType;
@@ -327,9 +306,9 @@ const result = await caller.call('myProcedure', input);
 `.trim();
 
 function createProcedureCaller(_def: AnyProcedureBuilderDef): AnyProcedure {
-  const procedure = async function resolve(opts: ProcedureCallOptions) {
+  async function procedure(opts: ProcedureCallOptions) {
     // is direct server-side call
-    if (!opts || !('rawInput' in opts)) {
+    if (!opts || !('getRawInput' in opts)) {
       throw new Error(codeblock);
     }
 
@@ -339,7 +318,7 @@ function createProcedureCaller(_def: AnyProcedureBuilderDef): AnyProcedure {
         ctx: any;
         index: number;
         input?: unknown;
-        rawInput?: unknown;
+        getRawInput?: GetRawInputFn;
       } = {
         index: 0,
         ctx: opts.ctx,
@@ -352,7 +331,7 @@ function createProcedureCaller(_def: AnyProcedureBuilderDef): AnyProcedure {
           ctx: callOpts.ctx,
           type: opts.type,
           path: opts.path,
-          rawInput: callOpts.rawInput ?? opts.rawInput,
+          getRawInput: callOpts.getRawInput ?? opts.getRawInput,
           meta: _def.meta,
           input: callOpts.input,
           next(_nextOpts?: any) {
@@ -360,7 +339,7 @@ function createProcedureCaller(_def: AnyProcedureBuilderDef): AnyProcedure {
               | {
                   ctx?: Record<string, unknown>;
                   input?: unknown;
-                  rawInput?: unknown;
+                  getRawInput?: GetRawInputFn;
                 }
               | undefined;
 
@@ -374,10 +353,10 @@ function createProcedureCaller(_def: AnyProcedureBuilderDef): AnyProcedure {
                 nextOpts && 'input' in nextOpts
                   ? nextOpts.input
                   : callOpts.input,
-              rawInput:
-                nextOpts && 'rawInput' in nextOpts
-                  ? nextOpts.rawInput
-                  : callOpts.rawInput,
+              getRawInput:
+                nextOpts && 'getRawInput' in nextOpts
+                  ? nextOpts.getRawInput
+                  : callOpts.getRawInput,
             });
           },
         });
@@ -406,9 +385,10 @@ function createProcedureCaller(_def: AnyProcedureBuilderDef): AnyProcedure {
       throw result.error;
     }
     return result.data;
-  };
+  }
+
   procedure._def = _def;
-  procedure.meta = _def.meta;
 
-  return procedure as AnyProcedure;
+  // FIXME typecast shouldn't be needed - fixittt
+  return procedure as unknown as AnyProcedure;
 }

package/src/core/internals/utils.ts

@@ -1,5 +1,5 @@
 import { Simplify } from '../../types';
-import { ProcedureParams } from '../procedure';
+import { AnyProcedureParams, ProcedureParams } from '../procedure';
 
 /**
  * @internal
@@ -15,12 +15,7 @@ export type Overwrite<TType, TWith> = TType extends any
       }
     : never
   : never;
-/**
- * @internal
- */
-export type OverwriteKnown<TType, TWith> = {
-  [K in keyof TType]: K extends keyof TWith ? TWith[K] : TType[K];
-};
+
 /**
  * @internal
  */
@@ -52,7 +47,9 @@ export type UnsetMarker = typeof unsetMarker;
 /**
  * @internal
  */
-export interface ResolveOptions<TParams extends ProcedureParams> {
+export interface ResolveOptions<
+  TParams extends ProcedureParams<AnyProcedureParams>,
+> {
   ctx: Simplify<
     Overwrite<TParams['_config']['$types']['ctx'], TParams['_ctx_out']>
   >;
@@ -79,3 +76,9 @@ export type PickFirstDefined<TType, TPick> = undefined extends TType
     ? never
     : TPick
   : TType;
+
+/**
+ * @internal
+ * Returns the raw input type of a procedure
+ */
+export type GetRawInputFn = () => Promise<unknown>;

package/src/core/middleware.ts

@@ -5,11 +5,12 @@ import { ParseFn } from './internals/getParseFn';
 import { ProcedureBuilderMiddleware } from './internals/procedureBuilder';
 import {
   DefaultValue as FallbackValue,
+  GetRawInputFn,
   MiddlewareMarker,
   Overwrite,
   UnsetMarker,
 } from './internals/utils';
-import { ProcedureParams } from './procedure';
+import { AnyProcedureParams, ProcedureParams } from './procedure';
 import { ProcedureType } from './types';
 
 /**
@@ -26,8 +27,9 @@ interface MiddlewareResultBase {
 /**
  * @internal
  */
-interface MiddlewareOKResult<_TParams extends ProcedureParams>
-  extends MiddlewareResultBase {
+interface MiddlewareOKResult<
+  _TParams extends ProcedureParams<AnyProcedureParams>,
+> extends MiddlewareResultBase {
   ok: true;
   data: unknown;
   // this could be extended with `input`/`rawInput` later
@@ -36,8 +38,9 @@ interface MiddlewareOKResult<_TParams extends ProcedureParams>
 /**
  * @internal
  */
-interface MiddlewareErrorResult<_TParams extends ProcedureParams>
-  extends MiddlewareResultBase {
+interface MiddlewareErrorResult<
+  _TParams extends ProcedureParams<AnyProcedureParams>,
+> extends MiddlewareResultBase {
   ok: false;
   error: TRPCError;
 }
@@ -45,21 +48,21 @@ interface MiddlewareErrorResult<_TParams extends ProcedureParams>
 /**
  * @internal
  */
-export type MiddlewareResult<TParams extends ProcedureParams> =
-  | MiddlewareErrorResult<TParams>
-  | MiddlewareOKResult<TParams>;
+export type MiddlewareResult<
+  TParams extends ProcedureParams<AnyProcedureParams>,
+> = MiddlewareErrorResult<TParams> | MiddlewareOKResult<TParams>;
 
 /**
  * @internal
  */
 export interface MiddlewareBuilder<
-  TRoot extends ProcedureParams,
-  TNewParams extends ProcedureParams,
+  TRoot extends ProcedureParams<AnyProcedureParams>,
+  TNewParams extends ProcedureParams<AnyProcedureParams>,
 > {
   /**
    * Create a new builder based on the current middleware builder
    */
-  unstable_pipe<$Params extends ProcedureParams>(
+  unstable_pipe<$Params extends ProcedureParams<AnyProcedureParams>>(
     fn: {
       _config: TRoot['_config'];
       _meta: TRoot['_meta'];
@@ -73,7 +76,7 @@ export interface MiddlewareBuilder<
         TRoot['_output_out'],
         TNewParams['_output_out']
       >;
-    } extends infer OParams extends ProcedureParams
+    } extends infer OParams extends ProcedureParams<AnyProcedureParams>
       ?
           | MiddlewareBuilder<OParams, $Params>
           | MiddlewareFunction<OParams, $Params>
@@ -95,9 +98,9 @@ export interface MiddlewareBuilder<
  * FIXME: there must be a nicer way of doing this, it's hard to maintain when we have several structures like this
  */
 type CreateMiddlewareReturnInput<
-  TRoot extends ProcedureParams,
-  TPrev extends ProcedureParams,
-  TNext extends ProcedureParams,
+  TRoot extends ProcedureParams<AnyProcedureParams>,
+  TPrev extends ProcedureParams<AnyProcedureParams>,
+  TNext extends ProcedureParams<AnyProcedureParams>,
 > = MiddlewareBuilder<
   TRoot,
   {
@@ -133,8 +136,8 @@ type deriveParamsFromConfig<
  * @internal
  */
 export type MiddlewareFunction<
-  TParams extends ProcedureParams,
-  TParamsAfter extends ProcedureParams,
+  TParams extends ProcedureParams<AnyProcedureParams>,
+  TParamsAfter extends ProcedureParams<AnyProcedureParams>,
 > = {
   (opts: {
     ctx: Simplify<
@@ -143,11 +146,11 @@ export type MiddlewareFunction<
     type: ProcedureType;
     path: string;
     input: TParams['_input_out'];
-    rawInput: unknown;
+    getRawInput: GetRawInputFn;
     meta: TParams['_meta'] | undefined;
     next: {
       (): Promise<MiddlewareResult<TParams>>;
-      <$Context>(opts: { ctx: $Context }): Promise<
+      <$Context>(opts: { ctx?: $Context; input?: unknown }): Promise<
         MiddlewareResult<{
           _config: TParams['_config'];
           _ctx_out: $Context;
@@ -158,7 +161,9 @@ export type MiddlewareFunction<
           _meta: TParams['_meta'];
         }>
       >;
-      (opts: { rawInput: unknown }): Promise<MiddlewareResult<TParams>>;
+      (opts: { getRawInput: GetRawInputFn }): Promise<
+        MiddlewareResult<TParams>
+      >;
     };
   }): Promise<MiddlewareResult<TParamsAfter>>;
   _type?: string | undefined;
@@ -171,7 +176,9 @@ export function createMiddlewareFactory<
   TConfig extends AnyRootConfig,
   TInputIn = unknown,
 >() {
-  function createMiddlewareInner<TNewParams extends ProcedureParams>(
+  function createMiddlewareInner<
+    TNewParams extends ProcedureParams<AnyProcedureParams>,
+  >(
     middlewares: MiddlewareFunction<any, any>[],
   ): MiddlewareBuilder<deriveParamsFromConfig<TConfig, TInputIn>, TNewParams> {
     return {
@@ -190,7 +197,9 @@ export function createMiddlewareFactory<
     };
   }
 
-  function createMiddleware<TNewParams extends ProcedureParams>(
+  function createMiddleware<
+    TNewParams extends ProcedureParams<AnyProcedureParams>,
+  >(
     fn: MiddlewareFunction<
       deriveParamsFromConfig<TConfig, TInputIn>,
       TNewParams
@@ -229,12 +238,10 @@ function isPlainObject(obj: unknown) {
  * Please note, `trpc-openapi` uses this function.
  */
 export function createInputMiddleware<TInput>(parse: ParseFn<TInput>) {
-  const inputMiddleware: ProcedureBuilderMiddleware = async ({
-    next,
-    rawInput,
-    input,
-  }) => {
+  const inputMiddleware: ProcedureBuilderMiddleware = async (opts) => {
     let parsedInput: ReturnType<typeof parse>;
+
+    const rawInput = await opts.getRawInput();
     try {
       parsedInput = await parse(rawInput);
     } catch (cause) {
@@ -246,15 +253,14 @@ export function createInputMiddleware<TInput>(parse: ParseFn<TInput>) {
 
     // Multiple input parsers
     const combinedInput =
-      isPlainObject(input) && isPlainObject(parsedInput)
+      isPlainObject(opts.input) && isPlainObject(parsedInput)
         ? {
-            ...input,
+            ...opts.input,
             ...parsedInput,
           }
         : parsedInput;
 
-    // TODO fix this typing?
-    return next({ input: combinedInput } as any);
+    return opts.next({ input: combinedInput });
   };
   inputMiddleware._type = 'input';
   return inputMiddleware;

package/src/core/procedure.ts

@@ -1,9 +1,5 @@
 import { AnyRootConfig } from './internals/config';
-import {
-  ProcedureBuilderDef,
-  ProcedureCallOptions,
-} from './internals/procedureBuilder';
-import { UnsetMarker } from './internals/utils';
+import { ProcedureCallOptions } from './internals/procedureBuilder';
 import { ProcedureType } from './types';
 
 type ClientContext = Record<string, unknown>;
@@ -20,77 +16,73 @@ export interface ProcedureOptions {
 }
 
 /**
- * FIXME: this should only take 1 generic argument instead of a list
  * @internal
+ * @deprecated
  */
-export interface ProcedureParams<
-  TConfig extends AnyRootConfig = AnyRootConfig,
-  TContextOut = unknown,
-  TInputIn = unknown,
-  TInputOut = unknown,
-  TOutputIn = unknown,
-  TOutputOut = unknown,
-  TMeta = unknown,
-> {
-  _config: TConfig;
-  /**
-   * @internal
-   */
-  _meta: TMeta;
-  /**
-   * @internal
-   */
-  _ctx_out: TContextOut;
-  /**
-   * @internal
-   */
-  _input_in: TInputIn;
-  /**
-   * @internal
-   */
-  _input_out: TInputOut;
-  /**
-   * @internal
-   */
-  _output_in: TOutputIn;
-  /**
-   * @internal
-   */
-  _output_out: TOutputOut;
-}
+export type AnyProcedureParams = {
+  _config: AnyRootConfig;
+  _meta: unknown;
+  _ctx_out: unknown;
+  _input_in: unknown;
+  _input_out: unknown;
+  _output_in: unknown;
+  _output_out: unknown;
+};
+
+/**
+ * @deprecated
+ */
+export type ProcedureParams<TParams extends AnyProcedureParams> = TParams;
 
 /**
  * @internal
  */
-export type ProcedureArgs<TParams extends ProcedureParams> =
-  TParams['_input_in'] extends UnsetMarker
+export type ProcedureArgs<TParams extends AnyProcedure['_def']> =
+  void extends TParams['_input_in']
     ? [input?: undefined | void, opts?: ProcedureOptions]
     : undefined extends TParams['_input_in']
     ? [input?: TParams['_input_in'] | void, opts?: ProcedureOptions]
     : [input: TParams['_input_in'], opts?: ProcedureOptions];
 
+interface BuiltProcedureDef {
+  input: unknown;
+  output: unknown;
+}
 /**
  *
  * @internal
  */
 export interface Procedure<
   TType extends ProcedureType,
-  TParams extends ProcedureParams,
+  TDef extends BuiltProcedureDef,
 > {
-  _type: TType;
-  _def: ProcedureBuilderDef<TParams> & TParams;
-  /**
-   * @deprecated use `._def.meta` instead
-   */
-  meta?: TParams['_meta'];
-  _procedure: true;
+  _def: {
+    _input_in: TDef['input'];
+    _output_out: TDef['output'];
+    procedure: true;
+    type: TType;
+    /**
+     * @internal
+     * Meta is not inferrable on individual procedures, only on the router
+     */
+    meta: unknown;
+  };
   /**
    * @internal
    */
   (opts: ProcedureCallOptions): Promise<unknown>;
 }
 
-export type AnyQueryProcedure = Procedure<'query', any>;
-export type AnyMutationProcedure = Procedure<'mutation', any>;
-export type AnySubscriptionProcedure = Procedure<'subscription', any>;
+export interface QueryProcedure<TDef extends BuiltProcedureDef>
+  extends Procedure<'query', TDef> {}
+
+export interface MutationProcedure<TDef extends BuiltProcedureDef>
+  extends Procedure<'mutation', TDef> {}
+
+export interface SubscriptionProcedure<TDef extends BuiltProcedureDef>
+  extends Procedure<'subscription', TDef> {}
+
+export type AnyQueryProcedure = QueryProcedure<any>;
+export type AnyMutationProcedure = MutationProcedure<any>;
+export type AnySubscriptionProcedure = SubscriptionProcedure<any>;
 export type AnyProcedure = Procedure<ProcedureType, any>;