handler

type Acknowledger interface {
	// Ack acknowledges the message, ensuring it is not handled again.
	//
	// b is the batch from the unit-of-work.
	Ack(ctx context.Context, b persistence.Batch) (persistence.Result, error)

	// Nack negatively-acknowledges the message, causing it to be retried.
	Nack(ctx context.Context, cause error) error
}

type DeferFunc func(Result, error)

type EntryPoint struct {
	// QueueEvents is the set of event types that must be added to the queue.
	QueueEvents *sets.Set[message.Type]

	// Handler is the handler implmentation that populates the unit-of-work.
	Handler Handler

	// OnSuccess is called for each unit-of-work that is persisted successfully.
	//
	// It is invoked before the unit-of-work's deferred functions are executed.
	OnSuccess func(Result)
}

type Handler interface {
	// HandleMessage handles the message in p.
	HandleMessage(ctx context.Context, w UnitOfWork, p parcel.Parcel) error
}

type QueueConsumer struct {
	// Queue is the message queue to consume.
	Queue *queue.Queue

	// EntryPoint is the handler entry-point used to dispatch the message.
	EntryPoint *EntryPoint

	// Persister is the persister used to persist the units-of-work produced
	// by the entry-point, and to update the queued messages.
	Persister persistence.Persister

	// BackoffStrategy is the strategy used to delay retrying a message after a
	// failure. If it is nil, backoff.DefaultStrategy is used.
	BackoffStrategy backoff.Strategy

	// Semaphore is used to limit the number of messages being handled
	// concurrently.
	Semaphore *semaphore.Weighted

	// Logger is the target for log messages about the consumed messages.
	// If it is nil, logging.DefaultLogger is used.
	Logger logging.Logger
}

type Result struct {
	// Queued is the set of messages that were placed on the message queue,
	// which may include events.
	Queued []queue.Message

	// Events is the set of events that were recorded in the unit-of-work.
	Events []eventstream.Event
}

type Router map[message.Type][]Handler

type UnitOfWork interface {
	// ExecuteCommand updates the unit-of-work to execute the command in p.
	ExecuteCommand(p parcel.Parcel)

	// ScheduleTimeout updates the unit-of-work to schedule the timeout in p.
	ScheduleTimeout(p parcel.Parcel)

	// RecordEvent updates the unit-of-work to record the event in p.
	RecordEvent(p parcel.Parcel)

	// Do updates the unit-of-work to include op in the persistence batch.
	Do(op persistence.Operation)

	// Defer registers fn to be called when the unit-of-work is complete.
	//
	// Like Go's defer keyword, deferred functions guaranteed to be invoked in
	// the reverse order to which they are registered.
	Defer(fn DeferFunc)
}