Advanced TypeScript Tricks to Improve Your Codebase

Ever felt like you’re just scratching the surface of TypeScript? Let’s dive deep into some advanced techniques that will take your codebase to the next level. These aren’t just your everyday tips – they’re battle-tested strategies I’ve gathered from years of working with TypeScript in production environments.

1. Leveraging Discriminated Unions

One of TypeScript’s most powerful features is its ability to handle complex type relationships. Discriminated unions are game-changers when dealing with related but distinct types.

type Success = {
  status: 'success';
  data: string[];
};

type Error = {
  status: 'error';
  message: string;
};

type Response = Success | Error;

function handleResponse(response: Response) {
  if (response.status === 'success') {
    // TypeScript knows response.data exists here
    response.data.map(item => console.log(item));
  } else {
    // TypeScript knows response.message exists here
    console.error(response.message);
  }
}

2. Template Literal Types

Template literal types are like string templates but at the type level. They’re incredibly useful for creating precise string-based types.

type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
type APIEndpoint = '/users' | '/posts' | '/comments';
type ValidRequest = `${HTTPMethod} ${APIEndpoint}`;

// Type-safe API requests
function makeRequest(request: ValidRequest) {
  // Only valid combinations are allowed
}

makeRequest('GET /users');     // Valid
makeRequest('POST /invalid');  // Error!

3. Conditional Types and infer

The infer keyword, combined with conditional types, lets us extract types from other types. It’s like pattern matching for types:

type UnwrapPromise\<T\> = T extends Promise<infer U> ? U : T;

// Example usage
type PromiseString = Promise<string>;
type ExtractedString = UnwrapPromise<PromiseString>; // string

4. Mapped Types with Key Remapping

Take your mapped types to the next level with key remapping. This feature lets you transform both the keys and values of your types:

type Getters\<T\> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
};

interface Person {
  name: string;
  age: number;
}

type PersonGetters = Getters<Person>;
// {
//   getName: () => string;
//   getAge: () => number;
// }

5. Using const Assertions

The as const assertion can make your objects immutable and their types more specific:

const config = {
  endpoint: 'api.example.com',
  version: 'v1',
  features: ['auth', 'messages'] as const
} as const;

// Now config.features is readonly ['auth', 'messages']
// Instead of string[]

Conclusion

These TypeScript features might seem advanced at first, but they’re invaluable tools for building more maintainable and type-safe applications. Start incorporating them gradually into your codebase, and you’ll see the benefits of stronger type checking and better developer experience.