Intermediate

// Sales Bounded Context - Customer means "Buyer with purchase history"
namespace SalesContext {
  // => SalesContext: context boundary namespace
 
  // Sales-specific Customer entity
  export class Customer {
    // => Sales context: Customer = buyer with payment info
    private readonly customerId: string; // => Unique identifier in Sales
    private readonly email: string; // => Contact for order confirmations
    private readonly creditLimit: number; // => Maximum order value allowed
    private orders: Order[] = []; // => Purchase history (Sales-specific)
 
    constructor(customerId: string, email: string, creditLimit: number) {
      // => Constructor: initializes new instance
 
      this.customerId = customerId; // => Initialize customer ID
      this.email = email; // => Set email for sales communications
      this.creditLimit = creditLimit; // => Set credit limit for orders
    }
 
    placeOrder(order: Order): void {
      // => Business rule: Sales validates against credit limit
      this.ensureCreditAvailable(order.getTotalAmount());
      // => Delegates to internal method
      this.orders.push(order); // => Add to purchase history
      // => Order placed successfully
    }
 
    private ensureCreditAvailable(amount: number): void {
      // => Internal logic (not part of public API)
      const totalOutstanding = this.getTotalOutstanding(); // => Calculate current debt
      if (totalOutstanding + amount > this.creditLimit) {
        // => Validate against credit limit
        throw new Error("Credit limit exceeded");
        // => Throws domain error: "Credit limit exceeded"
      }
      // => Credit check passed
    }
 
    private getTotalOutstanding(): number {
      // => Internal logic (not part of public API)
      return (
        this.orders
          // => Returns this.orders
 
          .filter((o) => !o.isPaid()) // => Filter unpaid orders
          .reduce((sum, o) => sum + o.getTotalAmount(), 0)
      ); // => Sum unpaid amounts
    }
 
    getCustomerId(): string {
      // => getCustomerId(): returns string
 
      return this.customerId; // => Expose customer ID
    }
 
    getEmail(): string {
      // => getEmail(): returns string
 
      return this.email; // => Expose email
    }
  }
 
  // Sales-specific Order entity
  export class Order {
    private readonly orderId: string; // => Order identifier
    private readonly totalAmount: number; // => Order total
    private paid: boolean = false; // => Payment status
 
    constructor(orderId: string, totalAmount: number) {
      // => Constructor: initializes new instance
 
      this.orderId = orderId; // => Initialize order ID
      this.totalAmount = totalAmount; // => Set total amount
    }
 
    markAsPaid(): void {
      // => markAsPaid(): returns void
 
      this.paid = true; // => Update payment status
    }
 
    isPaid(): boolean {
      // => isPaid(): returns boolean
 
      return this.paid; // => Return payment status
    }
 
    getTotalAmount(): number {
      // => getTotalAmount(): returns number
 
      return this.totalAmount; // => Expose total amount
    }
  }
 
  // Sales-specific repository
  export interface CustomerRepository {
    findById(customerId: string): Customer | null; // => Retrieve by ID
    save(customer: Customer): void; // => Persist customer
  }
}
 
// Usage - Sales Context operations
const salesCustomer = new SalesContext.Customer("C123", "alice@example.com", 10000);
// => salesCustomer: creditLimit=10000, orders=[]
const order = new SalesContext.Order("O456", 5000);
// => order: totalAmount=5000, paid=false
salesCustomer.placeOrder(order);
// => Order added to purchase history, credit limit checked
console.log(salesCustomer.getEmail());
// => Outputs result
// => Output: alice@example.com

// Shipping Bounded Context - Customer means "Delivery recipient"
namespace ShippingContext {
  // => ShippingContext: context boundary namespace
 
  // Shipping-specific Customer entity
  export class Customer {
    // => Shipping context: Customer = delivery address holder
    private readonly customerId: string; // => Unique identifier in Shipping
    private readonly name: string; // => Recipient name for delivery
    private readonly addresses: DeliveryAddress[] = []; // => Delivery locations
 
    constructor(customerId: string, name: string) {
      // => Constructor: initializes new instance
 
      this.customerId = customerId; // => Initialize customer ID
      this.name = name; // => Set recipient name
    }
 
    addDeliveryAddress(address: DeliveryAddress): void {
      // => addDeliveryAddress(): returns void
 
      this.addresses.push(address); // => Add delivery location
      // => Address added to customer's delivery options
    }
 
    getDefaultAddress(): DeliveryAddress | null {
      // => getDefaultAddress(): returns DeliveryAddress | null
 
      const defaultAddr = this.addresses.find((a) => a.isDefault());
      // => Find default address
      return defaultAddr || null; // => Return default or null
    }
 
    getCustomerId(): string {
      // => getCustomerId(): returns string
 
      return this.customerId; // => Expose customer ID
    }
  }
 
  // Shipping-specific value object
  export class DeliveryAddress {
    private readonly street: string; // => Street address
    private readonly city: string; // => City name
    private readonly zipCode: string; // => Postal code
    private readonly country: string; // => Country
    private readonly isDefaultAddress: boolean; // => Default flag
 
    constructor(street: string, city: string, zipCode: string, country: string, isDefaultAddress: boolean = false) {
      // => Constructor: initializes new instance
 
      this.street = street; // => Initialize street
      this.city = city; // => Initialize city
      this.zipCode = zipCode; // => Initialize zip code
      this.country = country; // => Initialize country
      this.isDefaultAddress = isDefaultAddress; // => Set default flag
    }
 
    isDefault(): boolean {
      // => isDefault(): returns boolean
 
      return this.isDefaultAddress; // => Return default status
    }
 
    getFullAddress(): string {
      // => getFullAddress(): returns string
 
      return `${this.street}, ${this.city}, ${this.zipCode}, ${this.country}`;
      // => Format complete address string
    }
  }
 
  // Shipment entity - Shipping context specific
  export class Shipment {
    private readonly shipmentId: string; // => Shipment identifier
    private readonly customerId: string; // => Reference to customer
    private readonly address: DeliveryAddress; // => Delivery destination
    private status: ShipmentStatus = "PENDING"; // => Current status
 
    constructor(shipmentId: string, customerId: string, address: DeliveryAddress) {
      // => Constructor: initializes new instance
 
      this.shipmentId = shipmentId; // => Initialize shipment ID
      this.customerId = customerId; // => Link to customer
      this.address = address; // => Set delivery address
    }
 
    ship(): void {
      // => ship(): returns void
 
      if (this.status !== "PENDING") {
        // => Validate current status
        throw new Error("Shipment already processed");
        // => Throws domain error: "Shipment already processed"
      }
      this.status = "SHIPPED"; // => Update to shipped
      // => Shipment marked as shipped
    }
 
    getStatus(): ShipmentStatus {
      // => getStatus(): returns ShipmentStatus
 
      return this.status; // => Return current status
    }
  }
 
  type ShipmentStatus = "PENDING" | "SHIPPED" | "DELIVERED";
  // => Type definition for shipment states
}
 
// Usage - Shipping Context operations
const shippingCustomer = new ShippingContext.Customer("C123", "Alice Smith");
// => shippingCustomer: name="Alice Smith", addresses=[]
const address = new ShippingContext.DeliveryAddress("123 Main St", "Seattle", "98101", "USA", true);
// => address: street="123 Main St", city="Seattle", isDefault=true
shippingCustomer.addDeliveryAddress(address);
// => Address added to customer's delivery options
const shipment = new ShippingContext.Shipment("S789", "C123", address);
// => shipment: status="PENDING", address=address
shipment.ship();
// => shipment.status becomes "SHIPPED"
console.log(shipment.getStatus());
// => Outputs result
// => Output: SHIPPED

// Shared Kernel - Common model shared between contexts
namespace SharedKernel {
  // => SharedKernel: context boundary namespace
 
  // Shared value object - used by multiple contexts
  export class Money {
    private readonly amount: number; // => Monetary amount
    private readonly currency: string; // => Currency code (USD, EUR, etc.)
 
