projection

type Cancel func()

type CatchUpCallback func(context.Context, eventid.EventID) (eventid.EventID, error)

type CatchUpOptions struct {
	StartOffset          time.Duration
	CatchUpWindow        time.Duration
	UpdateResumeInterval time.Duration

	AggregateKinds []eventsourcing.Kind
	// Metadata filters on top of metadata. Every key of the map is ANDed with every OR of the values
	// eg: [{"geo": "EU"}, {"geo": "USA"}, {"membership": "prime"}] equals to:  geo IN ("EU", "USA") AND membership = "prime"
	Metadata store.MetadataFilter
}

type Checkpoints[K eventsourcing.ID] struct {
	// contains filtered or unexported fields
}

type Consumer[K eventsourcing.ID] interface {
	Topic() string
	// returns the subscriber Positions. The first Position should be 1
	StartConsumer(ctx context.Context, startTime *time.Time, projectionName string, handle ConsumerHandler[K], options ...ConsumerOption[K]) error
}

type ConsumerHandler[K eventsourcing.ID] func(ctx context.Context, e *sink.Message[K], partition uint32, seq uint64) error

type ConsumerOption[K eventsourcing.ID] func(*ConsumerOptions[K])

type ConsumerOptions[K eventsourcing.ID] struct {
	Filter  func(e *sink.Message[K]) bool
	AckWait time.Duration
}

type ConsumerTopic struct {
	Topic      string
	Partitions []uint32
}

type Event[K eventsourcing.ID] struct {
	ID               eventid.EventID
	AggregateID      K
	AggregateVersion uint32
	AggregateKind    eventsourcing.Kind
	Kind             eventsourcing.Kind
	Body             encoding.Base64
	Metadata         eventsourcing.Metadata
	CreatedAt        time.Time
}

type EventsRepository[K eventsourcing.ID] interface {
	GetEvents(ctx context.Context, afterEventID eventid.EventID, untilEventID eventid.EventID, batchSize int, filter store.Filter) ([]*eventsourcing.Event[K], error)
}

type GetEventsReply[K eventsourcing.ID] struct {
	Events []*eventsourcing.Event[K]
	Error  error
}

type GrpcRepository[K eventsourcing.ID, PK eventsourcing.IDPt[K]] struct {
	// contains filtered or unexported fields
}

type GrpcServer[K eventsourcing.ID] struct {
	// contains filtered or unexported fields
}

type HandleEventsReply[K eventsourcing.ID] struct {
	AfterEventID eventid.EventID
	Count        int64
	Error        error
}

type LockerFactory func(lockName string) dist.Locker

type Message[K eventsourcing.ID] struct {
	Meta    Meta
	Message *sink.Message[K]
}

type MessageHandlerFunc[K eventsourcing.ID] func(ctx context.Context, e *sink.Message[K]) error

type MessageKind string

type Meta struct {
	Name      string
	Kind      MessageKind
	Partition uint32
	Sequence  uint64
}

type Option[K eventsourcing.ID] func(*Player[K])

type Player[K eventsourcing.ID] struct {
	// contains filtered or unexported fields
}

type Projection[K eventsourcing.ID] interface {
	Name() string
	CatchUpOptions() CatchUpOptions
	Handle(ctx context.Context, e Message[K]) error
}

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

type Start int

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

type SubscriberFactory[K eventsourcing.ID] func(context.Context, ResumeKey) Consumer[K]

type Token struct {
	Done    bool            `json:"done"`
	EventID eventid.EventID `json:"eventID,omitempty"`
}

type WaitLockerFactory func(lockName string) dist.WaitLocker