@trpc/server 9.21.0 → 9.23.1-alpha.0

package/src/internals/BaseHandlerOptions.ts

@@ -1,5 +1,5 @@
-import { OnErrorFunction } from './OnErrorFunction';
 import { AnyRouter } from '../router';
+import { OnErrorFunction } from './OnErrorFunction';
 
 /**
  * Base interface for any response handler

package/src/internals/OnErrorFunction.ts

@@ -1,5 +1,5 @@
-import { AnyRouter, inferRouterContext, ProcedureType } from '../router';
 import { TRPCError } from '../TRPCError';
+import { AnyRouter, ProcedureType, inferRouterContext } from '../router';
 
 export type OnErrorFunction<TRouter extends AnyRouter, TRequest> = (opts: {
   error: TRPCError;

package/src/internals/middlewares.ts

@@ -1,5 +1,5 @@
-import { ProcedureType } from '../router';
 import { TRPCError } from '../TRPCError';
+import { ProcedureType } from '../router';
 
 export const middlewareMarker = Symbol('middlewareMarker');
 interface MiddlewareResultBase<TContext> {
@@ -27,11 +27,12 @@ export type MiddlewareResult<TContext> =
   | MiddlewareOKResult<TContext>
   | MiddlewareErrorResult<TContext>;
 
-export type MiddlewareFunction<TInputContext, TContext> = (opts: {
+export type MiddlewareFunction<TInputContext, TContext, TMeta> = (opts: {
   ctx: TInputContext;
   type: ProcedureType;
   path: string;
   rawInput: unknown;
+  meta?: TMeta;
   next: {
     (): Promise<MiddlewareResult<TInputContext>>;
     <T>(opts: { ctx: T }): Promise<MiddlewareResult<T>>;

package/src/internals/procedure.ts

@@ -2,6 +2,7 @@
 import { TRPCError } from '../TRPCError';
 import { assertNotBrowser } from '../assertNotBrowser';
 import { ProcedureType } from '../router';
+import { InferLast } from '../types';
 import { getErrorFromUnknown } from './errors';
 import { MiddlewareFunction, middlewareMarker } from './middlewares';
 import { wrapCallSafe } from './wrapCallSafe';
@@ -44,11 +45,12 @@ export type ProcedureResolver<TContext, TInput, TOutput> = (opts: {
   type: ProcedureType;
 }) => Promise<TOutput> | TOutput;
 
-interface ProcedureOptions<TContext, TInput, TOutput, TParsedOutput> {
-  middlewares: Array<MiddlewareFunction<any, any>>;
+interface ProcedureOptions<TContext, TMeta, TInput, TOutput, TParsedOutput> {
+  middlewares: Array<MiddlewareFunction<any, any, any>>;
   resolver: ProcedureResolver<TContext, TInput, TOutput>;
   inputParser: ProcedureParser<TInput>;
   outputParser: ProcedureParser<TParsedOutput>;
+  meta: TMeta;
 }
 
 /**
@@ -100,21 +102,29 @@ function getParseFn<T>(procedureParser: ProcedureParser<T>): ParseFn<T> {
 export class Procedure<
   TInputContext,
   TContext,
+  TMeta,
   TInput,
   TParsedInput,
   TOutput,
   TParsedOutput,
   TFinalOutput = unknown extends TParsedOutput ? TOutput : TParsedOutput,
 > {
-  private middlewares: Readonly<Array<MiddlewareFunction<any, any>>>;
+  private middlewares: Readonly<Array<MiddlewareFunction<any, any, any>>>;
   private resolver: ProcedureResolver<TContext, TParsedInput, TOutput>;
   private readonly inputParser: ProcedureParser<TParsedInput>;
   private parseInputFn: ParseFn<TParsedInput>;
   private readonly outputParser: ProcedureParser<TFinalOutput>;
   private parseOutputFn: ParseFn<TFinalOutput>;
+  public readonly meta: TMeta;
 
   constructor(
-    opts: ProcedureOptions<TContext, TParsedInput, TOutput, TFinalOutput>,
+    opts: ProcedureOptions<
+      TContext,
+      TMeta,
+      TParsedInput,
+      TOutput,
+      TFinalOutput
+    >,
   ) {
     this.middlewares = opts.middlewares;
     this.resolver = opts.resolver;
@@ -122,6 +132,7 @@ export class Procedure<
     this.parseInputFn = getParseFn(this.inputParser);
     this.outputParser = opts.outputParser;
     this.parseOutputFn = getParseFn(this.outputParser);
+    this.meta = opts.meta;
   }
 
   private async parseInput(rawInput: unknown): Promise<TParsedInput> {
@@ -158,7 +169,11 @@ export class Procedure<
     const middlewaresWithResolver = this.middlewares.concat([
       async ({ ctx }: { ctx: TContext }) => {
         const input = await this.parseInput(opts.rawInput);
-        const rawOutput = await this.resolver({ ...opts, ctx, input });
+        const rawOutput = await this.resolver({
+          ...opts,
+          ctx,
+          input,
+        });
         const data = await this.parseOutput(rawOutput);
         return {
           marker: middlewareMarker,
@@ -178,6 +193,7 @@ export class Procedure<
             type: opts.type,
             path: opts.path,
             rawInput: opts.rawInput,
+            meta: this.meta,
             next: nextFns[index + 1],
           }),
         );
@@ -213,14 +229,21 @@ export class Procedure<
    * @param middlewares
    */
   public inheritMiddlewares(
-    middlewares: MiddlewareFunction<TInputContext, TContext>[],
+    middlewares: MiddlewareFunction<TInputContext, TContext, TMeta>[],
   ): this {
     const Constructor: {
       new (
-        opts: ProcedureOptions<TContext, TParsedInput, TOutput, TFinalOutput>,
+        opts: ProcedureOptions<
+          TContext,
+          TMeta,
+          TParsedInput,
+          TOutput,
+          TFinalOutput
+        >,
       ): Procedure<
         TInputContext,
         TContext,
+        TMeta,
         TInput,
         TParsedInput,
         TOutput,
@@ -233,20 +256,23 @@ export class Procedure<
       resolver: this.resolver,
       inputParser: this.inputParser,
       outputParser: this.outputParser,
+      meta: this.meta,
     });
 
     return instance as any;
   }
 }
 