    constructor(amount: number, currency: string) {
      // => Initialize object with parameters
      if (amount < 0) {
        // => Validate non-negative amount
        throw new Error("Amount cannot be negative");
        // => Raise domain exception
      }
      this.amount = amount; // => Initialize amount
      this.currency = currency; // => Initialize currency
    }
 
    add(other: Money): Money {
      // => add(): returns Money
 
      this.ensureSameCurrency(other); // => Validate currency match
      return new Money(this.amount + other.amount, this.currency);
      // => Return new Money with combined amount
    }
 
    private ensureSameCurrency(other: Money): void {
      // => Internal logic (not part of public API)
      if (this.currency !== other.currency) {
        // => Validate currencies match
        throw new Error("Cannot operate on different currencies");
        // => Raise domain exception
      }
      // => Currency validation passed
    }
 
    getAmount(): number {
      // => getAmount(): returns number
 
      return this.amount; // => Expose amount
    }
 
    getCurrency(): string {
      // => getCurrency(): returns string
 
      return this.currency; // => Expose currency
    }
  }
 
  // Shared enum - product category taxonomy
  export enum ProductCategory {
    ELECTRONICS = "ELECTRONICS", // => Electronic goods
    CLOTHING = "CLOTHING", // => Apparel items
    BOOKS = "BOOKS", // => Published works
    FOOD = "FOOD", // => Consumable products
  }
}
 
// Billing Context - uses shared kernel
namespace BillingContext {
  // => BillingContext: context boundary namespace
 
  import Money = SharedKernel.Money; // => Import shared Money type
 
  export class Invoice {
    private readonly invoiceId: string; // => Invoice identifier
    private readonly items: InvoiceItem[] = []; // => Line items
 
    constructor(invoiceId: string) {
      // => Constructor: initializes new instance
 
      this.invoiceId = invoiceId; // => Initialize invoice ID
    }
 
    addItem(item: InvoiceItem): void {
      // => addItem(): returns void
 
      this.items.push(item); // => Add line item
      // => Item added to invoice
    }
 
    getTotal(): Money {
      // => getTotal(): returns Money
 
      if (this.items.length === 0) {
        // => Check for empty invoice
        return new Money(0, "USD"); // => Return zero amount
      }
      return (
        // => Return result to caller
        this.items
          .map((item) => item.getPrice()) // => Extract prices
          .reduce((sum, price) => sum.add(price))
      ); // => Sum all prices
    }
  }
 
  export class InvoiceItem {
    private readonly description: string; // => Item description
    private readonly price: Money; // => Item price (shared type)
 
    constructor(description: string, price: Money) {
      // => Constructor: initializes new instance
 
      this.description = description; // => Initialize description
      this.price = price; // => Initialize price
    }
 
    getPrice(): Money {
      // => getPrice(): returns Money
 
      return this.price; // => Expose price
    }
  }
}
 
// Accounting Context - also uses shared kernel
namespace AccountingContext {
  // => AccountingContext: context boundary namespace
 
  import Money = SharedKernel.Money; // => Import shared Money type
 
  export class Transaction {
    private readonly transactionId: string; // => Transaction identifier
    private readonly amount: Money; // => Transaction amount (shared type)
    private readonly type: "DEBIT" | "CREDIT"; // => Transaction type
 
    constructor(transactionId: string, amount: Money, type: "DEBIT" | "CREDIT") {
      // => Constructor: initializes new instance
 
      this.transactionId = transactionId; // => Initialize transaction ID
      this.amount = amount; // => Initialize amount
      this.type = type; // => Set transaction type
    }
 
    getAmount(): Money {
      // => getAmount(): returns Money
 
      return this.amount; // => Expose amount
    }
 
    getType(): string {
      // => getType(): returns string
 
      return this.type; // => Expose transaction type
    }
  }
}
 
// Usage - Both contexts use shared Money type
const invoiceItem = new BillingContext.InvoiceItem("Laptop", new SharedKernel.Money(1200, "USD"));
// => invoiceItem: description="Laptop", price=Money{1200, USD}
const invoice = new BillingContext.Invoice("INV-001");
// => invoice: invoiceId="INV-001", items=[]
invoice.addItem(invoiceItem);
// => Item added to invoice
const total = invoice.getTotal();
// => total: Money{1200, USD}
console.log(`Total: ${total.getAmount()} ${total.getCurrency()}`);
// => Outputs result
// => Output: Total: 1200 USD
 
const transaction = new AccountingContext.Transaction("TXN-001", new SharedKernel.Money(1200, "USD"), "DEBIT");
// => transaction: amount=Money{1200, USD}, type="DEBIT"
console.log(`Transaction: ${transaction.getAmount().getAmount()}`);
// => Outputs result
// => Output: Transaction: 1200

// Supplier Context - Provides product catalog service
namespace ProductCatalogContext {
  // Supplier's public API
  export interface ProductCatalogService {
    getProduct(productId: string): ProductDTO | null; // => Public interface
    searchProducts(query: string): ProductDTO[]; // => Search functionality
  }
 
  // Data Transfer Object - Supplier's contract
  export interface ProductDTO {
    // => Communicates domain intent
    productId: string; // => Product identifier
    name: string; // => Product name
    description: string; // => Product description
    // => Validates business rule
    price: number; // => Price in cents
    // => Enforces invariant
    currency: string; // => Currency code
  }
  // => Validates business rule
 
  // Internal implementation (private to Supplier)
  class Product {
    constructor(
      // => Initialize object with parameters
      private readonly productId: string,
      // => Encapsulated state, not directly accessible
      private readonly name: string,
      // => Encapsulated state, not directly accessible
      private readonly description: string,
      // => Encapsulated state, not directly accessible
      private readonly price: number,
      // => Encapsulated state, not directly accessible
      private readonly currency: string,
      // => Encapsulated state, not directly accessible
    ) {}
    // => Enforces invariant
 
    toDTO(): ProductDTO {
      // => Convert internal model to public DTO
      return {
        productId: this.productId,
        // => Business rule enforced here
        name: this.name,
        // => Execution delegated to domain service
        description: this.description,
        // => Aggregate boundary enforced here
        price: this.price,
        // => Domain event triggered or handled
        currency: this.currency,
        // => Cross-context interaction point
      };
    }
  }
 
  // Supplier's service implementation
  export class ProductCatalogServiceImpl implements ProductCatalogService {
    private products: Map<string, Product> = new Map();
    // => Encapsulated field (not publicly accessible)
    // => Internal product storage
 
    constructor() {
      // => Initialize object with parameters
      // Seed with sample data
      const laptop = new Product("P1", "Laptop", "15-inch laptop", 120000, "USD");
      // => laptop: price=120000 cents = $1200
      this.products.set("P1", laptop);
      // => Delegates to internal method
      // => Product stored in catalog
    }
 
    getProduct(productId: string): ProductDTO | null {
      const product = this.products.get(productId);
      // => Retrieve product by ID
      return product ? product.toDTO() : null;
      // => Return DTO or null if not found
    }
 
    searchProducts(query: string): ProductDTO[] {
      const results: ProductDTO[] = [];
      // => Create data structure
      this.products.forEach((product) => {
        // => Iterate all products
        if (product["name"].toLowerCase().includes(query.toLowerCase())) {
          // => Check if name matches query
          results.push(product.toDTO());
          // => Add matching product to results
        }
        // => Communicates domain intent
      });
      return results; // => Return matching products
    }
  }
}
// => Validates business rule
 
// Customer Context - Depends on Supplier's service
namespace OrderManagementContext {
  // => Enforces invariant
  import ProductDTO = ProductCatalogContext.ProductDTO;
  // => Business rule enforced here
  import ProductCatalogService = ProductCatalogContext.ProductCatalogService;
  // => Import Supplier's public contracts
 
  // Customer's domain model
  export class OrderItem {
    private readonly productId: string; // => Reference to catalog product
    private readonly productName: string; // => Cached name
    private readonly price: number; // => Price at order time
    private readonly quantity: number; // => Quantity ordered
 
