State Machine Pattern

State machines model objects that change behavior based on their internal state.

Order State Machine

Order State Machine:

  ┌─────────┐    place    ┌─────────┐    pay    ┌──────────┐
  │ CREATED │───────────▶│ PENDING │─────────▶│  PAID    │
  └─────────┘            └─────────┘          └──────────┘
       │                      │                     │
       │ cancel               │ cancel              │ ship
       ▼                      ▼                     ▼
  ┌─────────┐            ┌─────────┐          ┌──────────┐
  │CANCELLED│◀───────────│CANCELLED│          │ SHIPPED  │
  └─────────┘            └─────────┘          └──────────┘
                                                   │
                                                   │ deliver
                                                   ▼
                                              ┌──────────┐
                                              │DELIVERED │
                                              └──────────┘

Implementation

// State enum
enum OrderState {
  CREATED = 'CREATED',
  PENDING = 'PENDING',
  PAID = 'PAID',
  SHIPPED = 'SHIPPED',
  DELIVERED = 'DELIVERED',
  CANCELLED = 'CANCELLED'
}

// Events that trigger transitions
enum OrderEvent {
  PLACE = 'PLACE',
  PAY = 'PAY',
  SHIP = 'SHIP',
  DELIVER = 'DELIVER',
  CANCEL = 'CANCEL'
}

// Transition definition
interface Transition {
  from: OrderState;
  event: OrderEvent;
  to: OrderState;
  guard?: (order: Order) => boolean;
  action?: (order: Order) => void;
}

// State machine
class OrderStateMachine {
  private transitions: Transition[] = [
    {
      from: OrderState.CREATED,
      event: OrderEvent.PLACE,
      to: OrderState.PENDING,
      action: (order) => console.log(`Order ${order.id} placed`)
    },
    {
      from: OrderState.PENDING,
      event: OrderEvent.PAY,
      to: OrderState.PAID,
      guard: (order) => order.paymentReceived,
      action: (order) => this.sendPaymentConfirmation(order)
    },
    {
      from: OrderState.PAID,
      event: OrderEvent.SHIP,
      to: OrderState.SHIPPED,
      guard: (order) => order.inventoryReserved,
      action: (order) => this.sendShippingNotification(order)
    },
    {
      from: OrderState.SHIPPED,
      event: OrderEvent.DELIVER,
      to: OrderState.DELIVERED,
      action: (order) => this.sendDeliveryConfirmation(order)
    },
    {
      from: OrderState.CREATED,
      event: OrderEvent.CANCEL,
      to: OrderState.CANCELLED,
      action: (order) => console.log(`Order ${order.id} cancelled`)
    },
    {
      from: OrderState.PENDING,
      event: OrderEvent.CANCEL,
      to: OrderState.CANCELLED,
      action: (order) => this.processRefund(order)
    }
  ];

  transition(order: Order, event: OrderEvent): Order {
    const transition = this.transitions.find(
      t => t.from === order.state && t.event === event
    );

    if (!transition) {
      throw new Error(
        `Invalid transition: ${order.state} + ${event}`
      );
    }

    if (transition.guard && !transition.guard(order)) {
      throw new Error(`Guard condition not met for ${event}`);
    }

    // Execute transition
    const newOrder = { ...order, state: transition.to };

    if (transition.action) {
      transition.action(newOrder);
    }

    return newOrder;
  }

  getAvailableEvents(state: OrderState): OrderEvent[] {
    return this.transitions
      .filter(t => t.from === state)
      .map(t => t.event);
  }

  private sendPaymentConfirmation(order: Order): void { /* ... */ }
  private sendShippingNotification(order: Order): void { /* ... */ }
  private sendDeliveryConfirmation(order: Order): void { /* ... */ }
  private processRefund(order: Order): void { /* ... */ }
}

// Usage
const stateMachine = new OrderStateMachine();
let order: Order = { id: '123', state: OrderState.CREATED };

order = stateMachine.transition(order, OrderEvent.PLACE);
console.log(order.state); // PENDING

order.paymentReceived = true;
order = stateMachine.transition(order, OrderEvent.PAY);
console.log(order.state); // PAID

console.log(stateMachine.getAvailableEvents(order.state)); // [SHIP]

State Pattern (Object-Oriented)

// State interface
interface OrderStateHandler {
  place(context: OrderContext): void;
  pay(context: OrderContext): void;
  ship(context: OrderContext): void;
  deliver(context: OrderContext): void;
  cancel(context: OrderContext): void;
}

// Context
class OrderContext {
  private state: OrderStateHandler;

  constructor() {
    this.state = new CreatedState();
  }

  setState(state: OrderStateHandler): void {
    this.state = state;
  }

  place(): void { this.state.place(this); }
  pay(): void { this.state.pay(this); }
  ship(): void { this.state.ship(this); }
  deliver(): void { this.state.deliver(this); }
  cancel(): void { this.state.cancel(this); }
}

// Concrete states
class CreatedState implements OrderStateHandler {
  place(context: OrderContext): void {
    console.log('Order placed');
    context.setState(new PendingState());
  }
  pay(context: OrderContext): void {
    throw new Error('Cannot pay before placing order');
  }
  ship(context: OrderContext): void {
    throw new Error('Cannot ship before payment');
  }
  deliver(context: OrderContext): void {
    throw new Error('Cannot deliver before shipping');
  }
  cancel(context: OrderContext): void {
    console.log('Order cancelled');
    context.setState(new CancelledState());
  }
}

class PendingState implements OrderStateHandler {
  place(context: OrderContext): void {
    throw new Error('Order already placed');
  }
  pay(context: OrderContext): void {
    console.log('Payment processed');
    context.setState(new PaidState());
  }
  ship(context: OrderContext): void {
    throw new Error('Cannot ship before payment');
  }
  deliver(context: OrderContext): void {
    throw new Error('Cannot deliver before shipping');
  }
  cancel(context: OrderContext): void {
    console.log('Order cancelled, refund initiated');
    context.setState(new CancelledState());
  }
}