realtime

type ConnectionOptions struct {
	// BaseURL is the base API URL (e.g., "https://api.spooled.cloud")
	BaseURL string
	// WSURL is the WebSocket URL (e.g., "wss://api.spooled.cloud/api/v1/ws")
	WSURL string
	// Token is the JWT or API key for authentication
	Token string
	// APIKey is the API key for authentication (alternative to Token)
	APIKey string
	// AutoReconnect is ignored: reconnecting is on unless DisableAutoReconnect is
	// set. A zero ConnectionOptions used to mean "never reconnect", so a client
	// built from Client.Realtime/RealtimeSSE went silent for good the first time
	// the connection dropped - and the server ends every stream after 30 minutes.
	//
	// Deprecated: use DisableAutoReconnect to turn reconnecting off.
	AutoReconnect bool
	// DisableAutoReconnect turns automatic reconnection off.
	DisableAutoReconnect bool
	// MaxReconnectAttempts is the maximum number of consecutive failed reconnect
	// attempts before the client gives up (default: 10; negative = unlimited). The
	// count restarts once a connection has stayed up for a while.
	MaxReconnectAttempts int
	// MaxMessageBytes is the largest event the client reads (default: 4 MiB). A
	// job.completed event carries the job result, which can be large; an event
	// over the limit drops the connection.
	MaxMessageBytes int
	// ReconnectDelay is the initial delay between reconnect attempts
	ReconnectDelay time.Duration
	// MaxReconnectDelay is the maximum delay between reconnect attempts
	MaxReconnectDelay time.Duration
	// Debug enables debug logging
	Debug bool
	// Logger is a custom logger function
	Logger func(msg string, args ...any)
}

type ConnectionState string

type Event struct {
	Type      EventType       `json:"type"`
	Timestamp time.Time       `json:"timestamp"`
	Data      json.RawMessage `json:"data"`
}

type EventHandler func(event *Event)

type EventType string

type JobEvent struct {
	JobID     string `json:"job_id"`
	QueueName string `json:"queue_name"`
	// Status is the job's status. On job.status_changed the server sends
	// old_status and new_status and no "status", so Status is filled from
	// NewStatus; a handler comparing e.Status to "processing" therefore works.
	Status string `json:"status"`
	// OldStatus and NewStatus are sent with job.status_changed.
	OldStatus  string  `json:"old_status,omitempty"`
	NewStatus  string  `json:"new_status,omitempty"`
	Priority   int     `json:"priority,omitempty"`
	RetryCount int     `json:"retry_count,omitempty"`
	Error      string  `json:"error,omitempty"`
	Progress   float64 `json:"progress,omitempty"`
	// DurationMs is how long the job ran; sent with job.completed.
	DurationMs int64 `json:"duration_ms,omitempty"`
	// Result is the job result when it is a JSON object, and nil otherwise.
	// RawResult has the result whatever its JSON type; a non-object result used to
	// make the whole event fail to decode and silently disappear.
	Result      map[string]any    `json:"-"`
	RawResult   any               `json:"result,omitempty"`
	WorkerID    string            `json:"worker_id,omitempty"`
	Timestamp   time.Time         `json:"timestamp,omitempty"`
	ScheduledAt *time.Time        `json:"scheduled_at,omitempty"`
	StartedAt   *time.Time        `json:"started_at,omitempty"`
	CompletedAt *time.Time        `json:"completed_at,omitempty"`
	FailedAt    *time.Time        `json:"failed_at,omitempty"`
	Metadata    map[string]string `json:"metadata,omitempty"`
}

type JobEventHandler func(event *JobEvent)

type QueueEvent struct {
	QueueName string `json:"queue_name"`
	Reason    string `json:"reason,omitempty"`
}

type QueueEventHandler func(event *QueueEvent)

type RealtimeClient interface {
	// Connect establishes the connection
	Connect() error
	// Disconnect closes the connection
	Disconnect() error
	// State returns the current connection state
	State() ConnectionState
	// Subscribe adds a subscription filter (WebSocket only - SSE uses filter at connect time)
	Subscribe(filter SubscriptionFilter) error
	// Unsubscribe removes a subscription (WebSocket only)
	Unsubscribe(filter SubscriptionFilter) error
	// OnEvent registers a handler for all events
	OnEvent(handler EventHandler)
	// OnJobEvent registers a handler for job events
	OnJobEvent(eventType EventType, handler JobEventHandler)
	// OnQueueEvent registers a handler for queue events
	OnQueueEvent(eventType EventType, handler QueueEventHandler)
	// OnWorkerEvent registers a handler for worker events
	OnWorkerEvent(eventType EventType, handler WorkerEventHandler)
	// OnStateChange registers a handler for state changes
	OnStateChange(handler StateChangeHandler)
}

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

type StateChangeHandler func(state ConnectionState)

type SubscriptionFilter struct {
	QueueName string   `json:"queue_name,omitempty"`
	JobID     string   `json:"job_id,omitempty"`
	WorkerID  string   `json:"worker_id,omitempty"`
	Events    []string `json:"events,omitempty"`
}

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

type WorkerEvent struct {
	WorkerID   string    `json:"worker_id"`
	QueueName  string    `json:"queue_name"`
	Hostname   string    `json:"hostname,omitempty"`
	Version    string    `json:"version,omitempty"`
	LastSeenAt time.Time `json:"last_seen_at,omitempty"`
}

type WorkerEventHandler func(event *WorkerEvent)