@trpc/server 11.0.0-next.92 → 11.0.0-rc.330

package/src/unstable-core-do-not-import/clientish/inference.ts

@@ -0,0 +1,60 @@
+import type { inferObservableValue } from '../../observable';
+import type {
+  AnyProcedure,
+  inferProcedureInput,
+  inferProcedureOutput,
+} from '../procedure';
+import type { AnyRouter, RouterRecord } from '../router';
+import type {
+  AnyClientTypes,
+  inferClientTypes,
+  InferrableClientTypes,
+} from './inferrable';
+import type { Serialize } from './serialize';
+
+/**
+ * @internal
+ */
+
+export type inferTransformedProcedureOutput<
+  TInferrable extends InferrableClientTypes,
+  TProcedure extends AnyProcedure,
+> = inferClientTypes<TInferrable>['transformer'] extends false
+  ? Serialize<inferProcedureOutput<TProcedure>>
+  : inferProcedureOutput<TProcedure>;
+/** @internal */
+
+export type inferTransformedSubscriptionOutput<
+  TInferrable extends InferrableClientTypes,
+  TProcedure extends AnyProcedure,
+> = inferClientTypes<TInferrable>['transformer'] extends false
+  ? Serialize<inferObservableValue<inferProcedureOutput<TProcedure>>>
+  : inferObservableValue<inferProcedureOutput<TProcedure>>;
+
+export type GetInferenceHelpers<
+  TType extends 'input' | 'output',
+  TRoot extends AnyClientTypes,
+  TRecord extends RouterRecord,
+> = {
+  [TKey in keyof TRecord]: TRecord[TKey] extends infer $Value
+    ? $Value extends RouterRecord
+      ? GetInferenceHelpers<TType, TRoot, $Value>
+      : $Value extends AnyProcedure
+      ? TType extends 'input'
+        ? inferProcedureInput<$Value>
+        : inferTransformedProcedureOutput<TRoot, $Value>
+      : never
+    : never;
+};
+
+export type inferRouterInputs<TRouter extends AnyRouter> = GetInferenceHelpers<
+  'input',
+  TRouter['_def']['_config']['$types'],
+  TRouter['_def']['record']
+>;
+
+export type inferRouterOutputs<TRouter extends AnyRouter> = GetInferenceHelpers<
+  'output',
+  TRouter['_def']['_config']['$types'],
+  TRouter['_def']['record']
+>;

package/src/unstable-core-do-not-import/clientish/inferrable.ts

@@ -0,0 +1,49 @@
+import type { AnyRootTypes } from '../rootConfig';
+
+export type AnyClientTypes = Pick<AnyRootTypes, 'errorShape' | 'transformer'>;
+
+/**
+ * Result of `initTRPC.create()`
+ */
+type InitLike = {
+  _config: {
+    $types: AnyClientTypes;
+  };
+};
+
+/**
+ * Result of `initTRPC.create().router()`
+ */
+type RouterLike = {
+  _def: InitLike;
+};
+
+/**
+ * Result of `initTRPC.create()._config`
+ */
+type RootConfigLike = {
+  $types: AnyClientTypes;
+};
+
+/**
+ * Anything that can be inferred to the root config types needed for a TRPC client
+ */
+export type InferrableClientTypes =
+  | RouterLike
+  | InitLike
+  | RootConfigLike
+  | AnyClientTypes;
+
+/**
+ * Infer the root types from a InferrableClientTypes
+ */
+export type inferClientTypes<TInferrable extends InferrableClientTypes> =
+  TInferrable extends AnyClientTypes
+    ? TInferrable
+    : TInferrable extends RootConfigLike
+    ? TInferrable['$types']
+    : TInferrable extends InitLike
+    ? TInferrable['_config']['$types']
+    : TInferrable extends RouterLike
+    ? TInferrable['_def']['_config']['$types']
+    : never;

package/src/unstable-core-do-not-import/clientish/serialize.ts

