evercore

type Aggregate interface {
	GetId() int64
	SetId(int64)
	GetSequence() int64
	SetSequence(int64)
	GetAggregateType() string
	GetSnapshotFrequency() int64
	GetSnapshotState() (*string, error)
	DecodeEvent(ev SerializedEvent) (EventState, error)
	ApplyEventState(eventState EventState, eventTime time.Time, reference string) error
	ApplySnapshot(snapshot *Snapshot) error
}

type AggregateState struct {
	AggregateId int64
	NaturalKey  *string
	Snapshot    *Snapshot
	Events      EventSlice
}

type ContextOwner interface {
	// contains filtered or unexported methods
}

type EventDecoder func(aggregateType string, ev SerializedEvent) (EventState, error)

type EventSlice []SerializedEvent

type EventState interface {
	GetEventType() string
	Serialize() string
}

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

type EventStoreContext interface {
	EventStoreReadonlyContext
	NewAggregateId(aggregateType string) (int64, error)
	NewAggregateIdWithKey(aggregateType string, naturalKey string) (int64, error)

	LoadOrCreateAggregate(agg Aggregate, naturalKey string) (bool, error)
	CreateAggregateInto(agg Aggregate) error
	CreateAggregateWithKeyInto(agg Aggregate, naturalKey string) error
	ApplyEventTo(agg Aggregate, event EventState, time time.Time, reference string) error

	Publish(*SerializedEvent)
	SaveSnapshot(snapshot Snapshot)
}

type EventStoreContextType struct {
	Transaction StorageEngineTxInfo
	// contains filtered or unexported fields
}

type EventStoreReadonlyContext interface {
	LoadStateInto(aggregate Aggregate, id int64) error
	LoadStateByKeyInto(aggregate Aggregate, naturalKey string) error

	LoadAggregateState(aggregateType string, aggregateId int64) (*AggregateState, error)
	LoadAggregateStateByKey(aggregateType string, naturalKey string) (*AggregateState, error)
}

type IdNameMap map[int64]string

type IdNamePair struct {
	Id   int64
	Name string
}

type MemoryStorageEngine struct {
	CapturedEvents    []StorageEngineEvent
	CapturedSnapshots []Snapshot

	AggregateTypes     map[string]int64
	AggregateTypesInv  map[int64]string
	EventTypes         map[string]int64
	EventTypesInv      map[int64]string
	CountAggregateType int64
	CountEventTypes    int64
	CountAggregates    int64
	AggregateToTypeId  map[int64]int64
	Aggregates         map[string]int64
	AggregateInv       map[int64]*string
}

type MemoryStorageEngineTransaction struct {
}

type NameIdMap map[string]int64

type SerializedEvent struct {
	AggregateId int64
	EventType   string
	State       string
	Sequence    int64
	Reference   string
	EventTime   time.Time
}

type Snapshot struct {
	AggregateId int64
	State       string
	Sequence    int64
}

type SnapshotSlice []Snapshot

type StateAggregate[T any] struct {
	Id       int64
	State    T
	Sequence int64
	// contains filtered or unexported fields
}

type StateEvent[T any] struct {
	State T
}

type StorageEngine interface {

	// Gets the maximum length of a natural key
	GetMaxKeyLength() int

	// Gets the id for the event type string.  It is added if it does not already exist.
	GetEventTypeId(tx StorageEngineTxInfo, ctx context.Context, typeName string) (int64, error)

	// Gets the id for the aggregate type string.  It is added if it does not already exist.
	GetAggregateTypeId(tx StorageEngineTxInfo, ctx context.Context, typeName string) (int64, error)

	// Adds a new aggregate of the specified type to the store and returns the id.
	NewAggregate(tx StorageEngineTxInfo, ctx context.Context, aggregateTypeId int64) (int64, error)

	// Adds a new aggregate of the specified type with the natural key to the store and returns the id.
	NewAggregateWithKey(tx StorageEngineTxInfo, ctx context.Context, aggregateTypeId int64, natrualKey string) (int64, error)

	// Gets aggregate id and corresponding natural key that corresponds to the type and id.
	GetAggregateById(tx StorageEngineTxInfo, ctx context.Context, aggregateTypeId int64, aggregateId int64) (int64, *string, error)

	// Gets the aggregate id corresponding to the type and natural key.
	GetAggregateByKey(tx StorageEngineTxInfo, ctx context.Context, aggregateTypeId int64, naturalKey string) (int64, error)

	// Gets or creates an aggregate id for the given type and natural key.
	// If an aggregate with the given natural key already exists, returns false and its id.
	// Otherwise creates a new aggregate with the key and returns true and its new id.
	// Returns error if:
	// - The natural key exceeds maximum length (ErrorKeyExceedsMaximumLength)
	// - The aggregate type doesn't exist
	// - There are database errors
	GetOrCreateAggregateByKey(tx StorageEngineTxInfo, ctx context.Context, aggregateTypeId int64, naturalKey string) (bool, int64, error)

	// Loads all the aggregate types.
	GetAggregateTypes(tx StorageEngineTxInfo, ctx context.Context) ([]IdNamePair, error)

	// Loads all the event types.
	GetEventTypes(tx StorageEngineTxInfo, ctx context.Context) ([]IdNamePair, error)

	// Gets a snapshot (if any) for the specified aggregate.
	GetSnapshotForAggregate(tx StorageEngineTxInfo, ctx context.Context, aggregateId int64) (*Snapshot, error)

	// Retrieve events for an aggregate which are after a sequence.
	GetEventsForAggregate(tx StorageEngineTxInfo, ctx context.Context, aggregateId int64, afterSequence int64) ([]SerializedEvent, error)

	// Writes events to storage.
	WriteState(tx StorageEngineTxInfo, ctx context.Context, events []StorageEngineEvent, snapshot SnapshotSlice) error

	// Gets a transaction state to track multiple
	GetTransactionInfo() (StorageEngineTxInfo, error)
}

type StorageEngineError struct {
	// The underlying error that triggered this error
	Err error
	// A human-readable message describing the error
	Message string
	// The type of error that occurred
	ErrorType string
}

type StorageEngineEvent struct {
	AggregateID int64
	Sequence    int64
	EventTypeID int64
	State       string
	EventTime   time.Time
	Reference   string
}

type StorageEngineTxInfo interface {
	Commit() error
	Rollback() error
}