Bounded Contexts: Drawing Lines That Matter

// A well-bounded Customer context cares about this:
class Customer {
  constructor(id, email, name) {
    this.id = id;
    this.email = email;
    this.name = name;
  }

  updateEmail(newEmail) {
    this.email = newEmail;
  }

  updateName(newName) {
    this.name = newName;
  }
}

// A poorly-bounded Customer tries to handle everything:
class Customer {
  constructor(id, email, name) {
    this.id = id;
    this.email = email;
    this.name = name;
    this.invoices = [];
    this.supportTickets = [];
    this.purchaseHistory = [];
    this.recommendations = [];
    this.subscriptionStatus = null;
    this.creditScore = null;
    this.shippingAddresses = [];
  }

  // Hundreds of methods...
}

// If your payment processing moves from internal system to Stripe,
// only the Billing context changes
class PaymentProcessor {
  processPayment(payment) {
    // Old: internal system
    // New: Stripe API
    // The change is isolated
  }
}

// Order context doesn't care how payment works,
// it just knows "payment succeeded" or "payment failed"

// An Order has a clear lifecycle that's different from Inventory
// Order lifecycle: created → placed → processing → shipped → delivered
// Inventory lifecycle: restocked → allocated → picked → shipped

class Order {
  status; // Order-specific states
}

class InventoryAllocation {
  status; // Inventory-specific states
}

// These have different rules and different lifecycles
// Likely different bounded contexts

// Product Catalog needs fast, complex queries:
// - "Find products matching these filters"
// - "Get product with related products"
// - Typically denormalized for read performance

// Order needs transactional consistency:
// - "Create order atomically with all line items"
// - Typically normalized

// Different persistence strategies suggest different contexts

// External payment provider (we don't control it)
class PaymentProviderAPI {
  submitTxn(data) {
    // Expects: {txn_id, amt, vnd_code, mrch_code}
    // Returns: {status, ref_num, ts}
  }
}

// Our Order context model (clean, clear)
class Payment {
  constructor(orderId, amount) {
    this.orderId = orderId;
    this.amount = amount;
  }
}

class PaymentProcessingResult {
  constructor(success, referenceNumber) {
    this.success = success;
    this.referenceNumber = referenceNumber;
  }
}

// Anticorruption Layer (adapter)
class ExternalPaymentAdapter {
  constructor(providerAPI, config) {
    this.provider = providerAPI;
    this.vendorCode = config.vendorCode;
    this.merchantCode = config.merchantCode;
  }

  processPayment(payment) {
    // Translate from our model to theirs
    const providerRequest = {
      txn_id: payment.orderId,
      amt: payment.amount.inCents(),
      vnd_code: this.vendorCode,
      mrch_code: this.merchantCode
    };

    const providerResponse = this.provider.submitTxn(providerRequest);

    // Translate back to our model
    return new PaymentProcessingResult(
      providerResponse.status === 'approved',
      providerResponse.ref_num
    );
  }
}

// Order context uses only our clean interface
class OrderService {
  constructor(paymentAdapter) {
    this.paymentAdapter = paymentAdapter;
  }

  placeOrder(order) {
    const payment = new Payment(order.id, order.total);
    const result = this.paymentAdapter.processPayment(payment);

    if (result.success) {
      order.markAsPaid(result.referenceNumber);
    }
  }
}

// Shared Kernel - used by both Order and Inventory contexts
// src/shared-kernel/Money.js
export class Money {
  constructor(amount, currency = 'USD') {
    this.amount = amount;
    this.currency = currency;
  }

  plus(other) {
    if (this.currency !== other.currency) {
      throw new Error("Can't add different currencies");
    }
    return new Money(this.amount + other.amount, this.currency);
  }

  minus(other) {
    return this.plus(new Money(-other.amount, other.currency));
  }

  equals(other) {
    return this.amount === other.amount && this.currency === other.currency;
  }
}

// Order context uses Money
import { Money } from '../shared-kernel/Money';
class Order {
  total() {
    return this.items.reduce(
      (sum, item) => sum.plus(item.price),
      new Money(0)
    );
  }
}

// Inventory context uses Money
class InventoryValuation {
  totalValue() {
    return this.allocations.reduce(
      (sum, alloc) => sum.plus(alloc.product.price.times(alloc.quantity)),
      new Money(0)
    );
  }
}

// Rule: shared kernel is read-only for most code
// Changes require agreement between teams

// Supplier: Catalog Context provides stable interface
export class CatalogService {
  getProductById(id) {
    return {
      id: id,
      name: string,
      description: string,
      basePrice: Money,
      inStock: boolean,
      discontinued: boolean
    };
  }

  searchProducts(filters) {
    // returns Product[]
  }
}

// Customer: Order Context depends on Catalog
class OrderService {
  constructor(catalogService) {
    this.catalog = catalogService;
  }

  addLineItem(orderId, productId, quantity) {
    const product = this.catalog.getProductById(productId);

    if (product.discontinued) {
      throw new Error("Product is discontinued");
    }

    // Use the well-defined interface
    const order = this.repository.getById(orderId);
    order.addLineItem(product, quantity);
  }
}

// The interface is the contract.
// Catalog commits to returning objects with these fields.
// Catalog commits to not breaking this interface.
// Order plans around this stability.

// Upstream: Identity Context provides User objects
export class User {
  constructor(id, email, verified, createdAt) {
    this.id = id;
    this.email = email;
    this.verified = verified;
    this.createdAt = createdAt;
  }
}

// Downstream: Order Context uses User directly (conformist)
class Order {
  constructor(id, user) {
    this.id = id;
    this.user = user; // No translation, no adaptation
    this.customerId = user.id;
  }

  canPlace() {
    return this.user.verified; // Use upstream model directly
  }
}

// Too granular - each class is a context
// This defeats the purpose
class UserContext { }
class OrderContext { }
class LineItemContext { }

// Right-sized - related aggregates grouped
class OrderContext {
  // Contains Order and LineItem aggregates
  // They're tightly related and change together
}

// Everything in one context
class AppContext {
  users = [];
  orders = [];
  products = [];
  payments = [];
  // ... 5,000 lines of code
}

// Better: Multiple contexts with clear boundaries
class UserContext { }
class OrderContext { }
class ProductContext { }

// Bad: Order reaches into Inventory directly
class Order {
  place() {
    for (let item of this.items) {
      // Direct manipulation of another context
      this.inventoryAllocation.quantity -= item.quantity;
    }
  }
}

// Good: Order publishes event, Inventory responds
class Order {
  place() {
    this.status = 'placed';
    this.domainEvents.push(new OrderPlacedEvent(this.id, this.items));
  }
}

class InventoryService {
  onOrderPlaced(event) {
    for (let item of event.items) {
      // Inventory makes its own decision
      const allocation = this.allocate(item.productId, item.quantity);
    }
  }
}