@@ -0,0 +1,122 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import type { Simplify, WithoutIndexSignature } from '../types';
+
+/**
+ * @link https://github.com/remix-run/remix/blob/2248669ed59fd716e267ea41df5d665d4781f4a9/packages/remix-server-runtime/serialize.ts
+ */
+type JsonPrimitive = boolean | number | string | null;
+// eslint-disable-next-line @typescript-eslint/ban-types
+type NonJsonPrimitive = Function | symbol | undefined;
+/*
+ * `any` is the only type that can let you equate `0` with `1`
+ * See https://stackoverflow.com/a/49928360/1490091
+ */
+type IsAny<T> = 0 extends T & 1 ? true : false;
+
+// `undefined` is a weird one that's technically not valid JSON,
+// but the return value of `JSON.parse` can be `undefined` so we
+// support it as both a Primitive and a NonJsonPrimitive
+type JsonReturnable = JsonPrimitive | undefined;
+
+type IsRecord<T extends object> = keyof WithoutIndexSignature<T> extends never
+  ? true
+  : false;
+
+/* prettier-ignore */
+export type Serialize<T> =
+  IsAny<T> extends true ? any :
+  unknown extends T ? unknown :
+  T extends JsonReturnable ? T :
+  T extends Map<any, any> | Set<any> ? object :
+  T extends NonJsonPrimitive ? never :
+  T extends { toJSON(): infer U } ? U :
+  T extends [] ? [] :
+  T extends [unknown, ...unknown[]] ? SerializeTuple<T> :
+  T extends readonly (infer U)[] ? (U extends NonJsonPrimitive ? null : Serialize<U>)[] :
+  T extends object ?
+    IsRecord<T> extends true ? Record<keyof T, Serialize<T[keyof T]>> :
+    Simplify<SerializeObject<UndefinedToOptional<T>>> :
+  never;
+
+/** 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]>;
+};
+
+// prettier-ignore
+type SerializeObjectKey<T extends Record<any, any>, K> = 
+  // never include entries where the key is a symbol
+  K extends symbol ? never : 
+  // always include entries where the value is any
+  IsAny<T[K]> extends true ? K :
+  // always include entries where the value is unknown
+  unknown extends T[K] ? K : 
+  // never include entries where the value is a non-JSON primitive
+  T[K] extends NonJsonPrimitive ? never : 
+  // otherwise serialize the value
+  K;
+/**
+ * JSON serialize objects (not including arrays) and classes
+ * @internal
+ **/
+export type SerializeObject<T extends object> = {
+  [K in keyof T as SerializeObjectKey<T, K>]: Serialize<T[K]>;
+};
+
+/**
+ * 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<
+  {
+    [K in keyof T]: undefined extends T[K] ? never : K;
+  }[keyof T],
+  undefined
+>;
+
+/**
+ * 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>>> &
+    // 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/src/{error → unstable-core-do-not-import/error}/TRPCError.ts

@@ -1,33 +1,10 @@
-import { TRPC_ERROR_CODE_KEY } from '../rpc/codes';
-import { isObject } from './utils';
-
-export function getTRPCErrorFromUnknown(cause: unknown): TRPCError {
-  if (cause instanceof TRPCError) {
-    return cause;
-  }
-  if (cause instanceof Error && cause.name === 'TRPCError') {
-    // https://github.com/trpc/trpc/pull/4848
-    return cause as TRPCError;
-  }
-
-  const trpcError = new TRPCError({
-    code: 'INTERNAL_SERVER_ERROR',
-    cause,
-  });
-
-  // Inherit stack from error
-  if (cause instanceof Error && cause.stack) {
-    trpcError.stack = cause.stack;
-  }
-
-  return trpcError;
-}
+import type { TRPC_ERROR_CODE_KEY } from '../rpc/codes';
+import { isObject } from '../utils';
 
 class UnknownCauseError extends Error {
   [key: string]: unknown;
 }
-
-function getCauseFromUnknown(cause: unknown): Error | undefined {
+export function getCauseFromUnknown(cause: unknown): Error | undefined {
   if (cause instanceof Error) {
     return cause;
   }
@@ -54,8 +31,32 @@ function getCauseFromUnknown(cause: unknown): Error | undefined {
   return undefined;
 }
 
+export function getTRPCErrorFromUnknown(cause: unknown): TRPCError {
+  if (cause instanceof TRPCError) {
+    return cause;
+  }
+  if (cause instanceof Error && cause.name === 'TRPCError') {
+    // https://github.com/trpc/trpc/pull/4848
+    return cause as TRPCError;
+  }
+
+  const trpcError = new TRPCError({
+    code: 'INTERNAL_SERVER_ERROR',
+    cause,
+  });
+
+  // Inherit stack from error
+  if (cause instanceof Error && cause.stack) {
+    trpcError.stack = cause.stack;
+  }
+
+  return trpcError;
+}
+
 export class TRPCError extends Error {
-  public readonly cause?: Error;
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore override doesn't work in all environments due to "This member cannot have an 'override' modifier because it is not declared in the base class 'Error'"
+  public override readonly cause?: Error;
   public readonly code;
 
   constructor(opts: {
@@ -72,5 +73,10 @@ export class TRPCError extends Error {
 
     this.code = opts.code;
     this.name = 'TRPCError';
+
+    if (!this.cause) {
+      // < ES2022 / < Node 16.9.0 compatability
+      this.cause = cause;
+    }
   }
 }

package/src/{error → unstable-core-do-not-import/error}/formatter.ts

@@ -1,17 +1,15 @@
-import { ProcedureType } from '../core';
-import {
+import type { ProcedureType } from '../procedure';
+import type {
   TRPC_ERROR_CODE_KEY,
   TRPC_ERROR_CODE_NUMBER,
   TRPCErrorShape,
 } from '../rpc';
-import { TRPCError } from './TRPCError';
+import type { TRPCError } from './TRPCError';
 
 /**
  * @internal
  */
