Advanced TypeScript Patterns for Enterprise Applications

In enterprise environments, we manage TypeScript codebases with millions of lines of code. These advanced patterns have proven essential for maintaining type safety, developer productivity, and code quality at enterprise scale.

1. Advanced Utility Types

// Custom utility types used in enterprise applications

// DeepPartial - Make all properties optional recursively
type DeepPartial = {
  [P in keyof T]?: T[P] extends object ? DeepPartial : T[P];
};

// DeepReadonly - Make all properties readonly recursively
type DeepReadonly = {
  readonly [P in keyof T]: T[P] extends object ? DeepReadonly : T[P];
};

// PickByType - Pick properties by their type
type PickByType = {
  [K in keyof T as T[K] extends U ? K : never]: T[K];
};

// OmitByType - Omit properties by their type
type OmitByType = {
  [K in keyof T as T[K] extends U ? never : K]: T[K];
};

// Example usage in enterprise user management system
interface User {
  id: string;
  name: string;
  email: string;
  createdAt: Date;
  updatedAt: Date;
  isActive: boolean;
  permissions: string[];
  metadata: {
    lastLogin: Date;
    loginCount: number;
    preferences: {
      theme: 'light' | 'dark';
      language: string;
    };
  };
}

// Only date fields
type UserDates = PickByType; // { createdAt: Date; updatedAt: Date; }

// User without dates
type UserWithoutDates = OmitByType;

// Partial update payload
type UserUpdatePayload = DeepPartial>;

2. Conditional Types and Template Literals

// Advanced conditional types for API responses

// Extract array element type
type ArrayElement = T extends (infer U)[] ? U : T;

// Function return type extractor
type ReturnTypeOf = T extends (...args: any[]) => infer R ? R : never;

// Promise unwrapper
type Awaited = T extends Promise ? U : T;

// Template literal types for API endpoints
type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
type APIEndpoint = 'users' | 'orders' | 'products' | 'analytics';

type APIRoute = 
  `${Method} /api/v1/${Endpoint}`;

type UserRoutes = APIRoute<'GET' | 'POST', 'users'>; 
// "GET /api/v1/users" | "POST /api/v1/users"

// Dynamic key generation
type EventType = 'click' | 'hover' | 'focus';
type ElementType = 'button' | 'input' | 'div';

type EventHandler = 
  `on${Capitalize}${Capitalize}`;

type ButtonHandlers = EventHandler;
// "onClickButton" | "onHoverButton" | "onFocusButton"

// Enterprise API response wrapper
interface APIResponse {
  data: T;
  status: 'success' | 'error';
  message: string;
  timestamp: string;
}

// Type-safe API client
class TypeSafeAPIClient {
  async get(endpoint: string): Promise> {
    const response = await fetch(`/api/v1/${endpoint}`);
    return response.json();
  }

  async post(
    endpoint: string, 
    data: TRequest
  ): Promise> {
    const response = await fetch(`/api/v1/${endpoint}`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(data)
    });
    return response.json();
  }
}

3. Advanced Mapped Types

// Mapped types for form validation

// Make specific fields required
type RequireFields = T & Required>;

// Make specific fields optional
type OptionalFields = Omit & Partial>;

// Transform all properties to validation results
type ValidationResult = {
  [K in keyof T]: {
    value: T[K];
    isValid: boolean;
    errors: string[];
  };
};

// Transform properties to form field configs
type FormConfig = {
  [K in keyof T]: {
    label: string;
    placeholder?: string;
    required: boolean;
    validator: (value: T[K]) => boolean;
  };
};

// Enterprise form management system
interface UserRegistrationForm {
  email: string;
  password: string;
  confirmPassword: string;
  firstName: string;
  lastName: string;
  phoneNumber?: string;
  marketingConsent: boolean;
}

type UserFormValidation = ValidationResult;
type UserFormConfig = FormConfig;

// Generic form manager
class FormManager> {
  private values: Partial = {};
  private validation: Partial> = {};

  constructor(private config: FormConfig) {}

  setValue(field: K, value: T[K]): void {
    this.values[field] = value;
    this.validateField(field);
  }

  private validateField(field: K): void {
    const value = this.values[field];
    const fieldConfig = this.config[field];
    
    if (value !== undefined) {
      const isValid = fieldConfig.validator(value);
      this.validation[field] = {
        value,
        isValid,
        errors: isValid ? [] : [`Invalid ${String(field)}`]
      } as ValidationResult[K];
    }
  }

  getValidationState(): Partial> {
    return this.validation;
  }

