Error Formatting (v11)

The error formatting in your router will be inferred all the way to your client.

Usage example highlighted

Adding custom formatting

server.ts

import { const initTRPC: TRPCBuilder<object, object>initTRPC } from '@trpc/server';
import { interface ZodError<T = unknown>
const ZodError: $constructor<ZodError<unknown>, $ZodIssue[]>ZodError } from 'zod';

export const const t: TRPCRootObject<object, object, {
    errorFormatter(opts: ErrorFormatterOptions<object | undefined>): {
        data: {
            zodError: $ZodFlattenedError<unknown, string> | null;
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    };
}, {
    ctx: object;
    meta: object;
    errorShape: {
        data: {
            zodError: $ZodFlattenedError<unknown, string> | null;
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    };
    transformer: false;
}>t = const initTRPC: TRPCBuilder<object, object>initTRPC.TRPCBuilder<object, object>.create<{
    errorFormatter(opts: ErrorFormatterOptions<object | undefined>): {
        data: {
            zodError: $ZodFlattenedError<unknown, string> | null;
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    };
}>(opts?: {
    errorFormatter(opts: ErrorFormatterOptions<object | undefined>): {
        data: {
            zodError: $ZodFlattenedError<unknown, string> | null;
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    };
} | undefined): TRPCRootObject<...>create({
  function errorFormatter(opts: ErrorFormatterOptions<object | undefined>): {
    data: {
        zodError: $ZodFlattenedError<unknown, string> | null;
        code: TRPC_ERROR_CODE_KEY;
        httpStatus: number;
        path?: string;
        stack?: string;
    };
    message: string;
    code: TRPC_ERROR_CODE_NUMBER;
}errorFormatter(opts: ErrorFormatterOptions<object | undefined>opts) {
    const { const shape: DefaultErrorShapeshape, const error: TRPCErrorerror } = opts: ErrorFormatterOptions<object | undefined>opts;
    return {
      ...const shape: DefaultErrorShapeshape,
      data: {
    zodError: $ZodFlattenedError<unknown, string> | null;
    code: TRPC_ERROR_CODE_KEY;
    httpStatus: number;
    path?: string;
    stack?: string;
}data: {
        ...const shape: DefaultErrorShapeshape.TRPCErrorShape<DefaultErrorData>.data: DefaultErrorDatadata,
        zodError: $ZodFlattenedError<unknown, string> | nullzodError:
          const error: TRPCErrorerror.TRPCError.code: "BAD_GATEWAY" | "BAD_REQUEST" | "CLIENT_CLOSED_REQUEST" | "CONFLICT" | "FORBIDDEN" | "GATEWAY_TIMEOUT" | "INTERNAL_SERVER_ERROR" | "METHOD_NOT_SUPPORTED" | "NOT_FOUND" | "NOT_IMPLEMENTED" | "PARSE_ERROR" | "PAYLOAD_TOO_LARGE" | "PAYMENT_REQUIRED" | "PRECONDITION_FAILED" | "PRECONDITION_REQUIRED" | "SERVICE_UNAVAILABLE" | "TIMEOUT" | "TOO_MANY_REQUESTS" | "UNAUTHORIZED" | "UNPROCESSABLE_CONTENT" | "UNSUPPORTED_MEDIA_TYPE"code === 'BAD_REQUEST' && const error: TRPCErrorerror.TRPCError.cause?: Error | undefinedcause instanceof const ZodError: $constructor<ZodError<unknown>, $ZodIssue[]>ZodError
            ? const error: TRPCErrorerror.TRPCError.cause?: ZodError<unknown>cause.ZodError<unknown>.flatten(): $ZodFlattenedError<unknown, string> (+1 overload)flatten()
            : null,
      },
    };
  },
});

Usage in React

components/MyComponent.tsx

import { function useEffect(effect: React.EffectCallback, deps?: React.DependencyList): voiduseEffect } from 'react';
import { const trpc: CreateTRPCReactBase<BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: {
        data: {
            zodError: $ZodFlattenedError<unknown, string> | null;
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    };
    transformer: false;
}, DecorateCreateRouterOptions<{
    addPost: MutationProcedure<{
        input: {
            title: string;
        };
        output: {
            title: string;
        };
        meta: object;
        errorShape: {
            data: {
                zodError: $ZodFlattenedError<unknown, string> | null;
                code: TRPC_ERROR_CODE_KEY;
                httpStatus: number;
                path?: string;
                stack?: string;
            };
            message: string;
            code: TRPC_ERROR_CODE_NUMBER;
        };
    }>;
}>>, unknown> & DecorateRouterRecord<...>trpc } from '../utils/trpc';

export function function MyComponent(): React.JSX.ElementMyComponent() {
  const const mutation: UseTRPCMutationResult<{
    title: string;
}, TRPCClientErrorLike<{
    input: {
        title: string;
    };
    output: {
        title: string;
    };
    transformer: false;
    errorShape: {
        data: {
            zodError: $ZodFlattenedError<unknown, string> | null;
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    };
}>, {
    title: string;
}, unknown>mutation = const trpc: CreateTRPCReactBase<BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: {
        data: {
            zodError: $ZodFlattenedError<unknown, string> | null;
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    };
    transformer: false;
}, DecorateCreateRouterOptions<{
    addPost: MutationProcedure<{
        input: {
            title: string;
        };
        output: {
            title: string;
        };
        meta: object;
        errorShape: {
            data: {
                zodError: $ZodFlattenedError<unknown, string> | null;
                code: TRPC_ERROR_CODE_KEY;
                httpStatus: number;
                path?: string;
                stack?: string;
            };
            message: string;
            code: TRPC_ERROR_CODE_NUMBER;
        };
    }>;
}>>, unknown> & DecorateRouterRecord<...>trpc.addPost: DecoratedMutation<{
    input: {
        title: string;
    };
    output: {
        title: string;
    };
    transformer: false;
    errorShape: {
        data: {
            zodError: $ZodFlattenedError<unknown, string> | null;
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    };
}>addPost.useMutation: <unknown>(opts?: UseTRPCMutationOptions<{
    title: string;
}, TRPCClientErrorLike<{
    input: {
        title: string;
    };
    output: {
        title: string;
    };
    transformer: false;
    errorShape: {
        data: {
            zodError: $ZodFlattenedError<unknown, string> | null;
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    };
}>, {
    title: string;
}, unknown> | undefined) => UseTRPCMutationResult<{
    title: string;
}, TRPCClientErrorLike<...>, {
    title: string;
}, unknown>useMutation();

  function useEffect(effect: React.EffectCallback, deps?: React.DependencyList): voiduseEffect(() => {
    const mutation: UseTRPCMutationResult<{
    title: string;
}, TRPCClientErrorLike<{
    input: {
        title: string;
    };
    output: {
        title: string;
    };
    transformer: false;
    errorShape: {
        data: {
            zodError: $ZodFlattenedError<unknown, string> | null;
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    };
}>, {
    title: string;
}, unknown>mutation.mutate: (variables: {
    title: string;
}, options?: MutateOptions<{
    title: string;
}, TRPCClientErrorLike<{
    input: {
        title: string;
    };
    output: {
        title: string;
    };
    transformer: false;
    errorShape: {
        data: {
            zodError: $ZodFlattenedError<unknown, string> | null;
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    };
}>, {
    title: string;
}, unknown> | undefined) => voidmutate({ title: stringtitle: 'example' });
  }, []);

  if (const mutation: UseTRPCMutationResult<{
    title: string;
}, TRPCClientErrorLike<{
    input: {
        title: string;
    };
    output: {
        title: string;
    };
    transformer: false;
    errorShape: {
        data: {
            zodError: $ZodFlattenedError<unknown, string> | null;
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    };
}>, {
    title: string;
}, unknown>mutation.error: TRPCClientErrorLike<{
    input: {
        title: string;
    };
    output: {
        title: string;
    };
    transformer: false;
    errorShape: {
        data: {
            zodError: $ZodFlattenedError<unknown, string> | null;
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    };
}> | nullerror?.TRPCClientErrorBase<{ data: { zodError: $ZodFlattenedError<unknown, string> | null; code: TRPC_ERROR_CODE_KEY; httpStatus: number; path?: string; stack?: string; }; message: string; code: TRPC_ERROR_CODE_NUMBER; }>.data: Maybe<{
    zodError: $ZodFlattenedError<unknown, string> | null;
    code: TRPC_ERROR_CODE_KEY;
    httpStatus: number;
    path?: string;
    stack?: string;
}>data?.zodError: $ZodFlattenedError<unknown, string> | null | undefinedzodError) {
    // zodError will be inferred
    return (
      <React.JSX.IntrinsicElements.pre: React.DetailedHTMLProps<React.HTMLAttributes<HTMLPreElement>, HTMLPreElement>pre>Error: {var JSON: JSONJSON.JSON.stringify(value: any, replacer?: (number | string)[] | null, space?: string | number): string (+1 overload)stringify(const mutation: TRPCHookResult & Override<MutationObserverErrorResult<{
    title: string;
}, TRPCClientErrorLike<{
    input: {
        title: string;
    };
    output: {
        title: string;
    };
    transformer: false;
    errorShape: {
        data: {
            zodError: $ZodFlattenedError<unknown, string> | null;
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    };
}>, {
    title: string;
}, unknown>, {
    ...;
}> & {
    ...;
}mutation.error: TRPCClientErrorLike<{
    input: {
        title: string;
    };
    output: {
        title: string;
    };
    transformer: false;
    errorShape: {
        data: {
            zodError: $ZodFlattenedError<unknown, string> | null;
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    };
}>error.TRPCClientErrorBase<{ data: { zodError: $ZodFlattenedError<unknown, string> | null; code: TRPC_ERROR_CODE_KEY; httpStatus: number; path?: string; stack?: string; }; message: string; code: TRPC_ERROR_CODE_NUMBER; }>.data: {
    zodError: $ZodFlattenedError<unknown, string> | null;
    code: TRPC_ERROR_CODE_KEY;
    httpStatus: number;
    path?: string;
    stack?: string;
}data.zodError: $ZodFlattenedError<unknown, string>zodError, null, 2)}</React.JSX.IntrinsicElements.pre: React.DetailedHTMLProps<React.HTMLAttributes<HTMLPreElement>, HTMLPreElement>pre>
    );
  }
  return <>[...]</>;
}

Per-procedure error formatting

Errors can be formatted on a per-procedure basis using the .errors() method, which can be chained to produce a union of possible error shapes for each procedure.

When a middleware or procedure throws an error, it bubbles upward through all .errors() handlers until one returns a shape or the global errorFormatter is reached.

server.ts

const const rateLimitedProcedure: ProcedureBuilder<object, object, {}, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, FoldErrorShape<DefaultErrorShape, {
    data: {
        kind: "RATE_LIMIT";
        code: TRPC_ERROR_CODE_KEY;
        httpStatus: number;
        path?: string;
        stack?: string;
    };
    message: string;
    code: TRPC_ERROR_CODE_NUMBER;
} | undefined>>rateLimitedProcedure = const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>t.TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.procedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>procedure
  .ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.errors<{
    data: {
        kind: "RATE_LIMIT";
        code: TRPC_ERROR_CODE_KEY;
        httpStatus: number;
        path?: string;
        stack?: string;
    };
    message: string;
    code: TRPC_ERROR_CODE_NUMBER;
} | undefined>(formatter: ProcedureErrorFormatter<object, object, {
    data: {
        kind: "RATE_LIMIT";
        code: TRPC_ERROR_CODE_KEY;
        httpStatus: number;
        path?: string;
        stack?: string;
    };
    message: string;
    code: TRPC_ERROR_CODE_NUMBER;
} | undefined>): ProcedureBuilder<...>errors((opts: ErrorFormatterOptions<{}>opts) => {
    if (opts: ErrorFormatterOptions<{}>opts.ErrorFormatterOptions<{}>.error: TRPCErrorerror.TRPCError.cause?: Error | undefinedcause instanceof class RateLimitErrorRateLimitError) {
      return {
        ...opts: ErrorFormatterOptions<{}>opts.ErrorFormatterOptions<{}>.shape: DefaultErrorShapeshape,
        data: {
    kind: "RATE_LIMIT";
    code: TRPC_ERROR_CODE_KEY;
    httpStatus: number;
    path?: string;
    stack?: string;
}data: { ...opts: ErrorFormatterOptions<{}>opts.ErrorFormatterOptions<{}>.shape: DefaultErrorShapeshape.TRPCErrorShape<DefaultErrorData>.data: DefaultErrorDatadata, kind: "RATE_LIMIT"kind: 'RATE_LIMIT' as type const = "RATE_LIMIT"const },
      };
    }
    return var undefinedundefined;
  })
  .ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, FoldErrorShape<DefaultErrorShape, { ...; } | undefined>>.use<object>(fn: MiddlewareBuilder<{}, object, object, UnsetMarker> | MiddlewareFunction<object, object, object, object, UnsetMarker>): ProcedureBuilder<object, object, {}, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, FoldErrorShape<DefaultErrorShape, {
    data: {
        kind: "RATE_LIMIT";
        code: TRPC_ERROR_CODE_KEY;
        httpStatus: number;
        path?: string;
        stack?: string;
    };
    message: string;
    code: TRPC_ERROR_CODE_NUMBER;
} | undefined>>use(opts: {
    ctx: {};
    type: ProcedureType;
    path: string;
    input: UnsetMarker;
    getRawInput: GetRawInputFn;
    meta: object | undefined;
    signal: AbortSignal | undefined;
    batchIndex: number;
    next: {
        (): Promise<MiddlewareResult<object>>;
        <$ContextOverride>(opts: {
            ctx?: $ContextOverride | undefined;
            input?: unknown;
        }): Promise<MiddlewareResult<$ContextOverride>>;
        (opts: {
            getRawInput: GetRawInputFn;
        }): Promise<...>;
    };
}opts => {
    // Important: errors bubble up so a throwing middleware must come after the .errors() handler
    if (function isRateLimited(opts: any): booleanisRateLimited(opts: {
    ctx: {};
    type: ProcedureType;
    path: string;
    input: UnsetMarker;
    getRawInput: GetRawInputFn;
    meta: object | undefined;
    signal: AbortSignal | undefined;
    batchIndex: number;
    next: {
        (): Promise<MiddlewareResult<object>>;
        <$ContextOverride>(opts: {
            ctx?: $ContextOverride | undefined;
            input?: unknown;
        }): Promise<MiddlewareResult<$ContextOverride>>;
        (opts: {
            getRawInput: GetRawInputFn;
        }): Promise<...>;
    };
}opts)) {
      throw new constructor RateLimitError(message?: string, options?: ErrorOptions): RateLimitError (+1 overload)RateLimitError();
    }

    return opts: {
    ctx: {};
    type: ProcedureType;
    path: string;
    input: UnsetMarker;
    getRawInput: GetRawInputFn;
    meta: object | undefined;
    signal: AbortSignal | undefined;
    batchIndex: number;
    next: {
        (): Promise<MiddlewareResult<object>>;
        <$ContextOverride>(opts: {
            ctx?: $ContextOverride | undefined;
            input?: unknown;
        }): Promise<MiddlewareResult<$ContextOverride>>;
        (opts: {
            getRawInput: GetRawInputFn;
        }): Promise<...>;
    };
}opts.next: () => Promise<MiddlewareResult<object>> (+2 overloads)next();
  });

const const billedProcedure: ProcedureBuilder<object, object, {}, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, FoldErrorShape<FoldErrorShape<DefaultErrorShape, {
    data: {
        kind: "RATE_LIMIT";
        code: TRPC_ERROR_CODE_KEY;
        httpStatus: number;
        path?: string;
        stack?: string;
    };
    message: string;
    code: TRPC_ERROR_CODE_NUMBER;
} | undefined>, {
    data: {
        kind: "PAYMENT_REQUIRED";
        amountDue: number;
        code: TRPC_ERROR_CODE_KEY;
        httpStatus: number;
        path?: string;
        stack?: string;
    };
    message: string;
    code: TRPC_ERROR_CODE_NUMBER;
} | undefined>>billedProcedure = const rateLimitedProcedure: ProcedureBuilder<object, object, {}, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, FoldErrorShape<DefaultErrorShape, {
    data: {
        kind: "RATE_LIMIT";
        code: TRPC_ERROR_CODE_KEY;
        httpStatus: number;
        path?: string;
        stack?: string;
    };
    message: string;
    code: TRPC_ERROR_CODE_NUMBER;
} | undefined>>rateLimitedProcedure
  .ProcedureBuilder<object, object, {}, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, FoldErrorShape<DefaultErrorShape, { ...; } | undefined>>.errors<{
    data: {
        kind: "PAYMENT_REQUIRED";
        amountDue: number;
        code: TRPC_ERROR_CODE_KEY;
        httpStatus: number;
        path?: string;
        stack?: string;
    };
    message: string;
    code: TRPC_ERROR_CODE_NUMBER;
} | undefined>(formatter: ProcedureErrorFormatter<object, {}, {
    data: {
        kind: "PAYMENT_REQUIRED";
        amountDue: number;
        code: TRPC_ERROR_CODE_KEY;
        httpStatus: number;
        path?: string;
        stack?: string;
    };
    message: string;
    code: TRPC_ERROR_CODE_NUMBER;
} | undefined>): ProcedureBuilder<...>errors((opts: ErrorFormatterOptions<{}>opts) => {
    if (opts: ErrorFormatterOptions<{}>opts.ErrorFormatterOptions<TContext>.error: TRPCErrorerror.TRPCError.cause?: Error | undefinedcause instanceof class PaymentRequiredErrorPaymentRequiredError) {
      return {
        ...opts: ErrorFormatterOptions<{}>opts.ErrorFormatterOptions<TContext>.shape: DefaultErrorShapeshape,
        data: {
    kind: "PAYMENT_REQUIRED";
    amountDue: number;
    code: TRPC_ERROR_CODE_KEY;
    httpStatus: number;
    path?: string;
    stack?: string;
}data: {
          ...opts: ErrorFormatterOptions<{}>opts.ErrorFormatterOptions<TContext>.shape: DefaultErrorShapeshape.TRPCErrorShape<DefaultErrorData>.data: DefaultErrorDatadata,
          kind: "PAYMENT_REQUIRED"kind: 'PAYMENT_REQUIRED' as type const = "PAYMENT_REQUIRED"const,
          amountDue: numberamountDue: opts: ErrorFormatterOptions<{}>opts.ErrorFormatterOptions<TContext>.error: TRPCErrorerror.TRPCError.cause?: PaymentRequiredErrorcause.PaymentRequiredError.amountDue: numberamountDue,
        },
      };
    }
    return var undefinedundefined;
  });

const const addPostProcedure: MutationProcedure<{
    input: void;
    output: {
        success: boolean;
    };
    meta: object;
    errorShape: FoldErrorShape<FoldErrorShape<DefaultErrorShape, {
        data: {
            kind: "RATE_LIMIT";
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    } | undefined>, {
        data: {
            kind: "PAYMENT_REQUIRED";
            amountDue: number;
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    } | undefined>;
}>addPostProcedure = const billedProcedure: ProcedureBuilder<object, object, {}, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, FoldErrorShape<FoldErrorShape<DefaultErrorShape, {
    data: {
        kind: "RATE_LIMIT";
        code: TRPC_ERROR_CODE_KEY;
        httpStatus: number;
        path?: string;
        stack?: string;
    };
    message: string;
    code: TRPC_ERROR_CODE_NUMBER;
} | undefined>, {
    data: {
        kind: "PAYMENT_REQUIRED";
        amountDue: number;
        code: TRPC_ERROR_CODE_KEY;
        httpStatus: number;
        path?: string;
        stack?: string;
    };
    message: string;
    code: TRPC_ERROR_CODE_NUMBER;
} | undefined>>billedProcedure.ProcedureBuilder<object, object, {}, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, FoldErrorShape<FoldErrorShape<DefaultErrorShape, { ...; } | undefined>, { ...; } | undefined>>.mutation<{
    success: boolean;
}>(resolver: ProcedureResolver<object, object, {}, UnsetMarker, UnsetMarker, {
    success: boolean;
}>): MutationProcedure<{
    input: void;
    output: {
        success: boolean;
    };
    meta: object;
    errorShape: FoldErrorShape<FoldErrorShape<DefaultErrorShape, {
        data: {
            kind: "RATE_LIMIT";
            code: TRPC_ERROR_CODE_KEY;
            httpStatus: number;
            path?: string;
            stack?: string;
        };
        message: string;
        code: TRPC_ERROR_CODE_NUMBER;
    } | undefined>, {
        ...;
    } | undefined>;
}>mutation(opts: ProcedureResolverOptions<object, object, {}, UnsetMarker>opts => {
  if (function isPaymentRequired(opts: any): booleanisPaymentRequired(opts: ProcedureResolverOptions<object, object, {}, UnsetMarker>opts)) {
    throw new constructor PaymentRequiredError(amountDue: number): PaymentRequiredErrorPaymentRequiredError(100);
  }

  return {
    success: booleansuccess: true,
  };
});

All properties sent to `errorFormatter()`

tRPC is compliant with JSON-RPC 2.0

interface ErrorFormatterOpts {
  ErrorFormatterOpts.error: TRPCErrorerror: class TRPCErrorTRPCError;
  ErrorFormatterOpts.type: "query" | "mutation" | "subscription" | "unknown"type: 'query' | 'mutation' | 'subscription' | 'unknown';
  ErrorFormatterOpts.path: string | undefinedpath: string | undefined;
  ErrorFormatterOpts.input: unknowninput: unknown;
  ErrorFormatterOpts.ctx: unknownctx: unknown;
  ErrorFormatterOpts.shape: {
    message: string;
    code: number;
    data: unknown;
}shape: { message: stringmessage: string; code: numbercode: number; data: unknowndata: unknown };
}

DefaultErrorShape:

type type DefaultErrorData = {
    code: TRPC_ERROR_CODE_KEY;
    httpStatus: number;
    path?: string;
    stack?: string;
}DefaultErrorData = {
  code: "PARSE_ERROR" | "BAD_REQUEST" | "INTERNAL_SERVER_ERROR" | "NOT_IMPLEMENTED" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "GATEWAY_TIMEOUT" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_SUPPORTED" | "TIMEOUT" | "CONFLICT" | "PRECONDITION_FAILED" | "PAYLOAD_TOO_LARGE" | "UNSUPPORTED_MEDIA_TYPE" | "UNPROCESSABLE_CONTENT" | "PRECONDITION_REQUIRED" | "TOO_MANY_REQUESTS" | "CLIENT_CLOSED_REQUEST"code: type TRPC_ERROR_CODE_KEY = "PARSE_ERROR" | "BAD_REQUEST" | "INTERNAL_SERVER_ERROR" | "NOT_IMPLEMENTED" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "GATEWAY_TIMEOUT" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_SUPPORTED" | "TIMEOUT" | "CONFLICT" | "PRECONDITION_FAILED" | "PAYLOAD_TOO_LARGE" | "UNSUPPORTED_MEDIA_TYPE" | "UNPROCESSABLE_CONTENT" | "PRECONDITION_REQUIRED" | "TOO_MANY_REQUESTS" | "CLIENT_CLOSED_REQUEST"TRPC_ERROR_CODE_KEY;
  httpStatus: numberhttpStatus: number;
  /**
   * Path to the procedure that threw the error
   */
  path?: string | undefinedpath?: string;
  /**
   * Stack trace of the error (only in development)
   */
  stack?: string | undefinedstack?: string;
};

interface DefaultErrorShape {
  DefaultErrorShape.message: stringmessage: string;
  DefaultErrorShape.code: TRPC_ERROR_CODE_NUMBERcode: type TRPC_ERROR_CODE_NUMBER = -32700 | -32600 | -32603 | -32001 | -32002 | -32003 | -32004 | -32005 | -32008 | -32009 | -32012 | -32013 | -32015 | -32022 | -32028 | -32029 | -32099TRPC_ERROR_CODE_NUMBER;
  DefaultErrorShape.data: DefaultErrorDatadata: type DefaultErrorData = {
    code: TRPC_ERROR_CODE_KEY;
    httpStatus: number;
    path?: string;
    stack?: string;
}DefaultErrorData;
}