Advanced TypeScript Patterns for Enterprise Applications

TypeScript has become the go-to choice for enterprise applications due to its type safety and developer experience. In this article, we'll explore advanced patterns that can help you build maintainable, scalable enterprise applications.

1. Utility Types for API Responses

Create type-safe API response handlers:

interface User {
  id: string;
  name: string;
  email: string;
  createdAt: Date;
}

type CreateUserRequest = Pick<User, 'name' | 'email'>;
type UpdateUserRequest = Partial<Pick<User, 'name' | 'email'>>;
type UserResponse = Omit<User, 'createdAt'> & {
  createdAt: string;
};

2. Conditional Types for Better APIs

Build flexible, type-safe APIs:

type ApiResponse<T, E = string> = 
  | { success: true; data: T }
  | { success: false; error: E };

async function fetchUser<T extends boolean>(
  id: string,
  includeMetadata?: T
): Promise<ApiResponse<T extends true ? UserWithMetadata : User>> {
  // Implementation
}

3. Template Literal Types

Create powerful string manipulation types:

type EventName<T extends string> = `on${Capitalize<T>}`;
type ComponentProps<T extends string> = {
  [K in EventName<T>]?: () => void;
};

// Usage: { onClick?: () => void; onHover?: () => void; }
type ButtonProps = ComponentProps<'click' | 'hover'>;

4. Design Patterns

Repository Pattern with Generics

interface Repository<T, K = string> {
  findById(id: K): Promise<T | null>;
  create(entity: Omit<T, 'id'>): Promise<T>;
  update(id: K, updates: Partial<T>): Promise<T>;
  delete(id: K): Promise<void>;
}

class UserRepository implements Repository<User> {
  // Implementation
}

Conclusion

These advanced TypeScript patterns provide the foundation for building robust, maintainable enterprise applications that scale with your team and requirements.