    constructor(productId: string, productName: string, price: number, quantity: number) {
      // => Method body begins here
      this.productId = productId; // => Initialize product ID
      this.productName = productName; // => Initialize cached name
      this.price = price; // => Initialize price snapshot
      this.quantity = quantity; // => Initialize quantity
    }
 
    getTotalPrice(): number {
      return this.price * this.quantity; // => Calculate line total
    }
 
    getProductName(): string {
      return this.productName; // => Expose product name
    }
  }
 
  // Customer's service using Supplier
  export class OrderService {
    constructor(private catalogService: ProductCatalogService) {}
    // => Inject Supplier's service
 
    createOrderItem(productId: string, quantity: number): OrderItem {
      const productDTO = this.catalogService.getProduct(productId);
      // => Call Supplier's API to get product
      if (!productDTO) {
        // => Validate product exists
        throw new Error("Product not found");
        // => Raise domain exception
      }
      return new OrderItem(productDTO.productId, productDTO.name, productDTO.price, quantity);
      // => Create order item with product data from Supplier
    }
  }
}
 
// Usage - Customer depends on Supplier
const catalogService = new ProductCatalogContext.ProductCatalogServiceImpl();
// => Supplier service instantiated
const orderService = new OrderManagementContext.OrderService(catalogService);
// => Customer service depends on Supplier
 
const orderItem = orderService.createOrderItem("P1", 2);
// => Calls Supplier API: getProduct("P1")
// => Creates OrderItem with product data
console.log(`Ordered: ${orderItem.getProductName()}, Total: ${orderItem.getTotalPrice()}`);
// => Outputs result
// => Output: Ordered: Laptop, Total: 240000

// External Payment Gateway - Third-party system with its own model
namespace ExternalPaymentGateway {
  // => ExternalPaymentGateway: context boundary namespace
 
  // External system's data structure (we don't control this)
  export interface PaymentResponse {
    transaction_id: string; // => Snake case naming
    status_code: number; // => Numeric status codes
    amount_cents: number; // => Amount in cents
    currency_iso: string; // => ISO currency code
    timestamp_ms: number; // => Unix timestamp
    customer_ref: string; // => External customer reference
  }
 
  // Simulated external API
  export class PaymentGatewayAPI {
    processPayment(amount: number, currency: string, customerRef: string): PaymentResponse {
      // => External system processes payment
      return {
        // => Returns {
 
        transaction_id: `TXN-${Date.now()}`, // => Generate transaction ID
        status_code: 200, // => 200 = success in their system
        amount_cents: amount,
        currency_iso: currency,
        timestamp_ms: Date.now(),
        // => Execute method
        customer_ref: customerRef,
      };
    }
  }
}
 
// Our Bounded Context - with its own domain model
namespace PaymentContext {
  // => PaymentContext: context boundary namespace
 
  // Our domain model - uses our ubiquitous language
  export class Payment {
    private readonly paymentId: string; // => Our naming: paymentId
    private readonly amount: Money; // => Our Money value object
    private readonly status: PaymentStatus; // => Our status enum
    private readonly processedAt: Date; // => Our Date type
 
    constructor(paymentId: string, amount: Money, status: PaymentStatus, processedAt: Date) {
      // => Constructor: initializes new instance
 
      this.paymentId = paymentId; // => Initialize payment ID
      this.amount = amount; // => Initialize amount
      this.status = status; // => Initialize status
      this.processedAt = processedAt; // => Initialize timestamp
    }
 
    isSuccessful(): boolean {
      // => isSuccessful(): returns boolean
 
      return this.status === PaymentStatus.COMPLETED;
      // => Check if payment succeeded
    }
 
    getPaymentId(): string {
      // => getPaymentId(): returns string
 
      return this.paymentId; // => Expose payment ID
    }
 
    getAmount(): Money {
      // => getAmount(): returns Money
 
      return this.amount; // => Expose amount
    }
  }
 
  export class Money {
    constructor(
      // => Initialize object with parameters
      private readonly amount: number,
      // => Encapsulated state, not directly accessible
      private readonly currency: string,
      // => Encapsulated state, not directly accessible
    ) {}
    // => Constructor body empty: no additional initialization needed
 
    getAmount(): number {
      // => getAmount(): returns number
 
      return this.amount; // => Expose amount
    }
 
    getCurrency(): string {
      // => getCurrency(): returns string
 
      return this.currency; // => Expose currency
    }
  }
 
  export enum PaymentStatus {
    PENDING = "PENDING", // => Payment initiated
    COMPLETED = "COMPLETED", // => Payment succeeded
    FAILED = "FAILED", // => Payment failed
  }
 
  // Anti-Corruption Layer - Translates external model to our model
  export class PaymentGatewayAdapter {
    constructor(private readonly gateway: ExternalPaymentGateway.PaymentGatewayAPI) {}
    // => Adapter wraps external system
 
    processPayment(amount: Money, customerRef: string): Payment {
      // => Public method uses our domain model
      const response = this.gateway.processPayment(amount.getAmount(), amount.getCurrency(), customerRef);
      // => Call external API (uses their model)
 
      return this.translateToPayment(response);
      // => Translate external response to our domain model
    }
 
    private translateToPayment(response: ExternalPaymentGateway.PaymentResponse): Payment {
      // => Internal logic (not part of public API)
      // => ACL translation logic
      const money = new Money(response.amount_cents, response.currency_iso);
      // => Convert external amount to our Money type
 
      const status = this.translateStatus(response.status_code);
      // => Convert external status code to our enum
 
      const processedAt = new Date(response.timestamp_ms);
      // => Convert Unix timestamp to Date
 
      return new Payment(response.transaction_id, money, status, processedAt);
      // => Create our domain model from external data
    }
 
    private translateStatus(statusCode: number): PaymentStatus {
      // => Internal logic (not part of public API)
      // => Map external status codes to our enum
      switch (statusCode) {
        case 200:
          return PaymentStatus.COMPLETED; // => 200 → COMPLETED
        case 400:
        case 500:
          return PaymentStatus.FAILED; // => Error codes → FAILED
        default:
          return PaymentStatus.PENDING; // => Unknown → PENDING
      }
    }
  }
}
 
// Usage - ACL protects our domain from external model
const externalGateway = new ExternalPaymentGateway.PaymentGatewayAPI();
// => External system instantiated
const adapter = new PaymentContext.PaymentGatewayAdapter(externalGateway);
// => ACL adapter wraps external system
 
const money = new PaymentContext.Money(5000, "USD");
// => Our Money value object
const payment = adapter.processPayment(money, "CUST-123");
// => Process payment through ACL
// => ACL calls external API, translates response to our model
 
console.log(`Payment ${payment.getPaymentId()} successful: ${payment.isSuccessful()}`);
// => Outputs result
// => Output: Payment TXN-[timestamp] successful: true

// Published Language - Shared contract for Order events
namespace OrderEventPublishedLanguage {
  // Version 1.0 - Stable, documented contract
  export interface OrderCreatedEvent {
    eventType: "OrderCreated"; // => Event discriminator
    version: "1.0"; // => Schema version for compatibility
    timestamp: string; // => ISO 8601 timestamp
    payload: {
      orderId: string; // => Order identifier
      customerId: string; // => Customer reference
      // => Communicates domain intent
      items: Array<{
        // => Order line items
        productId: string; // => Product reference
        quantity: number; // => Quantity ordered
        priceAtOrder: number; // => Price snapshot in cents
        // => Validates business rule
      }>;
      // => Enforces invariant
      totalAmount: number; // => Total in cents
      currency: string; // => Currency code (ISO 4217)
    };
  }
  // => Validates business rule
 
