@trpc/server 11.0.0-next-beta.234 → 11.0.0-next-beta.236

package/src/unstable-core-do-not-import/initTRPC.ts

@@ -7,142 +7,94 @@ import {
 } from './error/formatter';
 import { createMiddlewareFactory } from './middleware';
 import { createBuilder } from './procedureBuilder';
-import {
-  isServerDefault,
-  type CreateRootConfigTypes,
-  type RootConfig,
-  type RootConfigTypes,
-  type RuntimeConfig,
-} from './rootConfig';
+import { isServerDefault, type RootConfig } from './rootConfig';
 import {
   createCallerFactory,
   createRouterFactory,
   mergeRouters,
 } from './router';
-import {
-  defaultTransformer,
-  getDataTransformer,
-  type DataTransformerOptions,
-  type DefaultDataTransformer,
-} from './transformer';
-import type {
-  Overwrite,
-  PickFirstDefined,
-  Unwrap,
-  ValidateShape,
-} from './types';
-
-type PartialRootConfigTypes = Partial<RootConfigTypes>;
-
-type CreateRootConfigTypesFromPartial<TTypes extends PartialRootConfigTypes> =
-  CreateRootConfigTypes<{
-    ctx: TTypes['ctx'] extends RootConfigTypes['ctx'] ? TTypes['ctx'] : object;
-    meta: TTypes['meta'] extends RootConfigTypes['meta']
-      ? TTypes['meta']
-      : object;
-    errorShape: TTypes['errorShape'];
-    transformer: DataTransformerOptions;
-  }>;
-
-/**
- * TODO: This can be improved:
- * - We should be able to chain `.meta()`/`.context()` only once
- * - Simplify typings
- * - Doesn't need to be a class but it doesn't really hurt either
- */
+import type { DataTransformerOptions } from './transformer';
+import { defaultTransformer, getDataTransformer } from './transformer';
+import type { PickFirstDefined, Unwrap, ValidateShape } from './types';
+
+interface RuntimeConfigOptions<TContext extends object, TMeta extends object>
+  extends Partial<
+    Omit<
+      RootConfig<{
+        ctx: TContext;
+        meta: TMeta;
+        errorShape: any;
+        transformer: any;
+      }>,
+      '$types' | 'transformer'
+    >
+  > {
+  /**
+   * Use a data transformer
+   * @link https://trpc.io/docs/v11/data-transformers
+   */
+  transformer?: DataTransformerOptions;
+}
 
