autocore

type AbortCause string

type AbortError struct {
	Cause AbortCause
	Err   error
}

type ActivityContext interface {
	context.Context
	Logger() *slog.Logger
	WorkflowKey() WorkflowKey
	IdempotencyKey() string
	ExternalNamespaceID() ExternalNamespaceID
}

type ActivityExecutionDisposition string

type ActivityExecutionResult string

type ActivityName[I, O proto.Message] string

type ActivityPollPredicate[O proto.Message] func(ctx ActivityContext, output O, config []byte) (bool, error)

type CancelWorkflowOptions struct {
	WorkflowKey WorkflowKey
}

type CentralDB interface {
	OpenPool(ctx context.Context, opts ...pgtool.PoolOption) (*pgxpool.Pool, error)
	OpenMigrationDB() (*sql.DB, error)
}

type Channel[O proto.Message] interface {
	Selectable
	Receive() (O, error)
	Name() string
}

type ChildFuture[O proto.Message] interface {
	Future[O]
	WorkflowID() WorkflowID
}

type ChildWorkflowOptions struct {
	// Metadata is extra information about the child workflow execution, available
	// to interceptors. It is not inherited from the parent: a child that needs the
	// parent's metadata is given it explicitly here. Mirrors
	// ExecuteWorkflowOptions.Metadata.
	Metadata proto.Message
}

type Client interface {
	// ExecuteWorkflow executes the named workflow.
	// Do not use this method directly, use the ExecuteWorkflow function.
	ExecuteWorkflow(ctx context.Context, name string, input proto.Message, opts *ExecuteWorkflowOptions) (*ExecuteWorkflowResult, error)
	CancelWorkflow(ctx context.Context, opts *CancelWorkflowOptions) error
	// SendToWorkflow puts a value on one of the target workflow's channels.
	// Returns ErrWorkflowNotFound if no such workflow exists, ErrWorkflowNotRunning
	// if it is already terminal, and ErrSignalLimitExceeded once it has spent its
	// signal history budget. The latter two are permanent for that workflow.
	//
	// TODO: I think we want to align the name here with the workflow context.
	// Maybe SendMessageToWorkflow and ReceiveMessage (instead of ReceiveChannel)?
	// Not sure yet.
	SendToWorkflow(ctx context.Context, opts *SendToWorkflowOptions) error
	// GetWorkflowInfo returns a read-only snapshot of a workflow's execution
	// state and terminal result. Returns ErrWorkflowNotFound if no workflow
	// exists for the key.
	GetWorkflowInfo(ctx context.Context, key WorkflowKey) (*WorkflowInfo, error)
	// GetWorkflowInfoWithMetadata is GetWorkflowInfo and GetWorkflowMetadata in one
	// read of one row, for a caller that needs both. A caller that only needs the
	// status should use GetWorkflowInfo, which does not touch the payload column.
	// Returns ErrWorkflowNotFound if no workflow exists for the key.
	GetWorkflowInfoWithMetadata(ctx context.Context, key WorkflowKey) (*WorkflowInfo, []byte, error)
	// GetWorkflowMetadata returns the marshaled opaque metadata supplied via
	// ExecuteWorkflowOptions.Metadata when the workflow was created, or nil when
	// none was supplied. Returns ErrWorkflowNotFound if no workflow exists for
	// the key.
	GetWorkflowMetadata(ctx context.Context, key WorkflowKey) ([]byte, error)
}

type Config struct {
	Log            *slog.Logger
	MeterProvider  metric.MeterProvider
	TracerProvider trace.TracerProvider
	ErrCapturer    errz.ErrCapturer
	Validator      protovalidate.Validator
	RedisClient    rueidis.Client
	RedisKeyPrefix string
	InstanceID     int64
	CentralDB      CentralDB
	WorkflowDBs    WorkflowDBs
	Registry       *Registry
	// OnReady is called once the central database is migrated, before any work
	// starts.
	OnReady func()

	// If WorkflowPoolSize and ActivityPoolSize are 0, this Engine instance doesn't perform any work.
	// Only the client is functional.
	WorkflowPoolSize      int
	MaxSuspendedWorkflows int
	ActivityPoolSize      int
}

