diff --git a/pkg/account/client.go b/pkg/account/client.go
index 53ae9fb81924ec95370b3e9110de8fbfb93d3400..112a71f67fe130bb57c6483ad4793565bca8d0bd 100644
--- a/pkg/account/client.go
+++ b/pkg/account/client.go
@@ -53,9 +53,9 @@ func NewClient(conn *grpc.ClientConn, opts ...Option) *Account {
 func WithCaching(client *Account, size int, ttl time.Duration) *Account {
 	c := *client
 
-	c.Members = serviceMembers.CachingMiddleware(cache.NewCache(size, ttl))(client.Members)
-	c.Organizations = serviceOrganizations.CachingMiddleware(cache.NewCache(size, ttl))(client.Organizations)
-	c.Users = serviceUsers.CachingMiddleware(cache.NewCache(size, ttl))(client.Users)
+	c.Members = serviceMembers.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Members)
+	c.Organizations = serviceOrganizations.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Organizations)
+	c.Users = serviceUsers.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Users)
 
 	return &c
 }
diff --git a/pkg/cache/memory_cache.go b/pkg/cache/memory_cache.go
new file mode 100644
index 0000000000000000000000000000000000000000..12b9b55812bbfb11646f828a4a3e643027687c4b
--- /dev/null
+++ b/pkg/cache/memory_cache.go
@@ -0,0 +1,90 @@
+package cache
+
+import (
+	"fmt"
+	"time"
+
+	"git.perx.ru/perxis/perxis-go/pkg/service"
+	lru "github.com/hashicorp/golang-lru/v2"
+	"go.uber.org/zap"
+)
+
+const (
+	defaultCacheSize = 1000
+	defaultTTL       = 30 * time.Second
+)
+
+var _ Cache = &MemoryCache{}
+
+type MemoryCache struct {
+	cache  *lru.Cache[interface{}, interface{}]
+	ttl    time.Duration
+	logger *zap.Logger
+}
+
+type item struct {
+	value     interface{}
+	expiredAt time.Time
+}
+
+func NewMemoryCache(size int, ttl time.Duration, opts ...interface{}) *MemoryCache {
+	if size == 0 {
+		size = defaultCacheSize
+	}
+	if ttl == 0 {
+		ttl = defaultTTL
+	}
+	c, err := lru.New[interface{}, interface{}](size)
+	if err != nil {
+		panic(err)
+	}
+	ch := &MemoryCache{
+		cache:  c,
+		ttl:    ttl,
+		logger: zap.NewNop(),
+	}
+
+	for _, o := range opts {
+		switch p := o.(type) {
+		case *zap.Logger:
+			ch.logger = p
+		}
+	}
+
+	ch.logger = ch.logger.Named("Cache")
+
+	return ch
+}
+
+func (c *MemoryCache) Set(key, value interface{}) (err error) {
+	c.cache.Add(key, &item{value: value, expiredAt: time.Now().Add(c.ttl)})
+	c.logger.Debug("Set", zap.String("key", fmt.Sprintf("%v", key)), zap.String("ptr", fmt.Sprintf("%p", value)))
+	return nil
+}
+
+func (c *MemoryCache) Get(key interface{}) (value interface{}, err error) {
+	val, ok := c.cache.Get(key)
+	if ok {
+		v := val.(*item)
+		if v.expiredAt.Before(time.Now()) {
+			_ = c.Remove(key)
+			c.logger.Debug("Expired", zap.String("key", fmt.Sprintf("%v", key)), zap.String("ptr", fmt.Sprintf("%p", v.value)))
+			return nil, service.ErrNotFound
+		}
+		c.logger.Debug("Hit", zap.String("key", fmt.Sprintf("%v", key)), zap.String("ptr", fmt.Sprintf("%p", v.value)))
+		return v.value, nil
+	}
+	c.logger.Debug("Miss", zap.String("key", fmt.Sprintf("%v", key)))
+	return nil, service.ErrNotFound
+}
+
+func (c *MemoryCache) Remove(key interface{}) (err error) {
+	present := c.cache.Remove(key)
+	c.logger.Debug("Remove", zap.String("key", fmt.Sprintf("%v", key)))
+
+	if !present {
+		err = service.ErrNotFound
+	}
+
+	return
+}
diff --git a/pkg/cache/cache_test.go b/pkg/cache/memory_cache_test.go
similarity index 93%
rename from pkg/cache/cache_test.go
rename to pkg/cache/memory_cache_test.go
index b0d4304a499f0970cc695b667429c896763c1a33..b7cf246f6923f6fe131de760a5cbf3272fec2da1 100644
--- a/pkg/cache/cache_test.go
+++ b/pkg/cache/memory_cache_test.go
@@ -10,7 +10,7 @@ import (
 
 func TestCache(t *testing.T) {
 	t.Run("Simple", func(t *testing.T) {
-		c := NewCache(10, 0)
+		c := NewMemoryCache(10, 0)
 
 		{
 			val, err := c.Get("test_key")
@@ -37,7 +37,7 @@ func TestCache(t *testing.T) {
 		}
 	})
 	t.Run("Value Evicted", func(t *testing.T) {
-		c := NewCache(1, 0)
+		c := NewMemoryCache(1, 0)
 
 		{
 			err := c.Set("test_key_1", "test_val_1")
@@ -62,7 +62,7 @@ func TestCache(t *testing.T) {
 
 	})
 	t.Run("TTL expired", func(t *testing.T) {
-		c := NewCache(10, 10*time.Millisecond)
+		c := NewMemoryCache(10, 10*time.Millisecond)
 
 		err := c.Set("test_key", "test_val")
 		require.NoError(t, err)
diff --git a/pkg/clients/middleware/caching_middleware_test.go b/pkg/clients/middleware/caching_middleware_test.go
index b842e1183a5425a4b3aec8d59b0720e5627767ed..2a90c1db2c322ca9509cb2bf9bdd63b252e67c68 100644
--- a/pkg/clients/middleware/caching_middleware_test.go
+++ b/pkg/clients/middleware/caching_middleware_test.go
@@ -31,7 +31,7 @@ func TestClientsCache(t *testing.T) {
 	t.Run("Get from cache", func(t *testing.T) {
 		cs := &csmocks.Clients{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
 
 		cs.On("Get", mock.Anything, spaceID, cltID).Return(&clients.Client{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}, nil).Once()
 
@@ -52,7 +52,7 @@ func TestClientsCache(t *testing.T) {
 	t.Run("GetBy from cache", func(t *testing.T) {
 		cs := &csmocks.Clients{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
 
 		cs.On("GetBy", mock.Anything, spaceID, &clients.GetByParams{OAuthClientID: clientID}).Return(&clients.Client{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}, nil).Once()
 
@@ -73,7 +73,7 @@ func TestClientsCache(t *testing.T) {
 	t.Run("List", func(t *testing.T) {
 		cs := &csmocks.Clients{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
 
 		cs.On("List", mock.Anything, spaceID).Return([]*clients.Client{{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}}, nil).Once()
 
@@ -92,7 +92,7 @@ func TestClientsCache(t *testing.T) {
 		t.Run("After Update", func(t *testing.T) {
 			cs := &csmocks.Clients{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
 
 			cs.On("Get", mock.Anything, spaceID, cltID).Return(&clients.Client{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}, nil).Once()
 			cs.On("List", mock.Anything, spaceID).Return([]*clients.Client{{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}}, nil).Once()
@@ -143,7 +143,7 @@ func TestClientsCache(t *testing.T) {
 		t.Run("After Update(List)", func(t *testing.T) {
 			cs := &csmocks.Clients{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
 
 			cs.On("List", mock.Anything, spaceID).Return([]*clients.Client{{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}}, nil).Once()
 
@@ -172,7 +172,7 @@ func TestClientsCache(t *testing.T) {
 		t.Run("After Delete", func(t *testing.T) {
 			cs := &csmocks.Clients{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
 
 			cs.On("Get", mock.Anything, spaceID, cltID).Return(&clients.Client{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}, nil).Once()
 			cs.On("List", mock.Anything, spaceID).Return([]*clients.Client{{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}}, nil).Once()
@@ -222,7 +222,7 @@ func TestClientsCache(t *testing.T) {
 		t.Run("After Delete(List)", func(t *testing.T) {
 			cs := &csmocks.Clients{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
 
 			cs.On("List", mock.Anything, spaceID).Return([]*clients.Client{{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}}}, nil).Once()
 
@@ -250,7 +250,7 @@ func TestClientsCache(t *testing.T) {
 		t.Run("After Create", func(t *testing.T) {
 			cs := &csmocks.Clients{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
 
 			cs.On("List", mock.Anything, spaceID).Return([]*clients.Client{{ID: cltID, SpaceID: spaceID, Name: "client_1"}}, nil).Once()
 
@@ -279,7 +279,7 @@ func TestClientsCache(t *testing.T) {
 		t.Run("After Enable", func(t *testing.T) {
 			cs := &csmocks.Clients{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
 
 			tr := true
 			cs.On("Get", mock.Anything, spaceID, cltID).Return(&clients.Client{ID: cltID, SpaceID: spaceID, OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}, Disabled: &tr}, nil).Once()
@@ -329,7 +329,7 @@ func TestClientsCache(t *testing.T) {
 		t.Run("After Enable(List)", func(t *testing.T) {
 			cs := &csmocks.Clients{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
 
 			tr := true
 			cs.On("List", mock.Anything, spaceID).Return([]*clients.Client{{ID: cltID, SpaceID: spaceID, OAuth: &clients.OAuth{ClientID: clientID, AuthID: "authID"}, Disabled: &tr}}, nil).Once()
@@ -359,7 +359,7 @@ func TestClientsCache(t *testing.T) {
 		t.Run("After TTL expired", func(t *testing.T) {
 			cs := &csmocks.Clients{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
 
 			cs.On("Get", mock.Anything, spaceID, cltID).Return(&clients.Client{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID}}, nil).Once()
 			cs.On("Get", mock.Anything, spaceID, cltID).Return(&clients.Client{ID: cltID, SpaceID: spaceID, Name: "client_1", OAuth: &clients.OAuth{ClientID: clientID}}, nil).Once()
diff --git a/pkg/collaborators/middleware/caching_middleware_test.go b/pkg/collaborators/middleware/caching_middleware_test.go
index b7dc09281a9f972e9eafde3dd87ce628b0ea2fae..ea2ccaddb2621c306e317d6d873a455489a6a2a6 100644
--- a/pkg/collaborators/middleware/caching_middleware_test.go
+++ b/pkg/collaborators/middleware/caching_middleware_test.go
@@ -31,7 +31,7 @@ func TestCollaboratorsCache(t *testing.T) {
 	t.Run("Get from cache", func(t *testing.T) {
 		cs := &csmocks.Collaborators{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
 
 		cs.On("Get", mock.Anything, spaceID, userID).Return(spaceRole, nil).Once()
 
@@ -48,7 +48,7 @@ func TestCollaboratorsCache(t *testing.T) {
 	t.Run("ListCollaborators from cache", func(t *testing.T) {
 		cs := &csmocks.Collaborators{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
 
 		cs.On("ListCollaborators", mock.Anything, spaceID).Return([]*collaborators.Collaborator{{SpaceID: spaceID, Subject: userID, Role: spaceRole}}, nil).Once()
 
@@ -64,7 +64,7 @@ func TestCollaboratorsCache(t *testing.T) {
 	t.Run("ListSpaces from cache", func(t *testing.T) {
 		cs := &csmocks.Collaborators{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
 
 		cs.On("ListSpaces", mock.Anything, userID).Return([]*collaborators.Collaborator{{SpaceID: spaceID, Subject: userID, Role: spaceRole}}, nil).Once()
 
@@ -81,7 +81,7 @@ func TestCollaboratorsCache(t *testing.T) {
 		t.Run("After Remove", func(t *testing.T) {
 			cs := &csmocks.Collaborators{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
 
 			cs.On("Get", mock.Anything, spaceID, userID).Return(spaceRole, nil).Once()
 			cs.On("ListCollaborators", mock.Anything, spaceID).Return([]*collaborators.Collaborator{{SpaceID: spaceID, Subject: userID, Role: spaceRole}}, nil).Once()
@@ -135,7 +135,7 @@ func TestCollaboratorsCache(t *testing.T) {
 		t.Run("After TTL expired", func(t *testing.T) {
 			cs := &csmocks.Collaborators{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(cs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(cs)
 
 			cs.On("Get", mock.Anything, spaceID, userID).Return(spaceRole, nil).Once()
 			cs.On("ListCollaborators", mock.Anything, spaceID).Return([]*collaborators.Collaborator{{SpaceID: spaceID, Subject: userID, Role: spaceRole}}, nil).Once()
diff --git a/pkg/collections/middleware/caching_middleware_test.go b/pkg/collections/middleware/caching_middleware_test.go
index c9e58b6886e121bf6b1f2edd37d9f4d9a69c9319..ac284ce5464af7469fee9ad4a7babf377b9c335a 100644
--- a/pkg/collections/middleware/caching_middleware_test.go
+++ b/pkg/collections/middleware/caching_middleware_test.go
@@ -36,7 +36,7 @@ func TestCollections_Cache(t *testing.T) {
 		col := &colsmocks.Collections{}
 		env := &envmocks.Environments{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
 
 		env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 		col.On("Get", mock.Anything, spaceID, envID, colID).Return(&collections.Collection{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}, nil).Once()
@@ -60,7 +60,7 @@ func TestCollections_Cache(t *testing.T) {
 		col := &colsmocks.Collections{}
 		env := &envmocks.Environments{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
 
 		col.On("Get", mock.Anything, spaceID, envAlias, colID).Return(&collections.Collection{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}, nil).Once()
 		env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
@@ -84,7 +84,7 @@ func TestCollections_Cache(t *testing.T) {
 		col := &colsmocks.Collections{}
 		env := &envmocks.Environments{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
 
 		env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 		col.On("Get", mock.Anything, spaceID, envID, colID, mock.Anything).Run(func(args mock.Arguments) {
@@ -104,7 +104,7 @@ func TestCollections_Cache(t *testing.T) {
 	//	col := &colsmocks.Collections{}
 	//	env := &envmocks.Environments{}
 	//
-	//	svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+	//	svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
 	//
 	//	col.On("List", mock.Anything, spaceID, envID).Return([]*collections.Collection{{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}}, nil).Once()
 	//	env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
@@ -130,7 +130,7 @@ func TestCollections_Cache(t *testing.T) {
 		col := &colsmocks.Collections{}
 		env := &envmocks.Environments{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
 
 		col.On("List", mock.Anything, spaceID, envAlias, mock.Anything).Return([]*collections.Collection{{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}}, nil).Once()
 		col.On("List", mock.Anything, spaceID, envID, mock.Anything).Return([]*collections.Collection{{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}}, nil).Once()
@@ -150,7 +150,7 @@ func TestCollections_Cache(t *testing.T) {
 			col := &colsmocks.Collections{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 			col.On("Get", mock.Anything, spaceID, envID, colID).Return(&collections.Collection{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}, nil).Once()
@@ -199,7 +199,7 @@ func TestCollections_Cache(t *testing.T) {
 			col := &colsmocks.Collections{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 			//env.On("Get", mock.Anything, spaceID, envAlias).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
@@ -252,7 +252,7 @@ func TestCollections_Cache(t *testing.T) {
 			col := &colsmocks.Collections{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Twice()
 			col.On("Get", mock.Anything, spaceID, envID, colID).Return(&collections.Collection{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}, nil).Once()
@@ -317,7 +317,7 @@ func TestCollections_Cache(t *testing.T) {
 			col := &colsmocks.Collections{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Twice()
 			col.On("Get", mock.Anything, spaceID, envID, colID).Return(&collections.Collection{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}, nil).Once()
@@ -379,7 +379,7 @@ func TestCollections_Cache(t *testing.T) {
 			col := &colsmocks.Collections{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
 
 			//env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 			col.On("List", mock.Anything, spaceID, envID, mock.Anything).Return([]*collections.Collection{{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}}, nil).Twice()
@@ -430,7 +430,7 @@ func TestCollections_Cache(t *testing.T) {
 			col := &colsmocks.Collections{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), env)(col)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), env)(col)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil)
 			col.On("Get", mock.Anything, spaceID, envID, colID).Return(&collections.Collection{ID: colID, SpaceID: spaceID, EnvID: envID, Name: "name"}, nil).Once()
diff --git a/pkg/content/client.go b/pkg/content/client.go
index af5ba5bf9956cfaa51e0636acff0d98c82edfb38..bbdd62bb9474afd54ce63606055c244311478adc 100644
--- a/pkg/content/client.go
+++ b/pkg/content/client.go
@@ -76,15 +76,15 @@ func NewClient(conn *grpc.ClientConn, opts ...Option) *Content {
 func WithCaching(client *Content, size int, ttl time.Duration) *Content {
 	c := *client
 
-	c.Clients = clientsSvc.CachingMiddleware(cache.NewCache(size, ttl))(client.Clients)
-	c.Environments = environmentsSvc.CachingMiddleware(cache.NewCache(size, ttl))(client.Environments)
-	c.Locales = localesSvc.CachingMiddleware(cache.NewCache(size, ttl))(client.Locales)
-	c.Roles = rolesSvc.CachingMiddleware(cache.NewCache(size, ttl))(client.Roles)
-	c.Spaces = spacesSvc.CachingMiddleware(cache.NewCache(size, ttl))(client.Spaces)
-	c.Items = itemsSvc.CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), c.Environments)(client.Items)
-	c.Collections = collectionsSvc.CachingMiddleware(cache.NewCache(size, ttl), c.Environments)(client.Collections)
-	c.Collaborators = collaboratorsSvc.CachingMiddleware(cache.NewCache(size, ttl))(client.Collaborators)
-	c.Invitations = invitationsSvc.CachingMiddleware(cache.NewCache(size, ttl))(client.Invitations)
+	c.Clients = clientsSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Clients)
+	c.Environments = environmentsSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Environments)
+	c.Locales = localesSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Locales)
+	c.Roles = rolesSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Roles)
+	c.Spaces = spacesSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Spaces)
+	c.Items = itemsSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), c.Environments)(client.Items)
+	c.Collections = collectionsSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl), c.Environments)(client.Collections)
+	c.Collaborators = collaboratorsSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Collaborators)
+	c.Invitations = invitationsSvc.CachingMiddleware(cache.NewMemoryCache(size, ttl))(client.Invitations)
 
 	return &c
 }
diff --git a/pkg/delivery/client/client.go b/pkg/delivery/client/client.go
index 1de0dd684a2344264ad217c2834fbb74f19d837f..e3fb962c22cd76d4adc2cbd5ca9d6195eb9e41d6 100644
--- a/pkg/delivery/client/client.go
+++ b/pkg/delivery/client/client.go
@@ -44,10 +44,10 @@ func NewClient(conn *grpc.ClientConn, opts ...Option) (delivery.Delivery, error)
 func WithCaching(cfg *deliveryservice.Config, size int, ttl time.Duration) *deliveryservice.Config {
 	c := *cfg
 
-	c.Environments = environments.CachingMiddleware(cache.NewCache(size, ttl))(cfg.Environments)
-	c.Locales = locales.CachingMiddleware(cache.NewCache(size, ttl))(cfg.Locales)
-	c.Items = items.CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), c.Environments)(cfg.Items)
-	c.Collections = collections.CachingMiddleware(cache.NewCache(size, ttl), c.Environments)(cfg.Collections)
+	c.Environments = environments.CachingMiddleware(cache.NewMemoryCache(size, ttl))(cfg.Environments)
+	c.Locales = locales.CachingMiddleware(cache.NewMemoryCache(size, ttl))(cfg.Locales)
+	c.Items = items.CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), c.Environments)(cfg.Items)
+	c.Collections = collections.CachingMiddleware(cache.NewMemoryCache(size, ttl), c.Environments)(cfg.Collections)
 
 	return &c
 }
diff --git a/pkg/environments/middleware/caching_middleware_test.go b/pkg/environments/middleware/caching_middleware_test.go
index 2e1b73a8366873dfb31b8d9fd24d31ac894025ee..784ce35632e2bcd74993ce499f4ec1db329041d7 100644
--- a/pkg/environments/middleware/caching_middleware_test.go
+++ b/pkg/environments/middleware/caching_middleware_test.go
@@ -31,7 +31,7 @@ func TestEnvironmentsCache(t *testing.T) {
 	t.Run("Get from cache", func(t *testing.T) {
 		envs := &mocksenvironments.Environments{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
 
 		envs.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{envAlias}}, nil).Once()
 
@@ -52,7 +52,7 @@ func TestEnvironmentsCache(t *testing.T) {
 	t.Run("Get from cache(by Alias)", func(t *testing.T) {
 		envs := &mocksenvironments.Environments{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
 
 		envs.On("Get", mock.Anything, spaceID, envAlias).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{envAlias}}, nil).Once()
 
@@ -73,7 +73,7 @@ func TestEnvironmentsCache(t *testing.T) {
 	t.Run("List from cache", func(t *testing.T) {
 		envs := &mocksenvironments.Environments{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
 
 		envs.On("List", mock.Anything, spaceID).Return([]*environments.Environment{{ID: envID, SpaceID: spaceID, Description: "Environment"}}, nil).Once()
 
@@ -91,7 +91,7 @@ func TestEnvironmentsCache(t *testing.T) {
 		t.Run("After SetAlias", func(t *testing.T) {
 			envs := &mocksenvironments.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
 
 			envs.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{"envID2"}}, nil).Once()
 			envs.On("List", mock.Anything, spaceID).Return([]*environments.Environment{{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{"envID2"}}}, nil).Once()
@@ -135,7 +135,7 @@ func TestEnvironmentsCache(t *testing.T) {
 		t.Run("After RemoveAlias", func(t *testing.T) {
 			envs := &mocksenvironments.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
 
 			envs.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{"envID2", envAlias}}, nil).Once()
 			envs.On("List", mock.Anything, spaceID).Return([]*environments.Environment{{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{"envID2", envAlias}}}, nil).Once()
@@ -184,7 +184,7 @@ func TestEnvironmentsCache(t *testing.T) {
 		t.Run("After Update", func(t *testing.T) {
 			envs := &mocksenvironments.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
 
 			envs.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{envAlias}}, nil).Once()
 			envs.On("List", mock.Anything, spaceID).Return([]*environments.Environment{{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{envAlias}}}, nil).Once()
@@ -235,7 +235,7 @@ func TestEnvironmentsCache(t *testing.T) {
 		t.Run("After Update(List)", func(t *testing.T) {
 			envs := &mocksenvironments.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
 
 			envs.On("List", mock.Anything, spaceID).Return([]*environments.Environment{{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{envAlias}}}, nil).Once()
 			envs.On("Update", mock.Anything, mock.Anything).Return(nil).Once()
@@ -262,7 +262,7 @@ func TestEnvironmentsCache(t *testing.T) {
 		t.Run("After Delete", func(t *testing.T) {
 			envs := &mocksenvironments.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
 
 			envs.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{envAlias}}, nil).Once()
 			envs.On("List", mock.Anything, spaceID).Return([]*environments.Environment{{ID: envID, SpaceID: spaceID, Description: "Environment", Aliases: []string{envAlias}}}, nil).Once()
@@ -311,7 +311,7 @@ func TestEnvironmentsCache(t *testing.T) {
 		t.Run("After Create", func(t *testing.T) {
 			envs := &mocksenvironments.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
 
 			envs.On("List", mock.Anything, spaceID).Return([]*environments.Environment{{ID: envID, SpaceID: spaceID, Description: "Environment"}}, nil).Once()
 
@@ -338,7 +338,7 @@ func TestEnvironmentsCache(t *testing.T) {
 		t.Run("After size exceeded", func(t *testing.T) {
 			envs := &mocksenvironments.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(1, ttl))(envs)
+			svc := CachingMiddleware(cache.NewMemoryCache(1, ttl))(envs)
 
 			envs.On("Get", mock.Anything, spaceID, "envID2").Return(&environments.Environment{ID: "envID2", SpaceID: spaceID, Description: "Environment2"}, nil).Once()
 			envs.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Description: "Environment"}, nil).Once()
@@ -364,7 +364,7 @@ func TestEnvironmentsCache(t *testing.T) {
 		t.Run("After TTL expired", func(t *testing.T) {
 			envs := &mocksenvironments.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(envs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(envs)
 
 			envs.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Description: "Environment"}, nil).Once()
 			v1, err := svc.Get(ctx, spaceID, envID)
diff --git a/pkg/invitations/middleware/caching_middleware_test.go b/pkg/invitations/middleware/caching_middleware_test.go
index 8c83d76ec0a35f1fa06e1065da3624ab3f7198e3..e7fac6f545463644ddd7476a43123f248b9a16b8 100644
--- a/pkg/invitations/middleware/caching_middleware_test.go
+++ b/pkg/invitations/middleware/caching_middleware_test.go
@@ -32,7 +32,7 @@ func TestLocalesCache(t *testing.T) {
 	t.Run("Get from Cache", func(t *testing.T) {
 		inv := &invmocks.Invitations{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(inv)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(inv)
 
 		inv.On("Get", mock.Anything, invID).Return(&invitations.Invitation{ID: invID, Email: email, OrgID: orgID}, nil).Once()
 
@@ -50,7 +50,7 @@ func TestLocalesCache(t *testing.T) {
 		t.Run("Get from Accept", func(t *testing.T) {
 			inv := &invmocks.Invitations{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(inv)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(inv)
 
 			inv.On("Get", mock.Anything, invID).Return(&invitations.Invitation{ID: invID, Email: email, OrgID: orgID}, nil).Once()
 
@@ -77,7 +77,7 @@ func TestLocalesCache(t *testing.T) {
 		t.Run("Get from Delete", func(t *testing.T) {
 			inv := &invmocks.Invitations{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(inv)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(inv)
 
 			inv.On("Get", mock.Anything, invID).Return(&invitations.Invitation{ID: invID, Email: email, OrgID: orgID}, nil).Once()
 
@@ -104,7 +104,7 @@ func TestLocalesCache(t *testing.T) {
 		t.Run("After TTL expired", func(t *testing.T) {
 			inv := &invmocks.Invitations{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(inv)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(inv)
 
 			inv.On("Get", mock.Anything, invID).Return(&invitations.Invitation{ID: invID, Email: email, OrgID: orgID}, nil).Once()
 
diff --git a/pkg/items/middleware/caching_middleware_test.go b/pkg/items/middleware/caching_middleware_test.go
index b7ea569db094e7905b6aae2ce8bebfb381849f95..c3e862b1ffe3dd5e7fdde976cc4aa09e316a600f 100644
--- a/pkg/items/middleware/caching_middleware_test.go
+++ b/pkg/items/middleware/caching_middleware_test.go
@@ -37,7 +37,7 @@ func TestItemsCache(t *testing.T) {
 		itms := &itmsmocks.Items{}
 		env := &envmocks.Environments{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 		env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 		itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -61,7 +61,7 @@ func TestItemsCache(t *testing.T) {
 		itms := &itmsmocks.Items{}
 		env := &envmocks.Environments{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 		env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 		itms.On("Get", mock.Anything, spaceID, envAlias, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -85,7 +85,7 @@ func TestItemsCache(t *testing.T) {
 		itms := &itmsmocks.Items{}
 		env := &envmocks.Environments{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 		env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 		itms.On("GetPublished", mock.Anything, spaceID, envID, colID, itemID, mock.Anything).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -109,7 +109,7 @@ func TestItemsCache(t *testing.T) {
 		itms := &itmsmocks.Items{}
 		env := &envmocks.Environments{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 		env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 		itms.On("GetPublished", mock.Anything, spaceID, envAlias, colID, itemID, mock.Anything).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -138,7 +138,7 @@ func TestItemsCache(t *testing.T) {
 		itms := &itmsmocks.Items{}
 		env := &envmocks.Environments{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 		env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Twice()
 		itms.On("GetPublished", mock.Anything, spaceID, envAlias, colID, itemID, mock.Anything).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -176,7 +176,7 @@ func TestItemsCache(t *testing.T) {
 			env := &envmocks.Environments{}
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
-			svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 			itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, Data: map[string]interface{}{"f1": "d1"}}, nil).Once()
 
@@ -208,7 +208,7 @@ func TestItemsCache(t *testing.T) {
 			itms := &itmsmocks.Items{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 			itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -241,7 +241,7 @@ func TestItemsCache(t *testing.T) {
 			itms := &itmsmocks.Items{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 			itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -273,7 +273,7 @@ func TestItemsCache(t *testing.T) {
 			itms := &itmsmocks.Items{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 			itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StatePublished}, nil).Once()
@@ -313,7 +313,7 @@ func TestItemsCache(t *testing.T) {
 			itms := &itmsmocks.Items{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 			itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StatePublished}, nil).Once()
@@ -346,7 +346,7 @@ func TestItemsCache(t *testing.T) {
 			itms := &itmsmocks.Items{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 			itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -379,7 +379,7 @@ func TestItemsCache(t *testing.T) {
 			itms := &itmsmocks.Items{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 			itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, Data: map[string]interface{}{"f1": "d1"}}, nil).Once()
@@ -412,7 +412,7 @@ func TestItemsCache(t *testing.T) {
 			itms := &itmsmocks.Items{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 			itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StatePublished}, nil).Once()
@@ -445,7 +445,7 @@ func TestItemsCache(t *testing.T) {
 			itms := &itmsmocks.Items{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 			itms.On("GetPublished", mock.Anything, spaceID, envID, colID, itemID, mock.Anything).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StatePublished, Data: map[string]interface{}{"f1": "d1"}}, nil).Once()
@@ -486,7 +486,7 @@ func TestItemsCache(t *testing.T) {
 			itms := &itmsmocks.Items{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 			itms.On("GetPublished", mock.Anything, spaceID, envID, colID, itemID, mock.Anything).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
@@ -527,7 +527,7 @@ func TestItemsCache(t *testing.T) {
 			itms := &itmsmocks.Items{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 			itms.On("GetPublished", mock.Anything, spaceID, envID, colID, itemID, mock.Anything).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StatePublished}, nil).Once()
@@ -568,7 +568,7 @@ func TestItemsCache(t *testing.T) {
 			itms := &itmsmocks.Items{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 			itms.On("GetPublished", mock.Anything, spaceID, envID, colID, itemID, mock.Anything).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StatePublished}, nil).Once()
@@ -609,7 +609,7 @@ func TestItemsCache(t *testing.T) {
 			itms := &itmsmocks.Items{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
@@ -657,7 +657,7 @@ func TestItemsCache(t *testing.T) {
 			itms := &itmsmocks.Items{}
 			env := &envmocks.Environments{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl), cache.NewCache(size, ttl), env)(itms)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl), cache.NewMemoryCache(size, ttl), env)(itms)
 
 			env.On("Get", mock.Anything, spaceID, envID).Return(&environments.Environment{ID: envID, SpaceID: spaceID, Aliases: []string{envAlias}}, nil).Once()
 			itms.On("Get", mock.Anything, spaceID, envID, colID, itemID).Return(&items.Item{ID: itemID, SpaceID: spaceID, EnvID: envID, CollectionID: colID, State: items.StateDraft}, nil).Once()
diff --git a/pkg/locales/middleware/caching_middleware_test.go b/pkg/locales/middleware/caching_middleware_test.go
index d39e78d78e487c7c2c90f906559dee400aaa414b..281aa49611a83e4a0a28f1064dbf5fe149dd29f3 100644
--- a/pkg/locales/middleware/caching_middleware_test.go
+++ b/pkg/locales/middleware/caching_middleware_test.go
@@ -28,7 +28,7 @@ func TestLocalesCache(t *testing.T) {
 	t.Run("List from Cache", func(t *testing.T) {
 		loc := &locmocks.Locales{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(loc)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(loc)
 
 		loc.On("List", mock.Anything, spaceID).Return([]*locales.Locale{{ID: loc1, Name: "name1", SpaceID: spaceID}}, nil).Once()
 
@@ -46,7 +46,7 @@ func TestLocalesCache(t *testing.T) {
 		t.Run("After Delete", func(t *testing.T) {
 			loc := &locmocks.Locales{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(loc)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(loc)
 
 			loc.On("List", mock.Anything, spaceID).Return([]*locales.Locale{{ID: loc1, Name: "name1", SpaceID: spaceID}}, nil).Once()
 
@@ -74,7 +74,7 @@ func TestLocalesCache(t *testing.T) {
 		t.Run("After Create", func(t *testing.T) {
 			loc := &locmocks.Locales{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(loc)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(loc)
 
 			loc.On("List", mock.Anything, spaceID).Return([]*locales.Locale{{ID: loc1, Name: "name1", SpaceID: spaceID}}, nil).Once()
 
@@ -106,7 +106,7 @@ func TestLocalesCache(t *testing.T) {
 		t.Run("After TTL expired", func(t *testing.T) {
 			loc := &locmocks.Locales{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(loc)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(loc)
 
 			loc.On("List", mock.Anything, spaceID).Return([]*locales.Locale{{ID: loc1, Name: "name1", SpaceID: spaceID}}, nil).Once()
 
diff --git a/pkg/members/middleware/caching_middleware_test.go b/pkg/members/middleware/caching_middleware_test.go
index 4564dbe41a1fb943e86ad247a171497cffe01c18..eda7eb3a2a85123d36d20f09e9bd0c5188b609a9 100644
--- a/pkg/members/middleware/caching_middleware_test.go
+++ b/pkg/members/middleware/caching_middleware_test.go
@@ -26,7 +26,7 @@ func TestMembersCache(t *testing.T) {
 
 	t.Run("Get from cache", func(t *testing.T) {
 		mbrs := &mocksmembers.Members{}
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(mbrs)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(mbrs)
 
 		mbrs.On("Get", mock.Anything, orgId, userId).Return(members.RoleOwner, nil).Once()
 
@@ -43,7 +43,7 @@ func TestMembersCache(t *testing.T) {
 	t.Run("Invalidate cache", func(t *testing.T) {
 		t.Run("After Set", func(t *testing.T) {
 			mbrs := &mocksmembers.Members{}
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(mbrs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(mbrs)
 
 			mbrs.On("Get", mock.Anything, orgId, userId).Return(members.RoleOwner, nil).Once()
 
@@ -69,7 +69,7 @@ func TestMembersCache(t *testing.T) {
 
 		t.Run("After Remove", func(t *testing.T) {
 			mbrs := &mocksmembers.Members{}
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(mbrs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(mbrs)
 
 			mbrs.On("Get", mock.Anything, orgId, userId).Return(members.RoleOwner, nil).Once()
 
@@ -96,7 +96,7 @@ func TestMembersCache(t *testing.T) {
 
 		t.Run("After RemoveAll", func(t *testing.T) {
 			mbrs := &mocksmembers.Members{}
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(mbrs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(mbrs)
 
 			mbrs.On("Get", mock.Anything, orgId, userId).Return(members.RoleOwner, nil).Once()
 			mbrs.On("ListMembers", mock.Anything, orgId).Return([]*members.Member{{OrgId: orgId, UserId: userId, Role: members.RoleOwner}}, nil)
@@ -124,7 +124,7 @@ func TestMembersCache(t *testing.T) {
 
 		t.Run("After TTL expired", func(t *testing.T) {
 			mbrs := &mocksmembers.Members{}
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(mbrs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(mbrs)
 
 			mbrs.On("Get", mock.Anything, orgId, userId).Return(members.RoleOwner, nil).Once()
 
diff --git a/pkg/organizations/middleware/caching_middleware_test.go b/pkg/organizations/middleware/caching_middleware_test.go
index f468baf0d6d3653e54f90856bf8731c2626ddc65..19cd14d5b2e808f3d4c22f77d8b115a27a9025cf 100644
--- a/pkg/organizations/middleware/caching_middleware_test.go
+++ b/pkg/organizations/middleware/caching_middleware_test.go
@@ -28,7 +28,7 @@ func TestOrganizationsCache(t *testing.T) {
 
 	t.Run("Get from cache", func(t *testing.T) {
 		orgs := &mocksorgs.Organizations{}
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(orgs)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(orgs)
 
 		orgs.On("Get", mock.Anything, orgId).Return(&organizations.Organization{ID: orgId, Name: "Organization"}, nil).Once()
 
@@ -45,7 +45,7 @@ func TestOrganizationsCache(t *testing.T) {
 	t.Run("Invalidate cache", func(t *testing.T) {
 		t.Run("After Update", func(t *testing.T) {
 			orgs := &mocksorgs.Organizations{}
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(orgs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(orgs)
 
 			orgs.On("Get", mock.Anything, orgId).Return(&organizations.Organization{ID: orgId, Name: "Organization"}, nil).Once()
 
@@ -70,7 +70,7 @@ func TestOrganizationsCache(t *testing.T) {
 
 		t.Run("After Delete", func(t *testing.T) {
 			orgs := &mocksorgs.Organizations{}
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(orgs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(orgs)
 
 			orgs.On("Get", mock.Anything, orgId).Return(&organizations.Organization{ID: orgId, Name: "Organization"}, nil).Once()
 
@@ -94,7 +94,7 @@ func TestOrganizationsCache(t *testing.T) {
 
 		t.Run("After TTL expired", func(t *testing.T) {
 			orgs := &mocksorgs.Organizations{}
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(orgs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(orgs)
 
 			orgs.On("Get", mock.Anything, orgId).Return(&organizations.Organization{ID: orgId, Name: "Organization"}, nil).Once()
 
diff --git a/pkg/roles/middleware/caching_middleware_test.go b/pkg/roles/middleware/caching_middleware_test.go
index ff0165f8e9234d70d084a934d923b4e0b721ee0e..9d5d64f4231cf8bd86d533224fd50e762eebdcab 100644
--- a/pkg/roles/middleware/caching_middleware_test.go
+++ b/pkg/roles/middleware/caching_middleware_test.go
@@ -30,7 +30,7 @@ func TestRolesCache(t *testing.T) {
 	t.Run("Get from cache", func(t *testing.T) {
 		rl := &rsmocks.Roles{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(rl)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(rl)
 
 		rl.On("Get", mock.Anything, spaceID, roleID).Return(&roles.Role{ID: roleID, SpaceID: spaceID, Description: "Role"}, nil).Once()
 
@@ -47,7 +47,7 @@ func TestRolesCache(t *testing.T) {
 	t.Run("List from cache", func(t *testing.T) {
 		rl := &rsmocks.Roles{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(rl)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(rl)
 
 		rl.On("List", mock.Anything, spaceID).Return([]*roles.Role{{ID: roleID, SpaceID: spaceID, Description: "Role"}}, nil).Once()
 
@@ -65,7 +65,7 @@ func TestRolesCache(t *testing.T) {
 		t.Run("After Update", func(t *testing.T) {
 			rl := &rsmocks.Roles{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(rl)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(rl)
 
 			rl.On("Get", mock.Anything, spaceID, roleID).Return(&roles.Role{ID: roleID, SpaceID: spaceID, Description: "Role"}, nil).Once()
 			rl.On("List", mock.Anything, spaceID).Return([]*roles.Role{{ID: roleID, SpaceID: spaceID, Description: "Role"}}, nil).Once()
@@ -106,7 +106,7 @@ func TestRolesCache(t *testing.T) {
 		t.Run("After Delete", func(t *testing.T) {
 			rl := &rsmocks.Roles{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(rl)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(rl)
 
 			rl.On("Get", mock.Anything, spaceID, roleID).Return(&roles.Role{ID: roleID, SpaceID: spaceID, Description: "Role"}, nil).Once()
 			rl.On("List", mock.Anything, spaceID).Return([]*roles.Role{{ID: roleID, SpaceID: spaceID, Description: "Role"}}, nil).Once()
@@ -149,7 +149,7 @@ func TestRolesCache(t *testing.T) {
 		t.Run("After Create", func(t *testing.T) {
 			rl := &rsmocks.Roles{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(rl)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(rl)
 
 			rl.On("List", mock.Anything, spaceID).Return([]*roles.Role{{ID: roleID, SpaceID: spaceID, Description: "Role"}}, nil).Once()
 
@@ -177,7 +177,7 @@ func TestRolesCache(t *testing.T) {
 		t.Run("After TTL expired", func(t *testing.T) {
 			rl := &rsmocks.Roles{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(rl)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(rl)
 
 			rl.On("Get", mock.Anything, spaceID, roleID).Return(&roles.Role{ID: roleID, SpaceID: spaceID, Description: "Role"}, nil).Once()
 
diff --git a/pkg/spaces/middleware/caching_middleware_test.go b/pkg/spaces/middleware/caching_middleware_test.go
index a79a136f41690d0a6c6a16709bb9a591e5688735..e87ceb38c79c6b15d76ab6f6ff8f628a680a5aa6 100644
--- a/pkg/spaces/middleware/caching_middleware_test.go
+++ b/pkg/spaces/middleware/caching_middleware_test.go
@@ -31,7 +31,7 @@ func TestRolesCache(t *testing.T) {
 	t.Run("Get from cache", func(t *testing.T) {
 		sp := &spmocks.Spaces{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(sp)
 
 		sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "Space"}, nil).Once()
 
@@ -48,7 +48,7 @@ func TestRolesCache(t *testing.T) {
 	t.Run("List from cache", func(t *testing.T) {
 		sp := &spmocks.Spaces{}
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(sp)
 
 		sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "Space"}}, nil).Once()
 
@@ -66,7 +66,7 @@ func TestRolesCache(t *testing.T) {
 		t.Run("After Update", func(t *testing.T) {
 			sp := &spmocks.Spaces{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(sp)
 
 			sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "Space"}, nil).Once()
 			sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "Space"}}, nil).Once()
@@ -107,7 +107,7 @@ func TestRolesCache(t *testing.T) {
 		t.Run("After UpdateConfig", func(t *testing.T) {
 			sp := &spmocks.Spaces{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(sp)
 
 			sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "Space"}, nil).Once()
 			sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "Space"}}, nil).Once()
@@ -148,7 +148,7 @@ func TestRolesCache(t *testing.T) {
 		t.Run("After Delete", func(t *testing.T) {
 			sp := &spmocks.Spaces{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(sp)
 
 			sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "Space"}, nil).Once()
 			sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "Space"}}, nil).Once()
@@ -189,7 +189,7 @@ func TestRolesCache(t *testing.T) {
 		t.Run("After Create", func(t *testing.T) {
 			sp := &spmocks.Spaces{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(sp)
 
 			sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "Space"}}, nil).Once()
 
@@ -217,7 +217,7 @@ func TestRolesCache(t *testing.T) {
 		t.Run("After TTL expired", func(t *testing.T) {
 			sp := &spmocks.Spaces{}
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(sp)
 
 			sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "Space"}, nil).Once()
 
diff --git a/pkg/users/middleware/caching_middleware_test.go b/pkg/users/middleware/caching_middleware_test.go
index fde23379bebd1957e7084fb7dc51ac45be467b59..edc9176baac6656a1d70995b0881055b83642293 100644
--- a/pkg/users/middleware/caching_middleware_test.go
+++ b/pkg/users/middleware/caching_middleware_test.go
@@ -29,7 +29,7 @@ func TestUsersCache(t *testing.T) {
 		usrs := &mocks.Users{}
 		ctx := context.Background()
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(usrs)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(usrs)
 
 		usrs.On("Get", mock.Anything, userID).Return(&users.User{ID: userID, Name: "User", Identities: []string{identity}}, nil).Once()
 
@@ -51,7 +51,7 @@ func TestUsersCache(t *testing.T) {
 		usrs := &mocks.Users{}
 		ctx := context.Background()
 
-		svc := CachingMiddleware(cache.NewCache(size, ttl))(usrs)
+		svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(usrs)
 
 		usrs.On("GetByIdentity", mock.Anything, identity).Return(&users.User{ID: userID, Name: "User", Identities: []string{identity}}, nil).Once()
 
@@ -74,7 +74,7 @@ func TestUsersCache(t *testing.T) {
 			usrs := &mocks.Users{}
 			ctx := context.Background()
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(usrs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(usrs)
 
 			usrs.On("Get", mock.Anything, userID).Return(&users.User{ID: userID, Name: "User", Identities: []string{identity}}, nil).Once()
 			usrs.On("Update", mock.Anything, mock.Anything).Return(nil).Once()
@@ -107,7 +107,7 @@ func TestUsersCache(t *testing.T) {
 			usrs := &mocks.Users{}
 			ctx := context.Background()
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(usrs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(usrs)
 
 			usrs.On("Get", mock.Anything, userID).Return(&users.User{ID: userID, Name: "User", Identities: []string{identity}}, nil).Once()
 			usrs.On("Delete", mock.Anything, mock.Anything).Return(nil).Once()
@@ -140,7 +140,7 @@ func TestUsersCache(t *testing.T) {
 			usrs := &mocks.Users{}
 			ctx := context.Background()
 
-			svc := CachingMiddleware(cache.NewCache(size, ttl))(usrs)
+			svc := CachingMiddleware(cache.NewMemoryCache(size, ttl))(usrs)
 
 			usrs.On("Get", mock.Anything, userID).Return(&users.User{ID: userID, Name: "User", Identities: []string{identity}}, nil).Once()