workflow

type Base struct {
	*aggregate.Base
	// contains filtered or unexported fields
}

type CommandDispatchedData struct {
	EffectID uuid.UUID
}

type CommandRequestedData struct {
	EffectID      uuid.UUID
	Key           string
	TriggerID     uuid.UUID
	CommandID     uuid.UUID
	Name          string
	AggregateName string
	AggregateID   uuid.UUID
	Payload       []byte
}

type CompensationCompletedData struct{}

type CompensationFailedData struct {
	Reason string
}

type CompensationStartedData struct {
	Reason string
}

type CompletedData struct{}

type Config struct {
	// EventStore is the event store that persists workflow instances.
	EventStore event.Store

	// EventBus is the event bus that delivers trigger events. Required if
	// any definition registers trigger events.
	EventBus event.Bus

	// CommandBus is the command bus that dispatches recorded command
	// effects.
	CommandBus command.Bus

	// Commands encodes and decodes command payloads. If it implements
	// codec.Registerer, the built-in workflow events are registered into it
	// as well — pass the codec registry of the application here.
	Commands codec.Encoding

	// NewRepository constructs the aggregate repository that fetches and
	// saves workflow instances (default: repository.New(EventStore)).
	// Definitions that bring their own repository (see WithRepository) are
	// unaffected. The constructed repository must persist to EventStore.
	NewRepository func(event.Store) aggregate.Repository

	// Strict makes the Service report an error when a trigger event
	// correlates to an unknown workflow, instead of silently ignoring it.
	Strict bool

	// Workers is the number of concurrent trigger workers (default 1).
	// Trigger processing is synchronized per workflow, so multiple workers
	// are safe.
	Workers int

	// DispatchInterval is the interval at which pending commands are
	// dispatched and retried (default 100ms).
	DispatchInterval time.Duration

	// TimerResolution is the resolution of the timeout timer (default 25ms).
	TimerResolution time.Duration

	// TriggerReplayWindow enables the replay of trigger events from the
	// event store when the service starts: trigger events no older than the
	// window are re-processed, which recovers workflows that missed events
	// while no service was running — useful with non-durable event buses
	// such as NATS Core. Zero (the default) disables the replay. Already
	// handled triggers are deduplicated, so generous windows are safe.
	TriggerReplayWindow time.Duration

	// ResyncInterval is the interval at which the effect runtime re-reads
	// effect events from the event store (default 1m; a negative duration
	// disables periodic resyncs). Resyncs are the liveness backstop of the
	// effect runtime: they discover effects that were recorded by other
	// service instances — letting any instance take over the pending
	// commands and timeouts of a crashed one — and recover local effect
	// notifications that were dropped under load. Without periodic resyncs,
	// effects recorded by other instances are only picked up at startup.
	//
	// Effects discovered through resyncs are attempted only once they are
	// older than a short takeover grace, giving the instance that recorded
	// them a head start and avoiding duplicate dispatches between healthy
	// instances.
	ResyncInterval time.Duration

	// RecoveryWindow bounds how far the initial effect recovery reaches back
	// into the event store when the service starts (default 30 days; a
	// negative duration scans the full history). It keeps the startup scan
	// proportional to recent activity instead of the total history of the
	// store. Effects recorded before the window are not recovered after a
	// restart, so the window must exceed the longest timeout horizon of the
	// workflows plus the maximum expected downtime.
	RecoveryWindow time.Duration
}

type Correlator[Data any] func(event.Of[Data]) (uuid.UUID, bool)

type Ctx[Data any] interface {
	context.Context

	// Event returns the trigger event.
	Event() event.Of[Data]

	// Dispatch records an outgoing command effect under the given key. The
	// runtime dispatches the command after the workflow was saved, and
	// re-dispatches it after restarts until the dispatch was recorded, making
	// command dispatch at-least-once. Recording the same key with the same
	// command twice is a no-op; recording it with a different command returns
	// ErrEffectConflict.
	Dispatch(key string, cmd command.Command) error

	// Schedule records a timeout with the given key that fires at the given
	// time. Scheduling a key that already has an active timeout replaces it.
	Schedule(key string, at time.Time) error

	// Unschedule cancels the active timeout with the given key. Canceling
	// a key without an active timeout is a no-op.
	Unschedule(key string) error

	// Complete transitions the workflow to StatusCompleted and cancels all
	// active timeouts.
	Complete() error

	// Fail transitions the workflow to StatusFailed and cancels all active
	// timeouts.
	Fail(reason error) error

	// Compensate transitions the workflow to StatusCompensating and cancels
	// all active timeouts. From here on, only Compensates and
	// OnCompensationTimeout handlers run.
	Compensate(reason error) error

	// Compensated transitions the compensating workflow to
	// StatusCompensated.
	Compensated() error

	// CompensationFailed transitions the compensating workflow to
	// StatusFailed.
	CompensationFailed(reason error) error
}

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

type FailedData struct {
	Reason string
}

type Option[W Workflow] struct {
	// contains filtered or unexported fields
}

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

type StartedData struct{}

type Status string

type TimeoutCanceledData struct {
	EffectID uuid.UUID
	Key      string
}

type TimeoutFiredData struct {
	EffectID     uuid.UUID
	WorkflowID   uuid.UUID
	Key          string
	ScheduledFor time.Time
}

type TimeoutRequestedData struct {
	EffectID  uuid.UUID
	Key       string
	TriggerID uuid.UUID
	At        time.Time
}

type TriggerRecordedData struct {
	TriggerID   uuid.UUID
	TriggerName string
}

type Workflow interface {
	aggregate.TypedAggregate
	// contains filtered or unexported methods
}