Aggregates

📘What it really is

• An aggregate is a cluster of entities and value objects treated as one unit for changes, with one entry point, the aggregate root.

• The root protects the rules (invariants) that must always be true inside the aggregate. All changes go through the root's methods, never by editing the parts directly.

• In the booking platform, a TutorSchedule aggregate might own a tutor's availability rules and booked slots, guaranteeing no two bookings overlap:

export class TutorSchedule {
  readonly tutorId: string;
  private bookings: Booking[];
  constructor(tutorId: string, bookings: Booking[]) {
    this.tutorId = tutorId;
    this.bookings = bookings;
  }

  book(studentId: string, range: TimeRange): Booking {
    if (!this.isAvailable(range)) throw new SlotUnavailableError(); // within the tutor's availability rules
    if (this.bookings.some(b => b.isActive() && b.range.overlaps(range))) throw new SlotUnavailableError();
    const booking = Booking.request(studentId, range);
    this.bookings.push(booking);
    return booking;
  }
}

• Rules for aggregates:
• keep them small: include only what's needed to protect an invariant (a tutor's schedule for the relevant period, not every booking ever);
• one transaction changes one aggregate: save the whole aggregate together (Module 56); rules that span aggregates are handled by events (Lesson 5) and eventual consistency (Module 94);
• refer to other aggregates by ID, not by holding them (a booking holds a studentId, not the whole student);
• protect against concurrent changes with a version number (optimistic locking) or a database constraint, so two simultaneous bookings can't both succeed (Module 91's ADR).
• Repositories (Module 92) load and save whole aggregates.