timebox

type AggregateID []ID

type Aggregator[T any] struct {
	// contains filtered or unexported fields
}

type AlwaysReady struct{}

type AppendRequest struct {
	StatusAt time.Time
	*Store
	Status           *string
	Labels           map[string]string
	ID               AggregateID
	Events           []*Event
	ExpectedSequence int64
}

type Applier[T any] func(T, *Event) T

type Appliers[T any] map[EventType]Applier[T]

type ArchiveHandler func(context.Context, *ArchiveRecord) error

type ArchiveRecord struct {
	StreamID         string
	AggregateID      AggregateID
	SnapshotData     json.RawMessage
	Events           []*Event
	SnapshotSequence int64
}

type Archiver interface {
	// Archive moves an aggregate's persisted artifacts into archive storage
	Archive(id AggregateID) error

	// ConsumeArchive blocks until one archive record is available or ctx
	// is done
	ConsumeArchive(ctx context.Context, handler ArchiveHandler) error
}

type Backend interface {
	Persistence
	Queries
}

type Codec[Value, Data any] interface {
	// Encode encodes a value to the codec data format
	Encode(Value) (Data, error)

	// Decode decodes codec data to a value
	Decode(Data) (Value, error)

	// Append appends an encoded value to a buffer
	Append(Data, Value) (Data, error)

	// Read reads a value from a buffer and returns the remainder
	Read(Data) (Value, Data, error)
}

type Command[T any] func(T, *Aggregator[T]) error

type Config struct {
	Indexer       Indexer
	SnapshotRatio float64
	MaxRetries    int
	CacheSize     int
	TrimEvents    bool
}

type Event struct {
	Timestamp   time.Time       `json:"timestamp"`
	Type        EventType       `json:"type"`
	AggregateID AggregateID     `json:"aggregate_id"`
	Data        json.RawMessage `json:"data"`
	Sequence    int64           `json:"sequence"`
	Raised      bool            `json:"-"`
	// contains filtered or unexported fields
}

type EventCodec[Data any] interface {
	Codec[*Event, Data]
}

type EventType string

type EventsResult struct {
	Events        []*Event
	StartSequence int64
}

type Executor[T any] struct {
	// contains filtered or unexported fields
}

type Flusher func(int64, []*Event) error

type Handler func(*Event) error

type ID string

type Index struct {
	// Status represents the resultant aggregate status. nil means no
	// status change, and "" clears any prior status
	Status *string `json:"status,omitempty"`

	// Labels updates current label values for the aggregate. nil means no
	// label changes, and empty values remove the label
	Labels map[string]string `json:"labels,omitempty"`
}

type Indexer func([]*Event) []*Index

type LoadEventsRequest struct {
	*Store
	ID      AggregateID
	FromSeq int64
}

type LoadSnapshotRequest struct {
	*Store
	ID AggregateID
}

type Persistence interface {
	io.Closer

	// NewStore creates a Store using this Persistence instance
	NewStore(Config) (*Store, error)

	// Ready reports when the persistence backend can serve requests
	Ready() <-chan struct{}

	// Append atomically appends events if the expected sequence still
	// matches. It returns a VersionConflictError when the sequence check
	// fails
	Append(AppendRequest) error

	// LoadEvents loads raw persisted events starting at fromSeq
	LoadEvents(LoadEventsRequest) (*EventsResult, error)

	// LoadSnapshot loads the raw snapshot and any trailing raw events
	LoadSnapshot(LoadSnapshotRequest) (*SnapshotRecord, error)

	// SaveSnapshot stores raw snapshot data using the supplied semantics
	SaveSnapshot(SnapshotRequest) error
}

type Queries interface {
	// ListAggregates lists aggregate IDs that match the provided prefix
	ListAggregates(id AggregateID) ([]AggregateID, error)

	// GetAggregateStatus loads the current indexed status for an aggregate
	GetAggregateStatus(id AggregateID) (string, error)

	// ListAggregatesByStatus lists aggregates currently indexed by status
	ListAggregatesByStatus(status string) ([]StatusEntry, error)

	// ListAggregatesByLabel lists aggregates currently indexed by
	// label/value
	ListAggregatesByLabel(label, value string) ([]AggregateID, error)

	// ListLabelValues lists the distinct indexed values for a label
	ListLabelValues(label string) ([]string, error)
}

type SnapshotRecord struct {
	Data     json.RawMessage
	Events   []*Event
	Sequence int64
}

type SnapshotRequest struct {
	*Store
	ID       AggregateID
	Data     []byte
	Sequence int64
}

type SnapshotResult struct {
	AdditionalEvents []*Event
	NextSequence     int64
	SnapshotSize     int
	EventsSize       int
}

type StatusEntry struct {
	Timestamp time.Time
	ID        AggregateID
}

type Store struct {
	Queries
	// contains filtered or unexported fields
}

type SuccessAction[T any] func(T, []*Event)

type VersionConflictError struct {
	NewEvents        []*Event
	ExpectedSequence int64
	ActualSequence   int64
}

type With[T any] interface {
	With(T) T
}