queue

type Backoff struct {
	Base time.Duration
	Cap  time.Duration
}

type CountQuery struct {
	Types []string
}

type Definition[T any] struct {
	Type          string
	Handle        func(context.Context, Job[T]) error
	MaxAttempts   int
	Timeout       time.Duration
	MaxConcurrent int
	Backoff       Backoff
	ExclusiveBy   func(T) string
}

type ErrorCode string

type FailedCursor struct {
	FinishedAt time.Time
	ID         JobID
}

type FailedPage struct {
	Jobs []Status
	Next *FailedCursor
}

type FailedQuery struct {
	Types  []string
	Limit  int
	Before *FailedCursor
}

type Handler func(ctx context.Context, payload []byte, meta Meta) error

type Job[T any] struct {
	ID          JobID
	Payload     T
	Attempt     int
	MaxAttempts int
	EnqueuedAt  time.Time
}

type JobCursor struct {
	EnqueuedAt time.Time
	ID         JobID
}

type JobID string

type JobPage struct {
	Jobs []Status
	Next *JobCursor
}

type JobQuery struct {
	Types  []string
	States []State
	Limit  int
	Before *JobCursor
}

type Limits struct {
	Concurrency   int
	ClaimBatch    int
	LeaseDuration time.Duration
	PollInterval  time.Duration
	ShutdownGrace time.Duration
	// AbandonGrace is how long the worker waits for a handler to return after
	// cancelling it, on shutdown and on a per-type Timeout. Go cannot kill a
	// goroutine: once the grace elapses the worker stops waiting and records
	// the durable outcome while the handler may still be running, so an
	// abandoned timed-out job can execute concurrently with its own retry.
	// Handlers that must not run twice have to honour their context.
	AbandonGrace    time.Duration
	MaxPayloadBytes int
	// RetentionAge is how long a terminal job row survives automatic
	// retention. It bounds only succeeded, failed and canceled rows; live work
	// is never deleted.
	RetentionAge time.Duration
	// RetentionEvery is how often a worker runs automatic retention.
	// RetentionDisabled turns it off entirely and keeps every terminal row
	// until an operator calls RunRetention.
	RetentionEvery time.Duration
	RetentionRows  int
}

type Meta struct {
	ID          JobID
	Attempt     int
	MaxAttempts int
	EnqueuedAt  time.Time
}

type Operator interface {
	Inspect(ctx context.Context, id JobID) (Status, error)
	List(ctx context.Context, query JobQuery) (JobPage, error)
	ListFailed(ctx context.Context, query FailedQuery) (FailedPage, error)
	CountByState(ctx context.Context, query CountQuery) (StateCounts, error)
	Cancel(ctx context.Context, id JobID) (bool, error)
	CancelMany(ctx context.Context, ids []JobID) (int, error)
	Requeue(ctx context.Context, id JobID) (bool, error)
	RequeueFailed(ctx context.Context, ids []JobID) (int, error)
	RunRetention(ctx context.Context, policy RetentionPolicy) (int, error)
}

type Option func(*enqueueOptions)

type Outcome struct {
	Resolution Resolution
	Code       string
	Delay      time.Duration
	Scheduled  bool
	Uncounted  bool
	Err        error
}

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

type Registration struct {
	Type          string
	MaxAttempts   int
	Timeout       time.Duration
	MaxConcurrent int
	Backoff       Backoff
	Handle        Handler
}

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

type Resolution string

type Resource struct {
	Name        string
	Concurrency int
	Costs       map[string]int
}

type RetentionPolicy struct {
	OlderThan time.Time
	MaxRows   int
	States    []State
}

type State string

type StateCounts struct {
	Pending   int64
	Leased    int64
	Succeeded int64
	Failed    int64
	Canceled  int64
}

type Status struct {
	ID              JobID
	Type            string
	State           State
	Attempt         int
	MaxAttempts     int
	AvailableAt     time.Time
	LastCode        string
	CancelRequested bool
	EnqueuedAt      time.Time
	FinishedAt      *time.Time
}

type Type[T any] struct {
	// contains filtered or unexported fields
}