persistence

type AggregateMetaData struct {
	// HandlerKey is the identity key of the aggregate message handler.
	HandlerKey string

	// InstanceID is the aggregate instance ID.
	InstanceID string

	// Revision is the instance's current version, used to enforce optimistic
	// concurrency control.
	Revision uint64

	// LastEventID is the ID of the most recent event message recorded against
	// the instance.
	LastEventID string
}

type AggregateRepository interface {
	// LoadAggregateMetaData loads the meta-data for an aggregate instance.
	//
	// hk is the aggregate handler's identity key, id is the instance ID.
	LoadAggregateMetaData(
		ctx context.Context,
		hk, id string,
	) (AggregateMetaData, error)
}

type Batch []Operation

type ConflictError struct {
	// Cause is the operation that caused the conflict.
	Cause Operation
}

type DataStore interface {
	AggregateRepository
	EventRepository
	OffsetRepository
	ProcessRepository
	QueueRepository

	Persister

	// Close closes the data store.
	//
	// Closing a data-store causes any future calls to Persist() to return
	// ErrDataStoreClosed.
	//
	// The behavior read operations on a closed data-store is
	// implementation-defined.
	//
	// In general use it is expected that all pending calls to Persist() will
	// have finished before a data-store is closed. Close() may block until any
	// in-flight calls to Persist() return, or may prevent any such calls from
	// succeeding.
	Close() error
}

type DataStoreSet struct {
	Provider Provider
	// contains filtered or unexported fields
}

type Event struct {
	Offset   uint64
	Envelope *envelopespec.Envelope
}

type EventRepository interface {
	// NextEventOffset returns the next "unused" offset.
	NextEventOffset(ctx context.Context) (uint64, error)

	// LoadEventsByType loads events that match a specific set of message types.
	//
	// f is the set of message types to include in the result. The keys of f are
	// the "portable type name" produced when the events are marshaled.
	//
	// o specifies the (inclusive) lower-bound of the offset range to include in
	// the results.
	LoadEventsByType(
		ctx context.Context,
		f map[string]struct{},
		o uint64,
	) (EventResult, error)

	// LoadEventsBySource loads the events produced by a specific handler.
	//
	// hk is the handler's identity key.
	//
	// id is the instance ID, which must be empty if the handler type does not
	// use instances.
	LoadEventsBySource(
		ctx context.Context,
		hk, id string,
	) (EventResult, error)
}

type EventResult interface {
	// Next returns the next event in the result.
	//
	// It returns false if the are no more events in the result.
	Next(ctx context.Context) (Event, bool, error)

	// Close closes the cursor.
	Close() error
}

type OffsetRepository interface {
	// LoadOffset loads the offset associated with a specific application.
	//
	// ak is the application's identity key.
	LoadOffset(ctx context.Context, ak string) (uint64, error)
}

type Operation interface {
	// AcceptVisitor calls the appropriate visit method on the given visitor.
	AcceptVisitor(context.Context, OperationVisitor) error
	// contains filtered or unexported methods
}

type OperationVisitor interface {
	VisitSaveAggregateMetaData(context.Context, SaveAggregateMetaData) error
	VisitSaveEvent(context.Context, SaveEvent) error
	VisitSaveProcessInstance(context.Context, SaveProcessInstance) error
	VisitRemoveProcessInstance(context.Context, RemoveProcessInstance) error
	VisitSaveQueueMessage(context.Context, SaveQueueMessage) error
	VisitRemoveQueueMessage(context.Context, RemoveQueueMessage) error
	VisitSaveOffset(context.Context, SaveOffset) error
}

type Persister interface {
	// Persist commits a batch of operations atomically.
	//
	// If any one of the operations causes an optimistic concurrency conflict
	// the entire batch is aborted and a ConflictError is returned.
	Persist(context.Context, Batch) (Result, error)
}

type ProcessInstance struct {
	// HandlerKey is the identity key of the process message handler.
	HandlerKey string

	// InstanceID is the process instance ID.
	InstanceID string

	// Revision is the instance's current version, used to enforce optimistic
	// concurrency control.
	Revision uint64

	// Packet contains the binary representation of the process state.
	Packet marshaler.Packet
}

type ProcessRepository interface {
	// LoadProcessInstance loads a process instance.
	//
	// hk is the process handler's identity key, id is the instance ID.
	LoadProcessInstance(
		ctx context.Context,
		hk, id string,
	) (ProcessInstance, error)
}

type Provider interface {
	// Open returns a data-store for a specific application.
	//
	// k is the identity key of the application.
	//
	// Data stores are opened for exclusive use. If another engine instance has
	// already opened this application's data-store, ErrDataStoreLocked is
	// returned.
	Open(ctx context.Context, k string) (DataStore, error)
}

type QueueMessage struct {
	Revision      uint64
	FailureCount  uint
	NextAttemptAt time.Time
	Envelope      *envelopespec.Envelope
}

type QueueRepository interface {
	// LoadQueueMessages loads the next n messages from the queue.
	LoadQueueMessages(ctx context.Context, n int) ([]QueueMessage, error)
}

type RemoveProcessInstance struct {
	// Instance is the instance to remove.
	//
	// Instance.Revision must be the revision of the process instance as
	// currently persisted, otherwise an optimistic concurrency conflict occurs
	// and the entire batch of operations is rejected.
	Instance ProcessInstance
}

type RemoveQueueMessage struct {
	// Message is the message to remove from the queue.
	//
	// The message's revision field must be the revision of the message as
	// currently persisted, otherwise an optimistic concurrency conflict occurs
	// and the entire batch of operations is rejected.
	Message QueueMessage
}

type Result struct {
	// EventOffset contains the offsets of the events saved within the batch,
	// keyed by their message ID.
	EventOffsets map[string]uint64
}

type SaveAggregateMetaData struct {
	// MetaData is the meta-data to persist.
	//
	// MetaData.Revision must be the revision of the aggregate instance as
	// currently persisted, otherwise an optimistic concurrency conflict occurs
	// and the entire batch of operations is rejected.
	MetaData AggregateMetaData
}

type SaveEvent struct {
	// Envelope is the envelope containing the event to persist.
	Envelope *envelopespec.Envelope
}

type SaveOffset struct {
	// ApplicationKey is the identity key of the source application.
	ApplicationKey string

	// CurrentOffset must be offset currently associated with this application,
	// otherwise an optimistic concurrency conflict occurs and the entire batch
	// of operations is rejected.
	CurrentOffset uint64

	// NextOffset is the next offset to consume from this application.
	NextOffset uint64
}

type SaveProcessInstance struct {
	// Instance is the instance to persist.
	//
	// Instance.Revision must be the revision of the process instance as
	// currently persisted, otherwise an optimistic concurrency conflict occurs
	// and the entire batch of operations is rejected.
	Instance ProcessInstance
}

type SaveQueueMessage struct {
	// Message is the message to persist to the queue.
	//
	// The message's revision field must be the revision of the message as
	// currently persisted, otherwise an optimistic concurrency conflict occurs
	// and the entire batch of operations is rejected.
	Message QueueMessage
}

type UnknownMessageError struct {
	MessageID string
}