@trpc/server 10.0.0-alpha.42 → 10.0.0-alpha.45

package/src/core/router.ts

@@ -1,6 +1,5 @@
-/* eslint-disable @typescript-eslint/ban-types */
 import { inferProcedureOutput } from '.';
-import { Filter, Prefixer } from '..';
+import { Filter } from '..';
 import { TRPCError } from '../error/TRPCError';
 import {
   DefaultErrorShape,
@@ -25,7 +24,8 @@ import {
 } from './procedure';
 import { ProcedureType, procedureTypes } from './types';
 
-type ProcedureRecord = Record<string, Procedure<any>>;
+/** @internal **/
+export type ProcedureRecord = Record<string, Procedure<any>>;
 
 export type ProcedureRouterRecord = Record<string, Procedure<any> | AnyRouter>;
 
@@ -36,28 +36,6 @@ 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,
@@ -80,21 +58,32 @@ export interface RouterDef<
   _meta: TMeta;
   errorFormatter: ErrorFormatter<TContext, TErrorShape>;
   transformer: CombinedDataTransformer;
-  // FIXME this is slow
-  procedures: Filter<TRecord, Procedure<any>> &
-    SimpleFlatten<PrefixedProcedures<TRecord>>;
+  // FIXME this is slow:
+  // - I think this has to go & be replaced by something by only using `TRecord` without `& SimpleFlatten...`
+  // - Potentially, we have a `legacyProcedures` record where we only register the old things that are availble by string path
+  procedures: TRecord;
+  /**
+   * V9 procedures
+   * @deprecated
+   */
+  legacy: {};
   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>>;
+  /**
+   * FIXME remove?
+   * @deprecated
+   */
+  subscriptions: Filter<TRecord, SubscriptionProcedure<any> & { _old: true }>;
+  /**
+   * FIXME remove?
+   * @deprecated
+   */
+  queries: Filter<TRecord, QueryProcedure<any> & { _old: true }>;
+  /**
+   * FIXME remove?
+   * @deprecated
+   */
+  mutations: Filter<TRecord, MutationProcedure<any> & { _old: true }>;
 }
 
 export type AnyRouterDef<TContext = any> = RouterDef<TContext, any, any, any>;
