@trpc/server 9.4.0 → 9.6.1

package/dist/trpc-server.esm.js

@@ -1,16 +1,39 @@
-import { a as assertNotBrowser, g as getHTTPStatusCodeFromError, n as nodeHTTPRequestHandler } from './nodeHTTPRequestHandler-3c64002f.esm.js';
+import { a as assertNotBrowser, n as nodeHTTPRequestHandler, g as getHTTPStatusCodeFromError } from './nodeHTTPRequestHandler-3c64002f.esm.js';
 export { a as assertNotBrowser, r as resolveHTTPResponse } from './nodeHTTPRequestHandler-3c64002f.esm.js';
+export { S as Subscription, s as subscriptionPullFactory } from './subscription-fbda2888.esm.js';
 import { T as TRPCError, g as getErrorFromUnknown } from './transformTRPCResponse-f73dc4a2.esm.js';
 export { T as TRPCError } from './transformTRPCResponse-f73dc4a2.esm.js';
-import { T as TRPC_ERROR_CODES_BY_KEY } from './codes-3dd40769.esm.js';
-export { S as Subscription, s as subscriptionPullFactory } from './subscription-fbda2888.esm.js';
 import { createHTTPServer, createHTTPHandler } from '../adapters/standalone/dist/trpc-server-adapters-standalone.esm.js';
+import { T as TRPC_ERROR_CODES_BY_KEY } from './codes-3dd40769.esm.js';
 import 'url';
 import 'events';
 import 'http';
 
 assertNotBrowser();
 
+// this has been moved to separate package
+
+/**
+ * @deprecated use `createHTTPServer` from `@trpc/server/adapters/standalone`
+ */
+const createHttpServer = createHTTPServer;
+/**
+ * @deprecated use `createHTTPHandler` from `@trpc/server/adapters/standalone`
+ */
+
+const createHttpHandler = createHTTPHandler;
+/**
+ * @deprecated use `CreateHTTPHandlerOptions` from `@trpc/server/adapters/standalone`
+ */
+
+/**
+ * @deprecated use `nodeHTTPRequestHandler` from `@trpc/server/adapters/node-http`
+ */
+const requestHandler = nodeHTTPRequestHandler;
+/**
+ * @deprecated use `NodeHTTPCreateContextFn` from `@trpc/server/adapters/node-http`
+ */
+
 const middlewareMarker = /*#__PURE__*/Symbol('middlewareMarker');
 
 /**
@@ -87,21 +110,26 @@ class Procedure {
 
   async call(opts) {
     // wrap the actual resolver and treat as the last "middleware"
-    const middlewaresWithResolver = this.middlewares.concat([async () => {
+    const middlewaresWithResolver = this.middlewares.concat([async ({
+      ctx
+    }) => {
       const input = this.parseInput(opts.rawInput);
       const data = await this.resolver({ ...opts,
+        ctx,
         input
       });
       return {
         marker: middlewareMarker,
         ok: true,
-        data
+        data,
+        ctx
       };
     }]); // create `next()` calls in resolvers
 
     const nextFns = middlewaresWithResolver.map((fn, index) => {
-      return async () => {
+      return async nextOpts => {
         const res = await wrapCallSafe(() => fn({ ...opts,
+          ...nextOpts,
           next: nextFns[index + 1]
         }));
 
@@ -233,6 +261,10 @@ const defaultTransformer = {
     deserialize: obj => obj
   }
 };
+
+/**
+ * @internal The type signature of this class may change without warning.
+ */
 class Router {
   constructor(def) {
     var _def$queries, _def$mutations, _def$subscriptions, _def$middlewares, _def$errorFormatter, _def$transformer;
@@ -394,7 +426,6 @@ class Router {
   }
   /**
    * Function to be called before any procedure is invoked
-   * Can be async or sync
    * @link https://trpc.io/docs/middlewares
    */
 
@@ -468,31 +499,15 @@ class Router {
   }
 
 }
-function router() {
-  return new Router();
-}
-
-// this has been moved to separate package
-
-/**
- * @deprecated use `createHTTPServer` from `@trpc/server/adapters/standalone`
- */
-const createHttpServer = createHTTPServer;
-/**
- * @deprecated use `createHTTPHandler` from `@trpc/server/adapters/standalone`
- */
-
-const createHttpHandler = createHTTPHandler;
 /**
- * @deprecated use `CreateHTTPHandlerOptions` from `@trpc/server/adapters/standalone`
+ * Subclass of `VNextRouter` with `TInputContext` and `TContext` set to the same type, for backcompat.
+ *
+ * @deprecated
  */
 
-/**
- * @deprecated use `nodeHTTPRequestHandler` from `@trpc/server/adapters/node-http`
- */
-const requestHandler = nodeHTTPRequestHandler;
-/**
- * @deprecated use `NodeHTTPCreateContextFn` from `@trpc/server/adapters/node-http`
- */
+class LegacyRouter extends Router {}
+function router() {
+  return new Router();
+}
 
-export { Router, createHttpHandler, createHttpServer, requestHandler, router };
+export { LegacyRouter, LegacyRouter as Router, createHttpHandler, createHttpServer, requestHandler, router };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "9.4.0",
+  "version": "9.6.1",
   "description": "tRPC Server",
   "author": "KATT",
   "license": "MIT",
@@ -58,12 +58,12 @@
     "jest": "^27.1.0",
     "myzod": "^1.3.1",
     "next": "^11.1.0",
-    "typescript": "4.4.2",
+    "typescript": "4.4.3",
     "ws": "^8.0.0",
     "yup": "^0.32.8",
     "zod": "^3.0.0"
   },
