@trpc/server 10.0.0-alpha.30 → 10.0.0-alpha.31

package/src/core/internals/config.ts

@@ -1,4 +1,4 @@
-import { DefaultErrorShape, ErrorFormatter } from '../../error/formatter';
+import { ErrorFormatter } from '../../error/formatter';
 import {
   CombinedDataTransformer,
   DataTransformerOptions,
@@ -33,7 +33,8 @@ export type CreateInitGenerics<T extends InitGenerics> = T;
  */
 export interface RootConfig extends InitGenerics {
   transformer: CombinedDataTransformer;
-  errorShape: DefaultErrorShape;
+  // FIXME this should probably be restricted
+  errorShape: any;
 }
 
 /**

package/src/core/internals/mergeRouters.ts

@@ -4,9 +4,9 @@ import { AnyRouter, createRouterFactory } from '../router';
 import { mergeWithoutOverrides } from './mergeWithoutOverrides';
 
 export function mergeRouters(...routerList: AnyRouter[]): AnyRouter {
-  const procedures = mergeWithoutOverrides(
+  const record = mergeWithoutOverrides(
     {},
-    ...routerList.map((r) => r._def.procedures),
+    ...routerList.map((r) => r._def.record),
   );
   const errorFormatter = routerList.reduce(
     (currentErrorFormatter, nextRouter) => {
@@ -40,6 +40,6 @@ export function mergeRouters(...routerList: AnyRouter[]): AnyRouter {
   const router = createRouterFactory({
     errorFormatter,
     transformer,
-  })(procedures);
+  })(record);
   return router;
 }

package/src/core/internals/procedureBuilder.ts

@@ -17,6 +17,7 @@ type CreateProcedureReturnInput<
   TPrev extends ProcedureParams,
   TNext extends ProcedureParams,
 > = ProcedureBuilder<{
+  _config: TPrev['_config'];
   _meta: TPrev['_meta'];
   _ctx_in: TPrev['_ctx_in'];
   _ctx_out: Overwrite<TPrev['_ctx_out'], TNext['_ctx_out']>;
@@ -33,6 +34,7 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
   input<$TParser extends Parser>(
     schema: $TParser,
   ): ProcedureBuilder<{
+    _config: TParams['_config'];
     _meta: TParams['_meta'];
     _ctx_in: TParams['_ctx_in'];
     _ctx_out: TParams['_ctx_out'];
@@ -47,6 +49,7 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
   output<$TParser extends Parser>(
     schema: $TParser,
   ): ProcedureBuilder<{
+    _config: TParams['_config'];
     _meta: TParams['_meta'];
     _ctx_in: TParams['_ctx_in'];
     _ctx_out: TParams['_ctx_out'];
@@ -168,6 +171,7 @@ export interface ProcedureBuilder<TParams extends ProcedureParams> {
 }
 
 export function createBuilder<TConfig extends RootConfig>(): ProcedureBuilder<{
+  _config: TConfig;
   _ctx_in: TConfig['ctx'];
   _ctx_out: TConfig['ctx'];
   _input_out: UnsetMarker;

package/src/core/middleware.ts

@@ -58,6 +58,7 @@ export type MiddlewareFunction<
     (): Promise<MiddlewareResult<TParams>>;
     <$TContext>(opts: { ctx: $TContext }): Promise<
       MiddlewareResult<{
+        _config: any;
         _ctx_in: TParams['_ctx_in'];
         _ctx_out: $TContext;
         _input_in: TParams['_input_in'];
@@ -78,6 +79,7 @@ export function createMiddlewareFactory<TConfig extends RootConfig>() {
   return function createMiddleware<$TNewParams extends ProcedureParams>(
     fn: MiddlewareFunction<
       {
+        _config: TConfig;
         _ctx_in: TConfig['ctx'];
         _ctx_out: TConfig['ctx'];
         _input_out: unknown;

package/src/core/procedure.ts

@@ -1,3 +1,6 @@
+import { DefaultErrorShape } from '../error/formatter';
+import { CombinedDataTransformer } from '../transformer';
+import { RootConfig } from './internals/config';
 import { UnsetMarker } from './internals/utils';
 
 type ClientContext = Record<string, unknown>;
@@ -12,6 +15,12 @@ export interface ProcedureOptions {
  * @internal
  */
 export interface ProcedureParams<
+  TConfig extends RootConfig = {
+    transformer: CombinedDataTransformer;
+    errorShape: DefaultErrorShape;
+    ctx: Record<string, unknown>;
+    meta: Record<string, unknown>;
+  },
   TContextIn = unknown,
   TContextOut = unknown,
   TInputIn = unknown,
@@ -20,6 +29,8 @@ export interface ProcedureParams<
   TOutputOut = unknown,
   TMeta = unknown,
 > {
+  // FIXME make non-optional
+  _config: TConfig;
   /**
    * @internal
    */
@@ -64,10 +75,12 @@ export type ProcedureArgs<TParams extends ProcedureParams> =
  * @internal
  */
 export interface ProcedureBase<TParams extends ProcedureParams> {
+  _def: TParams;
   /**
    * @deprecated use `._def.meta` instead
    */
   meta?: TParams['_meta'];
+  _procedure: true;
 }
 
 export interface QueryProcedure<TParams extends ProcedureParams>

package/src/core/router.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/ban-types */
 import { inferProcedureOutput } from '.';
-import { Filter } from '..';
+import { Filter, Prefixer } from '..';
 import { TRPCError } from '../error/TRPCError';
 import {
   DefaultErrorShape,
@@ -36,13 +36,36 @@ export interface ProcedureStructure {
   procedures: ProcedureRecord;
 }
 
+type ObjKeyof<T> = T extends object ? keyof T : never;
+type KeyofKeyof<T> = ObjKeyof<T> | { [K in keyof T]: ObjKeyof<T[K]> }[keyof T];
+type StripNever<T> = Pick<
+  T,
+  { [K in keyof T]: [T[K]] extends [never] ? never : K }[keyof T]
+>;
+type Lookup<T, K> = T extends any ? (K extends keyof T ? T[K] : never) : never;
+type SimpleFlatten<T> = T extends object
+  ? StripNever<{
+      [K in KeyofKeyof<T>]:
+        | Exclude<K extends keyof T ? T[K] : never, object>
+        | { [P in keyof T]: Lookup<T[P], K> }[keyof T];
+    }>
+  : T;
+
+type PrefixedProcedures<T extends ProcedureRouterRecord> = {
+  [K in keyof T]: T[K] extends AnyRouter
+    ? T[K] extends Procedure<any>
+      ? never
+      : Prefixer<T[K]['_def']['procedures'], `${K & string}.`>
+    : never;
+};
 export interface RouterDef<
   // FIXME this should use RootConfig
   TContext,
   TErrorShape extends TRPCErrorShape<number>,
   TMeta extends Record<string, unknown>,
-  TProcedures extends ProcedureRouterRecord,
+  TRecord extends ProcedureRouterRecord,
 > {
+  router: true;
   /**
    * @internal
    */
@@ -57,21 +80,21 @@ export interface RouterDef<
   _meta: TMeta;
   errorFormatter: ErrorFormatter<TContext, TErrorShape>;
   transformer: CombinedDataTransformer;
-  // FIXME: separate `procedures` and `children`-routers
-  procedures: TProcedures;
-  // FIXME decide if these are deprecated
-  /**
-   * @deprecated
-   */
-  subscriptions: Filter<TProcedures, SubscriptionProcedure<any>>;
-  /**
-   * @deprecated
-   */
-  queries: Filter<TProcedures, QueryProcedure<any>>;
-  /**
-   * @deprecated
-   */
-  mutations: Filter<TProcedures, MutationProcedure<any>>;
+  // FIXME this is slow
+  procedures: Filter<TRecord, Procedure<any>> &
+    SimpleFlatten<PrefixedProcedures<TRecord>>;
+  routers: Filter<TRecord, Router<any>>;
+  record: TRecord;
+  // FIXME this is slow
+  subscriptions: Filter<TRecord, SubscriptionProcedure<any>> &
+    Filter<
+      SimpleFlatten<PrefixedProcedures<TRecord>>,
+      SubscriptionProcedure<any>
+    >;
+  queries: Filter<TRecord, QueryProcedure<any>> &
+    Filter<SimpleFlatten<PrefixedProcedures<TRecord>>, QueryProcedure<any>>;
+  mutations: Filter<TRecord, MutationProcedure<any>> &
+    Filter<SimpleFlatten<PrefixedProcedures<TRecord>>, MutationProcedure<any>>;
 }
 
 export type AnyRouterDef<TContext = any> = RouterDef<TContext, any, any, any>;
@@ -124,7 +147,7 @@ export interface Router<TDef extends AnyRouterDef> {
     TDef['_ctx'],
     TDef['_errorShape'],
     TDef['_meta'],
-    TDef['procedures']
+    TDef['record']
   >;
   /** @deprecated **/
   errorFormatter: TDef['errorFormatter'];
@@ -185,16 +208,19 @@ const emptyRouter = {
 export function createRouterFactory<TConfig extends RootConfig>(
   defaults?: RouterDefaultOptions<TConfig['ctx']>,
 ) {
-  return function createRouterInner<TProcedures extends ProcedureRouterRecord>(
-    procedures: TProcedures,
+  return function createRouterInner<
+    TProcRouterRecord extends ProcedureRouterRecord,
+  >(
+    opts: TProcRouterRecord,
   ): Router<
     RouterDef<
       TConfig['ctx'],
       TConfig['errorShape'],
       TConfig['meta'],
-      TProcedures
+      TProcRouterRecord
     >
-  > {
+  > &
+    TProcRouterRecord {
     const routerProcedures: Record<string, Procedure<any>> = omitPrototype({});
     function recursiveGetPaths(procedures: ProcedureRouterRecord, path = '') {
       for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})) {
@@ -210,7 +236,7 @@ export function createRouterFactory<TConfig extends RootConfig>(
       }
     }
 
-    recursiveGetPaths(procedures);
+    recursiveGetPaths(opts);
 
     const result = mergeWithoutOverrides<
       RouterDefaultOptions<TConfig['ctx']> & RouterBuildOptions<TConfig['ctx']>
@@ -223,9 +249,11 @@ export function createRouterFactory<TConfig extends RootConfig>(
     );
 
     const _def: AnyRouterDef<TConfig['ctx']> = {
+      router: true,
       procedures: {},
       ...emptyRouter,
       ...result,
+      record: opts,
       queries: Object.entries(result.procedures || {})
         .filter((pair) => (pair[1] as any)._def.query)
         .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
@@ -235,11 +263,9 @@ export function createRouterFactory<TConfig extends RootConfig>(
       subscriptions: Object.entries(result.procedures || {})
         .filter((pair) => (pair[1] as any)._def.subscription)
         .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
-    };
-    const def = {
-      _def,
-      transformer: _def.transformer,
-      errorFormatter: _def.errorFormatter,
+      routers: Object.entries(result.procedures || {})
+        .filter((pair) => (pair[1] as any)._def._router)
+        .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
     };
 
     function callProcedure(opts: InternalProcedureCallOptions) {
@@ -257,7 +283,10 @@ export function createRouterFactory<TConfig extends RootConfig>(
       return procedure(opts);
     }
     const router: AnyRouter = {
-      ...def,
+      ...opts,
+      _def,
+      transformer: _def.transformer,
+      errorFormatter: _def.errorFormatter,
       createCaller(ctx) {
         return {
           query: (path, ...args) =>

package/src/core/types.ts

@@ -40,9 +40,10 @@ export type inferProcedureInput<TProcedure extends Procedure<any>> =
 //     ? TProcedure['mutate']
 //     : never;
 
-export type inferProcedureParams<TProcedure extends Procedure<any>> =
-  TProcedure extends Procedure<infer $Params> ? $Params : never;
-export type inferProcedureOutput<TProcedure extends Procedure<any>> =
+export type inferProcedureParams<TProcedure> = TProcedure extends Procedure<any>
+  ? TProcedure['_def']
+  : never;
+export type inferProcedureOutput<TProcedure> =
   inferProcedureParams<TProcedure>['_output_out'];
 
 export type inferSubscriptionOutput<

package/src/deprecated/interop.ts

@@ -1,4 +1,5 @@
-import { ProcedureParams, ProcedureType } from '..';
+import { CombinedDataTransformer, ProcedureParams, ProcedureType } from '..';
+import { CreateRootConfig, RootConfig } from '../core/internals/config';
 import { getParseFnOrPassThrough } from '../core/internals/getParseFn';
 import {
   createInputMiddleware,
@@ -27,48 +28,53 @@ import { ProcedureRecord } from './router';
 
 type AnyOldProcedure = OldProcedure<any, any, any, any, any, any, any, any>;
 
-type convertProcedureParams<TProcedure extends AnyOldProcedure> =
-  TProcedure extends OldProcedure<
-    infer TInputContext,
-    infer TContext,
-    infer TMeta,
-    infer TInput,
-    infer TParsedInput,
-    infer TOutput,
-    infer _TParsedOutput,
-    infer TFinalInput
-  >
-    ? ProcedureParams<
-        TInputContext,
-        TContext,
-        TInput,
-        TParsedInput,
-        TOutput,
-        TFinalInput,
-        TMeta
-      >
-    : never;
+type convertProcedureParams<
+  TConfig extends RootConfig,
+  TProcedure extends AnyOldProcedure,
+> = TProcedure extends OldProcedure<
+  infer TInputContext,
+  infer TContext,
+  infer TMeta,
+  infer TInput,
+  infer TParsedInput,
+  infer TOutput,
+  infer _TParsedOutput,
+  infer TFinalInput
+>
+  ? ProcedureParams<
+      TConfig,
+      TInputContext,
+      TContext,
+      TInput,
+      TParsedInput,
+      TOutput,
+      TFinalInput,
+      TMeta
+    >
+  : never;
 
 type MigrateProcedure<
+  TConfig extends RootConfig,
   TProcedure extends AnyOldProcedure,
   TType extends ProcedureType,
 > = TType extends 'query'
-  ? QueryProcedure<convertProcedureParams<TProcedure>>
+  ? QueryProcedure<convertProcedureParams<TConfig, TProcedure>>
   : TType extends 'mutation'
-  ? MutationProcedure<convertProcedureParams<TProcedure>>
+  ? MutationProcedure<convertProcedureParams<TConfig, TProcedure>>
   : TType extends 'subscription'
-  ? SubscriptionProcedure<convertProcedureParams<TProcedure>>
+  ? SubscriptionProcedure<convertProcedureParams<TConfig, TProcedure>>
   : never;
 
 export type MigrateProcedureRecord<
+  TConfig extends RootConfig,
   T extends ProcedureRecord<any>,
   TType extends ProcedureType,
 > = {
-  [K in keyof T]: MigrateProcedure<T[K], TType>;
+  [K in keyof T]: MigrateProcedure<TConfig, T[K], TType>;
 };
 
 export type MigrateRouter<
-  TInputContext,
+  TInputContext extends Record<string, any>,
   TContext,
   TMeta extends Record<string, any>,
   TQueries extends ProcedureRecord<
@@ -98,15 +104,42 @@ export type MigrateRouter<
     unknown,
     unknown
   >,
-  TErrorShape extends TRPCErrorShape<number>,
+  TErrorShape extends TRPCErrorShape<any>,
 > = NewRouter<
   RouterDef<
     TInputContext,
     TErrorShape,
     TMeta,
-    MigrateProcedureRecord<TQueries, 'query'> &
-      MigrateProcedureRecord<TMutations, 'mutation'> &
-      MigrateProcedureRecord<TSubscriptions, 'subscription'>
+    MigrateProcedureRecord<
+      CreateRootConfig<{
+        ctx: TInputContext;
+        errorShape: TErrorShape;
+        meta: TMeta;
+        transformer: CombinedDataTransformer;
+      }>,
+      TQueries,
+      'query'
+    > &
+      MigrateProcedureRecord<
+        CreateRootConfig<{
+          ctx: TInputContext;
+          errorShape: TErrorShape;
+          meta: TMeta;
+          transformer: CombinedDataTransformer;
+        }>,
+        TMutations,
+        'mutation'
+      > &
+      MigrateProcedureRecord<
+        CreateRootConfig<{
+          ctx: TInputContext;
+          errorShape: TErrorShape;
+          meta: TMeta;
+          transformer: CombinedDataTransformer;
+        }>,
+        TSubscriptions,
+        'subscription'
+      >
   >
 >;
 
@@ -134,7 +167,7 @@ export type MigrateOldRouter<TRouter extends AnyOldRouter> =
 function migrateProcedure<
   TProcedure extends AnyOldProcedure,
   TType extends ProcedureType,
->(oldProc: TProcedure, type: TType): MigrateProcedure<TProcedure, TType> {
+>(oldProc: TProcedure, type: TType): MigrateProcedure<any, TProcedure, TType> {
   const def = oldProc._def();
 
   const inputParser = getParseFnOrPassThrough(def.inputParser);

package/src/types.ts

@@ -66,9 +66,11 @@ export type InferLast<T> = T & { [K in keyof T]: T[K] };
 export type inferAsyncReturnType<TFunction extends (...args: any) => any> =
   ThenArg<ReturnType<TFunction>>;
 
+type FilterKeys<T extends object, K> = {
+  [TKey in keyof T]: T[TKey] extends K ? TKey : never;
+}[keyof T];
+
 /**
  * @internal
  */
-export type Filter<T extends Record<any, any> | any[], K> = {
-  [TKey in keyof T]: T[TKey] extends K ? T[TKey] : never;
-};
+export type Filter<T extends object, K> = Pick<T, FilterKeys<T, K>>;