  // Validator for Published Language contract
  export class OrderCreatedEventValidator {
    static validate(event: any): event is OrderCreatedEvent {
      // => Type guard for validation
      return (
        event.eventType === "OrderCreated" && // => Check event type
        event.version === "1.0" && // => Check schema version
        typeof event.timestamp === "string" && // => Validate timestamp
        typeof event.payload.orderId === "string" && // => Validate orderId
        Array.isArray(event.payload.items) && // => Validate items array
        typeof event.payload.totalAmount === "number" // => Validate total
      );
      // => Enforces invariant
    }
  }
}
 
// Context 1 (Publisher) - Order Management publishes events
namespace OrderManagementContext {
  import OrderCreatedEvent = OrderEventPublishedLanguage.OrderCreatedEvent;
  // => Import Published Language contract
 
  export class Order {
    constructor(
      // => Initialize object with parameters
      private readonly orderId: string,
      // => Encapsulated state, not directly accessible
      private readonly customerId: string,
      // => Encapsulated state, not directly accessible
      private readonly items: OrderItem[],
      // => Encapsulated state, not directly accessible
      private readonly totalAmount: number,
      // => Encapsulated state, not directly accessible
    ) {}
 
    // Translate internal model to Published Language
    toOrderCreatedEvent(): OrderCreatedEvent {
      // => Convert domain model to Published Language
      return {
        eventType: "OrderCreated",
        // => DDD tactical pattern applied
        version: "1.0",
        // => Entity state transition managed
        timestamp: new Date().toISOString(), // => ISO 8601 format
        payload: {
          orderId: this.orderId,
          // => Transaction boundary maintained
          customerId: this.customerId,
          // => Entity state transition managed
          items: this.items.map((item) => ({
            // => Map domain items to Published Language
            productId: item.productId,
            // => Domain model consistency maintained
            quantity: item.quantity,
            // => Communicates domain intent
            priceAtOrder: item.price,
            // => Domain operation executes here
          })),
          totalAmount: this.totalAmount,
          // => Validates business rule
          currency: "USD",
          // => Enforces invariant
        },
      };
    }
  }
 
  export class OrderItem {
    constructor(
      // => Initialize object with parameters
      public readonly productId: string,
      public readonly quantity: number,
      public readonly price: number,
    ) {}
  }
}
 
// Context 2 (Subscriber) - Billing consumes events
namespace BillingContext {
  import OrderCreatedEvent = OrderEventPublishedLanguage.OrderCreatedEvent;
  // => Entity state transition managed
  import Validator = OrderEventPublishedLanguage.OrderCreatedEventValidator;
  // => Import Published Language contract and validator
 
  export class BillingService {
    handleOrderCreated(event: OrderCreatedEvent): void {
      // => Receive event in Published Language format
      if (!Validator.validate(event)) {
        // => Validate against Published Language schema
        throw new Error("Invalid OrderCreatedEvent");
        // => Raise domain exception
      }
 
      const invoice = this.createInvoice(event);
      // => Translate Published Language to our domain model
      console.log(`Invoice created: ${invoice.invoiceId}`);
      // => Outputs result
      // => Process in our context's ubiquitous language
    }
    // => Communicates domain intent
 
    private createInvoice(event: OrderCreatedEvent): Invoice {
      // => Internal logic (not part of public API)
      // => Convert Published Language to our domain model
      return new Invoice(
        // => Communicates domain intent
        `INV-${event.payload.orderId}`, // => Generate invoice ID
        event.payload.customerId,
        // => Domain operation executes here
        event.payload.totalAmount,
        // => Modifies aggregate internal state
      );
      // => Validates business rule
    }
    // => Enforces invariant
  }
 
  class Invoice {
    constructor(
      // => Initialize object with parameters
      public readonly invoiceId: string,
      public readonly customerId: string,
      public readonly amount: number,
    ) {}
  }
}
 
// Usage - Published Language enables clean integration
const orderItem = new OrderManagementContext.OrderItem("P123", 2, 5000);
// => orderItem: productId="P123", quantity=2, price=5000
const order = new OrderManagementContext.Order("O456", "C789", [orderItem], 10000);
// => order: orderId="O456", totalAmount=10000
 
const event = order.toOrderCreatedEvent();
// => Convert to Published Language format
console.log(`Event version: ${event.version}, Type: ${event.eventType}`);
// => Outputs result
// => Output: Event version: 1.0, Type: OrderCreated
 
const billingService = new BillingContext.BillingService();
// => Billing context service
billingService.handleOrderCreated(event);
// => Consume Published Language event
// => Output: Invoice created: INV-O456

// External System - Legacy ERP we must integrate with
namespace LegacyERPSystem {
  // => LegacyERPSystem: context boundary namespace
 
  // ERP's model (we don't control this)
  export class ERPCustomer {
    cust_id: string; // => Legacy naming convention
    full_name_text: string; // => Verbose field names
    email_addr: string; // => Abbreviated naming
    credit_limit_cents: number; // => Amount in cents
    status_flag: number; // => 1=active, 0=inactive
 
    constructor(
      // => Initialize object with parameters
      cust_id: string,
      full_name_text: string,
      email_addr: string,
      credit_limit_cents: number,
      status_flag: number,
    ) {
      this.cust_id = cust_id; // => Initialize customer ID
      this.full_name_text = full_name_text; // => Initialize name
      this.email_addr = email_addr; // => Initialize email
      this.credit_limit_cents = credit_limit_cents; // => Initialize credit limit
      this.status_flag = status_flag; // => Initialize status
    }
  }
 
  export class ERPService {
    private customers: Map<string, ERPCustomer> = new Map();
    // => Encapsulated field (not publicly accessible)
    // => ERP customer storage
 
    getCustomer(cust_id: string): ERPCustomer | null {
      // => getCustomer(): returns ERPCustomer | null
 
      return this.customers.get(cust_id) || null;
      // => Retrieve customer by legacy ID format
    }
 
    saveCustomer(customer: ERPCustomer): void {
      // => saveCustomer(): returns void
 
      this.customers.set(customer.cust_id, customer);
      // => Delegates to internal method
      // => Store customer in ERP
    }
  }
}
 
// Our Context - Conformist approach (no translation layer)
namespace SalesContext {
  // => SalesContext: context boundary namespace
 
  import ERPCustomer = LegacyERPSystem.ERPCustomer;
  import ERPService = LegacyERPSystem.ERPService;
  // => Direct import of ERP types (conformist)
 
  // We conform to ERP's model instead of maintaining our own
  export class SalesService {
    constructor(private erpService: ERPService) {}
    // => Inject ERP service
 
    createCustomer(name: string, email: string, creditLimit: number): ERPCustomer {
      // => Use ERP model directly in our domain
      const customer = new ERPCustomer(
        // => customer = new ERPCustomer(
 
        `CUST-${Date.now()}`, // => Generate ERP-format ID
        name,
        email,
        creditLimit * 100, // => Convert to cents for ERP
        1, // => 1 = active in ERP's convention
      );
      // => Create ERP customer directly
 
      this.erpService.saveCustomer(customer);
      // => Delegates to internal method
      // => Save using ERP service
      return customer; // => Return ERP model
    }
 
    isCustomerActive(customer: ERPCustomer): boolean {
      // => Our business logic uses ERP conventions
      return customer.status_flag === 1;
      // => Check status using ERP's numeric flag
    }
 
    getCreditLimitDollars(customer: ERPCustomer): number {
      // => Our helper methods work with ERP model
      return customer.credit_limit_cents / 100;
      // => Convert cents to dollars
    }
  }
}
 
// Usage - Conformist pattern (accept external model)
const erpService = new LegacyERPSystem.ERPService();
// => ERP service instantiated
const salesService = new SalesContext.SalesService(erpService);
// => Our service conforms to ERP
 
const customer = salesService.createCustomer("Alice", "alice@example.com", 5000);
// => Creates ERPCustomer directly
console.log(`Customer: ${customer.full_name_text}, Active: ${salesService.isCustomerActive(customer)}`);
// => Outputs result
// => Output: Customer: Alice, Active: true
console.log(`Credit limit: $${salesService.getCreditLimitDollars(customer)}`);
// => Outputs result
// => Output: Credit limit: $5000

