How to get errors from call utility in unit tests?

[ahmafi]

I'm trying something like this in my tests:

            try {
                const data = await call(appRouter.auth.checkUsername, {
                    username,
                });
            } catch (error) {
                if (isDefinedError(error)) {
                    // error is unknown here
                }
            }

But the error doesn't have a type. What else can I do?

[dosubot[bot]]

To get type-safe errors from the call utility in your unit tests, you can cast the caught error using the utility types from @orpc/contract. Specifically, use ErrorFromErrorMap<InferContractRouterErrorMap<typeof appRouter>>. Combine this with your isDefinedError guard for safe narrowing. Example:

import { InferContractRouterErrorMap, ErrorFromErrorMap } from '@orpc/contract';

try {
  const data = await call(appRouter.sellers.auth.checkUsername, { username });
} catch (e) {
  const error = e as ErrorFromErrorMap<InferContractRouterErrorMap<typeof appRouter>>;
  if (isDefinedError(error)) {
    // error is now properly typed here
    // you can access error.code, error.message, etc.
  }
}

This approach works as long as your router does not use lazy routers. The error will be either a contract-defined error or a generic throwable error, matching the contract's error map structure. More details and examples are available in the official discussion.

To reply, just mention @dosu.

---

^{How did I do? Good | Irrelevant | Incorrect | Verbose | Hallucination | Report 🐛 | Other}    

[ahmafi]

I'm not using @orpc/contract. It's on the server using call from @orpc/server.

[dosubot[bot]]

You don't need @orpc/contract to get typed errors from call in @orpc/server tests. The server package re-exports both isDefinedError and ORPCError from @orpc/client, so you can use these for error narrowing and type access. The error thrown by call is typed as ErrorFromErrorMap<TErrorMap> (based on your procedure's error map), but TypeScript's catch infers unknown, so you need to use a guard or cast.

Here's a pattern you can use:

import { call, isDefinedError, ORPCError } from '@orpc/server';

try {
  await call(appRouter.auth.checkUsername, { username });
} catch (error) {
  if (isDefinedError(error)) {
    // error is now narrowed to ORPCError
    // you can access error.code, error.message, error.data, etc.
    if (error instanceof ORPCError) {
      // Optionally, further type narrowing
      console.log(error.code, error.message);
    }
  }
}

This approach works for both runtime checks and type narrowing in tests, since isDefinedError and ORPCError are always available from @orpc/server cite. The error object will have properties like code, status, message, data, and defined cite.

If you want even more type safety, you can cast the error to ORPCError after the guard.

To reply, just mention @dosu.

---

^{How did I do? Good | Irrelevant | Incorrect | Verbose | Hallucination | Report 🐛 | Other}    

[unnoq]

Because of TypeScript’s limitations with try/catch, it's impossible to achieve type safety. You must use the safe utility instead.