riverpro

type Client[TTx any] struct {
	*river.Client[TTx]
	// contains filtered or unexported fields
}

type ConcurrencyConfig struct {
	// GlobalLimit is the maximum number of jobs that can run concurrently
	// across all workers.
	GlobalLimit int

	// LocalLimit is the maximum number of jobs that can run concurrently
	// on a single worker.
	LocalLimit int

	// Partition is the configuration for partitioning concurrency limits. By
	// default, concurrency limits are not partitioned and apply to the entire
	// queue.
	Partition PartitionConfig
}

type Config struct {
	river.Config

	// ProQueues holds the configuration for queues that use Pro-specific
	// features, including concurrency limits. A given queue can be configured
	// as either a Pro queue or a standard queue, but not both.
	ProQueues map[string]QueueConfig

	// SequenceSchedulerInterval is the amount of time to wait between runs of the sequence scheduler.
	SequenceSchedulerInterval time.Duration

	// WorkflowRescuerInterval is the amount of time to wait between runs of the workflow rescuer.
	WorkflowRescuerInterval time.Duration
}

type DependencyCycleError struct {
	DepStack []string
}

type DuplicateTaskError struct {
	TaskName string
}

type MissingDependencyError struct {
	ParentTaskName string
	TaskName       string
}

type PartitionConfig struct {
	// ByArgs is the list of fields in the job arguments to partition by.
	// For example, you may wish to limit the number of jobs that can run
	// concurrently for a given `customer_id`.
	//
	// If ByArgs is explicitly set to an empty slice, all fields in the job's
	// arguments will be used. This is generally not desirable as it can lead
	// to high cardinality and a large number of partitions.
	//
	// When set to nil (the default), arguments are not used for partitioning.
	ByArgs []string

	// ByKind indicates that the concurrency limit should be partitioned by the
	// kind of the job.
	ByKind bool
}

type QueueBundle struct {
	*river.QueueBundle
	// contains filtered or unexported fields
}

type QueueConfig struct {
	// Concurrency is the optional concurrency configuration for the queue.
	Concurrency ConcurrencyConfig

	// MaxWorkers is the maximum number of workers to run for the queue, or put
	// otherwise, the maximum parallelism to run.
	//
	// This is the maximum number of workers within this particular client
	// instance, but note that it doesn't control the total number of workers
	// across parallel processes. Installations will want to calculate their
	// total number by multiplying this number by the number of parallel nodes
	// running River clients configured to the same database and queue.
	//
	// Requires a minimum of 1, and a maximum of 10,000.
	MaxWorkers int
}

type SequenceOpts struct {
	// ByArgs indicates that the job's encoded arguments should be used to compute
	// a sequence key.
	//
	// Default is false, meaning that input arguments will not be considered for
	// sequencing.
	//
	// When set to true, the entire encoded args field will be included in the
	// sequence hash, which requires care to ensure that no irrelevant args are
	// factored into the sequence key. It is also possible to use a subset of
	// the args by indicating on the `JobArgs` struct which fields should be
	// included in the sequence using struct tags:
	//
	//  type MyJobArgs struct {
	//   CustomerID string `json:"customer_id" river:"sequence"`
	//   TraceID string `json:"trace_id"
	//  }
	//
	// In this example, only the encoded `customer_id` key will be included in the
	// sequence key and the `trace_id` key will be ignored.
	//
	// All keys are sorted alphabetically before hashing to ensure consistent
	// results.
	ByArgs bool

	// ByQueue indicates that sequences should be partitioned by queue.
	//
	// Default is false, meaning that as long as any other sequence property is
	// enabled, sequences will be constructed for a kind across all queues.
	ByQueue bool

	// ContinueOnCancelled indicates that the sequence should continue to be
	// processed even if the job is cancelled. Without this setting, the sequence
	// will be halted if any job in the sequence is cancelled.
	ContinueOnCancelled bool

	// ContinueOnDiscarded indicates that the sequence should continue to be
	// processed even if the job repeatedly errors and is discarded. Without this
	// setting, the sequence will be halted if any job in the sequence is
	// discarded.
	ContinueOnDiscarded bool

	// ExcludeKind indicates that the job kind should not be included in the
	// sequence partition key. This is useful when you want to include multiple
	// job kinds in the same sequence.
	ExcludeKind bool
}

type Workflow struct {/* contains filtered or unexported fields */}

type WorkflowCancelResult struct {
	CancelledJobs []*rivertype.JobRow
}

type WorkflowOpts struct {
	ID                  string
	IgnoreCancelledDeps bool
	IgnoreDeletedDeps   bool
	IgnoreDiscardedDeps bool
	Name                string
}

type WorkflowPrepareResult struct {
	// Jobs is a list of jobs to insert into the database. It's structured as a
	// list of InsertManyParams so the jobs can be inserted with InsertMany.
	Jobs []river.InsertManyParams
}

type WorkflowTask struct {
	// Name is the name of the workflow task.
	Name string
}

type WorkflowTaskOpts struct {
	// Deps are the names of other tasks in the workflow that this task depends
	// on. If any of the dependencies are cancelled, deleted, or discarded after
	// failing repeatedly, the task will be cancelled.
	Deps []string
	// IgnoreCancelledDeps specifies whether to ignore cancelled dependencies,
	// instead treating them as if they had completed successfully.
	//
	// If specified, this overrides the IgnoreCancelledDeps option specified in
	// the workflow.
	IgnoreCancelledDeps *bool
	// IgnoreDeletedDeps specifies whether to ignore deleted dependencies,
	// instead treating them as if they had completed successfully.
	//
	// If specified, this overrides the IgnoreDeletedDeps option specified in
	// the workflow.
	IgnoreDeletedDeps *bool
	// IgnoreDiscardedDeps specifies whether to ignore discarded dependencies,
	// instead treating them as if they had completed successfully.
	//
	// If specified, this overrides the IgnoreDiscardedDeps option specified in
	// the workflow.
	IgnoreDiscardedDeps *bool
}