// Our Bounded Context - Inventory Management (Host)
namespace InventoryContext {
  // Internal domain model (private)
  class Product {
    constructor(
      // => Initialize object with parameters
      private readonly productId: string,
      // => Encapsulated state, not directly accessible
      private readonly name: string,
      // => Encapsulated state, not directly accessible
      private stockLevel: number,
      // => Encapsulated field (not publicly accessible)
    ) {}
 
    reserveStock(quantity: number): void {
      if (this.stockLevel < quantity) {
        // => Validate sufficient stock
        throw new Error("Insufficient stock");
        // => Raise domain exception
      }
      this.stockLevel -= quantity; // => Reduce available stock
      // => Modifies stockLevel
      // => State change operation
      // => Stock reserved successfully
    }
    // => Validates business rule
 
    getStockLevel(): number {
      return this.stockLevel; // => Expose current stock
    }
    // => Enforces invariant
 
    getProductId(): string {
      return this.productId; // => Expose product ID
      // => Communicates domain intent
    }
 
    getName(): string {
      return this.name; // => Expose product name
    }
  }
 
  // Public API - Open Host Service
  export interface InventoryService {
    // => Public interface for external contexts
    checkAvailability(productId: string): StockAvailabilityDTO;
    // => Check stock availability
    reserveStock(request: StockReservationRequest): StockReservationResult;
    // => Reserve stock for order
  }
 
  // Public DTOs - Well-documented contracts
  export interface StockAvailabilityDTO {
    productId: string; // => Product identifier
    // => Validates business rule
    productName: string; // => Product name
    // => Enforces invariant
    availableQuantity: number; // => Current stock level
    isAvailable: boolean; // => Availability flag
  }
 
  export interface StockReservationRequest {
    productId: string; // => Product to reserve
    quantity: number; // => Quantity to reserve
    reservationId: string; // => Idempotency key
  }
 
  export interface StockReservationResult {
    success: boolean; // => Reservation outcome
    reservationId: string; // => Idempotency key
    remainingStock: number; // => Stock after reservation
  }
 
  // Open Host Service implementation
  export class InventoryServiceImpl implements InventoryService {
    private products: Map<string, Product> = new Map();
    // => Encapsulated field (not publicly accessible)
    // => Internal product storage
 
    constructor() {
      // => Initialize object with parameters
      // Seed initial inventory
      this.products.set("P1", new Product("P1", "Laptop", 50));
      // => Delegates to internal method
      // => Product P1: stockLevel=50
      this.products.set("P2", new Product("P2", "Mouse", 200));
      // => Delegates to internal method
      // => Product P2: stockLevel=200
    }
 
    checkAvailability(productId: string): StockAvailabilityDTO {
      // => Public method: check stock
      const product = this.products.get(productId);
      // => Retrieve product from internal model
 
      if (!product) {
        // => Product not found
        return {
          productId,
          // => Entity state transition managed
          productName: "Unknown",
          // => Domain model consistency maintained
          availableQuantity: 0,
          // => Communicates domain intent
          isAvailable: false,
          // => Domain operation executes here
        };
        // => Return unavailable DTO
      }
 
      return {
        // => Convert internal model to public DTO
        productId: product.getProductId(),
        // => Execute method
        productName: product.getName(),
        // => Execute method
        availableQuantity: product.getStockLevel(),
        // => Execute method
        isAvailable: product.getStockLevel() > 0,
        // => Execute method
      };
      // => Return availability DTO
    }
    // => Validates business rule
 
    reserveStock(request: StockReservationRequest): StockReservationResult {
      // => Public method: reserve stock
      const product = this.products.get(request.productId);
      // => Retrieve product
 
      if (!product) {
        // => Product not found
        return {
          success: false,
          // => Enforces invariant
          reservationId: request.reservationId,
          // => Business rule enforced here
          remainingStock: 0,
          // => Execution delegated to domain service
        };
      }
 
      try {
        product.reserveStock(request.quantity);
        // => Attempt reservation on domain model
        return {
          success: true,
          // => DDD tactical pattern applied
          reservationId: request.reservationId,
          // => Invariant validation executed
          remainingStock: product.getStockLevel(),
          // => Execute method
        };
        // => Return success result
      } catch (error) {
        // => Reservation failed (insufficient stock)
        return {
          success: false,
          // => Transaction boundary maintained
          reservationId: request.reservationId,
          // => Entity state transition managed
          remainingStock: product.getStockLevel(),
          // => Execute method
        };
        // => Return failure result
      }
    }
    // => Communicates domain intent
  }
}
 
// Consumer Context - Order Management uses Open Host Service
namespace OrderContext {
  // => Validates business rule
  import InventoryService = InventoryContext.InventoryService;
  // => Enforces invariant
  import StockReservationRequest = InventoryContext.StockReservationRequest;
  // => Import public contracts from Open Host
 
  export class OrderService {
    constructor(private inventoryService: InventoryService) {}
    // => Depend on Open Host Service interface
 
    placeOrder(productId: string, quantity: number): void {
      // => Place order using inventory service
      const availability = this.inventoryService.checkAvailability(productId);
      // => Check availability via Open Host Service
 
      if (!availability.isAvailable || availability.availableQuantity < quantity) {
        // => Validate stock sufficient
        throw new Error("Product not available");
        // => Raise domain exception
      }
 
      const result = this.inventoryService.reserveStock({
        // => Reserve stock via Open Host Service
        productId,
        // => Execution delegated to domain service
        quantity,
        // => Aggregate boundary enforced here
        reservationId: `RES-${Date.now()}`,
        // => Execute method
      });
 
      if (!result.success) {
        // => Validate reservation succeeded
        throw new Error("Reservation failed");
        // => Raise domain exception
      }
 
      console.log(`Order placed. Remaining stock: ${result.remainingStock}`);
      // => Outputs result
      // => Output success message
    }
  }
}
 
// Usage - Multiple consumers can easily integrate
const inventoryService = new InventoryContext.InventoryServiceImpl();
// => Open Host Service instantiated
 
const availability = inventoryService.checkAvailability("P1");
// => Check stock via public API
console.log(`${availability.productName}: ${availability.availableQuantity} available`);
// => Outputs result
// => Output: Laptop: 50 available
 
const orderService = new OrderContext.OrderService(inventoryService);
// => Consumer uses Open Host Service
orderService.placeOrder("P1", 5);
// => Order placed. Remaining stock: 45

// Context 1 - Employee HR Management
namespace HRContext {
  // => HRContext: context boundary namespace
 
  export class Employee {
    // => HR's Employee model
    private readonly employeeId: string; // => HR identifier
    private readonly fullName: string; // => Legal name
    private readonly department: string; // => Org structure
    private readonly salary: number; // => Compensation info
    private readonly hireDate: Date; // => Employment start date
 
    constructor(employeeId: string, fullName: string, department: string, salary: number, hireDate: Date) {
      // => Constructor: initializes new instance
 
      this.employeeId = employeeId; // => Initialize employee ID
      this.fullName = fullName; // => Initialize name
      this.department = department; // => Initialize department
      this.salary = salary; // => Initialize salary
      this.hireDate = hireDate; // => Initialize hire date
    }
 
    promoteEmployee(newDepartment: string, newSalary: number): void {
      // => HR operation: promotion
      // Note: No integration with CustomerSupport context
      console.log(`Promoted ${this.fullName} to ${newDepartment}`);
      // => Delegates to internal method
      // => Outputs result
      // => HR-specific business logic
    }
 
    getEmployeeId(): string {
      // => getEmployeeId(): returns string
 
      return this.employeeId; // => Expose employee ID
    }
  }
 
  export class HRService {
    private employees: Map<string, Employee> = new Map();
    // => Encapsulated field (not publicly accessible)
    // => HR employee records
 
