driver

type CancelWorkflowJobsWithFailedDepsManyParams struct {
	WorkflowDepsFailedAt time.Time
	WorkflowIDs          []string
}

type GetPendingWorkflowIDsParams struct {
	LastWorkflowID string
	LimitCount     int32
}

type GetPendingWorkflowIDsRow struct {
	JobID      int64
	WorkflowID string
}

type IndexExistsParams struct {
	IndexName string
	Schema    string
}

type ProDriver[TTx any] interface {
	riverdriver.Driver[TTx]

	GetProExecutor() ProExecutor
	ProConfigInit(pilot riverpilot.Pilot)
	UnwrapProExecutor(tx TTx) ProExecutorTx
}

type ProExecutor interface {
	riverdriver.Executor

	// BeginPro begins a new subtransaction returning a ProExecutorTx.
	// ErrSubTxNotSupported may be returned if the executor is a transaction and
	// the driver doesn't support subtransactions (like
	// riverdriver/riverdatabasesql for database/sql).
	BeginPro(ctx context.Context) (ProExecutorTx, error)

	CancelWorkflowJobsWithFailedDepsMany(ctx context.Context, params *CancelWorkflowJobsWithFailedDepsManyParams) ([]*rivertype.JobRow, error)
	GetPendingWorkflowIDs(ctx context.Context, params *GetPendingWorkflowIDsParams) ([]*GetPendingWorkflowIDsRow, error)
	IndexExists(ctx context.Context, params *IndexExistsParams) (bool, error)
	JobInsertFullMany(ctx context.Context, jobs []*riverdriver.JobInsertFullParams) ([]*rivertype.JobRow, error)
	SequenceAppendMany(ctx context.Context, seqKeys []string) (int, error)
	SequenceList(ctx context.Context, count int) ([]*Sequence, error)
	// SequencePromote promotes the sequences with the given keys. It returns the
	// keys of the sequences which were actually promoted.
	SequencePromote(ctx context.Context, params *SequencePromoteParams) ([]string, error)
	// SequencePromoteFromTable promotes sequences from the river_job_sequence
	// table. It returns the keys of the sequences which were actually promoted.
	SequencePromoteFromTable(ctx context.Context, params *SequencePromoteFromTableParams) (*SequencePromoteFromTableResult, error)
	SequenceScanAndPromoteStalled(ctx context.Context, params *SequenceScanAndPromoteStalledParams) (*SequenceScanAndPromoteStalledResult, error)
	StageWorkflowJobsMany(ctx context.Context, params *StageWorkflowJobsManyParams) ([]*rivertype.JobRow, error)
	WorkflowCancel(ctx context.Context, params *WorkflowCancelParams) ([]*rivertype.JobRow, error)
	WorkflowLoadTasksByNames(ctx context.Context, params *WorkflowLoadTasksByNamesParams) ([]*WorkflowTask, error)
}

type ProExecutorTx interface {
	ProExecutor
	riverdriver.ExecutorTx
}

type Sequence struct {
	ID        int64
	Key       string
	CreatedAt time.Time
}

type SequencePromoteFromTableParams struct {
	GracePeriod time.Duration
	Max         int
	Now         *time.Time
}

type SequencePromoteFromTableResult struct {
	Continue     bool
	NumDeleted   int
	PromotedKeys []string
}

type SequencePromoteParams struct {
	GracePeriod time.Duration
	Keys        []string
	Now         *time.Time
}

type SequenceScanAndPromoteStalledParams struct {
	GracePeriod     time.Duration
	LastSequenceKey string
	Max             int
	Now             *time.Time
}

type SequenceScanAndPromoteStalledResult struct {
	Continue   bool
	LastSeqKey string
}

type StageWorkflowJobsManyParams struct {
	WorkflowIDs      []string
	WorkflowStagedAt time.Time
}

type WorkflowCancelParams struct {
	CancelAttemptedAt time.Time
	ControlTopic      string
	WorkflowID        string
}

type WorkflowLoadTasksByNamesParams struct {
	TaskNames  []string
	WorkflowID string
}

type WorkflowTask struct {
	Deps       []string
	ID         int64
	State      rivertype.JobState
	Task       string
	WorkflowID string
}