@trpc/server 11.0.0-next-alpha.133 → 11.0.0-next-alpha.140

package/src/core/middleware.ts

@@ -1,16 +1,7 @@
 import { TRPCError } from '../error/TRPCError';
 import { Simplify } from '../types';
-import { AnyProcedureBuilderParams } from './internals/builderTypes';
-import { AnyRootConfig, RootConfig } from './internals/config';
 import { ParseFn } from './internals/getParseFn';
-import { ProcedureBuilderMiddleware } from './internals/procedureBuilder';
-import {
-  DefaultValue,
-  GetRawInputFn,
-  MiddlewareMarker,
-  Overwrite,
-  UnsetMarker,
-} from './internals/utils';
+import { GetRawInputFn, MiddlewareMarker, Overwrite } from './internals/utils';
 import { ProcedureType } from './types';
 
 /**
@@ -27,8 +18,7 @@ interface MiddlewareResultBase {
 /**
  * @internal
  */
-interface MiddlewareOKResult<_TParams extends AnyProcedureBuilderParams>
-  extends MiddlewareResultBase {
+interface MiddlewareOKResult<_TContextOverride> extends MiddlewareResultBase {
   ok: true;
   data: unknown;
   // this could be extended with `input`/`rawInput` later
@@ -37,7 +27,7 @@ interface MiddlewareOKResult<_TParams extends AnyProcedureBuilderParams>
 /**
  * @internal
  */
-interface MiddlewareErrorResult<_TParams extends AnyProcedureBuilderParams>
+interface MiddlewareErrorResult<_TContextOverride>
   extends MiddlewareResultBase {
   ok: false;
   error: TRPCError;
@@ -46,133 +36,96 @@ interface MiddlewareErrorResult<_TParams extends AnyProcedureBuilderParams>
 /**
  * @internal
  */
-export type MiddlewareResult<TParams extends AnyProcedureBuilderParams> =
-  | MiddlewareErrorResult<TParams>
-  | MiddlewareOKResult<TParams>;
+export type MiddlewareResult<_TContextOverride> =
+  | MiddlewareErrorResult<_TContextOverride>
+  | MiddlewareOKResult<_TContextOverride>;
 
 /**
  * @internal
  */
 export interface MiddlewareBuilder<
-  TRoot extends AnyProcedureBuilderParams,
-  TNewParams extends AnyProcedureBuilderParams,
+  TContext,
+  TMeta,
+  TContextOverrides,
+  TInputIn,
 > {
   /**
    * Create a new builder based on the current middleware builder
    */
-  unstable_pipe<$Params extends AnyProcedureBuilderParams>(
-    fn: {
-      _config: TRoot['_config'];
-      _meta: TRoot['_meta'];
-      _ctx_out: Overwrite<TRoot['_ctx_out'], TNewParams['_ctx_out']>;
-      _input_in: DefaultValue<TRoot['_input_in'], TNewParams['_input_in']>;
-      _input_out: DefaultValue<TRoot['_input_out'], TNewParams['_input_out']>;
-      _output_in: DefaultValue<TRoot['_output_in'], TNewParams['_output_in']>;
-      _output_out: DefaultValue<
-        TRoot['_output_out'],
-        TNewParams['_output_out']
-      >;
-    } extends infer OParams extends AnyProcedureBuilderParams
-      ?
-          | MiddlewareBuilder<OParams, $Params>
-          | MiddlewareFunction<OParams, $Params>
-      : never,
-  ): CreateMiddlewareReturnInput<
-    TRoot,
-    TNewParams,
-    Overwrite<TNewParams, $Params>
+  unstable_pipe<$ContextOverridesOut>(
+    fn:
+      | MiddlewareFunction<
+          TContext,
+          TMeta,
+          TContextOverrides,
+          $ContextOverridesOut,
+          TInputIn
+        >
+      | MiddlewareBuilder<
+          Overwrite<TContext, TContextOverrides>,
+          TMeta,
+          $ContextOverridesOut,
+          TInputIn
+        >,
+  ): MiddlewareBuilder<
+    TContext,
+    TMeta,
+    Overwrite<TContextOverrides, $ContextOverridesOut>,
+    TInputIn
   >;
 
   /**
    * List of middlewares within this middleware builder
    */
-  _middlewares: MiddlewareFunction<TRoot, TNewParams>[];
+  _middlewares: MiddlewareFunction<
+    TContext,
+    TMeta,
+    TContextOverrides,
+    object,
+    TInputIn
+  >[];
 }
 
-/**
- * @internal
- * FIXME: there must be a nicer way of doing this, it's hard to maintain when we have several structures like this
- */
-type CreateMiddlewareReturnInput<
-  TRoot extends AnyProcedureBuilderParams,
-  TPrev extends AnyProcedureBuilderParams,
-  TNext extends AnyProcedureBuilderParams,
-> = MiddlewareBuilder<
-  TRoot,
-  {
-    _config: TPrev['_config'];
-    _meta: TPrev['_meta'];
-    _ctx_out: Overwrite<TPrev['_ctx_out'], TNext['_ctx_out']>;
-    _input_in: DefaultValue<TNext['_input_in'], TPrev['_input_in']>;
-    _input_out: DefaultValue<TNext['_input_out'], TPrev['_input_out']>;
-    _output_in: DefaultValue<TNext['_output_in'], TPrev['_output_in']>;
-    _output_out: DefaultValue<TNext['_output_out'], TPrev['_output_out']>;
-  }
->;
-
-/**
- * @internal
- */
-type deriveParamsFromConfig<
-  TConfig extends AnyRootConfig,
-  TInputIn = unknown,
-> = {
-  _config: TConfig;
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  _ctx_out: {};
-  _input_out: UnsetMarker;
-  _input_in: TInputIn;
-  _output_in: unknown;
-  _output_out: unknown;
-  _meta: TConfig['$types']['meta'];
-};
 /**
  * @internal
  */
 export type MiddlewareFunction<
-  TParams extends AnyProcedureBuilderParams,
-  TParamsAfter extends AnyProcedureBuilderParams,
+  TContext,
+  TMeta,
+  TContextOverridesIn,
+  $ContextOverridesOut,
+  TInputIn,
 > = {
   (opts: {
-    ctx: Simplify<
-      Overwrite<TParams['_config']['$types']['ctx'], TParams['_ctx_out']>
-    >;
+    ctx: Simplify<Overwrite<TContext, TContextOverridesIn>>;
     type: ProcedureType;
     path: string;
-    input: TParams['_input_in'];
+    input: TInputIn;
     getRawInput: GetRawInputFn;
-    meta: TParams['_meta'] | undefined;
+    meta: TMeta | undefined;
     next: {
-      (): Promise<MiddlewareResult<TParams>>;
-      <$Context>(opts: { ctx?: $Context; input?: unknown }): Promise<
-        MiddlewareResult<{
-          _config: TParams['_config'];
-          _ctx_out: $Context;
-          _input_in: TParams['_input_in'];
-          _input_out: TParams['_input_out'];
-          _output_in: TParams['_output_in'];
-          _output_out: TParams['_output_out'];
-          _meta: TParams['_meta'];
-        }>
-      >;
+      (): Promise<MiddlewareResult<TContextOverridesIn>>;
+      <$ContextOverride>(opts: {
+        ctx?: $ContextOverride;
+        input?: unknown;
+      }): Promise<MiddlewareResult<$ContextOverride>>;
       (opts: { getRawInput: GetRawInputFn }): Promise<
-        MiddlewareResult<TParams>
+        MiddlewareResult<TContextOverridesIn>
       >;
     };
-  }): Promise<MiddlewareResult<TParamsAfter>>;
+  }): Promise<MiddlewareResult<$ContextOverridesOut>>;
   _type?: string | undefined;
 };
 
+export type AnyMiddlewareFunction = MiddlewareFunction<any, any, any, any, any>;
+export type AnyMiddlewareBuilder = MiddlewareBuilder<any, any, any, any>;
 /**
  * @internal
  */
-export function createMiddlewareFactory<
-  TConfig extends AnyRootConfig,
-  TInputIn = unknown,
->() {
-  function createMiddlewareInner<TNewParams extends AnyProcedureBuilderParams>(
-    middlewares: MiddlewareFunction<any, any>[],
-  ): MiddlewareBuilder<deriveParamsFromConfig<TConfig, TInputIn>, TNewParams> {
+export function createMiddlewareFactory<TContext, TMeta, TInputIn = unknown>() {
+  function createMiddlewareInner(
+    middlewares: AnyMiddlewareFunction[],
+  ): AnyMiddlewareBuilder {
     return {
       _middlewares: middlewares,
       unstable_pipe(middlewareBuilderOrFn) {
@@ -181,20 +134,20 @@ export function createMiddlewareFactory<
             ? middlewareBuilderOrFn._middlewares
             : [middlewareBuilderOrFn];
 
-        return createMiddlewareInner([
-          ...(middlewares as any),
-          ...pipedMiddleware,
-        ]);
+        return createMiddlewareInner([...middlewares, ...pipedMiddleware]);
       },
     };
   }
 
-  function createMiddleware<TNewParams extends AnyProcedureBuilderParams>(
+  function createMiddleware<$ContextOverrides>(
     fn: MiddlewareFunction<
-      deriveParamsFromConfig<TConfig, TInputIn>,
-      TNewParams
+      TContext,
+      TMeta,
+      object,
+      $ContextOverrides,
+      TInputIn
     >,
-  ): MiddlewareBuilder<deriveParamsFromConfig<TConfig, TInputIn>, TNewParams> {
+  ): MiddlewareBuilder<TContext, TMeta, $ContextOverrides, TInputIn> {
     return createMiddlewareInner([fn]);
   }
 
@@ -209,12 +162,8 @@ export const experimental_standaloneMiddleware = <
   },
 >() => ({
   create: createMiddlewareFactory<
-    RootConfig<{
-      ctx: TCtx extends { ctx: infer T extends object } ? T : object;
-      meta: TCtx extends { meta: infer T extends object } ? T : object;
-      errorShape: object;
-      transformer: object;
-    }>,
+    TCtx extends { ctx: infer T extends object } ? T : any,
+    TCtx extends { meta: infer T extends object } ? T : object,
     TCtx extends { input: infer T } ? T : unknown
   >(),
 });
@@ -228,30 +177,31 @@ function isPlainObject(obj: unknown) {
  * Please note, `trpc-openapi` uses this function.
  */
 export function createInputMiddleware<TInput>(parse: ParseFn<TInput>) {
-  const inputMiddleware: ProcedureBuilderMiddleware = async (opts) => {
-    let parsedInput: ReturnType<typeof parse>;
-
-    const rawInput = await opts.getRawInput();
-    try {
-      parsedInput = await parse(rawInput);
-    } catch (cause) {
-      throw new TRPCError({
-        code: 'BAD_REQUEST',
-        cause,
-      });
-    }
-
-    // Multiple input parsers
-    const combinedInput =
-      isPlainObject(opts.input) && isPlainObject(parsedInput)
-        ? {
-            ...opts.input,
-            ...parsedInput,
-          }
-        : parsedInput;
-
-    return opts.next({ input: combinedInput });
-  };
+  const inputMiddleware: AnyMiddlewareFunction =
+    async function inputValidatorMiddleware(opts) {
+      let parsedInput: ReturnType<typeof parse>;
+
+      const rawInput = await opts.getRawInput();
+      try {
+        parsedInput = await parse(rawInput);
+      } catch (cause) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          cause,
+        });
+      }
+
+      // Multiple input parsers
+      const combinedInput =
+        isPlainObject(opts.input) && isPlainObject(parsedInput)
+          ? {
+              ...opts.input,
+              ...parsedInput,
+            }
+          : parsedInput;
+
+      return opts.next({ input: combinedInput });
+    };
   inputMiddleware._type = 'input';
   return inputMiddleware;
 }
@@ -260,26 +210,27 @@ export function createInputMiddleware<TInput>(parse: ParseFn<TInput>) {
  * @internal
  */
 export function createOutputMiddleware<TOutput>(parse: ParseFn<TOutput>) {
-  const outputMiddleware: ProcedureBuilderMiddleware = async ({ next }) => {
-    const result = await next();
-    if (!result.ok) {
-      // pass through failures without validating
-      return result;
-    }
-    try {
-      const data = await parse(result.data);
-      return {
-        ...result,
-        data,
-      };
-    } catch (cause) {
-      throw new TRPCError({
-        message: 'Output validation failed',
-        code: 'INTERNAL_SERVER_ERROR',
-        cause,
-      });
-    }
-  };
+  const outputMiddleware: AnyMiddlewareFunction =
+    async function outputValidatorMiddleware({ next }) {
+      const result = await next();
+      if (!result.ok) {
+        // pass through failures without validating
+        return result;
+      }
+      try {
+        const data = await parse(result.data);
+        return {
+          ...result,
+          data,
+        };
+      } catch (cause) {
+        throw new TRPCError({
+          message: 'Output validation failed',
+          code: 'INTERNAL_SERVER_ERROR',
+          cause,
+        });
+      }
+    };
   outputMiddleware._type = 'output';
   return outputMiddleware;
 }

package/src/core/router.ts

@@ -46,12 +46,16 @@ type DecoratedProcedureRecord<TProcedures extends ProcedureRouterRecord> = {
 /**
  * @internal
  */
-type RouterCaller<TDef extends AnyRouterDef> = (
+export type RouterCaller<TDef extends AnyRouterDef> = (
   ctx: TDef['_config']['$types']['ctx'],
 ) => DecoratedProcedureRecord<TDef['record']>;
 
 export interface Router<TDef extends AnyRouterDef> {
   _def: TDef;
+  /**
+   * @deprecated use `t.createCallerFactory(router)` instead
+   * @see https://trpc.io/docs/server/server-side-calls
+   */
   createCaller: RouterCaller<TDef>;
 }
 
@@ -164,6 +168,7 @@ export function createRouterFactory<TConfig extends AnyRootConfig>(
         return proxy as ReturnType<RouterCaller<any>>;
       },
     };
+
     return router as any;
   };
 }
@@ -190,3 +195,27 @@ export function callProcedure(
 
   return proc(opts);
 }
+
+export function createCallerFactory<TConfig extends AnyRootConfig>() {
+  return function createCallerInner<
+    TRouter extends Router<AnyRouterDef<TConfig>>,
+  >(router: TRouter): RouterCaller<TRouter['_def']> {
+    const _def = router._def;
+
+    return function createCaller(ctx) {
+      const proxy = createRecursiveProxy(({ path, args }) => {
+        const fullPath = path.join('.');
+        const procedure = _def.procedures[fullPath] as AnyProcedure;
+
+        return procedure({
+          path: fullPath,
+          getRawInput: async () => args[0],
+          ctx,
+          type: procedure._def.type,
+        });
+      });
+
+      return proxy as ReturnType<RouterCaller<any>>;
+    };
+  };
+}

package/src/shared/internal/serialize.ts

@@ -40,48 +40,83 @@ export type Serialize<T> =
 
 /** JSON serialize [tuples](https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types) */
 type SerializeTuple<T extends [unknown, ...unknown[]]> = {
-  [k in keyof T]: T[k] extends NonJsonPrimitive ? null : Serialize<T[k]>;
+  [K in keyof T]: T[K] extends NonJsonPrimitive ? null : Serialize<T[K]>;
 };
 
 // prettier-ignore
-type SerializeObjectKey<T extends Record<any, any>, TKey> = 
+type SerializeObjectKey<T extends Record<any, any>, K> = 
   // never include entries where the key is a symbol
-  TKey extends symbol ? never : 
+  K extends symbol ? never : 
   // always include entries where the value is any
-  IsAny<T[TKey]> extends true ? TKey :
+  IsAny<T[K]> extends true ? K :
   // always include entries where the value is unknown
-  unknown extends T[TKey] ? TKey : 
+  unknown extends T[K] ? K : 
   // never include entries where the value is a non-JSON primitive
-  T[TKey] extends NonJsonPrimitive ? never : 
+  T[K] extends NonJsonPrimitive ? never : 
   // otherwise serialize the value
-  TKey;
+  K;
 /**
  * JSON serialize objects (not including arrays) and classes
  * @internal
  **/
 export type SerializeObject<T extends object> = {
-  [$Key in keyof T as SerializeObjectKey<T, $Key>]: Serialize<T[$Key]>;
+  [K in keyof T as SerializeObjectKey<T, K>]: Serialize<T[K]>;
 };
 
-type FilterDefinedKeys<TObj extends object> = Exclude<
+/**
+ * Extract keys from T where the value dosen't extend undefined
+ * Note: Can't parse IndexSignature or Record types
+ */
+type FilterDefinedKeys<T extends object> = Exclude<
   {
-    [TKey in keyof TObj]: undefined extends TObj[TKey] ? never : TKey;
-  }[keyof TObj],
+    [K in keyof T]: undefined extends T[K] ? never : K;
+  }[keyof T],
   undefined
 >;
 
-/*
- * For an object T, if it has any properties that are a union with `undefined`,
- * make those into optional properties instead.
- *
- * Example: { a: string | undefined} --> { a?: string}
+/**
+ * Get value of exactOptionalPropertyTypes config
+ */
+type ExactOptionalPropertyTypes = { a?: 0 | undefined } extends {
+  a?: 0;
+}
+  ? false
+  : true;
+
+/**
+ * Check if T has an index signature
+ */
+type HasIndexSignature<T extends object> = string extends keyof T
+  ? true
+  : false;
+
+/**
+ * { [key: string]: number | undefined } --> { [key: string]: number }
+ */
+type HandleIndexSignature<T extends object> = {
+  [K in keyof Omit<T, keyof WithoutIndexSignature<T>>]: Exclude<
+    T[K],
+    undefined
+  >;
+};
+
+/**
+ * { a: number | undefined } --> { a?: number }
+ * Note: Can't parse IndexSignature or Record types
+ */
+type HandleUndefined<T extends object> = {
+  [K in keyof Omit<T, FilterDefinedKeys<T>>]?: Exclude<T[K], undefined>;
+};
+
+/**
+ * Handle undefined, index signature and records
  */
 type UndefinedToOptional<T extends object> =
   // Property is not a union with `undefined`, keep as-is
-  Pick<
-    WithoutIndexSignature<T>,
-    FilterDefinedKeys<WithoutIndexSignature<T>>
-  > & {
-    // Property _is_ a union with `defined`. Set as optional (via `?`) and remove `undefined` from the union
-    [k in keyof Omit<T, FilterDefinedKeys<T>>]?: Exclude<T[k], undefined>;
-  };
+  Pick<WithoutIndexSignature<T>, FilterDefinedKeys<WithoutIndexSignature<T>>> &
+    // If following is true, don't merge undefined or optional into index signature if any in T
+    (ExactOptionalPropertyTypes extends true
+      ? HandleIndexSignature<T> & HandleUndefined<WithoutIndexSignature<T>>
+      : HasIndexSignature<T> extends true
+      ? HandleIndexSignature<T>
+      : HandleUndefined<T>);

package/dist/core/internals/builderTypes.d.ts

@@ -1,14 +0,0 @@
-import { AnyRootConfig } from './config';
-/**
- * @internal
- */
-export type AnyProcedureBuilderParams = {
-    _config: AnyRootConfig;
-    _meta: unknown;
-    _ctx_out: unknown;
-    _input_in: unknown;
-    _input_out: unknown;
-    _output_in: unknown;
-    _output_out: unknown;
-};
-//# sourceMappingURL=builderTypes.d.ts.map

package/dist/core/internals/builderTypes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"builderTypes.d.ts","sourceRoot":"","sources":["../../../src/core/internals/builderTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC,OAAO,EAAE,aAAa,CAAC;IACvB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC"}

package/src/core/internals/builderTypes.ts

@@ -1,14 +0,0 @@
-import { AnyRootConfig } from './config';
-
-/**
- * @internal
- */
-export type AnyProcedureBuilderParams = {
-  _config: AnyRootConfig;
-  _meta: unknown;
-  _ctx_out: unknown;
-  _input_in: unknown;
-  _input_out: unknown;
-  _output_in: unknown;
-  _output_out: unknown;
-};