    hireEmployee(employee: Employee): void {
      // => hireEmployee(): returns void
 
      this.employees.set(employee.getEmployeeId(), employee);
      // => Delegates to internal method
      // => Add employee to HR system
      console.log("Employee hired in HR system");
      // => Outputs result
      // => HR-specific process (no external context notified)
    }
  }
}
 
// Context 2 - Customer Support Ticketing (completely independent)
namespace CustomerSupportContext {
  // => CustomerSupportContext: context boundary namespace
 
  export class SupportAgent {
    // => Support's Agent model (different from HR Employee!)
    private readonly agentId: string; // => Support identifier
    private readonly displayName: string; // => Customer-facing name
    private readonly skillSet: string[]; // => Support categories
    private readonly activeTickets: number = 0; // => Current workload
 
    constructor(agentId: string, displayName: string, skillSet: string[]) {
      // => Constructor: initializes new instance
 
      this.agentId = agentId; // => Initialize agent ID
      this.displayName = displayName; // => Initialize display name
      this.skillSet = skillSet; // => Initialize skills
    }
 
    assignTicket(ticket: SupportTicket): void {
      // => Support operation: ticket assignment
      // Note: No integration with HR context
      console.log(`Ticket assigned to ${this.displayName}`);
      // => Delegates to internal method
      // => Outputs result
      // => Support-specific business logic
    }
 
    getAgentId(): string {
      // => getAgentId(): returns string
 
      return this.agentId; // => Expose agent ID
    }
  }
 
  export class SupportTicket {
    constructor(
      private readonly ticketId: string,
      // => ticketId: private readonly string field
 
      private readonly description: string,
      // => description: private readonly string field
    ) {}
    // => Constructor body empty: no additional initialization needed
 
    getTicketId(): string {
      // => getTicketId(): returns string
 
      return this.ticketId; // => Expose ticket ID
    }
  }
 
  export class SupportService {
    private agents: Map<string, SupportAgent> = new Map();
    // => Encapsulated field (not publicly accessible)
    // => Support agent records
 
    registerAgent(agent: SupportAgent): void {
      // => registerAgent(): returns void
 
      this.agents.set(agent.getAgentId(), agent);
      // => Delegates to internal method
      // => Add agent to Support system
      console.log("Agent registered in Support system");
      // => Outputs result
      // => Support-specific process (no HR context notified)
    }
  }
}
 
// Usage - Separate Ways: No integration between contexts
const hrService = new HRContext.HRService();
// => HR context service
const employee = new HRContext.Employee("E123", "Alice Johnson", "Engineering", 120000, new Date("2024-01-15"));
// => HR Employee entity
hrService.hireEmployee(employee);
// => Output: Employee hired in HR system
// => Note: No notification to Support context
 
const supportService = new CustomerSupportContext.SupportService();
// => Support context service (independent)
const agent = new CustomerSupportContext.SupportAgent("A456", "Alice J.", ["Technical", "Billing"]);
// => Support Agent entity (unrelated to HR Employee)
supportService.registerAgent(agent);
// => Output: Agent registered in Support system
// => Note: No notification to HR context
 
// These contexts operate independently - no shared data, no integration
console.log("Contexts operate separately with no integration");
// => Outputs result

// Context 1 - Order Management (Partner A)
namespace OrderManagementContext {
  export class Order {
    constructor(
      // => Initialize object with parameters
      private readonly orderId: string,
      // => Encapsulated state, not directly accessible
      private readonly customerId: string,
      // => Encapsulated state, not directly accessible
      private readonly items: OrderItem[],
      // => Encapsulated state, not directly accessible
      private status: OrderStatus = "PENDING",
      // => Encapsulated field (not publicly accessible)
    ) {}
 
    confirm(): void {
      if (this.status !== "PENDING") {
        // => Validate status
        throw new Error("Order already processed");
        // => Raise domain exception
      }
      this.status = "CONFIRMED"; // => Update status
      // => Order confirmed, ready for payment
    }
    // => Validates business rule
 
    getOrderId(): string {
      return this.orderId; // => Expose order ID
      // => Validates business rule
    }
    // => Enforces invariant
 
    getStatus(): OrderStatus {
      return this.status; // => Expose status
      // => Enforces invariant
    }
 
    getTotalAmount(): number {
      return this.items.reduce((sum, item) => sum + item.getTotal(), 0);
      // => Calculate total amount
    }
  }
 
  export class OrderItem {
    constructor(
      // => Initialize object with parameters
      private readonly productId: string,
      // => Encapsulated state, not directly accessible
      private readonly quantity: number,
      // => Encapsulated state, not directly accessible
      private readonly price: number,
      // => Encapsulated state, not directly accessible
    ) {}
 
    getTotal(): number {
      return this.quantity * this.price; // => Line item total
    }
  }
 
  export type OrderStatus = "PENDING" | "CONFIRMED" | "PAID" | "SHIPPED";
  // => Invariant validation executed
 
  // Partnership coordination method - supports PaymentContext
  export interface OrderService {
    getOrderForPayment(orderId: string): OrderPaymentDetails;
    // => Method designed in partnership with Payment team
    markOrderAsPaid(orderId: string): void;
    // => Callback method for Payment team to invoke
  }
 
  export interface OrderPaymentDetails {
    orderId: string; // => Order identifier
    customerId: string; // => Customer reference
    amount: number; // => Amount to charge
    currency: string; // => Currency code
  }
}
// => Communicates domain intent
 
// Context 2 - Payment Processing (Partner B)
namespace PaymentContext {
  import OrderPaymentDetails = OrderManagementContext.OrderPaymentDetails;
  // => Import partner's contract
 
  export class Payment {
    constructor(
      // => Initialize object with parameters
      private readonly paymentId: string,
      // => Encapsulated state, not directly accessible
      private readonly orderId: string,
      // => Encapsulated state, not directly accessible
      private readonly amount: number,
      // => Encapsulated state, not directly accessible
      private status: PaymentStatus = "PENDING",
      // => Encapsulated field (not publicly accessible)
    ) {}
 
    process(): void {
      if (this.status !== "PENDING") {
        // => Validate status
        throw new Error("Payment already processed");
        // => Raise domain exception
      }
      this.status = "COMPLETED"; // => Update status
      // => Payment processed successfully
    }
    // => Validates business rule
 
    getStatus(): PaymentStatus {
      return this.status; // => Expose status
    }
    // => Enforces invariant
 
    getOrderId(): string {
      return this.orderId; // => Expose order ID
    }
  }
 
  export type PaymentStatus = "PENDING" | "COMPLETED" | "FAILED";
  // => Aggregate boundary enforced here
 
  // Partnership coordination - designed with Order team
  export interface PaymentService {
    processOrderPayment(paymentDetails: OrderPaymentDetails): Payment;
    // => Method uses Order team's contract
  }
}
 
// Partnership implementation - coordinated development
class PartnershipCoordinator {
  constructor(
    // => Initialize object with parameters
    private orderRepository: Map<string, OrderManagementContext.Order>,
    // => Encapsulated field (not publicly accessible)
    private paymentRepository: Map<string, PaymentContext.Payment>,
    // => Encapsulated field (not publicly accessible)
  ) {}
 
  // Workflow coordinated between both teams
  processOrderWithPayment(orderId: string): void {
    // => Partnership workflow
    const order = this.orderRepository.get(orderId);
    // => Retrieve order
    if (!order) {
      throw new Error("Order not found");
      // => Raise domain exception
    }
 
    // Step 1: Order team confirms order
    order.confirm();
    // => Order status: PENDING → CONFIRMED
 
    // Step 2: Create payment details (agreed interface)
    const paymentDetails: OrderManagementContext.OrderPaymentDetails = {
      // => Create data structure
      orderId: order.getOrderId(),
      // => Execute method
      customerId: "CUST-123",
      // => Entity state transition managed
      amount: order.getTotalAmount(),
      // => Execute method
      currency: "USD",
      // => Domain model consistency maintained
    };
    // => Payment details extracted from order
 
    // Step 3: Payment team processes payment
    const payment = new PaymentContext.Payment(`PAY-${Date.now()}`, paymentDetails.orderId, paymentDetails.amount);
    // => Payment created
    payment.process();
    // => Payment processed
 
    this.paymentRepository.set(payment.getOrderId(), payment);
    // => Delegates to internal method
    // => Payment stored
 
    console.log(`Partnership workflow: Order ${orderId} confirmed and paid`);
    // => Outputs result
    // => Both contexts coordinated successfully
  }
  // => Communicates domain intent
}
 
