eventsource

type Aggregate interface {
	ID() AggregateID
	Type() AggregateType
	Version() AggregateVersion
	Changes() []Event
	StackChange(change Event)
	StackSnapshot(snapshot *Snapshot)
	StackedSnapshots() []*Snapshot
	SnapshotsWithFrequency(frequency int) []*Snapshot
	SetVersion(version AggregateVersion)
	IncrementVersion()
	PrepareForLoading()
	ParseEvents(context.Context, ...EventReadModel) []Event
}

type AggregateID string

type AggregateType string

type AggregateVersion int

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

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

type Event interface {
	fmt.Stringer
	ApplyTo(ctx context.Context, aggregate Aggregate) // ApplyTo applies the event to the aggregate
	ID() EventID                                      // ID returns the id of the event.
	Type() EventType                                  // Type returns the type of the event.
	OccurredAt() time.Time                            // OccurredAt of when the event was created.
	AggregateID() AggregateID                         // AggregateID is the id of the aggregate that the event belongs to.
	AggregateType() AggregateType                     // AggregateType is the type of the aggregate that the event can be applied to.
	AggregateVersion() AggregateVersion               // AggregateVersion is the version of the aggregate after the event has been applied.
	SetVersion(AggregateVersion)                      // SetVersion sets the aggregate version of the event
	Metadata() Metadata                               // Metadata is app-specific metadata such as request AggregateID, originating user etc.
}

type EventID string

type EventReadModel struct {
	ID               EventID                `json:"id"`
	Type             EventType              `json:"type"`
	OccurredAt       time.Time              `json:"occurred_at"`
	AggregateID      AggregateID            `json:"aggregate_id"`
	AggregateType    AggregateType          `json:"aggregate_type"`
	AggregateVersion AggregateVersion       `json:"aggregate_version"`
	Metadata         map[string]interface{} `json:"metadata"`
	Data             json.RawMessage        `json:"data"`
}

type EventStore interface {
	Save(ctx context.Context, tx Transaction, a Aggregate, opts ...SaveOption) error
	Load(ctx context.Context, tx Transaction, a Aggregate) (Aggregate, error)
	EventsHistory(ctx context.Context, tx Transaction, aggregateID, aggregateType string, fromVersion int, limit int) ([]EventReadModel, error)
}

type EventType string

type Marshaler interface {
	MarshalES() ([]byte, error)
}

type Metadata map[string]interface{}

type SaveOption func(*SaveOptions)

type SaveOptions struct {
	WithSnapshot          bool
	WithSnapshotFrequency int
}

type Snapshot struct {
	AggregateID      AggregateID
	AggregateType    AggregateType
	AggregateVersion AggregateVersion
	TakenAt          time.Time
	Data             []byte
}

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

type Unmarshaler interface {
	UnmarshalES(b []byte, object any) error
}