  isFormValid(): boolean {
    return Object.values(this.validation).every(
      field => field?.isValid === true
    );
  }
}

4. Discriminated Unions and Type Guards

// Discriminated unions for enterprise event system

interface BaseEvent {
  id: string;
  timestamp: Date;
  userId: string;
}

interface UserLoginEvent extends BaseEvent {
  type: 'USER_LOGIN';
  payload: {
    ipAddress: string;
    userAgent: string;
    loginMethod: 'password' | 'oauth' | 'sso';
  };
}

interface UserLogoutEvent extends BaseEvent {
  type: 'USER_LOGOUT';
  payload: {
    sessionDuration: number;
  };
}

interface OrderCreatedEvent extends BaseEvent {
  type: 'ORDER_CREATED';
  payload: {
    orderId: string;
    amount: number;
    currency: string;
    items: Array<{
      productId: string;
      quantity: number;
      price: number;
    }>;
  };
}

interface PaymentProcessedEvent extends BaseEvent {
  type: 'PAYMENT_PROCESSED';
  payload: {
    paymentId: string;
    orderId: string;
    status: 'success' | 'failed' | 'pending';
    amount: number;
    paymentMethod: string;
  };
}

type SystemEvent = 
  | UserLoginEvent 
  | UserLogoutEvent 
  | OrderCreatedEvent 
  | PaymentProcessedEvent;

// Type guards for event handling
function isUserEvent(event: SystemEvent): event is UserLoginEvent | UserLogoutEvent {
  return event.type === 'USER_LOGIN' || event.type === 'USER_LOGOUT';
}

function isOrderEvent(event: SystemEvent): event is OrderCreatedEvent {
  return event.type === 'ORDER_CREATED';
}

function isPaymentEvent(event: SystemEvent): event is PaymentProcessedEvent {
  return event.type === 'PAYMENT_PROCESSED';
}

// Event processor with exhaustive type checking
class EventProcessor {
  processEvent(event: SystemEvent): void {
    switch (event.type) {
      case 'USER_LOGIN':
        this.handleUserLogin(event.payload);
        break;
      case 'USER_LOGOUT':
        this.handleUserLogout(event.payload);
        break;
      case 'ORDER_CREATED':
        this.handleOrderCreated(event.payload);
        break;
      case 'PAYMENT_PROCESSED':
        this.handlePaymentProcessed(event.payload);
        break;
      default:
        // TypeScript ensures this is never reached
        const exhaustiveCheck: never = event;
        throw new Error(`Unhandled event type: ${exhaustiveCheck}`);
    }
  }

  private handleUserLogin(payload: UserLoginEvent['payload']): void {
    console.log(`User login from ${payload.ipAddress} via ${payload.loginMethod}`);
  }

  private handleUserLogout(payload: UserLogoutEvent['payload']): void {
    console.log(`User logout after ${payload.sessionDuration}ms`);
  }

  private handleOrderCreated(payload: OrderCreatedEvent['payload']): void {
    console.log(`Order ${payload.orderId} created for ${payload.amount} ${payload.currency}`);
  }

  private handlePaymentProcessed(payload: PaymentProcessedEvent['payload']): void {
    console.log(`Payment ${payload.paymentId} ${payload.status}`);
  }
}

5. Generic Constraints and Higher-Order Types

// Advanced generics for enterprise data access layer

// Entity base interface
interface Entity {
  id: string;
  createdAt: Date;
  updatedAt: Date;
}

// Repository pattern with generic constraints
interface Repository {
  findById(id: string): Promise;
  findMany(criteria: Partial): Promise;
  create(data: Omit): Promise;
  update(id: string, data: Partial>): Promise;
  delete(id: string): Promise;
}

// Query builder with fluent interface
class QueryBuilder {
  private conditions: Array<(item: T) => boolean> = [];
  private sortBy?: keyof T;
  private sortOrder: 'asc' | 'desc' = 'asc';
  private limitCount?: number;

  where(
    field: K, 
    operator: '=' | '!=' | '>' | '<' | 'in', 
    value: T[K] | T[K][]
  ): this {
    this.conditions.push((item: T) => {
      switch (operator) {
        case '=': return item[field] === value;
        case '!=': return item[field] !== value;
        case '>': return item[field] > value;
        case '<': return item[field] < value;
        case 'in': return Array.isArray(value) && value.includes(item[field]);
        default: return false;
      }
    });
    return this;
  }

  orderBy(field: K, order: 'asc' | 'desc' = 'asc'): this {
    this.sortBy = field;
    this.sortOrder = order;
    return this;
  }