// Usage - Partnership pattern in action
const orderRepo = new Map<string, OrderManagementContext.Order>();
// => Store value in orderRepo
const paymentRepo = new Map<string, PaymentContext.Payment>();
// => Store value in paymentRepo
 
const orderItem = new OrderManagementContext.OrderItem("P1", 2, 5000);
// => orderItem: quantity=2, price=5000
const order = new OrderManagementContext.Order("O123", "C456", [orderItem]);
// => order: totalAmount=10000, status="PENDING"
orderRepo.set("O123", order);
// => Execute method
 
const coordinator = new PartnershipCoordinator(orderRepo, paymentRepo);
// => Coordinator manages partnership workflow
coordinator.processOrderWithPayment("O123");
// => Output: Partnership workflow: Order O123 confirmed and paid

// ANTI-PATTERN: Big Ball of Mud - No clear context boundaries
class GodClass {
  // => Single class mixing multiple domain concerns
  private customerId: string; // => Sales concern
  private orderHistory: any[] = []; // => Order concern
  private shippingAddress: string; // => Shipping concern
  private creditLimit: number; // => Finance concern
  private supportTickets: any[] = []; // => Support concern
  // => Communicates domain intent
  private loyaltyPoints: number; // => Marketing concern
 
  // Sales method
  placeOrder(orderId: string, amount: number): void {
    // => Sales logic mixed with everything else
    if (amount > this.creditLimit) {
      throw new Error("Credit limit exceeded");
      // => Raise domain exception
    }
    this.orderHistory.push({ orderId, amount });
    // => Delegates to internal method
    this.loyaltyPoints += Math.floor(amount / 100);
    // => Modifies loyaltyPoints
    // => State change operation
    // => Multiple concerns entangled
  }
 
  // Support method
  createTicket(issue: string): void {
    // => Support logic mixed in
    this.supportTickets.push({ issue, date: new Date() });
    // => Delegates to internal method
  }
  // => Validates business rule
 
  // Shipping method
  updateAddress(newAddress: string): void {
    // => Shipping logic mixed in
    this.shippingAddress = newAddress;
    // => Update shippingAddress state
  }
  // => Enforces invariant
}
 
// REFACTORED: Clear Bounded Contexts
namespace RefactoredSalesContext {
  export class Customer {
    // => Sales-specific customer model
    private readonly customerId: string;
    // => Encapsulated state, not directly accessible
    private readonly creditLimit: number;
    // => Encapsulated state, not directly accessible
    private orders: string[] = [];
    // => Encapsulated field (not publicly accessible)
 
    constructor(customerId: string, creditLimit: number) {
      // => Initialize object with parameters
      this.customerId = customerId;
      // => Update customerId state
      this.creditLimit = creditLimit;
      // => Update creditLimit state
    }
 
    placeOrder(orderId: string, amount: number): void {
      // => Pure sales business logic
      if (amount > this.creditLimit) {
        throw new Error("Credit limit exceeded");
        // => Raise domain exception
      }
      this.orders.push(orderId);
      // => Delegates to internal method
      // => Sales concern isolated
    }
 
    getCustomerId(): string {
      return this.customerId;
      // => Return result to caller
    }
  }
}
 
namespace RefactoredShippingContext {
  export class DeliveryProfile {
    // => Shipping-specific model
    private readonly customerId: string;
    // => Encapsulated state, not directly accessible
    private shippingAddress: string;
    // => Encapsulated field (not publicly accessible)
 
    constructor(customerId: string, shippingAddress: string) {
      // => Initialize object with parameters
      this.customerId = customerId;
      // => Update customerId state
      this.shippingAddress = shippingAddress;
      // => Update shippingAddress state
    }
 
    updateAddress(newAddress: string): void {
      // => Pure shipping business logic
      this.shippingAddress = newAddress;
      // => Shipping concern isolated
    }
    // => Communicates domain intent
 
    getAddress(): string {
      return this.shippingAddress;
      // => Return result to caller
    }
  }
}
// => Validates business rule
 
namespace RefactoredSupportContext {
  // => Enforces invariant
  export class CustomerAccount {
    // => Support-specific model
    private readonly customerId: string;
    // => Encapsulated state, not directly accessible
    private tickets: Ticket[] = [];
    // => Encapsulated field (not publicly accessible)
 
    constructor(customerId: string) {
      // => Initialize object with parameters
      this.customerId = customerId;
      // => Update customerId state
    }
 
    createTicket(issue: string): Ticket {
      // => Pure support business logic
      const ticket = new Ticket(issue, new Date());
      // => Store value in ticket
      this.tickets.push(ticket);
      // => Delegates to internal method
      return ticket;
      // => Support concern isolated
    }
  }
 
  class Ticket {
    constructor(
      // => Initialize object with parameters
      public readonly issue: string,
      public readonly createdAt: Date,
    ) {}
  }
}
 
// Usage - Proper context boundaries
const salesCustomer = new RefactoredSalesContext.Customer("C123", 10000);
// => Sales context: focus on credit and orders
salesCustomer.placeOrder("O456", 5000);
// => Execute method
 
const deliveryProfile = new RefactoredShippingContext.DeliveryProfile("C123", "123 Main St");
// => Shipping context: focus on delivery logistics
deliveryProfile.updateAddress("456 Oak Ave");
// => Execute method
 
const supportAccount = new RefactoredSupportContext.CustomerAccount("C123");
// => Support context: focus on customer issues
supportAccount.createTicket("Product defect");
// => Execute method
 
console.log("Contexts properly separated with clear boundaries");
// => Outputs result

// Domain Layer - Rich domain model with business logic
class BankAccount {
  private constructor(
    // => Initialize object with parameters
    private readonly accountId: string,
    // => Encapsulated state, not directly accessible
    private balance: number,
    // => Encapsulated field (not publicly accessible)
    private readonly overdraftLimit: number,
    // => Encapsulated state, not directly accessible
  ) {}
 
  static create(accountId: string, initialDeposit: number, overdraftLimit: number): BankAccount {
    // => Factory method with business rules
    if (initialDeposit < 0) {
      throw new Error("Initial deposit cannot be negative");
      // => Raise domain exception
    }
    return new BankAccount(accountId, initialDeposit, overdraftLimit);
    // => Create new account with validated initial state
  }
  // => Validates business rule
 
  withdraw(amount: number): void {
    // => Domain business logic
    if (amount <= 0) {
      throw new Error("Withdrawal amount must be positive");
      // => Raise domain exception
    }
    // => Enforces invariant
    const availableBalance = this.balance + this.overdraftLimit;
    // => Store value in availableBalance
    if (amount > availableBalance) {
      throw new Error("Insufficient funds including overdraft");
      // => Raise domain exception
    }
    this.balance -= amount;
    // => State change operation
    // => Modifies state value
    // => Balance updated
    // => Balance updated, business rules enforced
  }
 
  deposit(amount: number): void {
    // => Domain business logic
    if (amount <= 0) {
      throw new Error("Deposit amount must be positive");
      // => Raise domain exception
    }
    this.balance += amount;
    // => State change operation
    // => Modifies state value
    // => Balance updated
    // => Balance updated
  }
 
  getBalance(): number {
    return this.balance;
    // => Return result to caller
  }
 
  getAccountId(): string {
    return this.accountId;
    // => Return result to caller
  }
}
 
// Repository Interface (Domain Layer)
interface BankAccountRepository {
  // => BankAccountRepository: contract definition
  findById(accountId: string): BankAccount | null;
  save(account: BankAccount): void;
}
 
