uptask

type AnyTask struct {
	Id        string
	CreatedAt time.Time
	Attempt   int
	Retried   int
	Scheduled bool
	Args      interface{}
}

type ClientOption func(*TaskClient)

type Handler interface {
	HandleEvent(context.Context, cloudevents.Event) error
}

type HandlerFunc func(context.Context, cloudevents.Event) error

type Logger interface {
	Debug(string, ...any)
	Warn(string, ...any)
	Info(string, ...any)
	Error(string, ...any)
}

type Middleware func(HandlerFunc) HandlerFunc

type MiddlewareFunc func(handler Handler) Handler

type RedisConfig struct {
	Addr     string
	Username string
	Password string
	DB       int
}

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

type ServiceOption func(*TaskService)

type Task[T any] struct {
	Id        string
	CreatedAt time.Time
	Attempt   int
	Retried   int
	Scheduled bool
	Args      T
}

type TaskArgs interface {
	// Kind is a string that uniquely identifies the type of job. This must be
	// provided on your job arguments struct.
	Kind() string
}

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

type TaskError struct {
	Message   string                 `json:"message"`
	Details   map[string]interface{} `json:"details,omitempty"`
	Timestamp time.Time              `json:"timestamp"`
}

type TaskExecution struct {
	// Core fields
	ID       string      `json:"id"`
	TaskKind string      `json:"task_kind"`
	Status   TaskStatus  `json:"status"`
	Args     interface{} `json:"args"`

	// Attempt tracking
	AttemptID   string `json:"attempt_id"`
	Attempt     int    `json:"attempt"`
	MaxAttempts int    `json:"max_attempts"`

	// External references
	QstashMessageID string `json:"qstash_message_id,omitempty"`
	ScheduleID      string `json:"schedule_id,omitempty"`

	// Timing information
	CreatedAt   time.Time `json:"created_at"`
	AttemptedAt time.Time `json:"attempted_at,omitempty"`
	ScheduledAt time.Time `json:"scheduled_at"`
	FinalizedAt time.Time `json:"finalized_at,omitempty"`

	// Error tracking
	Errors []TaskError `json:"errors,omitempty"`
	Queue  string      `json:"queue"`
}

type TaskFilter struct {
	Status   *TaskStatus
	Queue    string
	FromDate time.Time
	ToDate   time.Time
	Limit    int
}

type TaskHandler[T TaskArgs] interface {

	// Timeout is the maximum amount of time the task is allowed to run before
	// its context is cancelled. A timeout of zero (the default) means the task
	// will inherit the Service-level timeout. A timeout of -1 means the task's
	// context will never time out.
	Timeout(task *Task[T]) time.Duration

	// ProcessTask performs the task and returns an error if the task failed. The context
	// will be configured with a timeout according to the task handler settings and may
	// be cancelled for other reasons.
	//
	// If no error is returned, the task is assumed to have succeeded and will be
	// marked completed.
	//
	// It is important for any task handler to respect context cancellation to enable
	// the service to respond to shutdown requests; there is no way to cancel a
	// running task that does not respect context cancellation, other than
	// terminating the process.
	ProcessTask(ctx context.Context, task *Task[T]) error
}

type TaskHandlerDefaults[T TaskArgs] struct{}

type TaskInsertOpts struct {
	MaxRetries  int
	Queue       string
	ScheduledAt time.Time
	Tags        []string
}

type TaskService struct {
	*TaskClient
	// contains filtered or unexported fields
}

type TaskStatus string

type TaskStore interface {
	// Core operations
	CreateTaskExecution(ctx context.Context, task *TaskExecution) error
	GetTaskExecution(ctx context.Context, taskID string) (*TaskExecution, error)
	DeleteTaskExecution(ctx context.Context, taskID string) error
	UpdateTaskStatus(ctx context.Context, taskID string, status TaskStatus) error
	UpdateTaskScheduledAt(ctx context.Context, taskID string, scheduledAt time.Time) error

	AddTaskError(ctx context.Context, taskID string, err TaskError) error

	// Query operations
	ListTaskExecutions(ctx context.Context, filter TaskFilter) ([]*TaskExecution, error)
	GetMostRecentTaskExecutions(ctx context.Context, limit int) ([]*TaskExecution, error)

	// Optional: Cleanup operation if needed
	CleanupOldTaskExecutions(ctx context.Context, olderThan time.Duration) error
}

type Transport interface {
	Send(ctx context.Context, event cloudevents.Event, opts *TaskInsertOpts) error
}

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