Domain-driven design

// Value object: equal by value, immutable
class Money {
  constructor(readonly cents: number, readonly currency: string) {
    if (!Number.isInteger(cents) || cents < 0) throw new Error("bad amount");
  }
  add(other: Money): Money {
    if (other.currency !== this.currency) throw new Error("currency mismatch");
    return new Money(this.cents + other.cents, this.currency);
  }
  equals(other: Money) { return this.cents === other.cents && this.currency === other.currency; }
}

// Domain event: something that happened, named in the past tense
type OrderPlaced = { type: "OrderPlaced"; orderId: string; total: Money; at: Date };

// Entity and aggregate root: identity makes it this order; outside code changes it only through methods
class Order {
  #lines: { sku: string; qty: number; price: Money }[] = [];
  #placed = false;
  readonly events: OrderPlaced[] = [];
  constructor(readonly id: string) {}

  addLine(sku: string, qty: number, price: Money) {
    if (this.#placed) throw new Error("order already placed");
    if (qty <= 0) throw new Error("qty must be positive");
    this.#lines.push({ sku, qty, price });
  }
  total(): Money {
    return this.#lines.reduce((sum, l) => sum.add(new Money(l.price.cents * l.qty, l.price.currency)), new Money(0, "EUR"));
  }
  place() {
    if (this.#lines.length === 0) throw new Error("empty order");
    this.#placed = true;
    this.events.push({ type: "OrderPlaced", orderId: this.id, total: this.total(), at: new Date() });
  }
}

// Repository: looks like a collection of aggregates and hides the database
interface OrderRepository { get(id: string): Promise<Order | undefined>; save(order: Order): Promise<void> }
class InMemoryOrders implements OrderRepository {
  #rows = new Map<string, Order>();
  async get(id: string) { return this.#rows.get(id); }
  async save(order: Order) { this.#rows.set(order.id, order); }
}

const orders: OrderRepository = new InMemoryOrders();
const order = new Order("o-42");
order.addLine("tea", 2, new Money(450, "EUR"));
order.place();
await orders.save(order);
console.log(order.total().cents);                               // 900
console.log(order.events[0].type);                              // OrderPlaced
console.log(new Money(5, "EUR").equals(new Money(5, "EUR")));   // true
try { order.addLine("cake", 1, new Money(300, "EUR")); }
catch (e) { console.log((e as Error).message); }                // order already placed