resilience

type AppError interface {
	Error() string
	Unwrap() error
	Is(target error) bool
	GetStatus() *Status
	WithCause(cause error) AppError
	WithMetadata(md map[string]string) AppError
	GRPCStatus() any
}

type BreakerPolicy struct {
	Enabled               bool
	Strategy              string
	Threshold             float64
	MinRequestCount       int64
	MaxConcurrentRequests int64
	RetryTimeoutMs        int64
}

type CORSDefaults struct {
	AllowOrigins  []string `json:"allow_origins"`
	MaxAgeSeconds int      `json:"max_age_seconds"`
}

type CircuitBreaker interface {
	Allow(ctx context.Context, resource string) error
	RecordSuccess(ctx context.Context, resource string)
	RecordFailure(ctx context.Context, resource string, err error)
	Do(ctx context.Context, resource string, fn func() error) error
	State(ctx context.Context, resource string) CircuitBreakerState
}

type CircuitBreakerConfig struct {
	Enabled         bool
	Strategy        string
	ResourceConfigs map[string]ResourceConfig
	DefaultConfig   ResourceConfig
}

type CircuitBreakerState int

type ErrorReason string

type ErrorReport struct {
	Error      error
	Message    string
	Tags       map[string]string
	Context    map[string]any
	StackTrace string
	User       *ErrorUser
	Request    *ErrorRequest
}

type ErrorReporter interface {
	ReportSync(ctx context.Context, report *ErrorReport) error
	ReportAsync(ctx context.Context, report *ErrorReport)
	Flush()
}

type ErrorReporterConfig struct {
	Enabled     bool
	DSN         string
	Environment string
	Release     string
	SampleRate  float64
	Tags        map[string]string
}

type ErrorRequest struct {
	Method  string
	URL     string
	Headers map[string]string
	Body    string
}

type ErrorUser struct {
	ID    string
	Name  string
	Email string
}

type GovernanceDefaultsTable struct {
	Mode               GovernanceMode     `json:"mode"`
	FeatureDefaults    map[string]bool    `json:"feature_defaults"`
	ProviderDefaults   map[string]string  `json:"provider_defaults"`
	MiddlewareDefaults MiddlewareDefaults `json:"middleware_defaults"`
	RPCClientDefaults  RPCClientDefaults  `json:"rpc_client_defaults"`
}

type GovernanceFeatureSet struct {
	RequestIdentity bool
	Logging         bool
	Recovery        bool
	Timeout         bool
	Metrics         bool

	MetadataPropagation bool
	Tracing             bool
	Selector            bool
	ServiceAuth         bool
	CircuitBreaker      bool
	Retry               bool
	LoadShedding        bool
	Discovery           bool
}

type GovernanceMode string

type GovernancePolicyProvider interface {
	Mode() GovernanceMode
	TimeoutPolicy(resource string) TimeoutPolicy
	RetryPolicy(resource string) RetryPolicy
	BreakerPolicy(resource string) BreakerPolicy
	LoadSheddingPolicy(resource string) LoadSheddingPolicy
}

type HTTPMode string

type LoadShedder interface {
	Allow(ctx context.Context, resource string) error
	Done(ctx context.Context, resource string, err error)
}

type LoadSheddingConfig struct {
	Enabled          bool
	Strategy         string
	MaxConcurrency   int
	ResourcePolicies map[string]LoadSheddingPolicy
	DefaultPolicy    LoadSheddingPolicy
}

type LoadSheddingPolicy struct {
	Enabled        bool
	Strategy       string
	MaxConcurrency int
}

type LocaleDefaults struct {
	Supported []string `json:"supported"`
	Default   string   `json:"default"`
	QueryKeys []string `json:"query_keys"`
}

type MiddlewareDefaults struct {
	Timeout           string                 `json:"timeout"`
	BodyLimit         string                 `json:"body_limit"`
	MaxConcurrent     int                    `json:"max_concurrent"`
	EnableMetrics     bool                   `json:"enable_metrics"`
	EnableCompression bool                   `json:"enable_compression"`
	CORS              CORSDefaults           `json:"cors"`
	SecurityHeaders   SecurityHeaderDefaults `json:"security_headers"`
	Locale            LocaleDefaults         `json:"locale"`
}

type RPCClientDefaults struct {
	Timeout string `json:"timeout"`
}

type RateLimiter interface {
	Allow(ctx context.Context, resource string) error
	AllowN(ctx context.Context, resource string, n int) error
	Reserve(ctx context.Context, resource string) Reservation
	Wait(ctx context.Context, resource string) error
	WaitTimeout(ctx context.Context, resource string, timeout time.Duration) error
}

type RateLimiterConfig struct {
	Enabled         bool
	Strategy        string
	ResourceConfigs map[string]RateResourceConfig
	DefaultConfig   RateResourceConfig
}

type RateResourceConfig struct {
	QPS     float64
	Burst   int
	MaxWait time.Duration
}

type Reservation interface {
	OK() bool
	Delay() time.Duration
	Cancel()
	CancelAt(t time.Time)
}

type ResourceConfig struct {
	Threshold             float64
	MinRequestCount       int64
	MaxConcurrentRequests int64
	Timeout               time.Duration
	RetryTimeoutMs        int64
	Interval              time.Duration
}

type Retry interface {
	Do(ctx context.Context, fn func() error) error
	DoForResource(ctx context.Context, resource string, fn func() error) error
	DoWithResult(ctx context.Context, fn func() (any, error)) (any, error)
	IsRetryable(err error) bool
}

type RetryConfig struct {
	Enabled          bool
	Strategy         string
	DefaultPolicy    RetryPolicy
	ResourcePolicies map[string]RetryPolicy
}

type RetryPolicy struct {
	MaxAttempts        int
	InitialDelay       time.Duration
	MaxDelay           time.Duration
	Multiplier         float64
	RetryableErrors    []ErrorReason
	RetryableCodes     []int
	RetryableGRPCCodes []string
}

type SecurityHeaderDefaults struct {
	XFrameOptions       string `json:"x_frame_options"`
	XContentTypeOptions string `json:"x_content_type_options"`
	ReferrerPolicy      string `json:"referrer_policy"`
}

type Status struct {
	Code     int32             `json:"code"`
	Reason   ErrorReason       `json:"reason"`
	Message  string            `json:"message"`
	Metadata map[string]string `json:"metadata,omitempty"`
}

type TimeoutPolicy struct {
	Enabled   bool
	TimeoutMS int
}