-  "gitHead": "44e50cb6530999af5695d3c9301d84de593e1d00",
+  "gitHead": "711f122307c9441c16606add544c0810308d3f79",
   "dependencies": {
     "tslib": "^2.1.0"
   }

package/src/adapters/node-http/types.ts

@@ -15,7 +15,7 @@ export type NodeHTTPCreateContextOption<
   TRouter extends AnyRouter,
   TRequest,
   TResponse,
-> = inferRouterContext<TRouter> extends void
+> = unknown extends inferRouterContext<TRouter>
   ? {
       /**
        * @link https://trpc.io/docs/context

package/src/deprecated/LegacyRouter.ts

@@ -0,0 +1,3 @@
+export * from '../router';
+
+export { LegacyRouter as Router } from '../router';

package/src/index.ts

@@ -1,6 +1,5 @@
 export * from './assertNotBrowser';
 export * from './http';
-export * from './router';
 export * from './subscription';
 export * from './transformer';
 export * from './TRPCError';
@@ -9,3 +8,4 @@ export * from './types';
 // deprecated
 export * from './deprecated/createHttpServer';
 export * from './deprecated/requestHandler';
+export * from './deprecated/LegacyRouter';

package/src/internals/middlewares.ts

@@ -2,30 +2,37 @@ import { ProcedureType } from '../router';
 import { TRPCError } from '../TRPCError';
 
 export const middlewareMarker = Symbol('middlewareMarker');
-interface MiddlewareResultBase {
+interface MiddlewareResultBase<TContext> {
   /**
    * All middlewares should pass through their `next()`'s output.
    * Requiring this marker makes sure that can't be forgotten at compile-time.
    */
   readonly marker: typeof middlewareMarker;
+  ctx: TContext;
 }
 
-interface MiddlewareOKResult extends MiddlewareResultBase {
+interface MiddlewareOKResult<TContext> extends MiddlewareResultBase<TContext> {
   ok: true;
   data: unknown;
   // this could be extended with `input`/`rawInput` later
 }
-interface MiddlewareErrorResult extends MiddlewareResultBase {
+interface MiddlewareErrorResult<TContext>
+  extends MiddlewareResultBase<TContext> {
   ok: false;
   error: TRPCError;
   // we could guarantee it's always of this type
 }
 
-export type MiddlewareResult = MiddlewareOKResult | MiddlewareErrorResult;
+export type MiddlewareResult<TContext> =
+  | MiddlewareOKResult<TContext>
+  | MiddlewareErrorResult<TContext>;
 
-export type MiddlewareFunction<TContext> = (opts: {
-  ctx: TContext;
+export type MiddlewareFunction<TInputContext, TContext> = (opts: {
+  ctx: TInputContext;
   type: ProcedureType;
   path: string;
-  next: () => Promise<MiddlewareResult>;
-}) => Promise<MiddlewareResult>;
+  next: {
+    (): Promise<MiddlewareResult<TInputContext>>;
+    <T>(opts: { ctx: T }): Promise<MiddlewareResult<T>>;
+  };
+}) => Promise<MiddlewareResult<TContext>>;

package/src/internals/procedure.ts

@@ -34,7 +34,7 @@ export type ProcedureResolver<
 }) => Promise<TOutput> | TOutput;
 
 interface ProcedureOptions<TContext, TInput, TOutput> {
-  middlewares: MiddlewareFunction<TContext>[];
+  middlewares: Array<MiddlewareFunction<any, any>>;
   resolver: ProcedureResolver<TContext, TInput, TOutput>;
   inputParser: ProcedureInputParser<TInput>;
 }
