redis

type InspectLeakyBucketResponse struct {
	// RemainingTokens defines hwo many tokens are left in the bucket
	RemainingTokens int

	// ResetAt is the time at which the bucket will be fully refilled
	ResetAt time.Time
}

type InspectSlidingWindowResponse struct {
	// RemainingCapacity defines the remaining amount of capacity left in the bucket
	RemainingCapacity int
}

type LeakyBucket interface {
	// Inspect atomically inspects the leaky bucket and returns the capacity available. It does not take any tokens.
	Inspect(ctx context.Context, bucket *LeakyBucketOptions) (*InspectLeakyBucketResponse, error)

	// Use atomically attempts to use the leaky bucket. Use takeAmount to set how many tokens should be attempted to be removed
	// from the bucket: they are atomic, either all tokens are taken, or the ratelimit is unsuccessful.
	Use(ctx context.Context, bucket *LeakyBucketOptions, takeAmount int) (*UseLeakyBucketResponse, error)
}

type LeakyBucketImpl struct {
	// Adapter defines the Redis adapter
	Adapter adapters.Adapter
	// contains filtered or unexported fields
}

type LeakyBucketOptions struct {
	// KeyPrefix is the bucket key name in Redis.
	//
	// Note that this ratelimiter will create two keys in Redis, and suffix them with :last_fill and :tokens.
	KeyPrefix string

	// MaximumCapacity defines the maximum number of tokens in the leaky bucket. If a bucket has expired or otherwise doesn't exist,
	// the bucket is set to this size, it also ensures the bucket can never contain more than this number of tokens at any time.
	//
	// Note that if you decrease the number of tokens in an existing bucket, that bucket is automatically reduced to the new max size,
	// however, if you increase the maximum capacity of the bucket, it will refill faster, but not immediately be placed to the new, higher
	// capacity.
	MaximumCapacity int

	// WindowSeconds defines the maximum amount of time it takes to refill the bucket, the refill rate of the bucket is calculated using
	// maximumCapacity/windowSeconds, in other words, if your capacity was 60 tokens, and the window was 1 minute, you would refill at a constant
	// rate of 1 token per second.
	//
	// Windows have a maximum resolution of 1 second.
	WindowSeconds int
}

type SlidingWindow interface {
	// Inspect atomically inspects the sliding window and returns the capacity available. It does not take any tokens.
	Inspect(ctx context.Context, bucket *SlidingWindowOptions) (*InspectSlidingWindowResponse, error)

	// Use atomically attempts to use the sliding window. Sliding window ratelimiters always take 1 token at a time, as the key is inferred
	// from when it would expire in nanoseconds.
	Use(ctx context.Context, bucket *SlidingWindowOptions) (*UseSlidingWindowResponse, error)
}

type SlidingWindowImpl struct {
	// Adapter defines the Redis adapter
	Adapter adapters.Adapter
	// contains filtered or unexported fields
}

type SlidingWindowOptions struct {
	// Key defines the Redis key used for this sliding window ratelimiter
	Key string

	// MaximumCapacity defines the max size of the sliding window, no more tokens than this may be stored in the sliding
	// window at any time.
	MaximumCapacity int

	// Window defines the size of the sliding window, resolution is available up to nanoseconds.
	Window time.Duration
}

type UseLeakyBucketResponse struct {
	// Success is true when we were successfully able to take tokens from the bucket.
	Success bool

	// RemainingTokens defines hwo many tokens are left in the bucket
	RemainingTokens int

	// ResetAt is the time at which the bucket will be fully refilled
	ResetAt time.Time
}

type UseSlidingWindowResponse struct {
	// Success defines whether the sliding window was successfully used
	Success bool

	// RemainingCapacity defines the remaining amount of capacity left in the bucket
	RemainingCapacity int
}