saga

type Aggregate struct {
	ErrorIfNotFound
	CompletableByData

	Prototype Data
	Triggers  ax.MessageTypeSet
	Handle    typeswitch.Switch
	Apply     typeswitch.Switch
}

type Applier struct {
	Saga EventedSaga
	Data Data

	Next ax.Sender
}

type CompletableByData struct{}

type CompletableData interface {
	Data

	// IsInstanceComplete returns true if the data describes a "completed"
	// instance.
	IsInstanceComplete() bool
}

type Data interface {
	proto.Message

	// InstanceDescription returns a human-readable description of the saga
	// instance.
	//
	// Assume that the description will be used inside log messages or displayed
	// in audit logs.
	//
	// Follow the same conventions as for error messages:
	// https://github.com/golang/go/wiki/CodeReviewComments#error-strings
	InstanceDescription() string
}

type ErrorIfNotFound struct{}

type EventedSaga interface {
	Saga

	// ApplyEvent updates d to reflect the fact that an event has occurred.
	//
	// It may panic if env.Message does not implement ax.Event.
	ApplyEvent(d Data, env ax.Envelope)
}

type IgnoreNotFound struct{}

type Instance struct {
	// InstanceID is a globally unique identifier for the saga instance.
	InstanceID InstanceID

	// Data is the application-defined data associated with this instance.
	Data Data

	// Revision is the version of the instance that the Data field reflects.
	// A value of zero indicates that the instance has not yet been persisted.
	Revision Revision
}

type InstanceID struct {
	ident.ID
}

type InstancesNeverComplete struct{}

type Mapper interface {
	// MapMessageToInstance returns the ID of the saga instance that is the
	// target of the given message.
	//
	// It returns false if the message should be ignored.
	MapMessageToInstance(
		ctx context.Context,
		sg Saga,
		tx persistence.Tx,
		env ax.Envelope,
	) (InstanceID, bool, error)

	// UpdateMapping notifies the mapper that an instance has been modified,
	// allowing it to update it's mapping information, if necessary.
	UpdateMapping(
		ctx context.Context,
		sg Saga,
		tx persistence.Tx,
		i Instance,
	) error

	// DeleteMapping notifies the mapper that an instance has been completed,
	// allowing it to remove it's mapping information, if necessary.
	DeleteMapping(
		ctx context.Context,
		sg Saga,
		tx persistence.Tx,
		i Instance,
	) error
}

type MessageHandler struct {
	Saga      Saga
	Mapper    Mapper
	Persister Persister
}

type Persister interface {
	// BeginUnitOfWork starts a new unit-of-work that modifies a saga instance.
	//
	// If the saga instance does not exist, it returns a UnitOfWork with an
	// instance at revision zero.
	BeginUnitOfWork(
		ctx context.Context,
		sg Saga,
		tx persistence.Tx,
		s ax.Sender,
		id InstanceID,
	) (UnitOfWork, error)
}

type Revision uint64

type Saga interface {
	// PersistenceKey returns a unique identifier for the saga.
	//
	// The persistence key is used to relate persisted data with the saga
	// implementation that owns it. Persistence keys should not be changed once
	// a saga has active instances.
	PersistenceKey() string

	// MessageTypes returns the set of messages that are routed to this saga.
	//
	// tr is the set of "trigger" messages. If they can not be routed to an
	// existing saga instance a new instance is created.
	//
	// mt is the set of messages that are only routed to existing instances. If
	// they can not be routed to an existing instance, the HandleNotFound()
	// method is called instead.
	MessageTypes() (tr ax.MessageTypeSet, mt ax.MessageTypeSet)

	// NewData returns a pointer to a new zero-value instance of the
	// saga's data type.
	NewData() Data

	// HandleMessage handles a message for a particular saga instance.
	HandleMessage(context.Context, ax.Sender, ax.MessageContext, Instance) error

	// HandleNotFound handles a message that is intended for a saga instance
	// that could not be found.
	HandleNotFound(context.Context, ax.Sender, ax.MessageContext) error

	// IsInstanceComplete returns true if the given instance is complete.
	IsInstanceComplete(ctx context.Context, i Instance) (bool, error)
}

type UnitOfWork interface {
	// Sender returns the ax.Sender that the saga must use to send messages.
	// This allows the persister to capture new messages if necessary.
	Sender() ax.Sender

	// Instance returns the saga instance that the unit-of-work applies to.
	Instance() Instance

	// Save persists changes to the instance.
	//
	// It returns true if any changes have occurred.
	// On success, the Instance().Revision is updated to match the new revision.
	Save(ctx context.Context) (bool, error)

	// SaveAndComplete persists changes to a completed instance.
	//
	// The precise behavior is implementation defined. Typically meta-data about
	// the instance is discarded. The implementation may completely remove any
	// record of the instance.
	//
	// On success, the Instance().Revision is updated to match the revision
	// produced by the save.
	SaveAndComplete(ctx context.Context) error

	// Close is called when the unit-of-work has ended, regardless of whether
	// Save() has been called.
	Close()
}

type Workflow struct {
	ErrorIfNotFound
	CompletableByData

	Prototype     Data
	Triggers      ax.MessageTypeSet
	NonTriggers   ax.MessageTypeSet
	HandleCommand typeswitch.Switch
	HandleEvent   typeswitch.Switch
}