type Dropper interface {
	Drop()
}

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

type ExecuteActivityOption func(*executeActivityOptions)

type ExecuteInlineActivityOption func(*executeInlineActivityOptions)

type ExecuteWorkflowOptions struct {
	// ExternalNamespaceID is the caller's id of the namespace the workflow runs
	// in. Required, must be positive.
	ExternalNamespaceID ExternalNamespaceID
	// IdempotencyKey deduplicates workflow creation within the namespace. Required,
	// 1-255 bytes; the engine's reserved prefix is rejected. A user that wants a
	// workflow per call must mint a key that cannot collide, rather than leaving
	// this empty.
	IdempotencyKey string
	// ScheduleToCompleteTimeout overrides the engine's default per-workflow
	// schedule-to-complete deadline. Zero uses the engine default; a positive
	// value overrides it. The deadline cannot be disabled per workflow.
	ScheduleToCompleteTimeout time.Duration
	// Metadata is extra information about the workflow execution, available to interceptors.
	Metadata proto.Message
}

type ExecuteWorkflowResult struct {
	WorkflowKey   WorkflowKey
	AlreadyExists bool
}

type ExternalNamespaceID = persistence.ExternalNamespaceID

type Future[O proto.Message] interface {
	Selectable
	Get() (O, error)
}

type MembershipView struct {
	// Index is this instance's position among the ready instances, ordered by
	// instance ID. It is in [0, Count).
	Index int
	// Count is the number of ready instances, at least 1.
	Count int
	// Observed reports whether a fleet has ever been seen. Without one there is
	// no evidence that any peer exists, let alone that one died.
	Observed bool
	// Fresh reports whether the shared store still shows the fleet this view
	// describes. A view goes stale while the store is unreachable and while a
	// changed fleet has yet to hold still long enough to be accepted.
	Fresh bool
	// StaleFor is how long the view has described a fleet the store no longer
	// shows. Zero while Fresh.
	StaleFor time.Duration
	// Evicted reports that the store lists other instances but not this one, for
	// long enough that they have resized without it. Its leases are then the only
	// thing keeping them from covering its shards.
	Evicted bool
}

type ReadinessAnnouncer interface {
	// Announce registers this instance as ready in the shared store.
	Announce(ctx context.Context) error
	// Membership returns the fleet view with hysteresis applied.
	Membership(ctx context.Context) MembershipView
	// Deregister removes this instance from the ready set.
	Deregister(ctx context.Context) error
	// GC removes expired entries from the backing store.
	GC(ctx context.Context)
}

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

type ReadinessTrackerOption func(*ReadinessTracker)

type RegisterActivityOption[O proto.Message] func(r *Registry, name string)

type RegisterWorkflowOption func(r *Registry, name string)

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

type RetryPolicy = persistence.RetryPolicy

type Selectable interface {
	// ReadyAt reports whether the operation can be consumed without blocking
	// and, when it can, the sequence id of the history event that made it ready,
	// or 0 when no event did.
	//
	// Ids are comparable across operations and stable across a replay: an
	// operation that is not ready can only become ready at a higher id than one
	// that already is. Among several ready operations the lowest id is therefore
	// the one that became ready first, and a replay picks the same operation as
	// the live execution did even though it has seen more of the history.
	//
	// While a workflow is terminating, an operation that had not completed before
	// the cancellation reports the cancellation event's id.
	//
	// Workflow code must not call this and must never branch on readiness:
	// readiness is the one piece of state that differs between live execution and
	// replay, because replay loads the whole history up front. The method is
	// exported only so that a Selectable implemented in another package can
	// forward readiness to a Selector. Blocking on the operation, or letting a
	// Selector rank it, are the replay-safe ways to consume it.
	ReadyAt() (SequenceID, bool)
}

type Selector interface {
	AddCase(source Selectable, fn func()) Selector
	Select()
	HasPending() bool
}

