orbital

type AsyncResponder interface {
	ReceiveTaskRequest(ctx context.Context) (TaskRequest, error)
	SendTaskResponse(ctx context.Context, response TaskResponse) error
	Close(ctx context.Context) error
}

type Codec interface {
	EncodeTaskRequest(request TaskRequest) ([]byte, error)
	DecodeTaskRequest(bytes []byte) (TaskRequest, error)
	EncodeTaskResponse(response TaskResponse) ([]byte, error)
	DecodeTaskResponse(bytes []byte) (TaskResponse, error)
}

type Config struct {
	// TaskLimitNum is the maximum number of tasks to process at once.
	TaskLimitNum int
	// ConfirmJobAfter is the delay before confirming a job.
	ConfirmJobAfter time.Duration
	// ConfirmJobWorkerConfig holds the configuration for the job confirmation worker.
	ConfirmJobWorkerConfig WorkerConfig
	// CreateTasksWorkerConfig holds the configuration for the task creation worker.
	CreateTasksWorkerConfig WorkerConfig
	// ReconcilesWorkerConfig holds the configuration for the reconciliation worker.
	ReconcileWorkerConfig WorkerConfig
	// NotifyWorkerConfig holds the configuration for the notification worker.
	NotifyWorkerConfig WorkerConfig
	// NotifyJobGroupWorkerConfig holds the configuration for the job group notification worker.
	NotifyJobGroupWorkerConfig WorkerConfig
	// ScheduleJobGroupWorkerConfig holds the configuration for the job group scheduling worker.
	ScheduleJobGroupWorkerConfig WorkerConfig
	// BackoffBaseIntervalSec is the base interval for exponential backoff in seconds.
	// Default is 10 seconds.
	BackoffBaseIntervalSec uint64
	// BackoffMaxIntervalSec is the maximum interval for exponential backoff in seconds.
	// Default is 10240 seconds (2 hours and 50 minutes).
	BackoffMaxIntervalSec uint64
	// MaxPendingReconciles is the maximum number of pending reconciles for a task before marking it as failed.
	// Default is 10.
	MaxPendingReconciles uint64
}

type Entity struct {
	Name      query.EntityName
	ID        uuid.UUID
	CreatedAt int64
	UpdatedAt int64
	Values    map[string]any
}

type EntityTypes interface {
	Job | Task | JobCursor | JobEvent | JobGroup | JobGroupEvent
}

type FindResult struct {
	Entity Entity
	Exists bool
}

type HandlerFunc func(ctx context.Context, request HandlerRequest, resp *HandlerResponse)

type HandlerRequest struct {
	TaskID               uuid.UUID
	TaskType             string
	TaskData             []byte
	TaskRawWorkingState  []byte
	TaskCreatedAt        time.Time
	TaskLastReconciledAt time.Time
}

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

type Initiator interface {
	SendTaskRequest(ctx context.Context, request TaskRequest) error
	ReceiveTaskResponse(ctx context.Context) (TaskResponse, error)
	Close(ctx context.Context) error
}

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

type Job struct {
	ID           uuid.UUID
	ExternalID   string
	Data         []byte
	Type         string
	Status       JobStatus
	ErrorMessage string
	UpdatedAt    int64
	CreatedAt    int64
	Labels       Labels
}

type JobConfirmFunc func(ctx context.Context, job Job) (JobConfirmerResult, error)

type JobConfirmerResult interface {
	Type() JobConfirmerResultType
}

type JobConfirmerResultType int

type JobCursor struct {
	ID        uuid.UUID
	Cursor    TaskResolverCursor
	UpdatedAt int64
	CreatedAt int64
}

type JobEvent struct {
	ID         uuid.UUID
	IsNotified bool
	UpdatedAt  int64
	CreatedAt  int64
}

type JobEventQuery struct {
	ID                 uuid.UUID // Filter job events by their ID.
	IsNotified         *bool     // Filter job events by whether they have been notified.
	RetrievalModeQueue bool      // If true, enables queue-like retrieval mode.
	Limit              int       // Maximum number of job events to return.
	OrderByUpdatedAt   bool      // If true, orders job events by updated_at in ascending order.
}

