@trpc/server 10.32.0 → 10.33.1

package/src/error/TRPCError.ts

@@ -1,5 +1,5 @@
 import { TRPC_ERROR_CODE_KEY } from '../rpc/codes';
-import { getMessageFromUnknownError } from './utils';
+import { isObject } from './utils';
 
 export function getTRPCErrorFromUnknown(cause: unknown): TRPCError {
   if (cause instanceof TRPCError) {
@@ -19,6 +19,37 @@ export function getTRPCErrorFromUnknown(cause: unknown): TRPCError {
   return trpcError;
 }
 
+class UnknownCauseError extends Error {
+  [key: string]: unknown;
+}
+
+function getCauseFromUnknown(cause: unknown): Error | undefined {
+  if (cause instanceof Error) {
+    return cause;
+  }
+
+  const type = typeof cause;
+  if (type === 'undefined' || type === 'function' || cause === null) {
+    return undefined;
+  }
+
+  // Primitive types just get wrapped in an error
+  if (type !== 'object') {
+    return new Error(String(cause));
+  }
+
+  // If it's an object, we'll create a synthetic error
+  if (isObject(cause)) {
+    const err = new UnknownCauseError();
+    for (const key in cause) {
+      err[key] = cause[key];
+    }
+    return err;
+  }
+
+  return undefined;
+}
+
 export class TRPCError extends Error {
   public readonly cause?: Error;
   public readonly code;
@@ -28,12 +59,12 @@ export class TRPCError extends Error {
     code: TRPC_ERROR_CODE_KEY;
     cause?: unknown;
   }) {
-    const message =
-      opts.message ?? getMessageFromUnknownError(opts.cause, opts.code);
+    const cause = getCauseFromUnknown(opts.cause);
+    const message = opts.message ?? cause?.message ?? opts.code;
 
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore https://github.com/tc39/proposal-error-cause
-    super(message, { cause: opts.cause });
+    super(message, { cause });
 
     this.code = opts.code;
     this.name = this.constructor.name;

package/src/error/formatter.ts

@@ -16,7 +16,7 @@ export type ErrorFormatter<TContext, TShape extends TRPCErrorShape<number>> = ({
   type: ProcedureType | 'unknown';
   path: string | undefined;
   input: unknown;
-  ctx: undefined | TContext;
+  ctx: TContext | undefined;
   shape: DefaultErrorShape;
 }) => TShape;
 

package/src/error/utils.ts

@@ -1,7 +1,7 @@
 /**
  * @internal
  */
-function isObject(value: unknown): value is Record<string, unknown> {
+export function isObject(value: unknown): value is Record<string, unknown> {
   // check that value is object
   return !!value && !Array.isArray(value) && typeof value === 'object';
 }
@@ -21,11 +21,3 @@ export function getMessageFromUnknownError(
   }
   return fallback;
 }
-
-export function getCauseFromUnknown(cause: unknown) {
-  if (cause instanceof Error) {
-    return cause;
-  }
-
-  return undefined;
-}

package/src/http/contentType.ts

@@ -1,7 +1,6 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { AnyRouter } from '../core';
 import { TRPCError } from '../error/TRPCError';
-import { getCauseFromUnknown } from '../error/utils';
 import { CombinedDataTransformer } from '../transformer';
 import { MaybePromise } from '../types';
 import { HTTPRequest } from './types';
@@ -48,10 +47,10 @@ function getRawProcedureInputOrThrow(opts: {
       return req.body.length === 0 ? undefined : JSON.parse(req.body);
     }
     return req.body;
-  } catch (err) {
+  } catch (cause) {
     throw new TRPCError({
       code: 'PARSE_ERROR',
-      cause: getCauseFromUnknown(err),
+      cause,
     });
   }
 }

package/src/http/internals/types.ts

@@ -9,7 +9,7 @@ import { TRPCResponse } from '../../rpc';
 import { Dict } from '../../types';
 import { ResponseMeta } from '../types';
 
-export type HTTPHeaders = Dict<string | string[]>;
+export type HTTPHeaders = Dict<string[] | string>;
 
 export interface HTTPResponse {
   status: number;

package/src/http/resolveHTTPResponse.ts

@@ -133,10 +133,10 @@ async function inputToProcedureCall<
 >(procedureOpts: {
   opts: Pick<
     ResolveHTTPRequestOptions<TRouter, TRequest>,
-    'router' | 'onError' | 'req'
+    'onError' | 'req' | 'router'
   >;
   ctx: inferRouterContext<TRouter> | undefined;
-  type: 'query' | 'mutation';
+  type: 'mutation' | 'query';
   input: unknown;
   path: string;
 }): Promise<TRPCResponse<unknown, inferRouterError<TRouter>>> {
@@ -180,7 +180,7 @@ function caughtErrorToData<
   errorOpts: {
     opts: Pick<
       ResolveHTTPRequestOptions<TRouter, TRequest>,
-      'router' | 'onError' | 'req'
+      'onError' | 'req' | 'router'
     >;
     ctx: inferRouterContext<TRouter> | undefined;
     type: ProcedureType | 'unknown';
@@ -237,7 +237,7 @@ export async function resolveHTTPResponse<
 >(
   opts: Omit<
     ResolveHTTPRequestOptions<TRouter, TRequest>,
-    'unstable_onHead' | 'unstable_onChunk'
+    'unstable_onChunk' | 'unstable_onHead'
   >,
 ): Promise<HTTPResponse>;
 /**
@@ -257,7 +257,7 @@ export async function resolveHTTPResponse<
 >(
   opts: PartialBy<
     ResolveHTTPRequestOptions<TRouter, TRequest>,
-    'unstable_onHead' | 'unstable_onChunk'
+    'unstable_onChunk' | 'unstable_onHead'
   >,
 ): Promise<HTTPResponse | void> {
   const { router, req, unstable_onHead, unstable_onChunk } = opts;
@@ -379,7 +379,7 @@ export async function resolveHTTPResponse<
         promise.then((r) => [index, r] as const),
       ]),
     );
-    for (let i = 0; i < paths.length; i++) {
+    for (const _ of paths) {
       const [index, untransformedJSON] = await Promise.race(
         indexedPromises.values(),
       );

package/src/internals/types.ts

@@ -23,5 +23,5 @@ export type OnErrorFunction<TRouter extends AnyRouter, TRequest> = (opts: {
   path: string | undefined;
   req: TRequest;
   input: unknown;
-  ctx: undefined | inferRouterContext<TRouter>;
+  ctx: inferRouterContext<TRouter> | undefined;
 }) => void;

package/src/observable/internals/pipe.ts

@@ -3,7 +3,7 @@ import { identity } from './identity';
 
 /** @internal */
 export function pipeFromArray<TSource, TReturn>(
-  fns: Array<UnaryFunction<TSource, TReturn>>,
+  fns: UnaryFunction<TSource, TReturn>[],
 ): UnaryFunction<TSource, TReturn> {
   if (fns.length === 0) {
     return identity as UnaryFunction<any, any>;

package/src/rpc/envelopes.ts

@@ -76,13 +76,13 @@ export interface TRPCErrorResponse<
 export type TRPCResponse<
   TData = unknown,
   TError extends TRPCErrorShape = TRPCErrorShape,
-> = TRPCSuccessResponse<TData> | TRPCErrorResponse<TError>;
+> = TRPCErrorResponse<TError> | TRPCSuccessResponse<TData>;
 
 /////////////////////////// WebSocket envelopes ///////////////////////
 
-export type TRPCRequestMessage = {
+export type TRPCRequestMessage = TRPCRequest & {
   id: JSONRPC2.RequestId;
-} & TRPCRequest;
+};
 
 /**
  * The client asked the server to unsubscribe
@@ -102,21 +102,21 @@ export type TRPCClientOutgoingRequest = TRPCSubscriptionStopNotification;
  */
 export type TRPCClientOutgoingMessage =
   | TRPCRequestMessage
-  | ({ id: JSONRPC2.RequestId } & JSONRPC2.BaseRequest<'subscription.stop'>);
+  | (JSONRPC2.BaseRequest<'subscription.stop'> & { id: JSONRPC2.RequestId });
 
 export interface TRPCResultMessage<TData>
   extends JSONRPC2.ResultResponse<
-    | (TRPCResult<TData> & { type: 'data' })
     | { type: 'started' }
     | { type: 'stopped' }
+    | (TRPCResult<TData> & { type: 'data' })
   > {}
 
 export type TRPCResponseMessage<
   TData = unknown,
   TError extends TRPCErrorShape = TRPCErrorShape,
 > = { id: JSONRPC2.RequestId } & (
-  | TRPCResultMessage<TData>
   | TRPCErrorResponse<TError>
+  | TRPCResultMessage<TData>
 );
 
 /**
@@ -138,4 +138,4 @@ export type TRPCClientIncomingRequest = TRPCReconnectNotification;
 export type TRPCClientIncomingMessage<
   TResult = unknown,
   TError extends TRPCErrorShape = TRPCErrorShape,
-> = TRPCResponseMessage<TResult, TError> | TRPCClientIncomingRequest;
+> = TRPCClientIncomingRequest | TRPCResponseMessage<TResult, TError>;

package/src/shared/createProxy/index.ts

@@ -44,7 +44,7 @@ export const createRecursiveProxy = (callback: ProxyCallback) =>
  * @internal
  */
 export const createFlatProxy = <TFaux>(
-  callback: (path: keyof TFaux & string) => any,
+  callback: (path: string & keyof TFaux) => any,
 ): TFaux => {
   return new Proxy(noop, {
     get(_obj, name) {

package/src/shared/getErrorShape.ts

@@ -13,7 +13,7 @@ export function getErrorShape<TConfig extends AnyRootConfig>(opts: {
   type: ProcedureType | 'unknown';
   path: string | undefined;
   input: unknown;
-  ctx: undefined | TConfig['$types']['ctx'];
+  ctx: TConfig['$types']['ctx'] | undefined;
 }): TConfig['$types']['errorShape'] {
   const { path, error, config } = opts;
   const { code } = opts.error;

package/src/shared/internal/serialize.ts

@@ -4,24 +4,14 @@ import { FilterKeys, Simplify } from '../../types';
 /**
  * @link https://github.com/remix-run/remix/blob/2248669ed59fd716e267ea41df5d665d4781f4a9/packages/remix-server-runtime/serialize.ts
  */
-type JsonPrimitive =
-  | string
-  | number
-  | boolean
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  | String
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  | Number
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  | Boolean
-  | null;
+type JsonPrimitive = boolean | number | string | null;
 // eslint-disable-next-line @typescript-eslint/ban-types
-type NonJsonPrimitive = undefined | Function | symbol;
+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 1 & T ? true : false;
+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
@@ -37,7 +27,7 @@ export type Serialize<T> =
   T extends { toJSON(): infer U } ? U :
   T extends [] ? [] :
   T extends [unknown, ...unknown[]] ? SerializeTuple<T> :
-  T extends ReadonlyArray<infer U> ? (U extends NonJsonPrimitive ? null : Serialize<U>)[] :
+  T extends readonly (infer U)[] ? (U extends NonJsonPrimitive ? null : Serialize<U>)[] :
   T extends object ? Simplify<SerializeObject<UndefinedToOptional<T>>> :
   never;
 

package/src/subscription.ts

@@ -10,7 +10,7 @@ export function subscriptionPullFactory<TOutput>(opts: {
    * The interval of how often the function should run
    */
   intervalMs: number;
-  pull(emit: Observer<TOutput, unknown>): void | Promise<void>;
+  pull(emit: Observer<TOutput, unknown>): Promise<void> | void;
 }): Observable<TOutput, unknown> {
   let timer: any;
   let stopped = false;
@@ -32,7 +32,9 @@ export function subscriptionPullFactory<TOutput>(opts: {
   }
 
   return observable<TOutput>((emit) => {
-    _pull(emit).catch((err) => emit.error(getTRPCErrorFromUnknown(err)));
+    _pull(emit).catch((err) => {
+      emit.error(getTRPCErrorFromUnknown(err));
+    });
     return () => {
       clearTimeout(timer);
       stopped = true;

package/src/transformer.ts

@@ -53,7 +53,7 @@ export type CombinedDataTransformerClient = {
 /**
  * @public
  */
-export type DataTransformerOptions = DataTransformer | CombinedDataTransformer;
+export type DataTransformerOptions = CombinedDataTransformer | DataTransformer;
 
 /**
  * @public
@@ -62,8 +62,8 @@ export type DataTransformerOptions = DataTransformer | CombinedDataTransformer;
  * - https://github.com/trpc/trpc/issues/4130
  */
 export type ClientDataTransformerOptions =
-  | DataTransformer
-  | CombinedDataTransformerClient;
+  | CombinedDataTransformerClient
+  | DataTransformer;
 
 /**
  * @internal

package/src/types.ts

@@ -3,10 +3,11 @@
  */
 export type identity<TType> = TType;
 
-export type InferOptional<TType, TKeys extends keyof TType> = Partial<
-  Pick<TType, TKeys>
+export type InferOptional<TType, TKeys extends keyof TType> = Omit<
+  TType,
+  TKeys
 > &
-  Omit<TType, TKeys>;
+  Partial<Pick<TType, TKeys>>;
 
 export type UndefinedKeys<TType> = {
   [K in keyof TType]: undefined extends TType[K] ? K : never;
@@ -17,7 +18,7 @@ export type UndefinedKeys<TType> = {
  */
 export type FlatOverwrite<TType, TWith> = InferOptional<
   {
-    [TKey in keyof TWith | keyof TType]: TKey extends keyof TWith
+    [TKey in keyof TType | keyof TWith]: TKey extends keyof TWith
       ? TWith[TKey]
       : TKey extends keyof TType
       ? TType[TKey]
@@ -38,12 +39,12 @@ export type IntersectionError<TKey extends string> =
 export type ProtectedIntersection<TType, TWith> = keyof TType &
   keyof TWith extends never
   ? TType & TWith
-  : IntersectionError<keyof TType & keyof TWith & string>;
+  : IntersectionError<string & keyof TType & keyof TWith>;
 
 /**
  * @public
  */
-export type Maybe<TType> = TType | undefined | null;
+export type Maybe<TType> = TType | null | undefined;
 
 /**
  * @internal
@@ -67,7 +68,7 @@ export type Dict<TType> = Record<string, TType | undefined>;
 /**
  * @public
  */
-export type MaybePromise<TType> = TType | Promise<TType>;
+export type MaybePromise<TType> = Promise<TType> | TType;
 
 /**
  * @internal