RealWorld Design Patterns in TypeScript

The Proxy Pattern is used to limit or control access to an original object. While it is structurally similar to the Decorator Pattern (which adds functionality), the Proxy Pattern's primary purpose is to act as a surrogate or placeholder to manage access.

Key Advantages

• Decouple limitation logic: Keep access control logic separate from the original object's core business logic.
• Control access: Manage how and when the original object is accessed.
• Caching: Store results of expensive operations to avoid redundant calls to the original object.
• 3rd Party Control: Apply control logic to classes you do not own (3rd party libraries).

Common Use Case: Caching API Responses

Instead of calling an expensive API (like OpenAI) for every request, a Proxy can intercept the request, check if a cached response exists for a specific prompt, and return it immediately if available.

The Template Method Pattern is used when you have a series of similar tasks that share identical steps, optional steps, and unique steps.

Mental Model:

1. Parent Class (Template): Defines the skeleton of an algorithm. It implements the identical steps and provides default implementations for optional steps. It also declares abstract methods for the steps that must be unique to each implementation.
2. Template Method: A specific method in the parent class that orchestrates the execution of all steps in a fixed order. This method is typically the same for all child classes.
3. Child Classes: Implement the specific logic for the abstract methods defined by the parent.

Example Scenario: Fetching products from different providers (e.g., Amazon, Alibaba). The process of sending a request is identical, but the data parsing logic is unique to each provider.

// The parent class defines the structure
export abstract class BaseHandler<T, K> implements IBaseHandler<T, K> {
  // Identical step
  async fetchData(data: K): Promise<T> { ... }

  // Optional step with default implementation
  async paginate(data: T): Promise<T | Paginated<T>> {
    return data;
  }

  // Abstract step to be implemented by children
  abstract parseData(data: T | Paginated<T>): number[];

  // The Template Method: orchestrates the steps
  async handle(data: K) {
    const result = await this.fetchData(data);
    const paginated = await this.paginate(result);
    const parsed = this.parseData(paginated);
    return parsed;
  }
}

KISS states that systems work best when kept simple. Avoid unnecessary complexity by using the simplest solution that meets requirements and breaking complex problems into smaller, manageable parts.

Instead of using deeply nested conditional logic to handle business rules, use data-driven approaches like configuration arrays or rule objects to simplify the execution flow.

interface DiscountRule {
  userType: string;
  minPurchases: number;
  baseDiscount: number;
  seasonalBonus: number;
}

const discountRules: DiscountRule[] = [
  { userType: 'premium', minPurchases: 10, baseDiscount: 0.2, seasonalBonus: 0.05 },
  { userType: 'premium', minPurchases: 0, baseDiscount: 0.1, seasonalBonus: 0.02 },
  { userType: 'regular', minPurchases: 20, baseDiscount: 0.15, seasonalBonus: 0.03 },
  { userType: 'regular', minPurchases: 0, baseDiscount: 0.05, seasonalBonus: 0.01 },
];

function calculateDiscount(price: number, userType: string, purchaseCount: number, seasonalPromotion: boolean): number {
  const rule = discountRules.find(r => 
    r.userType === userType && purchaseCount >= r.minPurchases
  );
  
  if (!rule) return 0;
  
  let discount = price * rule.baseDiscount;
  if (seasonalPromotion) {
    discount += price * rule.seasonalBonus;
  }
  
  return discount;
}

Cross-cutting concerns are aspects of a program that affect multiple modules (e.g., logging, security, validation, transaction management, caching). If not handled correctly, they lead to 'tangled' code where business logic is mixed with infrastructure logic.

To keep business logic clean, use one of the following approaches to separate these concerns:

• Middleware: For request/response pipelines (e.g., Express.js).
• Decorators: To wrap methods with specific behaviors (e.g., @transactional, @logMethod).
• Aspect-Oriented Programming (AOP).
• Higher-Order Functions.

// Example of using Decorators to separate concerns

function transactional(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  descriptor.value = async function(...args: any[]) {
    const transaction = await db.beginTransaction();
    try {
      const result = await originalMethod.apply(this, args);
      await transaction.commit();
      return result;
    } catch (error) {
      await transaction.rollback();
      throw error;
    }
  };
}

class OrderService {
  @transactional
  async createOrder(orderData: OrderData): Promise<Order> {
    // Core business logic only
    return await db.orders.create(orderData);
  }
}