Domain-Driven Design (DDD) Cheat Sheet

// Entity: identity matters, attributes can changeclass Order {  constructor(    readonly id: OrderId,       // identity — never changes    private items: OrderLine[],    private status: OrderStatus,  ) {}  addLine(line: OrderLine) { this.items.push(line); }}// Value Object: no identity, immutable, equality by valueclass Money {  constructor(readonly amount: number, readonly currency: string) {}  equals(other: Money): boolean {    return this.amount === other.amount && this.currency === other.currency;  }  add(other: Money): Money {    if (other.currency !== this.currency) throw new Error('currency mismatch');    return new Money(this.amount + other.amount, this.currency);  }}

// Aggregate root: the only entry point for mutating the aggregateclass ShoppingCart {  private constructor(    readonly id: CartId,    private lines: CartLine[],  ) {}  static create(id: CartId): ShoppingCart {    return new ShoppingCart(id, []);  }  addItem(productId: ProductId, qty: number): void {    if (qty <= 0) throw new Error('quantity must be positive'); // invariant    this.lines.push(new CartLine(productId, qty));  }}interface CartRepository {  findById(id: CartId): Promise<ShoppingCart | null>;  save(cart: ShoppingCart): Promise<void>;}

class OrderPlaced {  readonly occurredAt = new Date();  constructor(readonly orderId: OrderId, readonly total: Money) {}}class Order {  private events: DomainEvent[] = [];  place(): void {    this.status = OrderStatus.Placed;    this.events.push(new OrderPlaced(this.id, this.total));  }  pullEvents(): DomainEvent[] {    const events = this.events;    this.events = [];    return events;  }}// Application layer publishes events after the transaction commitsconst events = order.pullEvents();events.forEach(e => eventBus.publish(e));

// Legacy CRM shape — outside our control, uses its own vocabularyinterface LegacyCrmCustomer {  cust_id: string;  full_nm: string;  acct_status_cd: 'A' | 'S' | 'C';}// Our domain's ubiquitous languageclass Customer {  private constructor(    readonly id: CustomerId,    readonly name: string,    readonly status: CustomerStatus,  ) {}  static fromLegacy(raw: LegacyCrmCustomer): Customer {    const statusMap: Record<string, CustomerStatus> = {      A: CustomerStatus.Active,      S: CustomerStatus.Suspended,      C: CustomerStatus.Closed,    };    return new Customer(      new CustomerId(raw.cust_id),      raw.full_nm,      statusMap[raw.acct_status_cd],    );  }}// The ACL is the only place that ever imports LegacyCrmCustomerclass CrmAntiCorruptionLayer {  constructor(private crmClient: LegacyCrmClient) {}  async getCustomer(id: CustomerId): Promise<Customer> {    const raw = await this.crmClient.fetch(id.value);    return Customer.fromLegacy(raw);  }}

interface Specification<T> {  isSatisfiedBy(candidate: T): boolean;  and(other: Specification<T>): Specification<T>;}abstract class BaseSpec<T> implements Specification<T> {  abstract isSatisfiedBy(candidate: T): boolean;  and(other: Specification<T>): Specification<T> {    return new AndSpec(this, other);  }}class AndSpec<T> extends BaseSpec<T> {  constructor(private left: Specification<T>, private right: Specification<T>) { super(); }  isSatisfiedBy(candidate: T): boolean {    return this.left.isSatisfiedBy(candidate) && this.right.isSatisfiedBy(candidate);  }}class IsPremiumCustomer extends BaseSpec<Customer> {  isSatisfiedBy(c: Customer): boolean { return c.tier === 'premium'; }}class HasNoOpenDisputes extends BaseSpec<Customer> {  isSatisfiedBy(c: Customer): boolean { return c.openDisputes === 0; }}const eligibleForCreditLine = new IsPremiumCustomer().and(new HasNoOpenDisputes());if (eligibleForCreditLine.isSatisfiedBy(customer)) { /* approve */ }

// Domain service: pure business logic spanning multiple aggregates,// no I/O, no framework dependenciesclass FundsTransferService {  transfer(from: Account, to: Account, amount: Money): void {    if (!from.canWithdraw(amount)) {      throw new InsufficientFundsError(from.id);    }    from.withdraw(amount);    to.deposit(amount);  }}// Application service: orchestrates the use case — loads aggregates,// calls the domain service, manages the transaction, publishes eventsclass TransferFundsUseCase {  constructor(    private accounts: AccountRepository,    private transferService: FundsTransferService,    private uow: UnitOfWork,  ) {}  async execute(cmd: TransferFundsCommand): Promise<void> {    await this.uow.transaction(async () => {      const from = await this.accounts.findById(cmd.fromId);      const to = await this.accounts.findById(cmd.toId);      this.transferService.transfer(from, to, cmd.amount);      await this.accounts.save(from);      await this.accounts.save(to);    });  }}