outbox

type DispatchResult struct {
	Processed         int
	Published         int
	Failed            int
	StateUpdateFailed int
}

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

type DispatcherConfig struct {
	// DispatchInterval is the periodic interval between dispatch cycles.
	DispatchInterval time.Duration
	// BatchSize is the max number of events processed per cycle.
	BatchSize int
	// PublishMaxAttempts is the max publish attempts for one event.
	PublishMaxAttempts int
	// PublishBackoff is the base backoff between publish retries.
	PublishBackoff time.Duration
	// ListPendingFailureThreshold emits an error log once repeated list failures reach this count.
	ListPendingFailureThreshold int
	// RetryWindow is the minimum age for failed events to become retry-eligible.
	RetryWindow time.Duration
	// MaxDispatchAttempts is the max total dispatch attempts before invalidation.
	MaxDispatchAttempts int
	// ProcessingTimeout is the age threshold for reclaiming stuck processing events.
	ProcessingTimeout time.Duration
	// PriorityBudget limits how many events can be selected via priority lists per cycle.
	PriorityBudget int
	// MaxFailedPerBatch limits how many failed events are reclaimed in one cycle.
	MaxFailedPerBatch int
	// PriorityEventTypes defines ordered event types to pull first each cycle.
	PriorityEventTypes []string
	// IncludeTenantMetrics enables tenant metric attributes and can increase cardinality.
	IncludeTenantMetrics bool
	// MaxTenantMetricDimensions caps unique tenant labels before falling back to an overflow label.
	MaxTenantMetricDimensions int
	// MaxTrackedListPendingFailureTenants caps in-memory tenant counters for ListPending failures.
	MaxTrackedListPendingFailureTenants int
	// MeterProvider overrides the default global meter provider when set.
	MeterProvider metric.MeterProvider
}

type DispatcherOption func(*Dispatcher)

type EventHandler func(ctx context.Context, event *OutboxEvent) error

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

type OutboxEvent struct {
	ID          uuid.UUID
	EventType   string
	AggregateID uuid.UUID
	Payload     []byte
	Status      string
	Attempts    int
	PublishedAt *time.Time
	LastError   string
	CreatedAt   time.Time
	UpdatedAt   time.Time
}

type OutboxEventStatus string

type OutboxRepository interface {
	Create(ctx context.Context, event *OutboxEvent) (*OutboxEvent, error)
	CreateWithTx(ctx context.Context, tx Tx, event *OutboxEvent) (*OutboxEvent, error)
	ListPending(ctx context.Context, limit int) ([]*OutboxEvent, error)
	ListPendingByType(ctx context.Context, eventType string, limit int) ([]*OutboxEvent, error)
	ListTenants(ctx context.Context) ([]string, error)
	GetByID(ctx context.Context, id uuid.UUID) (*OutboxEvent, error)
	MarkPublished(ctx context.Context, id uuid.UUID, publishedAt time.Time) error
	MarkFailed(ctx context.Context, id uuid.UUID, errMsg string, maxAttempts int) error
	ListFailedForRetry(ctx context.Context, limit int, failedBefore time.Time, maxAttempts int) ([]*OutboxEvent, error)
	ResetForRetry(ctx context.Context, limit int, failedBefore time.Time, maxAttempts int) ([]*OutboxEvent, error)
	ResetStuckProcessing(ctx context.Context, limit int, processingBefore time.Time, maxAttempts int) ([]*OutboxEvent, error)
	MarkInvalid(ctx context.Context, id uuid.UUID, errMsg string) error
}

type RetryClassifier interface {
	IsNonRetryable(err error) bool
}

type RetryClassifierFunc func(err error) bool

type TenantDiscoverer interface {
	DiscoverTenants(ctx context.Context) ([]string, error)
}

type TenantResolver interface {
	ApplyTenant(ctx context.Context, tx *sql.Tx, tenantID string) error
}

type Tx = *sql.Tx