type SendToWorkflowOptions struct {
	WorkflowKey    WorkflowKey
	IdempotencyKey string // user-supplied dedup key; required, 1-255 bytes, reserved prefix rejected
	ChannelName    string
	Payload        proto.Message
}

type SequenceID = persistence.SequenceID

type ShardID = persistence.ShardID

type SignalID = persistence.SignalID

type SignalPromotionContext struct {
	ShardID    ShardID
	WorkflowID WorkflowID
	SignalID   SignalID
	SignalName string
	Payload    []byte
	// CreatedAt is when the signal was accepted into the inbox, read off the
	// database clock at insert and never zero. It is the clock an interceptor
	// judges by.
	CreatedAt time.Time
}

type TerminalObserver func(result WorkflowExecutionResult, err error)

type TimerFuture interface {
	Future[*emptypb.Empty]
	Dropper
}

type TypedWorkflowInfo[O proto.Message] struct {
	WorkflowKey    WorkflowKey
	Name           string
	IdempotencyKey string
	State          WorkflowState
	CreatedAt      time.Time
	UpdatedAt      time.Time
	Output         O
	Error          string
}

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

type WorkerManagerOption func(*WorkerManager)

type WorkflowContext interface {
	Logger() *slog.Logger
	Replaying() bool
	Now() time.Time
	NewSelector() Selector
	// Sleep blocks the workflow until the duration elapses. Returns ErrCanceled
	// if the workflow is canceled while sleeping. Cancellation is cooperative:
	// the caller chooses whether to propagate the error or ignore it. If the
	// underlying context is canceled, Sleep panics with
	// the classified abort, so the round ends without persisting completion and
	// the workflow_task is retried within the abort budget.
	Sleep(d time.Duration) error
	NewTimer(d time.Duration) TimerFuture
	WorkflowKey() WorkflowKey
	// Deadline is when the workflow's schedule-to-complete timeout elapses: the
	// instant the engine times it out. Read from the creation event, so it is the
	// same value on every replay round. A child workflow reports its parent's
	// deadline, so a whole spawn tree shares the root's.
	Deadline() time.Time
	// Context is canceled, with the abort as its cause, when the round is
	// aborting: the shard fence was lost or the shard released, the engine is
	// shutting down, or the suspended goroutine outlived its TTL. Nothing the
	// workflow does after that is persisted, so observing it cannot change
	// history. Workflow code that computes for long without awaiting must return
	// once it is canceled; what it returns is discarded and the task is retried.
	// The context carries no deadline and no values.
	Context() context.Context
	// contains filtered or unexported methods
}

type WorkflowDB interface {
	// OpenDDLPool opens the pool partition DDL runs on, under the role owning the
	// tables. DDL needs that ownership and OpenPool's role does not have it, so
	// the two cannot share a pool.
	OpenDDLPool(ctx context.Context, opts ...pgtool.PoolOption) (*pgxpool.Pool, error)
	// OpenPool opens a pool for reading and writing rows, under a role entitled to
	// no more than that.
	OpenPool(ctx context.Context, opts ...pgtool.PoolOption) (*pgxpool.Pool, error)
	// OpenMigrationDB opens the handle goose runs on. It is a *sql.DB rather than
	// a pool because goose coordinates with a session-level advisory lock.
	OpenMigrationDB() (*sql.DB, error)
}

type WorkflowDBs interface {
	// Resolve is called once per worker start, so a credential that changed since
	// the last start takes effect there.
	Resolve(ctx context.Context, dbID persistence.DBID) (WorkflowDB, error)
}

type WorkflowExecutionResult string

type WorkflowID = persistence.WorkflowID

type WorkflowInfo struct {
	WorkflowKey    WorkflowKey
	Name           string
	IdempotencyKey string
	State          WorkflowState
	CreatedAt      time.Time
	UpdatedAt      time.Time
	Output         []byte
	Error          string
}

type WorkflowKey struct {
	ShardID    ShardID
	WorkflowID WorkflowID
}

type WorkflowName[I, O proto.Message] string

type WorkflowState = persistence.WorkflowExecutionState