goengine

type EventStore interface {
	ReadOnlyEventStore

	// Create creates an event stream
	Create(ctx context.Context, streamName StreamName) error

	// AppendTo appends the provided messages to the stream
	AppendTo(ctx context.Context, streamName StreamName, streamEvents []Message) error
}

type EventStream interface {
	// Next prepares the next result for reading.
	// It returns true on success, or false if there is no next result row or an error happened while preparing it.
	// Err should be consulted to distinguish between the two cases.
	Next() bool

	// Err returns the error, if any, that was encountered during iteration.
	Err() error

	// Close closes the EventStream, preventing further enumeration. If Next is called
	// and returns false and there are no further result sets,
	// result of Err. Close is idempotent and does not affect the result of Err.
	Close() error

	// Message returns the current message and it's number within the EventStream.
	Message() (Message, int64, error)
}

type Fields map[string]interface{}

type InvalidArgumentError string

type Logger interface {
	Error(msg string, fields func(LoggerEntry))
	Warn(msg string, fields func(LoggerEntry))
	Info(msg string, fields func(LoggerEntry))
	Debug(msg string, fields func(LoggerEntry))

	WithFields(fields func(LoggerEntry)) Logger
}

type LoggerEntry interface {
	Int(k string, v int)
	Int64(s string, v int64)
	String(k, v string)
	Error(err error)
	Any(k string, v interface{})
}

type Message interface {
	// UUID returns the identifier of this message
	UUID() UUID

	// CreatedAt returns the created time of the message
	CreatedAt() time.Time

	// Payload returns the payload of the message
	Payload() interface{}

	// Metadata return the message metadata
	Metadata() metadata.Metadata

	// WithMetadata Returns new instance of the message with key and value added to metadata
	WithMetadata(key string, value interface{}) Message
}

type MessageHandler func(ctx context.Context, state interface{}, message Message) (interface{}, error)

type MessagePayloadConverter interface {
	// ConvertPayload generates unique name for the event_name
	ConvertPayload(payload interface{}) (name string, data []byte, err error)
}

type MessagePayloadFactory interface {
	// CreatePayload returns a reconstructed payload or a error
	CreatePayload(payloadType string, data interface{}) (interface{}, error)
}

type MessagePayloadResolver interface {
	// ResolveName resolves the name of the underlying payload type
	ResolveName(payload interface{}) (string, error)
}

type Projection interface {
	Query

	// Name returns the name of the projection
	Name() string

	// FromStream returns the stream this projection is based on
	FromStream() StreamName
}

type ProjectionSaga interface {
	Projection

	// DecodeState reconstitute the projection state based on the provided state data
	DecodeState(data []byte) (interface{}, error)

	// EncodeState encode the given object for storage
	EncodeState(obj interface{}) ([]byte, error)
}

type Query interface {
	// init initializes the state of the Query
	Init(ctx context.Context) (interface{}, error)

	// Handlers return the handlers for a set of messages
	Handlers() map[string]MessageHandler
}

type ReadOnlyEventStore interface {
	// HasStream returns true if the stream exists
	HasStream(ctx context.Context, streamName StreamName) bool

	// Load returns a list of events based on the provided conditions
	Load(ctx context.Context, streamName StreamName, fromNumber int64, count *uint, metadataMatcher metadata.Matcher) (EventStream, error)
}

type StreamName string

type UUID = uuid.UUID