@trpc/server 10.0.0-proxy-beta.14 → 10.0.0-proxy-beta.16

package/src/core/internals/config.ts

@@ -1,16 +1,14 @@
 import { ErrorFormatter } from '../../error/formatter';
-import {
-  CombinedDataTransformer,
-  DataTransformerOptions,
-} from '../../transformer';
 
 /**
  * The initial generics that are used in the init function
  * @internal
  */
-export interface InitGenerics {
+export interface RootConfigTypes {
   ctx: Record<string, unknown>;
   meta: Record<string, unknown>;
+  errorShape: unknown;
+  transformer: unknown;
 }
 
 /**
@@ -23,40 +21,62 @@ export const isServerDefault: boolean =
   !!process.env.JEST_WORKER_ID;
 
 /**
- * The initial params that are used and actually represents real values underneath
+ * The runtime config that are used and actually represents real values underneath
  * @internal
  */
-export interface InitOptions<TType extends InitGenerics> {
-  transformer: DataTransformerOptions;
-  errorFormatter: ErrorFormatter<TType['ctx'], any>;
+export interface RuntimeConfig<TTypes extends RootConfigTypes> {
+  /**
+   * Use a data transformer
+   * @link https://trpc.io/docs/data-transformers
+   */
+  transformer: TTypes['transformer'];
+  /**
+   * Use custom error formatting
+   * @link https://trpc.io/docs/error-formatting
+   */
+  errorFormatter: ErrorFormatter<TTypes['ctx'], any>;
   /**
    * Allow `@trpc/server` to run in non-server environments
+   * @warning **Use with caution**, this should likely mainly be used within testing.
    * @default false
    */
   allowOutsideOfServer: boolean;
   /**
    * Is this a server environment?
+   * @warning **Use with caution**, this should likely mainly be used within testing.
+   * @default typeof window === 'undefined' || 'Deno' in window || process.env.NODE_ENV === 'test'
    */
   isServer: boolean;
+  /**
+   * Is this development?
+   * Will be used to decide if the API should return stack traces
+   * @default process.env.NODE_ENV !== 'production'
+   */
+  isDev: boolean;
 }
 
 /**
  * @internal
  */
-export type CreateInitGenerics<TType extends InitGenerics> = TType;
+export type CreateRootConfigTypes<TGenerics extends RootConfigTypes> =
+  TGenerics;
 
 /**
  * The config that is resolved after `initTRPC.create()` has been called
  * Combination of `InitTOptions` + `InitGenerics`
  * @internal
  */
-export interface RootConfig extends InitGenerics {
-  transformer: CombinedDataTransformer;
-  // FIXME this should probably be restricted
-  errorShape: any;
+export interface RootConfig<TGenerics extends RootConfigTypes>
+  extends RuntimeConfig<TGenerics> {
+  $types: TGenerics;
 }
 
 /**
  * @internal
  */
-export type CreateRootConfig<TConfig extends RootConfig> = TConfig;
+export type AnyRootConfig = RootConfig<{
+  ctx: any;
+  meta: any;
+  errorShape: any;
+  transformer: any;
+}>;

package/src/core/internals/mergeRouters.ts

@@ -11,16 +11,16 @@ export function mergeRouters(...routerList: AnyRouter[]): AnyRouter {
   const errorFormatter = routerList.reduce(
     (currentErrorFormatter, nextRouter) => {
       if (
-        nextRouter.errorFormatter &&
-        nextRouter.errorFormatter !== defaultFormatter
+        nextRouter._def._config.errorFormatter &&
+        nextRouter._def._config.errorFormatter !== defaultFormatter
       ) {
         if (
           currentErrorFormatter !== defaultFormatter &&
-          currentErrorFormatter !== nextRouter.errorFormatter
+          currentErrorFormatter !== nextRouter._def._config.errorFormatter
         ) {
           throw new Error('You seem to have several error formatters');
         }
-        return nextRouter.errorFormatter;
+        return nextRouter._def._config.errorFormatter;
       }
       return currentErrorFormatter;
     },
@@ -28,11 +28,17 @@ export function mergeRouters(...routerList: AnyRouter[]): AnyRouter {
   );
 
   const transformer = routerList.reduce((prev, current) => {
-    if (current.transformer && current.transformer !== defaultTransformer) {
-      if (prev !== defaultTransformer && prev !== current.transformer) {
+    if (
+      current._def._config.transformer &&
+      current._def._config.transformer !== defaultTransformer
+    ) {
+      if (
+        prev !== defaultTransformer &&
+        prev !== current._def._config.transformer
+      ) {
         throw new Error('You seem to have several transformers');
       }
-      return current.transformer;
+      return current._def._config.transformer;
     }
     return prev;
   }, defaultTransformer as CombinedDataTransformer);
@@ -40,6 +46,12 @@ export function mergeRouters(...routerList: AnyRouter[]): AnyRouter {
   const router = createRouterFactory({
     errorFormatter,
     transformer,
+    isDev: routerList.some((r) => r._def._config.isDev),
+    allowOutsideOfServer: routerList.some(
+      (r) => r._def._config.allowOutsideOfServer,
+    ),
+    isServer: routerList.some((r) => r._def._config.isServer),
+    $types: routerList[0]?._def._config.$types as any,
   })(record);
   return router;
 }

package/src/core/internals/procedureBuilder.ts

@@ -17,15 +17,16 @@ import {
   ProcedureParams,
 } from '../procedure';
 import { ProcedureType } from '../types';
-import { RootConfig } from './config';
+import { AnyRootConfig } from './config';
 import { getParseFn } from './getParseFn';
 import { mergeWithoutOverrides } from './mergeWithoutOverrides';
-import { ResolveOptions, middlewareMarker } from './utils';
 import {
   DefaultValue as FallbackValue,
   Overwrite,
   OverwriteKnown,
+  ResolveOptions,
   UnsetMarker,
+  middlewareMarker,
 } from './utils';
 
 type CreateProcedureReturnInput<
@@ -34,7 +35,6 @@ type CreateProcedureReturnInput<
 > = ProcedureBuilder<{
   _config: TPrev['_config'];
   _meta: TPrev['_meta'];
-  _ctx_in: TPrev['_ctx_in'];
   _ctx_out: Overwrite<TPrev['_ctx_out'], TNext['_ctx_out']>;
   _input_in: FallbackValue<TNext['_input_in'], TPrev['_input_in']>;
   _input_out: FallbackValue<TNext['_input_out'], TPrev['_input_out']>;
@@ -85,26 +85,25 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
   /**
    * Add an input parser to the procedure.
    */
-  input<TParser extends Parser>(
+  input<$Parser extends Parser>(
     schema: TParams['_input_out'] extends UnsetMarker
-      ? TParser
-      : inferParser<TParser>['out'] extends Record<string, unknown>
+      ? $Parser
+      : inferParser<$Parser>['out'] extends Record<string, unknown>
       ? TParams['_input_out'] extends Record<string, unknown>
-        ? TParser
+        ? $Parser
         : ErrorMessage<'All input parsers did not resolve to an object'>
       : ErrorMessage<'All input parsers did not resolve to an object'>,
   ): ProcedureBuilder<{
     _config: TParams['_config'];
     _meta: TParams['_meta'];
-    _ctx_in: TParams['_ctx_in'];
     _ctx_out: TParams['_ctx_out'];
     _input_in: OverwriteIfDefined<
       TParams['_input_in'],
-      inferParser<TParser>['in']
+      inferParser<$Parser>['in']
     >;
     _input_out: OverwriteIfDefined<
       TParams['_input_out'],
-      inferParser<TParser>['out']
+      inferParser<$Parser>['out']
     >;
     _output_in: TParams['_output_in'];
     _output_out: TParams['_output_out'];
@@ -112,17 +111,16 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
   /**
    * Add an output parser to the procedure.
    */
-  output<TParser extends Parser>(
-    schema: TParser,
+  output<$Parser extends Parser>(
+    schema: $Parser,
   ): ProcedureBuilder<{
     _config: TParams['_config'];
     _meta: TParams['_meta'];
-    _ctx_in: TParams['_ctx_in'];
     _ctx_out: TParams['_ctx_out'];
     _input_in: TParams['_input_in'];
     _input_out: TParams['_input_out'];
-    _output_in: inferParser<TParser>['in'];
-    _output_out: inferParser<TParser>['out'];
+    _output_in: inferParser<$Parser>['in'];
+    _output_out: inferParser<$Parser>['out'];
   }>;
   /**
    * Add a meta data to the procedure.
@@ -131,44 +129,44 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
   /**
    * Add a middleware to the procedure.
    */
-  use<TNewParams extends ProcedureParams>(
-    fn: MiddlewareFunction<TParams, TNewParams>,
-  ): CreateProcedureReturnInput<TParams, TNewParams>;
+  use<$Params extends ProcedureParams>(
+    fn: MiddlewareFunction<TParams, $Params>,
+  ): CreateProcedureReturnInput<TParams, $Params>;
   /**
    * Extend the procedure with another procedure.
    * @warning The TypeScript inference fails when chaining concatenated procedures.
    */
-  unstable_concat<TProcedureReturnType extends AnyProcedureBuilder>(
-    proc: TProcedureReturnType,
-  ): TProcedureReturnType extends ProcedureBuilder<infer $TParams>
+  unstable_concat<$ProcedureBuilder extends AnyProcedureBuilder>(
+    proc: $ProcedureBuilder,
+  ): $ProcedureBuilder extends ProcedureBuilder<infer $TParams>
     ? CreateProcedureReturnInput<TParams, $TParams>
     : never;
   /**
    * Query procedure
    */
-  query<TOutput>(
+  query<$Output>(
     resolver: (
       opts: ResolveOptions<TParams>,
-    ) => MaybePromise<FallbackValue<TParams['_output_in'], TOutput>>,
-  ): BuildProcedure<'query', TParams, TOutput>;
+    ) => MaybePromise<FallbackValue<TParams['_output_in'], $Output>>,
+  ): BuildProcedure<'query', TParams, $Output>;
 
   /**
    * Mutation procedure
    */
-  mutation<TOutput>(
+  mutation<$Output>(
     resolver: (
       opts: ResolveOptions<TParams>,
-    ) => MaybePromise<FallbackValue<TParams['_output_in'], TOutput>>,
-  ): BuildProcedure<'mutation', TParams, TOutput>;
+    ) => MaybePromise<FallbackValue<TParams['_output_in'], $Output>>,
+  ): BuildProcedure<'mutation', TParams, $Output>;
 
   /**
    * Mutation procedure
    */
-  subscription<TOutput>(
+  subscription<$Output>(
     resolver: (
       opts: ResolveOptions<TParams>,
-    ) => MaybePromise<FallbackValue<TParams['_output_in'], TOutput>>,
-  ): BuildProcedure<'subscription', TParams, TOutput>;
+    ) => MaybePromise<FallbackValue<TParams['_output_in'], $Output>>,
+  ): BuildProcedure<'subscription', TParams, $Output>;
   /**
    * @internal
    */
@@ -197,17 +195,16 @@ function createNewBuilder(
   } as any);
 }
 
-export function createBuilder<TConfig extends RootConfig>(
+export function createBuilder<TConfig extends AnyRootConfig>(
   initDef?: AnyProcedureBuilderDef,
 ): ProcedureBuilder<{
   _config: TConfig;
-  _ctx_in: TConfig['ctx'];
-  _ctx_out: TConfig['ctx'];
+  _ctx_out: TConfig['$types']['ctx'];
   _input_in: UnsetMarker;
   _input_out: UnsetMarker;
   _output_in: UnsetMarker;
   _output_out: UnsetMarker;
-  _meta: TConfig['meta'];
+  _meta: TConfig['$types']['meta'];
 }> {
   const _def: AnyProcedureBuilderDef = initDef || {
     inputs: [],

package/src/core/middleware.ts

@@ -1,6 +1,6 @@
 import { TRPCError } from '../error/TRPCError';
 import { getCauseFromUnknown } from '../error/utils';
-import { RootConfig } from './internals/config';
+import { AnyRootConfig } from './internals/config';
 import { ParseFn } from './internals/getParseFn';
 import { ProcedureBuilderMiddleware } from './internals/procedureBuilder';
 import { MiddlewareMarker } from './internals/utils';
@@ -60,11 +60,10 @@ export type MiddlewareFunction<
     meta: TParams['_meta'] | undefined;
     next: {
       (): Promise<MiddlewareResult<TParams>>;
-      <TContext>(opts: { ctx: TContext }): Promise<
+      <$Context>(opts: { ctx: $Context }): Promise<
         MiddlewareResult<{
-          _config: any;
-          _ctx_in: TParams['_ctx_in'];
-          _ctx_out: TContext;
+          _config: TParams['_config'];
+          _ctx_out: $Context;
           _input_in: TParams['_input_in'];
           _input_out: TParams['_input_out'];
           _output_in: TParams['_output_in'];
@@ -81,18 +80,17 @@ export type MiddlewareFunction<
  * @internal
  */
 // FIXME this should use RootConfig
-export function createMiddlewareFactory<TConfig extends RootConfig>() {
+export function createMiddlewareFactory<TConfig extends AnyRootConfig>() {
   return function createMiddleware<TNewParams extends ProcedureParams>(
     fn: MiddlewareFunction<
       {
         _config: TConfig;
-        _ctx_in: TConfig['ctx'];
-        _ctx_out: TConfig['ctx'];
+        _ctx_out: TConfig['$types']['ctx'];
         _input_out: unknown;
         _input_in: unknown;
         _output_in: unknown;
         _output_out: unknown;
-        _meta: TConfig['meta'];
+        _meta: TConfig['$types']['meta'];
       },
       TNewParams
     >,

package/src/core/procedure.ts

@@ -1,6 +1,4 @@
-import { DefaultErrorShape } from '../error/formatter';
-import { CombinedDataTransformer } from '../transformer';
-import { RootConfig } from './internals/config';
+import { AnyRootConfig } from './internals/config';
 import {
   ProcedureBuilderDef,
   ProcedureCallOptions,
@@ -26,13 +24,7 @@ export interface ProcedureOptions {
  * @internal
  */
 export interface ProcedureParams<
-  TConfig extends RootConfig = {
-    transformer: CombinedDataTransformer;
-    errorShape: DefaultErrorShape;
-    ctx: Record<string, unknown>;
-    meta: Record<string, unknown>;
-  },
-  TContextIn = unknown,
+  TConfig extends AnyRootConfig = AnyRootConfig,
   TContextOut = unknown,
   TInputIn = unknown,
   TInputOut = unknown,
@@ -40,16 +32,11 @@ export interface ProcedureParams<
   TOutputOut = unknown,
   TMeta = unknown,
 > {
-  // FIXME make non-optional
   _config: TConfig;
   /**
    * @internal
    */
   _meta: TMeta;
-  /**
-   * @internal
-   */
-  _ctx_in: TContextIn;
   /**
    * @internal
    */

package/src/core/router.ts

@@ -1,15 +1,10 @@
 import { TRPCError } from '../error/TRPCError';
-import {
-  DefaultErrorShape,
-  ErrorFormatter,
-  defaultFormatter,
-} from '../error/formatter';
+import { DefaultErrorShape, defaultFormatter } from '../error/formatter';
 import { getHTTPStatusCodeFromError } from '../http/internals/getHTTPStatusCode';
-import { TRPCErrorShape, TRPC_ERROR_CODES_BY_KEY } from '../rpc';
+import { TRPC_ERROR_CODES_BY_KEY } from '../rpc';
 import { createRecursiveProxy } from '../shared';
-import { CombinedDataTransformer, defaultTransformer } from '../transformer';
-import { RootConfig } from './internals/config';
-import { mergeWithoutOverrides } from './internals/mergeWithoutOverrides';
+import { defaultTransformer } from '../transformer';
+import { AnyRootConfig } from './internals/config';
 import { omitPrototype } from './internals/omitPrototype';
 import { ProcedureCallOptions } from './internals/procedureBuilder';
 import {
@@ -33,55 +28,52 @@ export interface ProcedureRouterRecord {
   [key: string]: AnyProcedure | AnyRouter;
 }
 
-export interface ProcedureStructure {
+/**
+ * @deprecated
+ */
+interface DeprecatedProcedureRouterRecord {
   queries: Record<string, AnyQueryProcedure>;
   mutations: Record<string, AnyMutationProcedure>;
   subscriptions: Record<string, AnySubscriptionProcedure>;
-  procedures: ProcedureRecord;
 }
 
 export interface RouterDef<
-  // FIXME this should use RootConfig
-  TContext,
-  TErrorShape extends TRPCErrorShape<number>,
-  TMeta extends Record<string, unknown>,
+  TConfig extends AnyRootConfig,
   TRecord extends ProcedureRouterRecord,
-> {
-  router: true;
-  /**
-   * @internal
-   */
-  _ctx: TContext;
-  /**
-   * @internal
-   */
-  _errorShape: TErrorShape;
   /**
-   * @internal
+   * @deprecated
    */
-  _meta: TMeta;
-  errorFormatter: ErrorFormatter<TContext, TErrorShape>;
-  transformer: CombinedDataTransformer;
+  TOld extends DeprecatedProcedureRouterRecord = {
+    queries: {};
+    mutations: {};
+    subscriptions: {};
+  },
+> {
+  _config: TConfig;
+  router: true;
   procedures: TRecord;
   record: TRecord;
   /**
    * V9 queries
    * @deprecated
    */
-  queries: {};
+  queries: TOld['queries'];
   /**
    * V9 mutations
    * @deprecated
    */
-  mutations: {};
+  mutations: TOld['mutations'];
   /**
    * V9 subscriptions
    * @deprecated
    */
-  subscriptions: {};
+  subscriptions: TOld['subscriptions'];
 }
 
-export type AnyRouterDef<TContext = any> = RouterDef<TContext, any, any, any>;
+export type AnyRouterDef<
+  TConfig extends AnyRootConfig = AnyRootConfig,
+  TOld extends DeprecatedProcedureRouterRecord = any,
+> = RouterDef<TConfig, any, TOld>;
 
 /**
  * @internal
@@ -112,7 +104,9 @@ type DecoratedProcedureRecord<TProcedures extends ProcedureRouterRecord> = {
 /**
  * @internal
  */
-type RouterCaller<TDef extends AnyRouterDef> = (ctx: TDef['_ctx']) => {
+type RouterCaller<TDef extends AnyRouterDef> = (
+  ctx: TDef['_config']['$types']['ctx'],
+) => {
   /**
    * @deprecated
    */
@@ -129,10 +123,6 @@ type RouterCaller<TDef extends AnyRouterDef> = (ctx: TDef['_ctx']) => {
 
 export interface Router<TDef extends AnyRouterDef> {
   _def: TDef;
-  /** @deprecated **/
-  errorFormatter: TDef['errorFormatter'];
-  /** @deprecated **/
-  transformer: TDef['transformer'];
   createCaller: RouterCaller<TDef>;
   // FIXME rename me and deprecate
   getErrorShape(opts: {
@@ -140,26 +130,18 @@ export interface Router<TDef extends AnyRouterDef> {
     type: ProcedureType | 'unknown';
     path: string | undefined;
     input: unknown;
-    ctx: undefined | TDef['_ctx'];
-  }): TDef['_errorShape'];
+    ctx: undefined | TDef['_config']['$types']['ctx'];
+  }): TDef['_config']['$types']['errorShape'];
 }
 
 /**
  * @internal
  */
-export type RouterDefaultOptions<TContext> = Pick<
-  AnyRouterDef<TContext>,
-  'transformer' | 'errorFormatter'
+export type RouterBuildOptions<TConfig extends AnyRootConfig> = Partial<
+  Pick<AnyRouterDef<TConfig>, 'procedures'>
 >;
 
-/**
- * @internal
- */
-export type RouterBuildOptions<TContext> = Partial<
-  Pick<AnyRouterDef<TContext>, 'procedures'>
->;
-
-export type AnyRouter = Router<any>;
+export type AnyRouter = Router<AnyRouterDef>;
 
 function isRouter(
   procedureOrRouter: AnyProcedure | AnyRouter,
@@ -193,29 +175,23 @@ const reservedWords = [
  * @internal
  */
 export type CreateRouterInner<
-  TConfig extends RootConfig,
+  TConfig extends AnyRootConfig,
   TProcRouterRecord extends ProcedureRouterRecord,
-> = Router<
-  RouterDef<
-    TConfig['ctx'],
-    TConfig['errorShape'],
-    TConfig['meta'],
-    TProcRouterRecord
-  >
-> &
-  TProcRouterRecord;
+> = Router<RouterDef<TConfig, TProcRouterRecord>> & TProcRouterRecord;
 
 /**
  * @internal
  */
-export function createRouterFactory<TConfig extends RootConfig>(
-  defaults?: RouterDefaultOptions<TConfig['ctx']>,
+export function createRouterFactory<TConfig extends AnyRootConfig>(
+  config: TConfig,
 ) {
   return function createRouterInner<
     TProcRouterRecord extends ProcedureRouterRecord,
-  >(opts: TProcRouterRecord): CreateRouterInner<TConfig, TProcRouterRecord> {
+  >(
+    procedures: TProcRouterRecord,
+  ): CreateRouterInner<TConfig, TProcRouterRecord> {
     const reservedWordsUsed = new Set(
-      Object.keys(opts).filter((v) => reservedWords.includes(v)),
+      Object.keys(procedures).filter((v) => reservedWords.includes(v)),
     );
     if (reservedWordsUsed.size > 0) {
       throw new Error(
@@ -234,44 +210,35 @@ export function createRouterFactory<TConfig extends RootConfig>(
           continue;
         }
 
+        if (routerProcedures[newPath]) {
+          throw new Error(`Duplicate key: ${newPath}`);
+        }
+
         routerProcedures[newPath] = procedureOrRouter;
       }
     }
+    recursiveGetPaths(procedures);
 
-    recursiveGetPaths(opts);
-
-    const result = mergeWithoutOverrides<
-      RouterDefaultOptions<TConfig['ctx']> & RouterBuildOptions<TConfig['ctx']>
-    >(
-      {
-        transformer: defaults?.transformer ?? defaultTransformer,
-        errorFormatter: defaults?.errorFormatter ?? defaultFormatter,
-      },
-      { procedures: routerProcedures },
-    );
-
-    const _def: AnyRouterDef<TConfig['ctx']> = {
+    const _def: AnyRouterDef<TConfig> = {
+      _config: config,
       router: true,
-      procedures: {},
+      procedures: routerProcedures,
       ...emptyRouter,
-      ...result,
-      record: opts,
-      queries: Object.entries(result.procedures || {})
+      record: procedures,
+      queries: Object.entries(routerProcedures || {})
         .filter((pair) => (pair[1] as any)._def.query)
         .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
-      mutations: Object.entries(result.procedures || {})
+      mutations: Object.entries(routerProcedures || {})
         .filter((pair) => (pair[1] as any)._def.mutation)
         .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
-      subscriptions: Object.entries(result.procedures || {})
+      subscriptions: Object.entries(routerProcedures || {})
         .filter((pair) => (pair[1] as any)._def.subscription)
         .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
     };
 
     const router: AnyRouter = {
-      ...opts,
+      ...procedures,
       _def,
-      transformer: _def.transformer,
-      errorFormatter: _def.errorFormatter,
       createCaller(ctx) {
         const proxy = createRecursiveProxy(({ path, args }) => {
           // interop mode
@@ -319,16 +286,13 @@ export function createRouterFactory<TConfig extends RootConfig>(
             httpStatus: getHTTPStatusCodeFromError(error),
           },
         };
-        if (
-          process.env.NODE_ENV !== 'production' &&
-          typeof opts.error.stack === 'string'
-        ) {
+        if (config.isDev && typeof opts.error.stack === 'string') {
           shape.data.stack = opts.error.stack;
         }
         if (typeof path === 'string') {
           shape.data.path = path;
         }
-        return this._def.errorFormatter({ ...opts, shape });
+        return this._def._config.errorFormatter({ ...opts, shape });
       },
     };
     return router as any;

package/src/core/types.ts

@@ -11,11 +11,11 @@ export type inferRouterDef<TRouter extends AnyRouter> = TRouter extends Router<
   : never;
 
 export type inferRouterContext<TRouter extends AnyRouter> =
-  inferRouterDef<TRouter>['_ctx'];
+  inferRouterDef<TRouter>['_config']['$types']['ctx'];
 export type inferRouterError<TRouter extends AnyRouter> =
-  inferRouterDef<TRouter>['_errorShape'];
+  inferRouterDef<TRouter>['_config']['$types']['errorShape'];
 export type inferRouterMeta<TRouter extends AnyRouter> =
-  inferRouterDef<TRouter>['_meta'];
+  inferRouterDef<TRouter>['_config']['$types']['meta'];
 
 export const procedureTypes = ['query', 'mutation', 'subscription'] as const;
 /**