redistool

type BuilderKV[K2 any] struct {
	HashKey K2
	// Value is the value to store in Redis.
	Value *ExpiringValue
}

type ErrCacher[K any] struct {
	Log           *zap.Logger
	ErrRep        errz.ErrReporter
	Client        rueidis.Client
	ErrMarshaler  ErrMarshaler
	KeyToRedisKey KeyToRedisKey[K]
}

type ErrMarshaler interface {
	// Marshal turns error into []byte.
	Marshal(error) ([]byte, error)
	// Unmarshal turns []byte into error.
	Unmarshal([]byte) (error, error)
}

type ExpiringHash[K1 any, K2 any] interface {
	// GetName returns the name of this hash
	GetName() string
	// Set sets the key -> hashKey -> value. The mapping is stored in RAM and in the backing store.
	// Use Refresh to refresh the value in the backing store.
	Set(ctx context.Context, key K1, hashKey K2, value []byte) error
	// SetEX sets the key -> hashKey -> value. The value is stored in the backing store only (unlike Set).
	// Refresh does not refresh this value in the backing store. Use this method to re-set (i.e. refresh) the value
	// in the backing store.
	// Safe for concurrent use.
	SetEX(ctx context.Context, key K1, hashKey K2, value []byte, expiresAt time.Time) error
	Unset(ctx context.Context, key K1, hashKey K2) error
	// Forget only removes the item from the in-memory map.
	Forget(key K1, hashKey K2)
	// Scan iterates key-value pairs for key.
	// Safe for concurrent use.
	Scan(ctx context.Context, key K1, cb ScanCallback) error
	// Len returns number of key-value mappings in the hash identified by key.
	Len(ctx context.Context, key K1) (int64, error)
	// GC returns a function that iterates all relevant stored data and deletes expired entries.
	// The returned function can be called concurrently as it does not interfere with the hash's operation.
	// The function returns number of deleted Redis (hash) keys, including when an error occurred.
	// It only inspects/GCs hashes where it has entries. Other concurrent clients GC same and/or other corresponding hashes.
	// Hashes that don't have a corresponding client (e.g. because it crashed) will expire because of TTL on the hash key.
	GC() func(context.Context) (int, error)
	// GCFor returns a function that iterates the hash for the given keys and deletes expired entries.
	// GCFor is useful when executing GC for specific keys.
	GCFor(keys []K1) func(context.Context) (int, error)
	// Refresh refreshes data in the backing store to prevent it from expiring.
	Refresh(ctx context.Context, nextRefresh time.Time) error
}

type ExpiringHashAPI[K1 any, K2 any] interface {
	SetBuilder() SetBuilder[K1, K2]
	Unset(ctx context.Context, key K1, hashKey K2) error
	Scan(ctx context.Context, key K1, cb ScanCallback) error
	GCFor(keys []K1, transactional bool) func(context.Context) (int, error)
}

type ExpiringValue struct {
	ExpiresAt int64  `protobuf:"varint,1,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"`
	Value     []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type ExpiringValueTimestamp struct {
	ExpiresAt int64 `protobuf:"varint,1,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"`
	// contains filtered or unexported fields
}

type KeyToRedisKey[K any] func(key K) string

type RPCAPI interface {
	Log() *zap.Logger
	HandleProcessingError(msg string, err error)
	RequestKey() []byte
}

type RedisExpiringHash[K1 comparable, K2 comparable] struct {
	// contains filtered or unexported fields
}

type RedisExpiringHashAPI[K1 any, K2 any] struct {
	// contains filtered or unexported fields
}

type RedisSetBuilder[K1 any, K2 any] struct {
	// contains filtered or unexported fields
}

type ScanCallback func(rawHashKey string, value []byte, err error) (bool, error)

type SetBuilder[K1 any, K2 any] interface {
	// Set enqueues a HSET command. Does nothing if no kvs provided.
	Set(key K1, ttl time.Duration, kvs ...BuilderKV[K2])
	// Do executes enqueued commands. Does nothing if no commands have been enqueued.
	// Builder must not be reused after this method has been called.
	Do(context.Context) error
}

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