type JobGroup struct {
	ID           uuid.UUID
	Type         string
	Jobs         []Job // Jobs in the group, ordered by their position
	CreatedAt    int64
	UpdatedAt    int64
	Status       JobGroupStatus
	Labels       Labels
	ErrorMessage string
}

type JobGroupEvent struct {
	ID         uuid.UUID
	IsNotified bool
	UpdatedAt  int64
	CreatedAt  int64
}

type JobGroupStatus string

type JobGroupTerminatedEventFunc func(ctx context.Context, group JobGroup) error

type JobStatus string

type JobStatuses []JobStatus

type JobTerminatedEventFunc func(ctx context.Context, job Job) error

type Labels map[string]string

type ListJobGroupEventQuery struct {
	ID                 uuid.UUID // Filter job group events by their ID.
	IsNotified         *bool     // Filter job group events by whether they have been notified.
	RetrievalModeQueue bool      // If true, enables queue-like retrieval mode.
	Limit              int       // Maximum number of job group events to return.
	OrderByUpdatedAt   bool      // If true, orders job group events by updated_at in ascending order.
}

type ListJobGroupsQuery struct {
	StatusIn           []JobGroupStatus // Filter job groups by a list of statuses.
	Limit              int              // Maximum number of job groups to return.
	RetrievalModeQueue bool             // If true, enables queue-like retrieval mode (FOR UPDATE SKIP LOCKED).
	OrderByUpdatedAt   bool             // If true, orders job groups by updated_at in ascending order.
}

type ListJobsQuery struct {
	Status             JobStatus   // Filter jobs by their status.
	StatusIn           []JobStatus // Filter jobs by a list of statuses.
	UpdatedAt          int64       // Filter jobs updated at or after this timestamp.
	CreatedAt          int64       // Filter jobs created at or after this timestamp.
	Limit              int         // Maximum number of jobs to return.
	RetrievalModeQueue bool        // If true, enables queue-like retrieval mode.
	OrderByUpdatedAt   bool        // If true, orders jobs by updated_at in descending order.
	Labels             Labels      // Filter jobs by labels (AND logic - all labels must match).
}

type ListResult struct {
	Entities []Entity
	Cursor   query.Cursor
	Exists   bool
}

type ListTasksQuery struct {
	JobID              uuid.UUID    // Filter tasks by the associated job ID.
	Status             TaskStatus   // Filter tasks by their status.
	StatusIn           []TaskStatus // Filter tasks by a list of statuses.
	CreatedAt          int64        // Filter tasks created at or after this timestamp.
	UpdatedAt          int64        // Filter tasks updated at or after this timestamp.
	Limit              int          // Maximum number of tasks to return.
	IsReconcileReady   bool         // If true, filters tasks that are ready to be reconciled.
	RetrievalModeQueue bool         // If true, enables queue-like retrieval mode.
	OrderByUpdatedAt   bool         // If true, orders jobs by updated_at in ascending order.
}

type Manager struct {
	Config Config
	// contains filtered or unexported fields
}

type ManagerOptsFunc func(mgr *Manager)

type MetaData map[string]string

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

type Option func(*config) error

type Repository struct {
	Store Store
}

type Responder = any

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

type Signature MetaData

type Store interface {
	Create(ctx context.Context, r ...Entity) ([]Entity, error)
	Update(ctx context.Context, r ...Entity) ([]Entity, error)
	Find(ctx context.Context, q query.Query) (FindResult, error)
	List(ctx context.Context, q query.Query) (ListResult, error)
	Transaction(ctx context.Context, txFunc TransactionFunc) error
}

type SyncResponder interface {
	Run(ctx context.Context, handler TaskRequestHandler) error
	Close(ctx context.Context) error
}

type TargetManager struct {
	Client             Initiator
	Signer             TaskRequestSigner
	Verifier           TaskResponseVerifier
	MustCheckSignature bool
}

type TargetOperator struct {
	Client             Responder
	Verifier           TaskRequestVerifier
	Signer             TaskResponseSigner
	MustCheckSignature bool
}

