mclient

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

type ClientConfig struct {
	// BaseURL specifies the base URL for all requests.
	BaseURL string `mconv:"base_url"`
	// Timeout specifies a time limit for requests made by this client.
	Timeout time.Duration `mconv:"timeout"`
	// Transport specifies the mechanism by which individual HTTP requests are made.
	Transport http.RoundTripper
	// Header specifies the default header for requests.
	Header http.Header
}

type HandlerFunc func(*Request) (*Response, error)

type MiddlewareFunc func(HandlerFunc) HandlerFunc

type RateLimitConfig struct {
	// RequestsPerSecond is the number of requests allowed per second
	RequestsPerSecond float64
	// Burst is the maximum number of requests allowed to happen at once
	Burst int
	// Skip determines if rate limiting should be skipped for a request
	Skip func(*Request) bool
	// ErrorHandler handles rate limit errors
	ErrorHandler func(context.Context, error) (*Response, error)
}

type RateLimiter interface {
	// Wait blocks until a request can be allowed or context is cancelled.
	Wait(ctx context.Context) error
	// TryAcquire tries to acquire a token without blocking.
	TryAcquire() bool
}

type Request struct {
	*http.Request // Request is the underlying http.Request object.
	// contains filtered or unexported fields
}

type Response struct {
	*http.Response // Response is the underlying http.Response object of certain request.
	// contains filtered or unexported fields
}

type RetryConfig struct {
	// Count is the maximum number of retries.
	// For example, if Count is 3, the request will be tried up to 4 times (initial attempt + 3 retries).
	Count int

	// BaseInterval is the base interval between retries.
	// This is the starting point for calculating the delay between retries.
	// For example, if BaseInterval is 1 second, the first retry will wait at least 1 second.
	BaseInterval time.Duration

	// MaxInterval is the maximum interval between retries.
	// This prevents the delay from growing too large due to exponential backoff.
	// For example, if MaxInterval is 30 seconds, even if the calculated delay is 60 seconds,
	// the actual delay will be capped at 30 seconds.
	MaxInterval time.Duration

	// BackoffFactor is the factor for exponential backoff.
	// Each retry's delay is calculated by multiplying the previous delay by this factor.
	// For example, if BaseInterval is 1 second and BackoffFactor is 2.0:
	// - First retry: 1 second
	// - Second retry: 2 seconds
	// - Third retry: 4 seconds
	// - And so on...
	BackoffFactor float64

	// JitterFactor is the factor for random jitter.
	// This adds randomness to the delay to prevent multiple clients from retrying simultaneously.
	// The actual jitter is calculated as: delay * JitterFactor * (random number between -1 and 1)
	// For example, if the calculated delay is 1 second and JitterFactor is 0.1:
	// - The actual delay will be between 0.9 and 1.1 seconds
	// A value of 0 means no jitter will be added.
	JitterFactor float64
}

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