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

package/src/deprecated/interop.ts

@@ -1,5 +1,5 @@
-import { CombinedDataTransformer, ProcedureParams, ProcedureType } from '..';
-import { CreateRootConfig, RootConfig } from '../core/internals/config';
+import { DefaultDataTransformer, ProcedureParams, ProcedureType } from '..';
+import { AnyRootConfig, RootConfig } from '../core/internals/config';
 import { getParseFnOrPassThrough } from '../core/internals/getParseFn';
 import { mergeWithoutOverrides } from '../core/internals/mergeWithoutOverrides';
 import { createBuilder } from '../core/internals/procedureBuilder';
@@ -25,10 +25,10 @@ import { ProcedureRecord } from './router';
 type AnyOldProcedure = OldProcedure<any, any, any, any, any, any, any, any>;
 
 type convertProcedureParams<
-  TConfig extends RootConfig,
+  TConfig extends AnyRootConfig,
   TProcedure extends AnyOldProcedure,
 > = TProcedure extends OldProcedure<
-  infer TInputContext,
+  infer _TInputContext,
   infer TContext,
   infer TMeta,
   infer TInput,
@@ -39,7 +39,6 @@ type convertProcedureParams<
 >
   ? ProcedureParams<
       TConfig,
-      TInputContext,
       TContext,
       TInput,
       TParsedInput,
@@ -50,13 +49,13 @@ type convertProcedureParams<
   : never;
 
 type MigrateProcedure<
-  TConfig extends RootConfig,
+  TConfig extends AnyRootConfig,
   TProcedure extends AnyOldProcedure,
   TType extends ProcedureType,
 > = Procedure<TType, convertProcedureParams<TConfig, TProcedure>>;
 
 export type MigrateProcedureRecord<
-  TConfig extends RootConfig,
+  TConfig extends AnyRootConfig,
   TProcedureRecord extends ProcedureRecord<any>,
   TType extends ProcedureType,
 > = {
@@ -100,38 +99,48 @@ export type MigrateRouter<
   >,
   TErrorShape extends TRPCErrorShape<any>,
 > = NewRouter<
-  {
-    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, {}>
+  RouterDef<
+    RootConfig<{
+      ctx: TInputContext;
+      errorShape: TErrorShape;
+      meta: TMeta;
+      transformer: DefaultDataTransformer;
+    }>,
+    {},
+    {
+      queries: MigrateProcedureRecord<
+        RootConfig<{
+          ctx: TInputContext;
+          errorShape: TErrorShape;
+          meta: TMeta;
+
+          transformer: DefaultDataTransformer;
+        }>,
+        TQueries,
+        'query'
+      >;
+      mutations: MigrateProcedureRecord<
+        RootConfig<{
+          ctx: TInputContext;
+          errorShape: TErrorShape;
+          meta: TMeta;
+          transformer: DefaultDataTransformer;
+        }>,
+        TMutations,
+        'mutation'
+      >;
+      subscriptions: MigrateProcedureRecord<
+        RootConfig<{
+          ctx: TInputContext;
+          errorShape: TErrorShape;
+          meta: TMeta;
+          transformer: DefaultDataTransformer;
+        }>,
+        TSubscriptions,
+        'subscription'
+      >;
+    }
+  >
 >;
 
 export type MigrateOldRouter<TRouter extends AnyOldRouter> =
@@ -212,6 +221,7 @@ export function migrateRouter<TOldRouter extends AnyOldRouter>(
   const newRouter = createRouterFactory<any>({
     transformer,
     errorFormatter,
+    isDev: process.env.NODE_ENV !== 'production',
   })(procedures);
 
   return newRouter as any;

package/src/http/internals/types.ts

@@ -1,4 +1,9 @@
-import { AnyRouter, ProcedureType, inferRouterDef } from '../../core';
+import {
+  AnyRouter,
+  ProcedureType,
+  inferRouterContext,
+  inferRouterError,
+} from '../../core';
 import { TRPCError } from '../../error/TRPCError';
 import { BaseHandlerOptions } from '../../internals/types';
 import { TRPCResponse } from '../../rpc';
@@ -24,8 +29,8 @@ export interface HTTPRequest {
  * @internal
  */
 export type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
-  data: TRPCResponse<unknown, inferRouterDef<TRouter>['_error']>[];
-  ctx?: inferRouterDef<TRouter>['_ctx'];
+  data: TRPCResponse<unknown, inferRouterError<TRouter>>[];
+  ctx?: inferRouterContext<TRouter>;
   /**
    * The different tRPC paths requested
    **/

package/src/http/resolveHTTPResponse.ts

@@ -143,7 +143,7 @@ export async function resolveHTTPResponse<
 
     const deserializeInputValue = (rawValue: unknown) => {
       return typeof rawValue !== 'undefined'
-        ? router._def.transformer.input.deserialize(rawValue)
+        ? router._def._config.transformer.input.deserialize(rawValue)
         : rawValue;
     };
     const getInputs = (): Record<number, unknown> => {

package/src/internals/transformTRPCResponse.ts

@@ -7,7 +7,7 @@ function transformTRPCResponseItem<
   if ('error' in item) {
     return {
       ...item,
-      error: router._def.transformer.output.serialize(item.error),
+      error: router._def._config.transformer.output.serialize(item.error),
     };
   }
 
@@ -16,7 +16,9 @@ function transformTRPCResponseItem<
       ...item,
       result: {
         ...item.result,
-        data: router._def.transformer.output.serialize(item.result.data),
+        data: router._def._config.transformer.output.serialize(
+          item.result.data,
+        ),
       },
     };
   }

package/src/internals/types.ts

@@ -1,5 +1,4 @@
-import { inferRouterDef } from '../core';
-import { ProcedureType } from '../core';
+import { ProcedureType, inferRouterContext } from '../core';
 import { AnyRouter } from '../core/router';
 import { TRPCError } from '../error/TRPCError';
 
@@ -20,5 +19,5 @@ export type OnErrorFunction<TRouter extends AnyRouter, TRequest> = (opts: {
   path: string | undefined;
   req: TRequest;
   input: unknown;
-  ctx: undefined | inferRouterDef<TRouter>['_ctx'];
+  ctx: undefined | inferRouterContext<TRouter>;
 }) => void;