trcache

type Cache[K comparable, V any] interface {
	// Name returns the name for the cache. It can be useful in cases where multiple caches are used at the same time,
	// like on [github.com/rrgmc/trcache/cache/chain.Chain]. It often is blank.
	Name() string

	// Get gets the value of an item from the cache with this key. If not found, it returns [ErrNotFound] as the error.
	Get(ctx context.Context, key K, options ...GetOption) (V, error)

	// Set sets the value of the key on the cache.
	Set(ctx context.Context, key K, value V, options ...SetOption) error

	// Delete deletes the key from the cache.
	Delete(ctx context.Context, key K, options ...DeleteOption) error
}

type CacheRefreshFunc[K comparable, V any] func(ctx context.Context, key K, options RefreshFuncOptions) (V, error)

type CallDefaultOptions[K comparable, V any] interface {
	// OptCallDefaultGetOptions sets the default options to be appended to all [Cache.Get] calls.
	OptCallDefaultGetOptions(options ...GetOption)
	// OptCallDefaultSetOptions sets the default options to be appended to all [Cache.Set] calls.
	OptCallDefaultSetOptions(options ...SetOption)
	// OptCallDefaultDeleteOptions sets the default options to be appended to all [Cache.Delete] calls.
	OptCallDefaultDeleteOptions(options ...DeleteOption)
}

type CallDefaultRefreshOptions[K comparable, V any] interface {
	// OptCallDefaultRefreshOptions sets the default options to be appended to all [RefreshCache.GetOrRefresh] calls.
	OptCallDefaultRefreshOptions(options ...RefreshOption)
}

type Codec[V any] interface {
	Encode(ctx context.Context, data V) (any, error)
	Decode(ctx context.Context, data any) (V, error)
}

type CodecError struct {
	Err error
}

type DefaultRefreshOptions[K comparable, V any] interface {
	// OptDefaultRefreshFunc sets the default refresh function to be used for [RefreshCache.GetOrRefresh].
	OptDefaultRefreshFunc(refreshFunc CacheRefreshFunc[K, V])
}

type DeleteOption = IOption[IDeleteOpt]

type DeleteOptions[K comparable, V any] interface {
}

type GetOption = IOption[IGetOpt]

type GetOptions[K comparable, V any] interface {
}

type IDeleteOpt int

type IGetOpt int

type IIsOption[T any] struct {
}

type IOption[T any] interface {
	Option
	// contains filtered or unexported methods
}

type IRefreshOpt int

type IRootOpt int

type ISetOpt int

type InvalidValueTypeError struct {
	Message string
}

type IsDeleteOption = IIsOption[IDeleteOpt]

type IsGetOption = IIsOption[IGetOpt]

type IsRefreshOption = IIsOption[IRefreshOpt]

type IsRootOption = IIsOption[IRootOpt]

type IsSetOption = IIsOption[ISetOpt]

type KeyCodec[K comparable] interface {
	Convert(ctx context.Context, key K) (any, error)
}

type Metrics interface {
	Hit(ctx context.Context, name string, key any)
	Miss(ctx context.Context, name string, key any)
	Error(ctx context.Context, name string, key any, errorType MetricsErrorType)
}

type MetricsErrorType int

type MetricsOptions[K comparable, V any] interface {
	// OptMetrics sets the [Metrics] instance to call for metrics.
	OptMetrics(metrics Metrics, name string)
}

type NameOptions[K comparable, V any] interface {
	// OptName sets the cache name.
	OptName(name string)
}

type Option interface {
	ApplyCacheOpt(any) bool
	CacheOptName() string
	CacheOptHash() uint64
}

type OptionChecker[O IOption[TO], TO any] interface {
	IOption[TO]
	CheckCacheOpt(opt Option)
	CheckCacheError() error
	CheckCacheOptList() []IOption[TO]
}

type OptionNotSupportedError struct {
	Message string
	Option  Option
}

type Options[K comparable, V any] interface {
}

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

type RefreshCache[K comparable, V any] interface {
	Cache[K, V]

	// GetOrRefresh tries to get the value for the key on the cache, calling a refresh function if not found,
	// and then storing the newly loaded value to cache before returning it.
	GetOrRefresh(ctx context.Context, key K, options ...RefreshOption) (V, error)
}

type RefreshFuncOptions struct {
	// Data is the custom data sent with [WithRefreshData].
	Data any
}

type RefreshOption = IOption[IRefreshOpt]

type RefreshOptions[K comparable, V any] interface {
	// OptData sets a custom data to be sent to the refresh function.
	OptData(data any)
	// OptFunc sets the refresh function for this call, possibly overriding a default one.
	OptFunc(refreshFunc CacheRefreshFunc[K, V])
	// OptGetOptions sets the options to be appended to all [Cache.Get] calls inside the refresh function.
	OptGetOptions(options ...GetOption)
	// OptSetOptions sets the options to be appended to all [Cache.Set] calls inside the refresh function.
	OptSetOptions(options ...SetOption)
}

type RootOption = IOption[IRootOpt]

type SetOption = IOption[ISetOpt]

type SetOptions[K comparable, V any] interface {
	// OptDuration sets the cache duration (TTL) to be used for this set call instead of the default.
	OptDuration(duration time.Duration)
}

type ValidationError struct {
	Err error
}

type Validator[V any] interface {
	ValidateGet(ctx context.Context, data V) error
}