-class TRPCBuilder<TParams extends PartialRootConfigTypes = object> {
+class TRPCBuilder<TContext extends object, TMeta extends object> {
   /**
    * Add a context shape as a generic to the root object
    * @link https://trpc.io/docs/v11/server/context
    */
-  context<
-    TNewContext extends
-      | RootConfigTypes['ctx']
-      | ((...args: unknown[]) => RootConfigTypes['ctx']),
-  >() {
-    type NextParams = Overwrite<TParams, { ctx: Unwrap<TNewContext> }>;
-
-    return new TRPCBuilder<NextParams>();
+  context<TNewContext extends object | ((...args: unknown[]) => object)>() {
+    return new TRPCBuilder<Unwrap<TNewContext>, TMeta>();
   }
 
   /**
    * Add a meta shape as a generic to the root object
    * @link https://trpc.io/docs/v11/quickstart
    */
-  meta<TNewMeta extends RootConfigTypes['meta']>() {
-    type NextParams = Overwrite<TParams, { meta: TNewMeta }>;
-
-    return new TRPCBuilder<NextParams>();
+  meta<TNewMeta extends object>() {
+    return new TRPCBuilder<TContext, TNewMeta>();
   }
 
   /**
    * Create the root object
    * @link https://trpc.io/docs/v11/server/routers#initialize-trpc
    */
-  create<
-    TOptions extends Partial<
-      RuntimeConfig<CreateRootConfigTypesFromPartial<TParams>>
-    >,
-  >(
-    options?:
-      | ValidateShape<
-          TOptions,
-          Partial<RuntimeConfig<CreateRootConfigTypesFromPartial<TParams>>>
-        >
+  create<TOptions extends RuntimeConfigOptions<TContext, TMeta>>(
+    opts?:
+      | ValidateShape<TOptions, RuntimeConfigOptions<TContext, TMeta>>
       | undefined,
   ) {
-    return createTRPCInner<TParams>()<TOptions>(options);
-  }
-}
-
-/**
- * Builder to initialize the tRPC root object - use this exactly once per backend
- * @link https://trpc.io/docs/v11/quickstart
- */
-export const initTRPC = new TRPCBuilder();
-
-function createTRPCInner<TParams extends PartialRootConfigTypes>() {
-  type $Generics = CreateRootConfigTypesFromPartial<TParams>;
-
-  type $Context = $Generics['ctx'];
-  type $Meta = $Generics['meta'];
-  type $Runtime = Partial<RuntimeConfig<$Generics>>;
-
-  return function initTRPCInner<TOptions extends $Runtime>(
-    runtime?: ValidateShape<TOptions, $Runtime>,
-  ) {
-    type $Formatter = PickFirstDefined<
-      TOptions['errorFormatter'],
-      ErrorFormatter<$Context, DefaultErrorShape>
+    type $Transformer = undefined extends TOptions['transformer']
+      ? false
+      : true;
+    type $ErrorShape = ErrorFormatterShape<
+      PickFirstDefined<
+        TOptions['errorFormatter'],
+        ErrorFormatter<TContext, DefaultErrorShape>
+      >
     >;
-    type $Transformer = TOptions['transformer'] extends DataTransformerOptions
-      ? TOptions['transformer']
-      : DefaultDataTransformer;
-    type $ErrorShape = ErrorFormatterShape<$Formatter>;
 
     type $Config = RootConfig<{
-      ctx: $Context;
-      meta: $Meta;
+      ctx: TContext;
+      meta: TMeta;
       errorShape: $ErrorShape;
       transformer: $Transformer;
     }>;
 
-    const errorFormatter = runtime?.errorFormatter ?? defaultFormatter;
+    const errorFormatter = opts?.errorFormatter ?? defaultFormatter;
     const transformer = getDataTransformer(
-      runtime?.transformer ?? defaultTransformer,
-    ) as $Transformer;
+      opts?.transformer ?? defaultTransformer,
+    );
 
     const config: $Config = {
       transformer,
       isDev:
-        runtime?.isDev ??
+        opts?.isDev ??
         // eslint-disable-next-line @typescript-eslint/dot-notation
         globalThis.process?.env?.['NODE_ENV'] !== 'production',
-      allowOutsideOfServer: runtime?.allowOutsideOfServer ?? false,
+      allowOutsideOfServer: opts?.allowOutsideOfServer ?? false,
       errorFormatter,
-      isServer: runtime?.isServer ?? isServerDefault,
+      isServer: opts?.isServer ?? isServerDefault,
       /**
+       * These are just types, they can't be used at runtime
        * @internal
        */
       $types: createFlatProxy((key) => {
@@ -154,9 +106,9 @@ function createTRPCInner<TParams extends PartialRootConfigTypes>() {
 
     {
       // Server check
-      const isServer: boolean = runtime?.isServer ?? isServerDefault;
+      const isServer: boolean = opts?.isServer ?? isServerDefault;
 
-      if (!isServer && runtime?.allowOutsideOfServer !== true) {
+      if (!isServer && opts?.allowOutsideOfServer !== true) {
         throw new Error(
           `You're trying to use @trpc/server in a non-server environment. This is not supported by default.`,
         );
@@ -164,7 +116,7 @@ function createTRPCInner<TParams extends PartialRootConfigTypes>() {
     }
     return {
       /**
-       * These are just types, they can't be used
+       * Your router config
        * @internal
        */
       _config: config,
@@ -176,7 +128,7 @@ function createTRPCInner<TParams extends PartialRootConfigTypes>() {
         $Config['$types']['ctx'],
         $Config['$types']['meta']
       >({
-        meta: runtime?.defaultMeta,
+        meta: opts?.defaultMeta,
       }),
       /**
        * Create reusable middlewares
@@ -202,5 +154,11 @@ function createTRPCInner<TParams extends PartialRootConfigTypes>() {
        */
       createCallerFactory: createCallerFactory<$Config>(),
     };
-  };
+  }
 }
+
+/**
+ * Builder to initialize the tRPC root object - use this exactly once per backend
+ * @link https://trpc.io/docs/v11/quickstart
+ */
+export const initTRPC = new TRPCBuilder();

package/src/unstable-core-do-not-import/procedure.ts

@@ -1,8 +1,7 @@
 import type { inferObservableValue } from '../observable';
 import type { ProcedureCallOptions } from './procedureBuilder';
 import type { Serialize } from './serialize';
-import type { DefaultDataTransformer } from './transformer';
-import type { inferConfig, TRPCInferrable } from './TRPCInferrable';
+import type { inferConfigTypes, TRPCInferrable } from './TRPCInferrable';
 
 export const procedureTypes = ['query', 'mutation', 'subscription'] as const;
 /**
@@ -72,7 +71,7 @@ export type AnyProcedure = Procedure<ProcedureType, any>;
 export type inferTransformedProcedureOutput<
   TInferrable extends TRPCInferrable,
   TProcedure extends AnyProcedure,
-> = inferConfig<TInferrable>['transformer'] extends DefaultDataTransformer
+> = inferConfigTypes<TInferrable>['transformer'] extends false
   ? Serialize<TProcedure['_def']['_output_out']>
   : TProcedure['_def']['_output_out'];
 
@@ -80,7 +79,7 @@ export type inferTransformedProcedureOutput<
 export type inferTransformedSubscriptionOutput<
   TInferrable extends TRPCInferrable,
   TProcedure extends AnyProcedure,
-> = inferConfig<TInferrable>['transformer'] extends DefaultDataTransformer
+> = inferConfigTypes<TInferrable>['transformer'] extends false
   ? Serialize<inferObservableValue<TProcedure['_def']['_output_out']>>
   : inferObservableValue<TProcedure['_def']['_output_out']>;
 

package/src/unstable-core-do-not-import/procedureBuilder.ts

@@ -22,15 +22,19 @@ import type {
   QueryProcedure,
   SubscriptionProcedure,
 } from './procedure';
-import type { GetRawInputFn, MaybePromise, Overwrite, Simplify } from './types';
+import type {
+  GetRawInputFn,
+  MaybePromise,
+  Overwrite,
+  Simplify,
+  TypeError,
+} from './types';
 import { mergeWithoutOverrides } from './utils';
 
 type IntersectIfDefined<TType, TWith> = TType extends UnsetMarker
   ? TWith
   : Simplify<TType & TWith>;
 
-type ErrorMessage<TMessage extends string> = TMessage;
-
 /** @internal */
 export const unsetMarker = Symbol('unsetMarker');
 type UnsetMarker = typeof unsetMarker;
@@ -98,10 +102,10 @@ export interface ProcedureBuilder<
         ? undefined extends inferParser<$Parser>['out'] // if current is optional the previous must be too
           ? undefined extends TInputOut
             ? $Parser
-            : ErrorMessage<'Cannot chain an optional parser to a required parser'>
+            : TypeError<'Cannot chain an optional parser to a required parser'>
           : $Parser
-        : ErrorMessage<'All input parsers did not resolve to an object'>
-      : ErrorMessage<'All input parsers did not resolve to an object'>,
+        : TypeError<'All input parsers did not resolve to an object'>
+      : TypeError<'All input parsers did not resolve to an object'>,
   ): ProcedureBuilder<
     TContext,
     TMeta,

package/src/unstable-core-do-not-import/rootConfig.ts

@@ -1,3 +1,4 @@
+import type { CombinedDataTransformer } from '.';
 import type { ErrorFormatter } from './error/formatter';
 import type { TRPCErrorShape } from './rpc';
 
@@ -9,7 +10,7 @@ export interface RootConfigTypes {
   ctx: object;
   meta: object;
   errorShape: unknown;
-  transformer: unknown;
+  transformer: boolean;
 }
 
 /**
@@ -24,15 +25,20 @@ export const isServerDefault: boolean =
   !!globalThis.process?.env?.['VITEST_WORKER_ID'];
 
 /**
- * The runtime config that are used and actually represents real values underneath
+ * The tRPC root config
  * @internal
  */
-export interface RuntimeConfig<TTypes extends RootConfigTypes> {
+export interface RootConfig<TTypes extends RootConfigTypes> {
+  /**
+   * The types that are used in the config
+   * @internal
+   */
+  $types: TTypes;
   /**
    * Use a data transformer
    * @link https://trpc.io/docs/v11/data-transformers
    */
-  transformer: TTypes['transformer'];
+  transformer: CombinedDataTransformer;
   /**
    * Use custom error formatting
    * @link https://trpc.io/docs/v11/error-formatting
@@ -69,16 +75,6 @@ export interface RuntimeConfig<TTypes extends RootConfigTypes> {
 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<TGenerics extends RootConfigTypes>
-  extends RuntimeConfig<TGenerics> {
-  $types: TGenerics;
-}
-
 /**
  * @internal
  */

package/src/unstable-core-do-not-import/router.ts

@@ -8,7 +8,6 @@ import type {
 } from './procedure';
 import type { ProcedureCallOptions } from './procedureBuilder';
 import type { AnyRootConfig } from './rootConfig';
-import type { CombinedDataTransformer } from './transformer';
 import { defaultTransformer } from './transformer';
 import type { MaybePromise } from './types';
 import { mergeWithoutOverrides, omitPrototype } from './utils';
@@ -353,7 +352,7 @@ export function mergeRouters<TRouters extends AnyRouter[]>(
       return current._def._config.transformer;
     }
     return prev;
-  }, defaultTransformer as CombinedDataTransformer);
+  }, defaultTransformer);
 
   const router = createRouterFactory({
     errorFormatter,

package/src/unstable-core-do-not-import/transformer.ts

@@ -79,15 +79,7 @@ export function getDataTransformer(
 /**
  * @internal
  */
-export type DefaultDataTransformer = CombinedDataTransformer & {
-  _default: true;
-};
-
-/**
- * @internal
- */
-export const defaultTransformer: DefaultDataTransformer = {
-  _default: true,
+export const defaultTransformer: CombinedDataTransformer = {
   input: { serialize: (obj) => obj, deserialize: (obj) => obj },
   output: { serialize: (obj) => obj, deserialize: (obj) => obj },
 };

package/src/unstable-core-do-not-import/types.ts

@@ -149,3 +149,9 @@ export type ProtectedIntersection<TType, TWith> = keyof TType &
  * Returns the raw input type of a procedure
  */
 export type GetRawInputFn = () => Promise<unknown>;
+
+const ERROR_SYMBOL = Symbol('TypeError');
+export type TypeErrorSymbol = typeof ERROR_SYMBOL;
+export type TypeError<TMessage extends string> = TMessage & {
+  _: TypeErrorSymbol;
+};