Advanced TypeScript Patterns for Scale

// Prevent mixing different ID types
type UserId = string & { readonly __brand: unique symbol };
type OrderId = string & { readonly __brand: unique symbol };

function createUserId(id: string): UserId {
  return id as UserId;
}

// This prevents accidentally passing wrong ID types
function getOrder(userId: UserId, orderId: OrderId) {
  // Implementation
}

// Extract promise return types
type Awaited<T> = T extends Promise<infer U> ? U : T;

// Create type-safe API response handlers
type ApiResponse<T> = {
  success: true;
  data: T;
} | {
  success: false;
  error: string;
};

type ExtractData<T> = T extends ApiResponse<infer U> ? U : never;

// Type-safe API route generation
type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
type ApiRoute = `/api/${string}`;
type ApiEndpoint<M extends HttpMethod, R extends ApiRoute> = `${M} ${R}`;

// Usage
type UserRoutes =
  | ApiEndpoint<'GET', '/api/users'>
  | ApiEndpoint<'POST', '/api/users'>
  | ApiEndpoint<'PUT', '/api/users/:id'>;

interface Repository<T, K = string> {
  findById(id: K): Promise<T | null>;
  save(entity: T): Promise<T>;
  delete(id: K): Promise<void>;
}

class UserRepository implements Repository<User, UserId> {
  // Type-safe implementation
}

type DomainEvent<T extends string, P = {}> = {
  type: T;
  payload: P;
  timestamp: Date;
};

type UserEvents =
  | DomainEvent<'user.created', { userId: UserId }>
  | DomainEvent<'user.updated', { userId: UserId; changes: Partial<User> }>;

// Type-safe event handlers
type EventHandler<T extends DomainEvent<string, any>> = (event: T) => Promise<void>;

// Avoid importing heavy types in hot paths
type LazyUser = () => Promise<import('./user-types').User>;

// More efficient than regular arrays/objects
const statuses = ['pending', 'completed', 'failed'] as const;
type Status = typeof statuses[number]; // Union type