-export type CreateProcedureWithInput<TContext, TInput, TOutput> = {
+export type CreateProcedureWithInput<TContext, TMeta, TInput, TOutput> = {
   input: ProcedureParser<TInput>;
   output?: ProcedureParser<TOutput>;
-  resolve: ProcedureResolver<TContext, TInput, TOutput>;
+  meta?: TMeta;
+  resolve: ProcedureResolver<TContext, TInput, InferLast<TOutput>>;
 };
 
 export type CreateProcedureWithInputOutputParser<
   TContext,
+  TMeta,
   TInput,
   TParsedInput,
   TOutput,
@@ -254,18 +280,26 @@ export type CreateProcedureWithInputOutputParser<
 > = {
   input: ProcedureParserWithInputOutput<TInput, TParsedInput>;
   output?: ProcedureParserWithInputOutput<TOutput, TParsedOutput>;
-  resolve: ProcedureResolver<TContext, TParsedInput, TOutput>;
+  meta?: TMeta;
+  resolve: ProcedureResolver<TContext, TParsedInput, InferLast<TOutput>>;
 };
 
-export type CreateProcedureWithoutInput<TContext, TOutput, TParsedOutput> = {
+export type CreateProcedureWithoutInput<
+  TContext,
+  TMeta,
+  TOutput,
+  TParsedOutput,
+> = {
   output?:
     | ProcedureParserWithInputOutput<TOutput, TParsedOutput>
     | ProcedureParser<TOutput>;
-  resolve: ProcedureResolver<TContext, undefined, TOutput>;
+  meta?: TMeta;
+  resolve: ProcedureResolver<TContext, undefined, InferLast<TOutput>>;
 };
 
 export type CreateProcedureOptions<
   TContext,
+  TMeta = undefined,
   TInput = undefined,
   TParsedInput = undefined,
   TOutput = undefined,
@@ -273,16 +307,18 @@ export type CreateProcedureOptions<
 > =
   | CreateProcedureWithInputOutputParser<
       TContext,
+      TMeta,
       TInput,
       TParsedInput,
       TOutput,
       TParsedOutput
     >
-  | CreateProcedureWithInput<TContext, TInput, TOutput>
-  | CreateProcedureWithoutInput<TContext, TOutput, TParsedOutput>;
+  | CreateProcedureWithInput<TContext, TMeta, TInput, TOutput>
+  | CreateProcedureWithoutInput<TContext, TMeta, TOutput, TParsedOutput>;
 
 export function createProcedure<
   TContext,
+  TMeta,
   TInput,
   TParsedInput,
   TOutput,
@@ -290,12 +326,21 @@ export function createProcedure<
 >(
   opts: CreateProcedureOptions<
     TContext,
+    TMeta,
     TInput,
     TParsedInput,
     TOutput,
     TParsedOutput
   >,
-): Procedure<unknown, TContext, TInput, TParsedInput, TOutput, TParsedOutput> {
+): Procedure<
+  unknown,
+  TContext,
+  TMeta,
+  TInput,
+  TParsedInput,
+  TOutput,
+  TParsedOutput
+> {
   const inputParser =
     'input' in opts
       ? opts.input
@@ -319,14 +364,16 @@ export function createProcedure<
     resolver: opts.resolve as any,
     middlewares: [],
     outputParser: outputParser as any,
+    meta: opts.meta as any,
   });
 }
 
 export type inferProcedureFromOptions<
   TInputContext,
-  TOptions extends CreateProcedureOptions<any, any, any, any, any>,
+  TOptions extends CreateProcedureOptions<any, any, any, any, any, any>,
 > = TOptions extends CreateProcedureOptions<
   infer TContext,
+  infer TMeta,
   infer TInput,
   infer TParsedInput,
   infer TOutput,
@@ -335,6 +382,7 @@ export type inferProcedureFromOptions<
   ? Procedure<
       TInputContext,
       TContext,
+      TMeta,
       unknown extends TInput ? undefined : TInput,
       unknown extends TParsedInput ? undefined : TParsedInput,
       TOutput,