jwindridge / event-sourcing-kit Goto Github PK

Currently, repositories load all aggregate instances by replaying the full event history from version 0.

For small deployments / low-throughput systems this is fine (initially), however repository latency will increase linearly with application activity, since the repository will have to traverse more of the event history with each operation.

Adding an optional argument to the repository to allow it to intermittently save serialized aggregate states & only load events that have occurred since that point allows for faster load times.

Currently all attempts to apply a command to an aggregate with an incorrect version raise an error - need to add an optional function to an aggregate root that can determine whether the Repository can tolerate the version mismatch, or whether the command should be rejected.

Should receive the following arguments:

• currentState: Current state of the aggregate once all events from the store have been applied
• expectedState: State of the aggregate at the version expected by the command
• savedEvents: Array of the events that have been saved to the aggregate between the expected & current versions
• newEvents: Array of the domain events that caused the AppendOnlyStoreConcurrencyError

Function signature:

interface IConcurrentModificationHandler<T> {
  ({ 
      currentState: IAggregateState<T>, 
      expectedState: IAggregateState<T>, 
      newEvents: IDomainEvent[], 
      savedEvents: IAggregateEvent[]
  }): boolean
}

The function should return true iff all of the events rejected from the event store can be tolerated by the aggregate & should be appended onto the end of the event stream for this aggregate.

This can then be utilised within a try/catch block in a Repository in order to determine whether a "genuine" ConcurrencyError needs to be raised or whether it can be swallowed silently.

By using the @injectable & @inject decorators present within the inversify framework, the storage backing aggregate repositories, messaging, etc. can be implemented in this library while leaving wiring up of dependencies to consumers via appropriate set up of Inversify container instances at application startup.

File handles are left open in the _ensureExists function call, by virtue of a call to await fs.open(...) without a corresponding fs.close call

Currently the Eventstore implementation provides no way to store events from multiple bounded contexts (where aggregate names may clash).

Need to add a boundedContext or domain argument to the constructor to allow the same underlying event store to service multiple domains

The name of this interface is misleading, since it encompasses more than just the aggregate's state - this is made all the more confusing given that it actually has a state field.

Possible alternatives:

• IVersionedAggregateState
• IAggregateInstance