-export type ErrorFormatter<TContext, TShape extends TRPCErrorShape<number>> = ({
-  error,
-}: {
+export type ErrorFormatter<TContext, TShape extends TRPCErrorShape> = (opts: {
   error: TRPCError;
   type: ProcedureType | 'unknown';
   path: string | undefined;
@@ -20,35 +18,30 @@ export type ErrorFormatter<TContext, TShape extends TRPCErrorShape<number>> = ({
   shape: DefaultErrorShape;
 }) => TShape;
 
-export type ErrorFormatterShape<TType> = TType extends ErrorFormatter<
-  any,
-  infer TShape
->
-  ? TShape
-  : DefaultErrorShape;
 /**
  * @internal
  */
 export type DefaultErrorData = {
   code: TRPC_ERROR_CODE_KEY;
   httpStatus: number;
+  /**
+   * Path to the procedure that threw the error
+   */
   path?: string;
+  /**
+   * Stack trace of the error (only in development)
+   */
   stack?: string;
 };
 
 /**
  * @internal
  */
-export interface DefaultErrorShape
-  extends TRPCErrorShape<TRPC_ERROR_CODE_NUMBER, DefaultErrorData> {
+export interface DefaultErrorShape extends TRPCErrorShape<DefaultErrorData> {
   message: string;
   code: TRPC_ERROR_CODE_NUMBER;
 }
 
-export const defaultFormatter: ErrorFormatter<any, any> = ({
-  shape,
-}: {
-  shape: DefaultErrorShape;
-}) => {
+export const defaultFormatter: ErrorFormatter<any, any> = ({ shape }) => {
   return shape;
 };

package/src/{shared → unstable-core-do-not-import/error}/getErrorShape.ts

@@ -1,21 +1,21 @@
-import { ProcedureType } from '../core';
-import { AnyRootConfig } from '../core/internals/config';
-import { DefaultErrorShape } from '../error/formatter';
-import { TRPCError } from '../error/TRPCError';
 import { getHTTPStatusCodeFromError } from '../http/getHTTPStatusCode';
+import type { ProcedureType } from '../procedure';
+import type { AnyRootTypes, RootConfig } from '../rootConfig';
 import { TRPC_ERROR_CODES_BY_KEY } from '../rpc';
+import type { DefaultErrorShape } from './formatter';
+import type { TRPCError } from './TRPCError';
 
 /**
  * @internal
  */
-export function getErrorShape<TConfig extends AnyRootConfig>(opts: {
-  config: TConfig;
+export function getErrorShape<TRoot extends AnyRootTypes>(opts: {
+  config: RootConfig<TRoot>;
   error: TRPCError;
   type: ProcedureType | 'unknown';
   path: string | undefined;
   input: unknown;
-  ctx: TConfig['$types']['ctx'] | undefined;
-}): TConfig['$types']['errorShape'] {
+  ctx: TRoot['ctx'] | undefined;
+}): TRoot['errorShape'] {
   const { path, error, config } = opts;
   const { code } = opts.error;
   const shape: DefaultErrorShape = {

package/src/{http → unstable-core-do-not-import/http}/contentType.ts

@@ -1,9 +1,9 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { AnyRouter } from '../core';
 import { TRPCError } from '../error/TRPCError';
-import { CombinedDataTransformer } from '../transformer';
-import { MaybePromise } from '../types';
-import { HTTPRequest } from './types';
+import type { AnyRouter } from '../router';
+import type { CombinedDataTransformer } from '../transformer';
+import type { MaybePromise } from '../types';
+import type { HTTPRequest } from './types';
 
 type GetInputs = (opts: {
   req: HTTPRequest;

package/src/{http → unstable-core-do-not-import/http}/getHTTPStatusCode.ts

@@ -1,11 +1,8 @@
-import { TRPCError } from '../error/TRPCError';
-import { invert } from '../internals/invert';
-import { TRPC_ERROR_CODES_BY_KEY, TRPCResponse } from '../rpc';
+import type { DefaultErrorData } from '../error/formatter';
+import type { TRPCError } from '../error/TRPCError';
+import type { TRPC_ERROR_CODES_BY_KEY, TRPCResponse } from '../rpc';
+import { TRPC_ERROR_CODES_BY_NUMBER } from '../rpc';
 
-export const TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
-type ValueOf<TType> = TType[keyof TType];
-
-export type TRPC_ERROR_CODE_NUMBER = ValueOf<typeof TRPC_ERROR_CODES_BY_KEY>;
 const JSONRPC2_TO_HTTP_CODE: Record<
   keyof typeof TRPC_ERROR_CODES_BY_KEY,
   number
@@ -20,6 +17,7 @@ const JSONRPC2_TO_HTTP_CODE: Record<
   CONFLICT: 409,
   PRECONDITION_FAILED: 412,
   PAYLOAD_TOO_LARGE: 413,
+  UNSUPPORTED_MEDIA_TYPE: 415,
   UNPROCESSABLE_CONTENT: 422,
   TOO_MANY_REQUESTS: 429,
   CLIENT_CLOSED_REQUEST: 499,
@@ -36,7 +34,9 @@ export function getHTTPStatusCode(json: TRPCResponse | TRPCResponse[]) {
   const httpStatuses = new Set(
     arr.map((res) => {
       if ('error' in res) {
-        const data = res.error.data;
+        const data = res.error.data as
+          | Record<string, unknown>
+          | DefaultErrorData;
         if (typeof data.httpStatus === 'number') {
           return data.httpStatus;
         }

package/src/unstable-core-do-not-import/http/index.ts

@@ -0,0 +1,29 @@
+export {
+  getHTTPStatusCode,
+  getHTTPStatusCodeFromError,
+} from './getHTTPStatusCode';
+export { resolveHTTPResponse } from './resolveHTTPResponse';
+export type {
+  BaseHandlerOptions,
+  HTTPBaseHandlerOptions,
+  HTTPHeaders,
+  HTTPRequest,
+  HTTPResponse,
+  /**
+   * @deprecated Use `HTTPErrorHandler` instead
+   */
+  HTTPErrorHandler as OnErrorFunction,
+  HTTPErrorHandler,
+  ProcedureCall,
+  ResolveHTTPRequestOptionsContextFn,
+  ResponseChunk,
+  ResponseMeta,
+  ResponseMetaFn,
+  TRPCRequestInfo,
+} from './types';
+
+export { getBatchStreamFormatter } from './batchStreamFormatter';
+export type { BaseContentTypeHandler, BodyResult } from './contentType';
+export { getJsonContentTypeInputs } from './contentType';
+
+export { toURL } from './toURL';

package/src/{http → unstable-core-do-not-import/http}/resolveHTTPResponse.ts

@@ -1,25 +1,25 @@
-import {
+import { getErrorShape } from '../error/getErrorShape';
+import { getTRPCErrorFromUnknown, TRPCError } from '../error/TRPCError';
+import type { ProcedureType } from '../procedure';
+import type {
   AnyRouter,
-  callProcedure,
   inferRouterContext,
   inferRouterError,
-  ProcedureType,
-} from '../core';
-import { getTRPCErrorFromUnknown, TRPCError } from '../error/TRPCError';
-import { TRPCResponse } from '../rpc';
-import { getErrorShape } from '../shared/getErrorShape';
-import { transformTRPCResponse } from '../shared/transformTRPCResponse';
-import { Maybe } from '../types';
-import {
-  BaseContentTypeHandler,
-  getJsonContentTypeInputs,
-} from './contentType';
+} from '../router';
+import { callProcedure } from '../router';
+import type { TRPCResponse } from '../rpc';
+import { transformTRPCResponse } from '../transformer';
+import type { Maybe } from '../types';
+import type { BaseContentTypeHandler } from './contentType';
+import { getJsonContentTypeInputs } from './contentType';
 import { getHTTPStatusCode } from './getHTTPStatusCode';
-import { HTTPHeaders, HTTPResponse, ResponseChunk } from './internals/types';
-import {
+import type {
   HTTPBaseHandlerOptions,
+  HTTPHeaders,
   HTTPRequest,
+  HTTPResponse,
   ResolveHTTPRequestOptionsContextFn,
+  ResponseChunk,
   TRPCRequestInfo,
 } from './types';
 
@@ -132,51 +132,6 @@ function initResponse<
   };
 }
 
-async function inputToProcedureCall<
-  TRouter extends AnyRouter,
-  TRequest extends HTTPRequest,
->(procedureOpts: {
-  opts: Pick<
-    ResolveHTTPRequestOptions<TRouter, TRequest>,
-    'onError' | 'req' | 'router'
-  >;
-  ctx: inferRouterContext<TRouter> | undefined;
-  type: 'mutation' | 'query';
-  input: unknown;
-  path: string;
-}): Promise<TRPCResponse<unknown, inferRouterError<TRouter>>> {
-  const { opts, ctx, type, input, path } = procedureOpts;
-  try {
-    const data = await callProcedure({
-      procedures: opts.router._def.procedures,
-      path,
-      getRawInput: async () => input,
-      ctx,
-      type,
-    });
-    return {
-      result: {
-        data,
-      },
-    };
-  } catch (cause) {
-    const error = getTRPCErrorFromUnknown(cause);
-
-    opts.onError?.({ error, path, input, ctx, type: type, req: opts.req });
-
-    return {
-      error: getErrorShape({
-        config: opts.router._def._config,
-        error,
-        type,
-        path,
-        input,
-        ctx,
-      }),
-    };
-  }
-}
-
 function caughtErrorToData<
   TRouter extends AnyRouter,
   TRequest extends HTTPRequest,
@@ -278,7 +233,9 @@ export async function resolveHTTPResponse<
   }
   const contentTypeHandler =
     opts.contentTypeHandler ?? fallbackContentTypeHandler;
-  const batchingEnabled = opts.batching?.enabled ?? true;
+  const allowBatching = opts.allowBatching ?? opts.batching?.enabled ?? true;
+  const allowMethodOverride = opts.allowMethodOverride ?? false;
+
   const type =
     HTTP_METHOD_PROCEDURE_TYPE_MAP[req.method] ?? ('unknown' as const);
   let ctx: inferRouterContext<TRouter> | undefined = undefined;
@@ -295,8 +252,11 @@ export async function resolveHTTPResponse<
     if (opts.error) {
       throw opts.error;
     }
-    if (isBatchCall && !batchingEnabled) {
-      throw new Error(`Batching is not enabled on the server`);
+    if (isBatchCall && !allowBatching) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: `Batching is not enabled on the server`,
+      });
     }
     /* istanbul ignore if -- @preserve */
     if (type === 'subscription') {
@@ -331,9 +291,52 @@ export async function resolveHTTPResponse<
       })),
     };
     ctx = await opts.createContext({ info });
-    const promises = paths.map((path, index) =>
-      inputToProcedureCall({ opts, ctx, type, input: inputs[index], path }),
-    );
+
+    const errors: TRPCError[] = [];
+
+    const promises: Promise<
+      TRPCResponse<unknown, inferRouterError<TRouter>>
+    >[] = paths.map(async (path, index) => {
+      const input = inputs[index];
+      try {
+        const data = await callProcedure({
+          procedures: opts.router._def.procedures,
+          path,
+          getRawInput: async () => input,
+          ctx,
+          type,
+          allowMethodOverride,
+        });
+        return {
+          result: {
+            data,
+          },
+        };
+      } catch (cause) {
+        const error = getTRPCErrorFromUnknown(cause);
+        errors.push(error);
+
+        opts.onError?.({
+          error,
+          path,
+          input,
+          ctx,
+          type: type,
+          req: opts.req,
+        });
+
+        return {
+          error: getErrorShape({
+            config: opts.router._def._config,
+            error,
+            type,
+            path,
+            input,
+            ctx,
+          }),
+        };
+      }
+    });
 
     if (!isStreamCall) {
       /**
@@ -344,9 +347,6 @@ export async function resolveHTTPResponse<
        */
 
       const untransformedJSON = await Promise.all(promises);
-      const errors = untransformedJSON.flatMap((response) =>
-        'error' in response ? [response.error] : [],
-      );
 
       const headResponse = initResponse({
         ctx,

package/src/unstable-core-do-not-import/http/toURL.ts

@@ -0,0 +1,7 @@
+export function toURL(urlOrPathname: string): URL {
+  const url = urlOrPathname.startsWith('/')
+    ? `http://127.0.0.1${urlOrPathname}`
+    : urlOrPathname;
+
+  return new URL(url);
+}