type Task struct {
	ID                 uuid.UUID
	JobID              uuid.UUID
	Type               string
	Data               []byte
	WorkingState       []byte
	LastReconciledAt   int64  // The last time the task was reconciled.
	ReconcileCount     uint64 // The number of times the task has been reconciled.
	ReconcileAfterSec  uint64 // The number of seconds after which the task should be reconciled.
	TotalSentCount     uint64
	TotalReceivedCount uint64
	ETag               string
	Status             TaskStatus
	Target             string
	ErrorMessage       string
	UpdatedAt          int64
	CreatedAt          int64
}

type TaskInfo struct {
	// Data contains the byte data that needs to be sent.
	Data []byte
	// Type specifies the type of the data.
	Type string
	// Targets lists the target identifiers associated with job.
	Target string
}

type TaskRequest struct {
	TaskID               uuid.UUID `json:"taskId"`               // TaskID is used to identify the task.
	Type                 string    `json:"type"`                 // Type is the type of the task.
	ExternalID           string    `json:"externalId"`           // External ID serves as an identifier for a Job
	Data                 []byte    `json:"data"`                 // Data is the static context for the task.
	WorkingState         []byte    `json:"workingState"`         // WorkingState is the current state of the task that the operator works upon.
	ETag                 string    `json:"eTag"`                 // ETag is used to identify the version of the TaskRequest.
	MetaData             MetaData  `json:"metaData"`             // MetaData contains additional information about the TaskRequest.
	TaskCreatedAt        int64     `json:"taskCreatedAt"`        // TaskCreatedAt is the timestamp when the task was created, represented as Unix time in seconds.
	TaskLastReconciledAt int64     `json:"taskLastReconciledAt"` // TaskLastReconciledAt is the timestamp when the task was last reconciled, represented as Unix time in seconds.
}

type TaskRequestHandler func(ctx context.Context, req TaskRequest) (TaskResponse, error)

type TaskRequestSigner interface {
	// Sign signs the given TaskRequest and returns a Signature.
	Sign(ctx context.Context, request TaskRequest) (Signature, error)
}

type TaskRequestVerifier interface {
	// Verify verifies the authenticity of the given TaskRequest.
	Verify(ctx context.Context, request TaskRequest) error
}

type TaskResolveFunc func(ctx context.Context, job Job, cursor TaskResolverCursor) (TaskResolverResult, error)

type TaskResolverCursor string

type TaskResolverResult interface {
	Type() TaskResolverResultType
}

type TaskResolverResultType int

type TaskResponse struct {
	TaskID            uuid.UUID `json:"taskId"`                 // TaskID is used to identify the task.
	Type              string    `json:"type"`                   // Type is the type of the task.
	ExternalID        string    `json:"externalId"`             // External ID serves as an identifier for a Job
	WorkingState      []byte    `json:"workingState"`           // WorkingState is the state of the task that the operator updates.
	ETag              string    `json:"eTag"`                   // ETag is used to correlate the TaskResponse with the TaskRequest.
	Status            string    `json:"status"`                 // Status is the status of the task.
	ErrorMessage      string    `json:"errorMessage,omitempty"` // ErrorMessage contains the error message if the task fails.
	ReconcileAfterSec uint64    `json:"reconcileAfterSec"`      // ReconcileAfterSec is the time in seconds after which the next TaskRequest should be queued again.
	MetaData          MetaData  `json:"metaData"`               // MetaData contains additional information about the TaskResponse.
}

type TaskResponseSigner interface {
	// Sign signs the given TaskResponse and returns a Signature.
	Sign(ctx context.Context, response TaskResponse) (Signature, error)
}

type TaskResponseVerifier interface {
	// Verify verifies the authenticity of the given TaskResponse.
	Verify(ctx context.Context, response TaskResponse) error
}

type TaskStatus string

type TransactionFunc func(context.Context, Repository) error

type WorkerConfig struct {
	// NoOfWorkers specifies the number of concurrent workers.
	NoOfWorkers int
	// ExecInterval is the interval between executions.
	ExecInterval time.Duration
	// Timeout is the maximum duration allowed for a single execution.
	Timeout time.Duration
}

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