@@ -156,12 +145,7 @@ type RouterCaller<TDef extends AnyRouterDef> = (ctx: TDef['_ctx']) => {
 } & DecoratedProcedureRecord<TDef['record']>;
 
 export interface Router<TDef extends AnyRouterDef> {
-  _def: RouterDef<
-    TDef['_ctx'],
-    TDef['_errorShape'],
-    TDef['_meta'],
-    TDef['record']
-  >;
+  _def: TDef;
   /** @deprecated **/
   errorFormatter: TDef['errorFormatter'];
   /** @deprecated **/
@@ -259,6 +243,7 @@ export function createRouterFactory<TConfig extends RootConfig>(
 
     const _def: AnyRouterDef<TConfig['ctx']> = {
       router: true,
+      legacy: {},
       procedures: {},
       ...emptyRouter,
       ...result,

package/src/deprecated/interop.ts

@@ -53,16 +53,26 @@ type convertProcedureParams<
     >
   : never;
 
+/**
+ * @deprecated
+ */
+export type OldProcedureTag = {
+  _old: true;
+};
+
 type MigrateProcedure<
   TConfig extends RootConfig,
   TProcedure extends AnyOldProcedure,
   TType extends ProcedureType,
 > = TType extends 'query'
-  ? QueryProcedure<convertProcedureParams<TConfig, TProcedure>>
+  ? QueryProcedure<convertProcedureParams<TConfig, TProcedure>> &
+      OldProcedureTag
   : TType extends 'mutation'
-  ? MutationProcedure<convertProcedureParams<TConfig, TProcedure>>
+  ? MutationProcedure<convertProcedureParams<TConfig, TProcedure>> &
+      OldProcedureTag
   : TType extends 'subscription'
-  ? SubscriptionProcedure<convertProcedureParams<TConfig, TProcedure>>
+  ? SubscriptionProcedure<convertProcedureParams<TConfig, TProcedure>> &
+      OldProcedureTag
   : never;
 
 export type MigrateProcedureRecord<
@@ -106,7 +116,40 @@ export type MigrateRouter<
   >,
   TErrorShape extends TRPCErrorShape<any>,
 > = NewRouter<
-  RouterDef<
+  {
+    legacy: {
+      queries: MigrateProcedureRecord<
+        CreateRootConfig<{
+          ctx: TInputContext;
+          errorShape: TErrorShape;
+          meta: TMeta;
+          transformer: CombinedDataTransformer;
+        }>,
+        TQueries,
+        'query'
+      >;
+      mutations: MigrateProcedureRecord<
+        CreateRootConfig<{
+          ctx: TInputContext;
+          errorShape: TErrorShape;
+          meta: TMeta;
+          transformer: CombinedDataTransformer;
+        }>,
+        TMutations,
+        'mutation'
+      >;
+      subscriptions: MigrateProcedureRecord<
+        CreateRootConfig<{
+          ctx: TInputContext;
+          errorShape: TErrorShape;
+          meta: TMeta;
+          transformer: CombinedDataTransformer;
+        }>,
+        TSubscriptions,
+        'subscription'
+      >;
+    };
+  } & RouterDef<
     TInputContext,
     TErrorShape,
     TMeta,

package/src/deprecated/router.ts

@@ -1,5 +1,3 @@
-/* eslint-disable @typescript-eslint/ban-types */
-
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { assertNotBrowser } from '../assertNotBrowser';
 import { TRPCError } from '../error/TRPCError';

package/src/rpc/envelopes.ts

@@ -48,28 +48,31 @@ export namespace JSONRPC2 {
   }
 }
 
-/**
- * TRPC HTTP Envelopes
- */
+/////////////////////////// HTTP envelopes ///////////////////////
 
-export type TRPCRequest = JSONRPC2.Request<
-  ProcedureType,
-  { path: string; input: unknown }
->;
+export interface TRPCRequest
+  extends JSONRPC2.Request<ProcedureType, { path: string; input: unknown }> {}
 
-export type TRPCResult<TData = unknown> = { data: TData };
+export interface TRPCResult<TData = unknown> {
+  data: TData;
+}
 
-export type TRPCErrorResponse<TError extends TRPCErrorShape = TRPCErrorShape> =
-  JSONRPC2.ErrorResponse<TError>;
+export interface TRPCSuccessResponse<TData>
+  extends JSONRPC2.ResultResponse<
+    TRPCResult<TData> & {
+      type?: 'data';
+    }
+  > {}
+export interface TRPCErrorResponse<
+  TError extends TRPCErrorShape = TRPCErrorShape,
+> extends JSONRPC2.ErrorResponse<TError> {}
 
 export type TRPCResponse<
-  TResult = unknown,
+  TData = unknown,
   TError extends TRPCErrorShape = TRPCErrorShape,
-> = JSONRPC2.ResultResponse<TRPCResult<TResult>> | TRPCErrorResponse<TError>;
+> = TRPCSuccessResponse<TData> | TRPCErrorResponse<TError>;
 
-/**
- * HTTP WS Envelopes
- */
+/////////////////////////// WebSocket envelopes ///////////////////////
 
 export type TRPCRequestMessage = {
   id: JSONRPC2.RequestId;
@@ -78,9 +81,10 @@ export type TRPCRequestMessage = {
 /**
  * The client asked the server to unsubscribe
  */
-export type TRPCSubscriptionStopNotification = {
+export interface TRPCSubscriptionStopNotification
+  extends JSONRPC2.BaseRequest<'subscription.stop'> {
   id: null;
-} & JSONRPC2.BaseRequest<'subscription.stop'>;
+}
 
 /**
  * The client's outgoing request types
@@ -94,25 +98,28 @@ export type TRPCClientOutgoingMessage =
   | TRPCRequestMessage
   | ({ id: JSONRPC2.RequestId } & JSONRPC2.BaseRequest<'subscription.stop'>);
 
-export type TRPCResultMessage<TData = unknown> =
-  | ({ type: 'data' } & TRPCResult<TData>)
-  | { type: 'started' }
-  | { type: 'stopped' };
+export interface TRPCResultMessage<TData>
+  extends JSONRPC2.ResultResponse<
+    | (TRPCResult<TData> & { type: 'data' })
+    | { type: 'started' }
+    | { type: 'stopped' }
+  > {}
 
 export type TRPCResponseMessage<
-  TResult = unknown,
+  TData = unknown,
   TError extends TRPCErrorShape = TRPCErrorShape,
 > = { id: JSONRPC2.RequestId } & (
-  | JSONRPC2.ResultResponse<TRPCResultMessage<TResult>>
+  | TRPCResultMessage<TData>
   | TRPCErrorResponse<TError>
 );
 
 /**
  * The server asked the client to reconnect - useful when restarting/redeploying service
  */
-export type TRPCReconnectNotification = {
+export interface TRPCReconnectNotification
+  extends JSONRPC2.BaseRequest<'reconnect'> {
   id: JSONRPC2.RequestId;
-} & JSONRPC2.BaseRequest<'reconnect'>;
+}
 
 /**
  * The client's incoming request types

package/src/types.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/ban-types */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 /**