caching_middleware.go

package middleware

import (
	"context"
	"strings"

	"git.perx.ru/perxis/perxis-go/pkg/cache"
	"git.perx.ru/perxis/perxis-go/pkg/data"
	service "git.perx.ru/perxis/perxis-go/roles"
)

func makeKey(ss ...string) string {
	return strings.Join(ss, "-")
}

func CachingMiddleware(cache cache.Cache) Middleware {
	return func(next service.Roles) service.Roles {
		return &cachingMiddleware{
			cache: cache,
			next:  next,
		}
	}
}

type cachingMiddleware struct {
	cache cache.Cache
	next  service.Roles
}

func (m cachingMiddleware) Create(ctx context.Context, role *service.Role) (rl *service.Role, err error) {
	rl, err = m.next.Create(ctx, role)
	if err == nil {
		_ = m.cache.Remove(rl.SpaceID)
	}
	return rl, err
}

func (m cachingMiddleware) Get(ctx context.Context, spaceId string, roleId string) (rl *service.Role, err error) {
	key := makeKey(spaceId, roleId)
	value, e := m.cache.Get(key)
	if e == nil {
		return value.(*service.Role).Clone(), nil
	}
	rl, err = m.next.Get(ctx, spaceId, roleId)
	if err == nil {
		_ = m.cache.Set(key, rl)
		return rl.Clone(), nil
	}
	return nil, err
}

func (m cachingMiddleware) List(ctx context.Context, spaceId string) (roles []*service.Role, err error) {
	value, e := m.cache.Get(spaceId)
	if e == nil {
		return data.CloneSlice(value.([]*service.Role)), nil
	}
	roles, err = m.next.List(ctx, spaceId)
	if err == nil {
		_ = m.cache.Set(spaceId, roles)
		return data.CloneSlice(roles), nil
	}
	return nil, err
}

func (m cachingMiddleware) Update(ctx context.Context, role *service.Role) (err error) {
	err = m.next.Update(ctx, role)
	if err == nil {
		key := makeKey(role.SpaceID, role.ID)
		_ = m.cache.Remove(key)
		_ = m.cache.Remove(role.SpaceID)