sql

type EventStreamLoader func(ctx context.Context, conn *sql.Conn, notification *ProjectionNotification, position int64) (goengine.EventStream, error)

type Execer interface {
	ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)
}

type Listener interface {
	// Listen starts listening to the event stream and call the trigger when a event was appended
	Listen(ctx context.Context, trigger ProjectionTrigger) error
}

type MessageFactory interface {
	// CreateEventStream reconstructs the message from the provided rows
	CreateEventStream(rows *sql.Rows) (goengine.EventStream, error)
}

type PersistenceStrategy interface {
	CreateSchema(tableName string) []string
	ColumnNames() []string
	PrepareData([]goengine.Message) ([]interface{}, error)
	GenerateTableName(streamName goengine.StreamName) (string, error)
}

type ProjectionErrorAction int

type ProjectionErrorCallback func(err error, notification *ProjectionNotification) ProjectionErrorAction

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

type ProjectionNotification struct {
	No          int64  `json:"no"`
	AggregateID string `json:"aggregate_id"`
}

type ProjectionRawState struct {
	Position        int64
	ProjectionState []byte
}

type ProjectionState struct {
	Position        int64
	ProjectionState interface{}
}

type ProjectionStateDecoder func(data []byte) (interface{}, error)

type ProjectionStateEncoder func(interface{}) ([]byte, error)

type ProjectionStateInitializer func(ctx context.Context) (interface{}, error)

type ProjectionStorage interface {
	// PersistState persists the state of the projection
	PersistState(conn Execer, notification *ProjectionNotification, state ProjectionState) error

	// Acquire this function is used to acquire the projection and it's projectionState
	// A projection can only be acquired once and must be released using the returned func
	Acquire(ctx context.Context, conn *sql.Conn, notification *ProjectionNotification) (func(), *ProjectionRawState, error)
}

type ProjectionTrigger func(ctx context.Context, notification *ProjectionNotification) error

type Queryer interface {
	QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)
}

type ReadOnlyEventStore interface {
	// LoadWithConnection returns a eventstream based on the provided constraints using the provided Queryer
	LoadWithConnection(ctx context.Context, conn Queryer, streamName goengine.StreamName, fromNumber int64, count *uint, metadataMatcher metadata.Matcher) (goengine.EventStream, error)
}