Mastering TypeScript Conditional Types for Smarter Error Handling

Error handling is a crucial part of building robust applications. TypeScript's type system offers powerful features to make error handling more predictable and safer. One such feature is conditional types, which allow you to create types that change based on conditions. In this article, we'll explore how to use conditional types to build smarter error handling solutions that can help catch mistakes during compile time.

Conditional types in TypeScript work like a ternary operator for types: they choose different types depending on a condition. The syntax looks like this:

type Example<T> = T extends string ? "It's a string" : "It's something else";

Here, if the generic type `T` is a `string`, the type resolves to "It's a string"; otherwise, it resolves to "It's something else". This flexibility becomes especially useful when handling different error conditions.

Let's create a practical example. Imagine you have a function `fetchData` that either returns data or throws an error. We want to type the function so that the error type depends on the kind of data expected.

type FetchError<T> = T extends { id: number } ? { code: number; message: string } : { message: string };

function fetchData<T>(shouldFail: boolean): T | FetchError<T> {
  if (shouldFail) {
    if (({} as T).hasOwnProperty && ({} as T).hasOwnProperty('id')) {
      return { code: 404, message: 'Not Found' } as FetchError<T>;
    } else {
      return { message: 'Error occurred' } as FetchError<T>;
    }
  }

  // Assuming data fetched successfully
  return {} as T;
}

In this example, `FetchError` uses a conditional type: if `T` has an `id` property (like an object with an `id` number), the error includes a `code` and `message`; otherwise, it just has a `message`. This makes error handling more specific to the expected data.

You can also use conditional types to create utility types that extract or transform error information. For example, let's create a type that picks only the `message` from any error type:

type ErrorMessage<T> = T extends { message: infer M } ? M : never;

// Usage example

type MyError = { code: number; message: string };
type Msg = ErrorMessage<MyError>; // Msg is string

This helps write error handling code that can safely access error messages without worrying about the full error structure.

In summary, conditional types help you create flexible and precise error types that adapt to your data structures. This leads to better error checking and improved reliability in your TypeScript applications.

To master error handling with conditional types, start incorporating conditions into your error type definitions, and leverage TypeScript's powerful inference capabilities to tailor your error types effectively.