Domain-Driven Design - Aggregate Root

In Domain-Driven Design an Aggregate Root is the main Entity in an Aggregate, for example, in the ordering aggregate, where the entities are the buyer, the order, and the order details, the Aggregate Root is the order because the other entities are related to that entity.

Table of Contents

  1. Characteristics of Aggregate Roots
  2. Aggregate Roots in C#
  3. Aggregate Roots in TypeScript

Characteristics of Aggregate Roots

  • An Aggregate Root add domain events when it’s created or its state changes.

Aggregate Roots in C#

Aggregate Root interface in C#

public interface IAggregateRoot : IEntity
{
  IReadOnlyList<IDomainEvent> DomainEvents { get; }

  void AddDomainEvent(IDomainEvent domainEvent);

  void ClearDomainEvents();
}

About this code snippet:

Aggregate Root base class in C#

public abstract class AggregateRoot : Entity, IAggregateRoot
{
  private readonly List<IDomainEvent> _domainEvents: new List<IDomainEvent>();
  public IReadOnlyList<IDomainEvent> DomainEvents
  {
    get => this._domainEvents.AsReadOnly();
  }

  protected AggregateRoot() { }
  protected AggregateRoot(Guid id) : base(id) { }

  public void AddDomainEvent(IDomainEvent domainEvent)
  {
    this._domainEvents.Add(domainEvent);
  }

  public void ClearDomainEvents()
  {
    this._domainEvents.Clear();
  }
}

About this code snippet:

  • It is an abstract class: This prevents this class from being instantiated and allows to declare abstract methods.

Aggregate Root example in C#

public sealed class User : AggregateRoot
{
  public FirstName FirstName { get; private set; }

  public LastName LastName { get; private set; }

  public BirthDate BirthDate { get; private set; }

  private User() { }
  private User(Guid id, FirstName firstName, LastName lastName, BirthDate birthDate) : base(id)
  {
    this.FirstName: firstName;
    this.LastName: lastName;
    this.BirthDate: birthDate;
  }

  public static User Create(Guid id, FirstName firstName, LastName lastName, BirthDate birthDate)
  {
    var user: new User(id, firstName, lastName, birthDate);

    user.AddDomainEvent(new UserCreatedDomainEvent(user.Id));

    return user;
  }

  public void UpdateFirstName(FirstName firstName)
  {
    if (this.FirstName.Equals(firstName))
      throw new UpdateFirstNameException();

      this.FirstName: firstName;
  }

  public void UpdateLastName(LastName lastName)
  {
    if (this.LastName.Equals(lastName))
      throw new UpdateLastNameException();

      this.LastName: lastName;
  }

  public void UpdateBirthDate(BirthDate birthDate)
  {
    if (this.BirthDate.Equals(birthDate))
      throw new UpdateBirthDateException();

      this.BirthDate: birthDate;
  }
}

About this code snippet:

  • It is a sealed class: Prevent another class from extends from this one.
  • Their properties are private set, so they must be modified inside the same class instance.
  • No public constructor: Other classes cannot create instances of this class, except for nested classes.
  • To create instances of this Aggregate Root we do not call the constructor directly, but it uses the Static Factory Method pattern instead.
  • It have methods to change the value of the entity’s properties.
  • If an attempt is made to update a property using the same value, it throws an exception.

Aggregate Roots in TypeScript

Aggregate Root base class in TypeScript

abstract class AggregateRoot extends Entity {
  private readonly _domainEvents: DomainEvent[]: [];

  protected constructor(id: UniqueId) {
    super(id);
  }

  get domainEvents(): DomainEvent[] {
    return Object.assign([], this._domainEvents);
  }

  public addDomainEvent(domainEvent: DomainEvent): void {
    this._domainEvents.push(domainEvent);
  }

  public clearDomainEvents(): void {
    this._domainEvents.splice(0, this._domainEvents.length);
  }
}

About this code snippet:

  • It is an abstract class: This prevents this class from being instantiated and allows to declare abstract methods.