kvstore

type ChainConfiguration struct {
	ModelId             mdl.ModelId           `cfg:"model_id"`
	Type                string                `cfg:"type" default:"chain" validate:"eq=chain"`
	Elements            []string              `cfg:"elements" validate:"min=1"`
	Ddb                 DdbSettings           `cfg:"ddb"`
	Ttl                 time.Duration         `cfg:"ttl"`
	BatchSize           int                   `cfg:"batch_size" default:"100" validate:"min=1"`
	MissingCacheEnabled bool                  `cfg:"missing_cache_enabled" default:"false"`
	MetricsEnabled      bool                  `cfg:"metrics_enabled" default:"false"`
	InMemory            InMemoryConfiguration `cfg:"in_memory"`
	Redis               RedisConfiguration    `cfg:"redis"`
}

type ChainKvStore[T any] interface {
	KvStore[T]
	Add(elementFactory ElementFactory[T]) error
	AddStore(store KvStore[T])
}

type DdbDeleteItem struct {
	Key string `json:"key" ddb:"key=hash"`
}

type DdbItem struct {
	Key   string `json:"key"   ddb:"key=hash"`
	Value string `json:"value"`
}

type DdbSettings struct {
	ClientName string `cfg:"client_name" default:"default"`
}

type ElementFactory[T any] func(ctx context.Context, config cfg.Config, logger log.Logger, settings *Settings) (KvStore[T], error)

type Factory[T any] func(elementFactory ElementFactory[T], settings *Settings) (KvStore[T], error)

type InMemoryConfiguration struct {
	MaxSize        int64  `cfg:"max_size" default:"5000"`
	Buckets        uint32 `cfg:"buckets" default:"16"`
	ItemsToPrune   uint32 `cfg:"items_to_prune" default:"500"`
	DeleteBuffer   uint32 `cfg:"delete_buffer" default:"1024"`
	PromoteBuffer  uint32 `cfg:"promote_buffer" default:"1024"`
	GetsPerPromote int32  `cfg:"gets_per_promote" default:"3"`
}

type InMemoryKvStore[T any] struct {
	// contains filtered or unexported fields
}

type InMemorySettings struct {
	MaxSize        int64
	Buckets        uint32
	ItemsToPrune   uint32
	DeleteBuffer   uint32
	PromoteBuffer  uint32
	GetsPerPromote int32
}

type KvStore[T any] interface {
	// Check if a key exists in the store.
	Contains(ctx context.Context, key any) (bool, error)
	// Retrieve a value from the store by the given key. If the value does
	// not exist, false is returned and value is not modified.
	// value should be a pointer to the model you want to retrieve.
	Get(ctx context.Context, key any, value *T) (bool, error)
	// Retrieve a set of values from the store. Each value is written to the
	// map in values at its key.  Values should be something which can be converted to map[any]T.
	// Returns a list of missing keys in the store.
	GetBatch(ctx context.Context, keys any, values any) ([]any, error)
	// Write a value to the store
	Put(ctx context.Context, key any, value T) error
	// Write a batch of values to the store. Values should be something which
	// can be converted to map[any]T.
	PutBatch(ctx context.Context, values any) error
	// Remove the value with the given key from the store
	Delete(ctx context.Context, key any) error
	// Remove all values with the given keys from the store
	DeleteBatch(ctx context.Context, keys any) error
}

type KvStoreFixture struct {
	Key   any
	Value any
}

type MetricStore[T any] struct {
	KvStore[T]
	// contains filtered or unexported fields
}

type RedisConfiguration struct {
	DB         int    `cfg:"db" default:"0"`
	KeyPattern string `cfg:"key_pattern,nodecode" default:"{app.namespace}-kvstore-{store}-{key}"`
}

type RedisSettings struct {
	KeyPrefixPattern string
}

type Settings struct {
	mdl.ModelId
	InMemorySettings
	DdbSettings    DdbSettings
	RedisSettings  RedisSettings
	Ttl            time.Duration
	BatchSize      int
	MetricsEnabled bool
}

type SizedStore[T any] interface {
	KvStore[T]
	// return an estimate about how many elements are currently in the store
	// returns nil if no estimate could be returned
	EstimateSize() *int64
}