cache/cache.go

package cache

import (
	"context"
	"fmt"
	"time"
)

// Option for get/set/delete methods.
type Option func(*Item)

// Configure configure cache.
type Configure func(*Cache)

// WithDataOption sets cache default data options.
func WithDataOption(do ...Option) Configure {
	return func(c *Cache) {
		factory := c.dataFactory
		c.dataFactory = func(key, value interface{}, opts ...Option) *Item {
			return factory(key, value, append(do, opts...)...)
		}
	}
}

// WithHandleDelete sets handlers delete.
func WithHandleDelete(h ...Handle) Configure {
	return func(m *Cache) {
		m.delete = chain(m.delete, h...)
	}
}

// WithHandle sets get/set/delete handler.
func WithHandle(get, set, delete Handle) Configure {
	return func(c *Cache) {
		if set != nil {
			c.set = chain(c.set, set)
		}

		if get != nil {
			c.get = chain(c.get, get)
		}

		if delete != nil {
			c.delete = chain(c.delete, delete)
		}
	}
}

// WithHandleCache add handler by cache operation type.
func WithHandleCache(handlers ...func() (Operation, func(ctx context.Context, c *Cache, item *Item, next Init) error)) Configure {
	return func(c *Cache) {
		for _, factory := range handlers {
			op, h := factory()
			switch op {
			case OperationSet:
				c.set = chain(c.set, func(ctx context.Context, item *Item, next Init) error {
					return h(ctx, c, item, next)
				})
			case OperationGet:
				c.get = chain(c.get, func(ctx context.Context, item *Item, next Init) error {
					return h(ctx, c, item, next)
				})
			case OperationDelete:
				c.delete = chain(c.delete, func(ctx context.Context, item *Item, next Init) error {
					return h(ctx, c, item, next)
				})
			}
		}
	}
}

// WithHandleSet sets handlers set.
func WithHandleSet(h ...Handle) Configure {
	return func(m *Cache) {
		m.set = chain(m.set, h...)
	}
}

// WithHandleGet sets handlers get.
func WithHandleGet(h ...Handle) Configure {
	return func(m *Cache) {
		m.get = chain(m.get, h...)
	}
}

// WithNamespace sets prefix and separator.
func WithNamespace(prefix, sep string) Option {
	return func(d *Item) {
		d.Key.Prefix = prefix
		d.Key.Separator = sep
	}
}

// WithTTL sets ttl.
func WithTTL(ttl time.Duration) Option {
	return func(d *Item) {
		d.TTL = ttl
	}
}

// New creates new cache by provider.
func New(prov Provider, opts ...Configure) *Cache {
	c := &Cache{
		get:         prov.Get,
		set:         prov.Set,
		delete:      prov.Delete,
		dataFactory: NewItem,
	}

	for _, o := range opts {
		o(c)
	}

	return c
}

// Provider cache.
type Provider interface {
	Delete(ctx context.Context, d *Item) error
	Get(ctx context.Context, d *Item) error
	Set(ctx context.Context, d *Item) error
}

// Cache base cache.
type Cache struct {
	dataFactory func(key, value interface{}, opts ...Option) *Item
	set         Init
	get         Init
	delete      Init
}

// Init func for get/set/delete.
type Init func(ctx context.Context, item *Item) error

// Handle middlewaare brfore/after init method.
type Handle func(ctx context.Context, item *Item, next Init) error

// Set handles middlewares and sets value by key and options.
func (c *Cache) Set(ctx context.Context, key, value interface{}, opts ...Option) error {
	return c.set(ctx, c.dataFactory(key, value, opts...))
}

// Get handles middlewares and gets value by key and options.
func (c *Cache) Get(ctx context.Context, key, value interface{}, opts ...Option) error {
	return c.get(ctx, c.dataFactory(key, value, opts...))
}

// Delete handles middlewares and delete value by key and options.
func (c *Cache) Delete(ctx context.Context, key interface{}, opts ...Option) error {
	return c.delete(ctx, c.dataFactory(key, nil, opts...))
}

// NewItem creates new item and configure them for provider.
func NewItem(key, value interface{}, opts ...Option) *Item {
	d := &Item{
		Key: Key{
			Key: key,
		},
		Value: value,
	}

	for _, o := range opts {
		o(d)
	}

	return d
}

// Item to get/set/delete in provider.
type Item struct {
	Key   Key
	Value interface{}
	TTL   time.Duration
}

// CopyTo copy iyem to target.
func (i *Item) CopyTo(target *Item) error {
	target.TTL = i.TTL

	return TypeAssert(i.Value, target.Value)
}

// IsExpired checks expired item.
func (i *Item) IsExpired() bool {
	return i.TTL < 0
}

// Options gets item options.
func (i *Item) Options() []Option {
	opts := []Option{
		WithTTL(i.TTL),
	}

	if i.Key.Prefix != "" {
		opts = append(opts, WithNamespace(i.Key.Prefix, i.Key.Separator))
	}

	return opts
}

// TTLInSecond sets ttl by seconds.
func (i *Item) TTLInSecond(in int64) {
	i.TTL = time.Second * time.Duration(in)
}

// Expired gets expired time by ttl.
func (i *Item) Expired() time.Time {
	return time.Now().Add(i.TTL)
}

// Key with prefix and separator.
type Key struct {
	Key       interface{}
	Prefix    string
	Separator string
}

// String return prefix+separator+key for key.
func (k Key) String() string {
	return fmt.Sprint(k.Prefix, k.Separator, k.Key)
}

func chain(init Init, handleFunc ...Handle) Init {
	n := len(handleFunc)
	if n > 0 {
		lastI := n - 1

		return func(ctx context.Context, d *Item) error {
			var (
				chainHandler func(ctx context.Context, d *Item) error
				curI         int
			)

			chainHandler = func(currentCtx context.Context, currentData *Item) error {
				if curI == lastI {
					return init(currentCtx, currentData)
				}
				curI++
				err := handleFunc[curI](currentCtx, currentData, chainHandler)
				curI--

				return err
			}

			return handleFunc[0](ctx, d, chainHandler)
		}
	}

	return init
}