  limit(count: number): this {
    this.limitCount = count;
    return this;
  }

  execute(data: T[]): T[] {
    let result = data.filter(item => 
      this.conditions.every(condition => condition(item))
    );

    if (this.sortBy) {
      result.sort((a, b) => {
        const aVal = a[this.sortBy!];
        const bVal = b[this.sortBy!];
        const comparison = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
        return this.sortOrder === 'asc' ? comparison : -comparison;
      });
    }

    if (this.limitCount) {
      result = result.slice(0, this.limitCount);
    }

    return result;
  }
}

// Usage with specific entity types
interface User extends Entity {
  email: string;
  name: string;
  role: 'admin' | 'user' | 'moderator';
  lastLoginAt?: Date;
}

interface Order extends Entity {
  userId: string;
  amount: number;
  status: 'pending' | 'completed' | 'cancelled';
  items: OrderItem[];
}

interface OrderItem {
  productId: string;
  quantity: number;
  price: number;
}

// Type-safe repository implementations
class UserRepository implements Repository {
  async findById(id: string): Promise {
    // Implementation
    return null;
  }

  async findMany(criteria: Partial): Promise {
    // Implementation
    return [];
  }

  async create(data: Omit): Promise {
    // Implementation
    throw new Error('Not implemented');
  }

  async update(id: string, data: Partial>): Promise {
    // Implementation
    throw new Error('Not implemented');
  }

  async delete(id: string): Promise {
    // Implementation
    return false;
  }

  // Additional user-specific methods
  async findByEmail(email: string): Promise {
    // Implementation
    return null;
  }

  async findActiveUsers(): Promise {
    return new QueryBuilder()
      .where('lastLoginAt', '>', new Date(Date.now() - 30 * 24 * 60 * 60 * 1000))
      .orderBy('lastLoginAt', 'desc')
      .execute(await this.findMany({}));
  }
}

6. Module Augmentation and Declaration Merging

// Extending external libraries safely

// Extend Express Request interface
declare global {
  namespace Express {
    interface Request {
      user?: {
        id: string;
        email: string;
        role: string;
      };
      correlationId: string;
      startTime: number;
    }
  }
}

// Extend Window interface for enterprise analytics
declare global {
  interface Window {
    EnterpriseAnalytics?: {
      track: (event: string, properties?: Record) => void;
      identify: (userId: string, traits?: Record) => void;
    };
    __ORACLE_CONFIG__?: {
      apiUrl: string;
      version: string;
      environment: 'development' | 'staging' | 'production';
    };
  }
}

// Module augmentation for custom utility types
declare module 'lodash' {
  interface LoDashStatic {
    deepMergeWith(
      object: T,
      source: U,
      customizer: (objValue: any, srcValue: any, key: string) => any
    ): T & U;
  }
}

// Custom assertion functions
function assertIsString(value: unknown): asserts value is string {
  if (typeof value !== 'string') {
    throw new Error(`Expected string, got ${typeof value}`);
  }
}

function assertIsUser(value: unknown): asserts value is User {
  if (!value || typeof value !== 'object') {
    throw new Error('Expected user object');
  }
  
  const user = value as any;
  if (!user.id || !user.email || !user.name) {
    throw new Error('Invalid user object');
  }
}

// Environment-specific configuration with type safety
interface EnvironmentConfig {
  database: {
    host: string;
    port: number;
    name: string;
  };
  redis: {
    host: string;
    port: number;
  };
  auth: {
    jwtSecret: string;
    tokenExpiry: string;
  };
}

function loadConfig(): EnvironmentConfig {
  const config = process.env;
  
  return {
    database: {
      host: config.DB_HOST || 'localhost',
      port: parseInt(config.DB_PORT || '5432'),
      name: config.DB_NAME || 'oracle_app'
    },
    redis: {
      host: config.REDIS_HOST || 'localhost',
      port: parseInt(config.REDIS_PORT || '6379')
    },
    auth: {
      jwtSecret: config.JWT_SECRET || (() => {
        throw new Error('JWT_SECRET is required');
      })(),
      tokenExpiry: config.TOKEN_EXPIRY || '24h'
    }
  };
}

Conclusion

These advanced TypeScript patterns have proven essential for maintaining large-scale applications in enterprise environments. They provide type safety, improve developer experience, and catch errors at compile time rather than runtime.

Key takeaways for enterprise TypeScript development:

• Leverage utility types for code reuse and consistency
• Use discriminated unions for complex state management
• Implement generic constraints for flexible yet safe APIs
• Practice defensive programming with assertion functions
• Maintain strict TypeScript configuration for maximum safety