esrc

type Aggregate interface {
	ID() ID
	InitialVersion() int
	Changes() []Event
	Snapshot() ([]byte, error)
}

type AggregateFactory[T Aggregate] interface {
	NewAggregateFromSnapshotAndEvents(RawSnapshot, []Event) (T, error)
	NewAggregateFromEvents([]Event) (T, error)
}

type AggregateType string

type Event interface {
	EventName() string
}

type EventFactory interface {
	CreateEmptyEvent(name string) (Event, error)
}

type EventMarshaler interface {
	MarshalEvent(Event) ([]byte, error)
	UnmarshalEvent([]byte, Event) error
}

type EventRaiserAggregate struct {
	// contains filtered or unexported fields
}

type EventStore interface {
	// AddAggregate adds a new aggregate to the event store.
	// errs:
	// 		ErrAggregateAlreadyExists
	//		ErrAggregateRequiresEvents
	AddAggregate(context.Context, AggregateType, ID, []RawEvent) error
	// AppendEvents adds events to an existing aggregate.
	// errs:
	//		ErrAggregateNotFound
	//		ErrOptimisticConcurrency
	AppendEvents(ctx context.Context, t AggregateType, id ID, fromVersion int, events []RawEvent) error
	// AddSnapshot stores a snapshot of an aggregate.
	// errs:
	//		ErrAggregateNotFound
	//		ErrSnapshotWithGreaterVersionThanAggregate
	AddSnapshot(context.Context, AggregateType, ID, RawSnapshot) error
	// LatestSnapshot retrieves the snapshot with higher version of an aggregate. Returns a nil snapshot if there isn't any.
	LatestSnapshot(context.Context, AggregateType, ID) (*RawSnapshot, error)
	// Events retrieves all events of an aggregate from a given event number. If requested from event 0 all events
	// are obtained.
	Events(ctx context.Context, t AggregateType, id ID, fromEventNumber int) ([]RawEvent, error)
	// Contains looks if there is an event stream for an aggregate ID without loading its events,
	// returns true if the aggregate exists.
	ContainsAggregate(context.Context, AggregateType, ID) (bool, error)
}

type ID any

type JSONEventMarshaler struct{}

type MockAggregate struct {
	IDFn             func() ID
	InitialVersionFn func() int
	ChangesFn        func() []Event
	SnapshotFn       func() ([]byte, error)
}

type MockAggregateFactory[T Aggregate] struct {
	NewAggregateFromSnapshotAndEventsFn func(RawSnapshot, []Event) (T, error)
	NewAggregateFromEventsFn            func([]Event) (T, error)
}

type MockEvent struct {
	EventNameFn func() string
}

type MockEventFactory struct {
	CreateEmptyEventFn func(name string) (Event, error)
}

type MockEventMarshaler struct {
	MarshalEventFn   func(Event) ([]byte, error)
	UnmarshalEventFn func([]byte, Event) error
}

type MockEventStore struct {
	AddAggregateFn      func(context.Context, AggregateType, ID, []RawEvent) error
	AppendEventsFn      func(ctx context.Context, t AggregateType, id ID, fromVersion int, events []RawEvent) error
	AddSnapshotFn       func(context.Context, AggregateType, ID, RawSnapshot) error
	LatestSnapshotFn    func(context.Context, AggregateType, ID) (*RawSnapshot, error)
	EventsFn            func(context.Context, AggregateType, ID, int) ([]RawEvent, error)
	ContainsAggregateFn func(context.Context, AggregateType, ID) (bool, error)
}

type RawEvent struct {
	Name string
	Data []byte
}

type RawSnapshot struct {
	Version int
	Data    []byte
}

type Repository[T Aggregate] struct {
	// contains filtered or unexported fields
}

type RepositoryOption[T Aggregate] func(*Repository[T])