// Application Service - Orchestrates use case
class TransferApplicationService {
  // => Application layer: coordinates domain objects
  constructor(private readonly accountRepository: BankAccountRepository) {}
  // => Initialize object with parameters
 
  transferMoney(fromAccountId: string, toAccountId: string, amount: number): void {
    // => Use case: transfer money between accounts
    // Step 1: Load aggregates
    const fromAccount = this.accountRepository.findById(fromAccountId);
    // => Store value in fromAccount
    const toAccount = this.accountRepository.findById(toAccountId);
    // => Store value in toAccount
 
    if (!fromAccount || !toAccount) {
      throw new Error("Account not found");
      // => Raise domain exception
    }
 
    // Step 2: Execute domain logic (business rules in domain)
    fromAccount.withdraw(amount);
    // => Domain enforces withdrawal rules
    toAccount.deposit(amount);
    // => Domain enforces deposit rules
 
    // Step 3: Persist changes (transaction boundary)
    this.accountRepository.save(fromAccount);
    // => Delegates to internal method
    // => Save updated source account
    this.accountRepository.save(toAccount);
    // => Delegates to internal method
    // => Save updated target account
 
    // => Application Service coordinates, domain objects enforce rules
  }
}
// => Communicates domain intent
 
// Infrastructure Layer - Repository implementation
class InMemoryBankAccountRepository implements BankAccountRepository {
  private accounts: Map<string, BankAccount> = new Map();
  // => Encapsulated field (not publicly accessible)
 
  findById(accountId: string): BankAccount | null {
    return this.accounts.get(accountId) || null;
    // => Retrieve account
  }
 
  save(account: BankAccount): void {
    this.accounts.set(account.getAccountId(), account);
    // => Delegates to internal method
    // => Persist account
  }
}
// => Validates business rule
 
// Usage - Application Service orchestrates use case
const repository = new InMemoryBankAccountRepository();
// => Infrastructure dependency
 
const account1 = BankAccount.create("ACC-001", 1000, 500);
// => account1: balance=1000, overdraftLimit=500
repository.save(account1);
// => Execute method
 
const account2 = BankAccount.create("ACC-002", 500, 0);
// => account2: balance=500, overdraftLimit=0
repository.save(account2);
// => Execute method
 
const transferService = new TransferApplicationService(repository);
// => Application Service instantiated
transferService.transferMoney("ACC-001", "ACC-002", 300);
// => Orchestrates: withdraw from ACC-001, deposit to ACC-002
 
console.log(`ACC-001 balance: ${account1.getBalance()}`);
// => Outputs result
// => Output: ACC-001 balance: 700
console.log(`ACC-002 balance: ${account2.getBalance()}`);
// => Outputs result
// => Output: ACC-002 balance: 800

// Domain Event
class OrderPlacedEvent {
  // => Domain event representing business-significant occurrence
  constructor(
    // => Initialize object with parameters
    public readonly orderId: string,
    public readonly customerId: string,
    public readonly totalAmount: number,
    public readonly occurredAt: Date,
  ) {}
}
 
// Domain Model
class Order {
  private events: OrderPlacedEvent[] = [];
  // => Encapsulated field (not publicly accessible)
  // => Collect domain events
 
  constructor(
    // => Initialize object with parameters
    private readonly orderId: string,
    // => Encapsulated state, not directly accessible
    private readonly customerId: string,
    // => Encapsulated state, not directly accessible
    private readonly items: OrderItem[],
    // => Encapsulated state, not directly accessible
    private status: OrderStatus = "DRAFT",
    // => Encapsulated field (not publicly accessible)
  ) {}
  // => Validates business rule
 
  place(): void {
    // => Domain business logic
    if (this.status !== "DRAFT") {
      throw new Error("Order already placed");
      // => Raise domain exception
    }
    // => Enforces invariant
    this.status = "PLACED";
    // => Status updated
 
    // Raise domain event
    this.events.push(new OrderPlacedEvent(this.orderId, this.customerId, this.getTotalAmount(), new Date()));
    // => Delegates to internal method
    // => Event recorded for later publication
  }
 
  getEvents(): OrderPlacedEvent[] {
    return [...this.events];
    // => Expose collected events
  }
 
  clearEvents(): void {
    this.events = [];
    // => Clear events after publication
  }
 
  private getTotalAmount(): number {
    // => Internal logic (not part of public API)
    return this.items.reduce((sum, item) => sum + item.price, 0);
    // => Return result to caller
  }
 
  getOrderId(): string {
    return this.orderId;
    // => Return result to caller
  }
}
 
class OrderItem {
  constructor(
    // => Initialize object with parameters
    public readonly productId: string,
    public readonly price: number,
  ) {}
}
 
type OrderStatus = "DRAFT" | "PLACED" | "SHIPPED";
// => Entity state transition managed
 
// Event Publisher Interface
interface EventPublisher {
  // => EventPublisher: contract definition
  publish(event: OrderPlacedEvent): void;
}
 
// Application Service - Publishes events after transaction
class PlaceOrderApplicationService {
  constructor(
    // => Initialize object with parameters
    private readonly orderRepository: OrderRepository,
    // => Encapsulated state, not directly accessible
    private readonly eventPublisher: EventPublisher,
    // => Encapsulated state, not directly accessible
  ) {}
  // => Communicates domain intent
 
  placeOrder(orderId: string): void {
    // => Use case: place order
    const order = this.orderRepository.findById(orderId);
    // => Store value in order
    if (!order) {
      throw new Error("Order not found");
      // => Raise domain exception
    }
 
    // Execute domain logic
    order.place();
    // => Domain raises event internally
 
    // Persist changes
    this.orderRepository.save(order);
    // => Delegates to internal method
    // => Save order state
 
    // Publish domain events (after transaction succeeds)
    const events = order.getEvents();
    // => Store value in events
    events.forEach((event) => this.eventPublisher.publish(event));
    // => Publish events to external subscribers
 
    order.clearEvents();
    // => Clear events after publication
  }
}
// => Validates business rule
 
interface OrderRepository {
  // => OrderRepository: contract definition
  findById(orderId: string): Order | null;
  save(order: Order): void;
}
// => Enforces invariant
 
// Infrastructure - Simple event publisher
class InMemoryEventPublisher implements EventPublisher {
  private publishedEvents: OrderPlacedEvent[] = [];
  // => Encapsulated field (not publicly accessible)
 
  publish(event: OrderPlacedEvent): void {
    this.publishedEvents.push(event);
    // => Delegates to internal method
    // => Record published event
    console.log(`Event published: OrderPlaced for ${event.orderId}`);
    // => Outputs result
  }
 
  getPublishedEvents(): OrderPlacedEvent[] {
    return this.publishedEvents;
    // => Return result to caller
  }
}
 
class InMemoryOrderRepository implements OrderRepository {
  private orders: Map<string, Order> = new Map();
  // => Encapsulated field (not publicly accessible)
 
  findById(orderId: string): Order | null {
    return this.orders.get(orderId) || null;
    // => Return result to caller
  }
 
  save(order: Order): void {
    this.orders.set(order.getOrderId(), order);
    // => Delegates to internal method
  }
}
 
// Usage - Application Service publishes events
const orderRepo = new InMemoryOrderRepository();
// => Store value in orderRepo
const eventPublisher = new InMemoryEventPublisher();
// => Store value in eventPublisher
 
const order = new Order("O123", "C456", [new OrderItem("P1", 5000), new OrderItem("P2", 3000)]);
// => order: totalAmount=8000, status="DRAFT"
orderRepo.save(order);
// => Execute method
 
const placeOrderService = new PlaceOrderApplicationService(orderRepo, eventPublisher);
// => Application Service with event publishing
placeOrderService.placeOrder("O123");
// => Output: Event published: OrderPlaced for O123
 
console.log(`Events published: ${eventPublisher.getPublishedEvents().length}`);
// => Outputs result
// => Output: Events published: 1