@@ -72,11 +72,12 @@ function getParseFn<TInput>(
  * @internal
  */
 export abstract class Procedure<
-  TContext = unknown,
-  TInput = unknown,
-  TOutput = unknown,
+  TInputContext, //
+  TContext,
+  TInput,
+  TOutput,
 > {
-  private middlewares: Readonly<MiddlewareFunction<TContext>[]>;
+  private middlewares: Readonly<Array<MiddlewareFunction<any, any>>>;
   private resolver: ProcedureResolver<TContext, TInput, TOutput>;
   private readonly inputParser: ProcedureInputParser<TInput>;
   private parse: ParseFn<TInput>;
@@ -103,25 +104,32 @@ export abstract class Procedure<
    * Trigger middlewares in order, parse raw input & call resolver
    * @internal
    */
-  public async call(opts: ProcedureCallOptions<TContext>): Promise<TOutput> {
+  public async call(
+    opts: ProcedureCallOptions<TInputContext>,
+  ): Promise<TOutput> {
     // wrap the actual resolver and treat as the last "middleware"
     const middlewaresWithResolver = this.middlewares.concat([
-      async () => {
+      async ({ ctx }: { ctx: TContext }) => {
         const input = this.parseInput(opts.rawInput);
-        const data = await this.resolver({ ...opts, input });
+        const data = await this.resolver({ ...opts, ctx, input });
         return {
           marker: middlewareMarker,
           ok: true,
           data,
-        };
+          ctx,
+        } as const;
       },
     ]);
 
     // create `next()` calls in resolvers
     const nextFns = middlewaresWithResolver.map((fn, index) => {
-      return async () => {
+      return async (nextOpts?: { ctx: TContext }) => {
         const res = await wrapCallSafe(() =>
-          fn({ ...opts, next: nextFns[index + 1] }),
+          fn({
+            ...(opts as any),
+            ...(nextOpts as any),
+            next: nextFns[index + 1],
+          }),
         );
         if (res.ok) {
           return res.data;
@@ -154,9 +162,12 @@ export abstract class Procedure<
    * Create new procedure with passed middlewares
    * @param middlewares
    */
-  public inheritMiddlewares(middlewares: MiddlewareFunction<TContext>[]): this {
+  public inheritMiddlewares(
+    middlewares: MiddlewareFunction<TInputContext, TContext>[],
+  ): this {
     const Constructor: {
       new (opts: ProcedureOptions<TContext, TInput, TOutput>): Procedure<
+        TInputContext,
         TContext,
         TInput,
         TOutput
@@ -173,17 +184,18 @@ export abstract class Procedure<
   }
 }
 
-export class ProcedureWithoutInput<TContext, TOutput> extends Procedure<
+export class ProcedureWithoutInput<
+  TInputContext,
   TContext,
-  undefined,
-  TOutput
-> {}
+  TOutput,
+> extends Procedure<TInputContext, TContext, undefined, TOutput> {}
 
-export class ProcedureWithInput<TContext, TInput, TOutput> extends Procedure<
+export class ProcedureWithInput<
+  TInputContext,
   TContext,
   TInput,
-  TOutput
-> {}
+  TOutput,
+> extends Procedure<TInputContext, TContext, TInput, TOutput> {}
 
 export type CreateProcedureWithInput<TContext, TInput, TOutput> = {
   input: ProcedureInputParser<TInput>;
@@ -206,15 +218,15 @@ function isProcedureWithInput<TContext, TInput, TOutput>(
 ): opts is CreateProcedureWithInput<TContext, TInput, TOutput> {
   return !!opts.input;
 }
-export function createProcedure<TContext, TInput, TOutput>(
+export function createProcedure<TInputContext, TContext, TInput, TOutput>(
   opts: CreateProcedureWithInput<TContext, TInput, TOutput>,
-): ProcedureWithInput<TContext, TInput, TOutput>;
-export function createProcedure<TContext, TOutput>(
+): ProcedureWithInput<TInputContext, TContext, TInput, TOutput>;
+export function createProcedure<TInputContext, TContext, TOutput>(
   opts: CreateProcedureWithoutInput<TContext, TOutput>,
-): ProcedureWithoutInput<TContext, TOutput>;
-export function createProcedure<TContext, TInput, TOutput>(
+): ProcedureWithoutInput<TInputContext, TContext, TOutput>;
+export function createProcedure<TInputContext, TContext, TInput, TOutput>(
   opts: CreateProcedureOptions<TContext, TInput, TOutput>,
-): Procedure<TContext, TInput, TOutput>;
+): Procedure<TInputContext, TContext, TInput, TOutput>;
 export function createProcedure<TContext, TInput, TOutput>(
   opts: CreateProcedureOptions<TContext, TInput, TOutput>,
 ) {
@@ -241,17 +253,18 @@ export function createProcedure<TContext, TInput, TOutput>(
 }
 
 export type inferProcedureFromOptions<
+  TInputContext,
   TOptions extends CreateProcedureOptions<any, any, any>,
 > = TOptions extends CreateProcedureWithInput<
   infer TContext,
   infer TInput,
   infer TOutput
 >
-  ? ProcedureWithInput<TContext, TInput, TOutput>
+  ? ProcedureWithInput<TInputContext, TContext, TInput, TOutput>
   : TOptions extends CreateProcedureWithoutInput<
       //
       infer TContext,
       infer TOutput
     >
-  ? ProcedureWithoutInput<TContext, TOutput>
-  : Procedure<unknown, unknown>;
+  ? ProcedureWithoutInput<TInputContext, TContext, TOutput>
+  : Procedure<unknown, unknown, unknown, unknown>;

package/src/router.ts

@@ -23,7 +23,7 @@ import {
 import { Subscription } from './subscription';
 import { CombinedDataTransformer, DataTransformerOptions } from './transformer';
 import { TRPCError } from './TRPCError';
-import { flatten, Prefixer, ThenArg } from './types';
+import { flatten, format, Prefixer, ThenArg } from './types';
 
 assertNotBrowser();
 
@@ -36,18 +36,20 @@ export type ProcedureType = 'query' | 'mutation' | 'subscription';
  * @internal
  */
 export type ProcedureRecord<
+  TInputContext = any,
   TContext = any,
   TInput = any,
   TOutput = any,
-> = Record<string, Procedure<TContext, TInput, TOutput>>;
+> = Record<string, Procedure<TInputContext, TContext, TInput, TOutput>>;
 
 /**
  * @public
  */
-export type inferProcedureInput<TProcedure extends Procedure<any, any, any>> =
-  TProcedure extends ProcedureWithInput<any, infer Input, any>
-    ? Input
-    : undefined;
+export type inferProcedureInput<
+  TProcedure extends Procedure<any, any, any, any>,
+> = TProcedure extends ProcedureWithInput<any, any, infer Input, any>
+  ? Input
+  : undefined;
 
 /**
  * @public
@@ -58,8 +60,9 @@ export type inferAsyncReturnType<TFunction extends (...args: any) => any> =
 /**
  * @public
  */
-export type inferProcedureOutput<TProcedure extends Procedure> =
-  inferAsyncReturnType<TProcedure['call']>;
+export type inferProcedureOutput<
+  TProcedure extends Procedure<any, any, any, any>,
+> = inferAsyncReturnType<TProcedure['call']>;
 
 /**
  * @public
@@ -82,18 +85,18 @@ function getDataTransformer(
   }
   return { input: transformer, output: transformer };
 }
-
 /**
  * @internal
  */
-export type inferHandlerInput<TProcedure extends Procedure> =
-  TProcedure extends ProcedureWithInput<any, infer TInput, any>
-    ? undefined extends TInput // ? is input optional
-      ? unknown extends TInput // ? is input unset
-        ? [(null | undefined)?] // -> there is no input
-        : [(TInput | null | undefined)?] // -> there is optional input
-      : [TInput] // -> input is required
-    : [(undefined | null)?]; // -> there is no input
+export type inferHandlerInput<
+  TProcedure extends Procedure<any, any, any, any>,
+> = TProcedure extends ProcedureWithInput<any, any, infer TInput, any>
+  ? undefined extends TInput // ? is input optional
+    ? unknown extends TInput // ? is input unset
+      ? [(null | undefined)?] // -> there is no input
+      : [(TInput | null | undefined)?] // -> there is optional input
+    : [TInput] // -> input is required
+  : [(undefined | null)?]; // -> there is no input
 
 type inferHandlerFn<TProcedures extends ProcedureRecord> = <
   TProcedure extends TProcedures[TPath],
@@ -113,7 +116,14 @@ export type inferRouterContext<TRouter extends AnyRouter> = Parameters<
 /**
  * @public
  */
-export type AnyRouter<TContext = any> = Router<TContext, any, any, any, any>;
+export type AnyRouter<TContext = any> = Router<
+  any,
+  TContext,
+  any,
+  any,
+  any,
+  any
+>;
 
 /**
  * @internal
@@ -192,11 +202,36 @@ const defaultTransformer: CombinedDataTransformer = {
   output: { serialize: (obj) => obj, deserialize: (obj) => obj },
 };
 
+type SwapProcedureContext<
+  TProcedure extends Procedure<any, any, any, any>,
+  TNewContext,
+> = TProcedure extends ProcedureWithInput<
+  infer TInputContext,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  infer _TOldContext,
+  infer TInput,
+  infer TOutput
+>
+  ? ProcedureWithInput<TInputContext, TNewContext, TInput, TOutput>
+  : never;
+
+type SwapContext<
+  TObj extends ProcedureRecord<any, any, any, any>,
+  TNewContext,
+> = format<{
+  [P in keyof TObj]: SwapProcedureContext<TObj[P], TNewContext>;
+}>;
+
+/**
+ * @internal The type signature of this class may change without warning.
+ */
 export class Router<
+  TInputContext,
   TContext,
-  TQueries extends ProcedureRecord<TContext>,
-  TMutations extends ProcedureRecord<TContext>,
+  TQueries extends ProcedureRecord<TInputContext, TContext>,
+  TMutations extends ProcedureRecord<TInputContext, TContext>,
   TSubscriptions extends ProcedureRecord<
+    TInputContext,
     TContext,
     unknown,
     Subscription<unknown>
@@ -207,7 +242,7 @@ export class Router<
     queries: Readonly<TQueries>;
     mutations: Readonly<TMutations>;
     subscriptions: Readonly<TSubscriptions>;
-    middlewares: MiddlewareFunction<TContext>[];
+    middlewares: MiddlewareFunction<TInputContext, TContext>[];
     errorFormatter: ErrorFormatter<TContext, TErrorShape>;
     transformer: CombinedDataTransformer;
   }>;
@@ -216,7 +251,7 @@ export class Router<
     queries?: TQueries;
     mutations?: TMutations;
     subscriptions?: TSubscriptions;
-    middlewares?: MiddlewareFunction<TContext>[];
+    middlewares?: MiddlewareFunction<TInputContext, TContext>[];
     errorFormatter?: ErrorFormatter<TContext, TErrorShape>;
     transformer?: CombinedDataTransformer;
   }) {
@@ -245,10 +280,11 @@ export class Router<
     path: TPath,
     procedure: CreateProcedureWithInput<TContext, TInput, TOutput>,
   ): Router<
+    TInputContext,
     TContext,
     flatten<
       TQueries,
-      Record<TPath, inferProcedureFromOptions<typeof procedure>>
+      Record<TPath, inferProcedureFromOptions<TInputContext, typeof procedure>>
     >,
     TMutations,
     TSubscriptions,
@@ -258,10 +294,11 @@ export class Router<
     path: TPath,
     procedure: CreateProcedureWithoutInput<TContext, TOutput>,
   ): Router<
+    TInputContext,
     TContext,
     flatten<
       TQueries,
-      Record<TPath, inferProcedureFromOptions<typeof procedure>>
+      Record<TPath, inferProcedureFromOptions<TInputContext, typeof procedure>>
     >,
     TMutations,
     TSubscriptions,
@@ -271,24 +308,25 @@ export class Router<
     path: TPath,
     procedure: CreateProcedureOptions<TContext, TInput, TOutput>,
   ) {
-    const router = new Router<TContext, any, {}, {}, any>({
+    const router = new Router<TContext, TContext, any, {}, {}, any>({
       queries: safeObject({
         [path]: createProcedure(procedure),
       }),
     });
 
-    return this.merge(router) as any;
+    return this.merge(router);
   }
 
   public mutation<TPath extends string, TInput, TOutput>(
     path: TPath,
     procedure: CreateProcedureWithInput<TContext, TInput, TOutput>,
   ): Router<
+    TInputContext,
     TContext,
     TQueries,
     flatten<
       TMutations,
-      Record<TPath, inferProcedureFromOptions<typeof procedure>>
+      Record<TPath, inferProcedureFromOptions<TInputContext, typeof procedure>>
     >,
     TSubscriptions,
     TErrorShape
@@ -297,11 +335,12 @@ export class Router<
     path: TPath,
     procedure: CreateProcedureWithoutInput<TContext, TOutput>,
   ): Router<
+    TInputContext,
     TContext,
     TQueries,
     flatten<
       TMutations,
-      Record<TPath, inferProcedureFromOptions<typeof procedure>>
+      Record<TPath, inferProcedureFromOptions<TInputContext, typeof procedure>>
     >,
     TSubscriptions,
     TErrorShape
@@ -310,13 +349,13 @@ export class Router<
     path: TPath,
     procedure: CreateProcedureOptions<TContext, TInput, TOutput>,
   ) {
-    const router = new Router<TContext, {}, any, {}, any>({
+    const router = new Router<TContext, TContext, {}, any, {}, any>({
       mutations: safeObject({
         [path]: createProcedure(procedure),
       }),
     });
 
-    return this.merge(router) as any;
+    return this.merge(router);
   }
   /**
    * @beta Might change without a major version bump
@@ -329,10 +368,12 @@ export class Router<
     path: TPath,
     procedure: CreateProcedureWithInput<TContext, TInput, TOutput>,
   ): Router<
+    TInputContext,
     TContext,
     TQueries,
     TMutations,
-    TSubscriptions & Record<TPath, inferProcedureFromOptions<typeof procedure>>,
+    TSubscriptions &
+      Record<TPath, inferProcedureFromOptions<TInputContext, typeof procedure>>,
     TErrorShape
   >;
   /**
@@ -345,10 +386,12 @@ export class Router<
     path: TPath,
     procedure: CreateProcedureWithoutInput<TContext, TOutput>,
   ): Router<
+    TInputContext,
     TContext,
     TQueries,
     TMutations,
-    TSubscriptions & Record<TPath, inferProcedureFromOptions<typeof procedure>>,
+    TSubscriptions &
+      Record<TPath, inferProcedureFromOptions<TInputContext, typeof procedure>>,
     TErrorShape
   >;
   /**
@@ -359,7 +402,7 @@ export class Router<
     TInput,
     TOutput extends Subscription<unknown>,
   >(path: TPath, procedure: CreateProcedureOptions<TContext, TInput, TOutput>) {
-    const router = new Router<TContext, {}, {}, any, any>({
+    const router = new Router<TContext, TContext, {}, {}, any, any>({
       subscriptions: safeObject({
         [path]: createProcedure(procedure),
       }),
@@ -372,10 +415,11 @@ export class Router<
    * Merge router with other router
    * @param router
    */
-  public merge<TChildRouter extends AnyRouter<TContext>>(
+  public merge<TChildRouter extends Router<TContext, any, any, any, any, any>>(
     router: TChildRouter,
   ): Router<
-    TContext,
+    TInputContext,
+    inferRouterContext<TChildRouter>,
     flatten<TQueries, TChildRouter['_def']['queries']>,
     flatten<TMutations, TChildRouter['_def']['mutations']>,
     flatten<TSubscriptions, TChildRouter['_def']['subscriptions']>,
@@ -387,11 +431,15 @@ export class Router<
    * @param prefix Prefix that this router should live under
    * @param router
    */
-  public merge<TPath extends string, TChildRouter extends AnyRouter<TContext>>(
+  public merge<
+    TPath extends string,
+    TChildRouter extends Router<TContext, any, any, any, any, any>,
+  >(
     prefix: TPath,
     router: TChildRouter,
   ): Router<
-    TContext,
+    TInputContext,
+    inferRouterContext<TChildRouter>,
     flatten<TQueries, Prefixer<TChildRouter['_def']['queries'], `${TPath}`>>,
     flatten<
       TMutations,
@@ -437,7 +485,7 @@ export class Router<
       throw new Error(`Duplicate endpoint(s): ${duplicates.join(', ')}`);
     }
 
-    const mergeProcedures = (defs: ProcedureRecord<any>) => {
+    const mergeProcedures = (defs: ProcedureRecord) => {
       const newDefs = safeObject() as typeof defs;
       for (const key in defs) {
         const procedure = defs[key];
@@ -450,7 +498,7 @@ export class Router<
       return Router.prefixProcedures(newDefs, prefix);
     };
 
-    return new Router<TContext, any, any, any, TErrorShape>({
+    return new Router<TInputContext, any, any, any, any, TErrorShape>({
       ...this._def,
       queries: safeObject(
         this._def.queries,
@@ -470,11 +518,15 @@ export class Router<
   /**
    * Invoke procedure. Only for internal use within library.
    */
-  private async call(opts: ProcedureCallOptions<TContext>): Promise<unknown> {
+  private async call(
+    opts: ProcedureCallOptions<TInputContext>,
+  ): Promise<unknown> {
     const { type, path } = opts;
     const defTarget = PROCEDURE_DEFINITION_MAP[type];
     const defs = this._def[defTarget];
-    const procedure = defs[path] as Procedure<TContext> | undefined;
+    const procedure = defs[path] as
+      | Procedure<TInputContext, TContext, any, any>
+      | undefined;
 
     if (!procedure) {
       throw new TRPCError({
@@ -486,7 +538,7 @@ export class Router<
     return procedure.call(opts);
   }
 
-  public createCaller(ctx: TContext): {
+  public createCaller(ctx: TInputContext): {
     query: inferHandlerFn<TQueries>;
     mutation: inferHandlerFn<TMutations>;
     subscription: inferHandlerFn<TSubscriptions>;
@@ -518,22 +570,25 @@ export class Router<
       },
     };
   }
+
   /**
    * Function to be called before any procedure is invoked
-   * Can be async or sync
    * @link https://trpc.io/docs/middlewares
    */
-  public middleware(middleware: MiddlewareFunction<TContext>) {
-    return new Router<
-      TContext,
-      TQueries,
-      TMutations,
-      TSubscriptions,
-      TErrorShape
-    >({
+  public middleware<TNewContext>(
+    middleware: MiddlewareFunction<TContext, TNewContext>,
+  ): Router<
+    TInputContext,
+    TNewContext,
+    SwapContext<TQueries, TNewContext>,
+    SwapContext<TMutations, TNewContext>,
+    SwapContext<TSubscriptions, TNewContext>,
+    TErrorShape
+  > {
+    return new Router({
       ...this._def,
-      middlewares: [...this._def.middlewares, middleware],
-    });
+      middlewares: [...this._def.middlewares, middleware as any],
+    } as any);
   }
 
   /**
@@ -548,8 +603,14 @@ export class Router<
         'You seem to have double `formatError()`-calls in your router tree',
       );
     }
-    type TShape = ReturnType<TErrorFormatter>;
-    return new Router<TContext, TQueries, TMutations, TSubscriptions, TShape>({
+    return new Router<
+      TInputContext,
+      TContext,
+      TQueries,
+      TMutations,
+      TSubscriptions,
+      ReturnType<TErrorFormatter>
+    >({
       ...this._def,
       errorFormatter: errorFormatter as any,
     });
@@ -597,6 +658,7 @@ export class Router<
       );
     }
     return new Router<
+      TInputContext,
       TContext,
       TQueries,
       TMutations,
@@ -609,6 +671,31 @@ export class Router<
   }
 }
 
-export function router<TContext = void>() {
-  return new Router<TContext, {}, {}, {}, DefaultErrorShape>();
+/**
+ * Subclass of `VNextRouter` with `TInputContext` and `TContext` set to the same type, for backcompat.
+ *
+ * @deprecated
+ */
+export class LegacyRouter<
+  TContext,
+  TQueries extends ProcedureRecord<TContext, TContext>,
+  TMutations extends ProcedureRecord<TContext, TContext>,
+  TSubscriptions extends ProcedureRecord<
+    TContext,
+    TContext,
+    unknown,
+    Subscription<unknown>
+  >,
+  TErrorShape extends TRPCErrorShape<number>,
+> extends Router<
+  TContext,
+  TContext,
+  TQueries,
+  TMutations,
+  TSubscriptions,
+  TErrorShape
+> {}
+
+export function router<TContext>() {
+  return new Router<TContext, TContext, {}, {}, {}, DefaultErrorShape>();
 }