Building a Domain Events Subject

// shared/domain/AggregateRoot.ts

import { Entity } from "./Entity"
import { IDomainEvent } from "./events/IDomainEvent"
import { DomainEvents } from "./events/DomainEvents"
import { UniqueEntityID } from "./UniqueEntityID"

export abstract class AggregateRoot<T> extends Entity<T> {
  /**
   * All of the domain events for a subclass of AggregateRoot<T>
   * get added to this private array.
   */

  private _domainEvents: IDomainEvent[] = []

  get id(): UniqueEntityID {
    return this._id
  }

  get domainEvents(): IDomainEvent[] {
    return this._domainEvents
  }

  /**
   * @method addDomainEvent
   * @protected
   * @desc Called by a subclass in order to add a Domain Event
   * to the list of Domain Events currently on this aggregate
   * within a transactional boundary. Also notifies the DomainEvents
   * subject that the current aggregate has at least one Domain Event
   * that we will need to publish if the transaction completes.
   */

  protected addDomainEvent(domainEvent: IDomainEvent): void {
    // Add the domain event to this aggregate's list of domain events
    this._domainEvents.push(domainEvent)
    // Add this aggregate instance to the domain event's list of aggregates who's
    // events it eventually needs to dispatch.
    DomainEvents.markAggregateForDispatch(this)
    // Log the domain event
    this.logDomainEventAdded(domainEvent)
  }

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

  private logDomainEventAdded(domainEvent: IDomainEvent): void {
    const thisClass = Reflect.getPrototypeOf(this)
    const domainEventClass = Reflect.getPrototypeOf(domainEvent)
    console.info(
      `[Domain Event Created]:`,
      thisClass.constructor.name,
      "==>",
      domainEventClass.constructor.name
    )
  }
}