models

type AggregateStateProjection interface {
	Apply
	// contains filtered or unexported methods
}

type Apply interface {
	// Apply a new event to the aggregate state, adds the event to the list of pending changes,
	// and increases the `CurrentVersion` property and `LastCommittedVersion` will be unchanged.
	Apply(event domain.IDomainEvent, isNew bool) error
}

type EventSourcedAggregateRoot struct {
	*domain.Entity
	// contains filtered or unexported fields
}

type EventSourcedAggregateRootDataModel struct {
	*domain.EntityDataModel
	OriginalVersion int64 `json:"originalVersion" bson:"originalVersion"`
}

type IEventSourcedAggregateRoot interface {
	domain.IEntity

	// OriginalVersion Gets the original version is the aggregate version we got from the store. This is used to ensure optimistic concurrency,
	// to check if there were no changes made to the aggregate state between load and save for the current operation.
	OriginalVersion() int64

	SetOriginalVersion(version int64)

	// CurrentVersion Gets the current version is set to original version when the aggregate is loaded from the store.
	// It should increase for each state transition performed within the scope of the current operation.
	CurrentVersion() int64

	// AddDomainEvents adds a new domain_events event to the aggregate's uncommitted events.
	AddDomainEvents(event domain.IDomainEvent) error

	// MarkUncommittedEventAsCommitted Mark all changes (events) as committed, clears uncommitted changes and updates the current version of the aggregate.
	MarkUncommittedEventAsCommitted()

	// HasUncommittedEvents Does the aggregate have change that have not been committed to storage
	HasUncommittedEvents() bool

	// UncommittedEvents Gets a list of uncommitted events for this aggregate.
	UncommittedEvents() []domain.IDomainEvent

	// LoadFromHistory Loads the current state of the aggregate from a list of events.
	LoadFromHistory(events []domain.IDomainEvent, metadata metadata.Metadata) error

	AggregateStateProjection
}

type IHaveEventSourcedAggregate interface {
	When
	NewEmptyAggregate()
	IEventSourcedAggregateRoot
}

type StreamEvent struct {
	EventID  uuid.UUID
	Version  int64
	Position int64
	Event    domain.IDomainEvent
	Metadata metadata.Metadata
}

type When interface {
	// When Update the aggregate state with new events that are added to the event store and also for events that are already in the event store without increasing the version.
	When(event domain.IDomainEvent) error
}

type WhenFunc func(event domain.IDomainEvent) error