wip: scope headers

Author: nshntarora

api/handlers/cache_handlers.go

@@ -17,9 +17,9 @@ const CACHE_STATUS_BYPASS = "BYPASS"
 const CACHE_STATUS_HIT = "HIT"
 const CACHE_STATUS_MISS = "MISS"
 
-func GetCacheHandler(cache *graphcache.GraphCache, cfg *config.Config) http.HandlerFunc {
+func GetCacheHandler(cfg *config.Config) http.HandlerFunc {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-
+		cache := graphcache.NewGraphCacheWithOptions(GetCacheOptions(cfg, GetScopeValues(cfg, r)))
 		w.Header().Add("Content-Type", "application/json")
 
 		// Create a new HTTP request with the same method, URL, and body as the original request

api/handlers/cache_purge_handlers.go

@@ -7,25 +7,29 @@ import (
 	"net/http"
 )
 
-func GetFlushCacheHandler(Cache *graphcache.GraphCache, cfg *config.Config) http.HandlerFunc {
+type FlushCacheByTypeRequest struct {
+	Type string `json:"type"`
+	ID   string `json:"id"`
+}
+
+func GetFlushCacheHandler(cfg *config.Config) http.HandlerFunc {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		Cache.Flush()
+		cache := graphcache.NewGraphCacheWithOptions(GetCacheOptions(cfg, GetScopeValues(cfg, r)))
+		cache.Flush()
 		w.WriteHeader(http.StatusOK)
 		w.Write([]byte("success"))
 	})
 }
 
-func GetFlushCacheByTypeHandler(Cache *graphcache.GraphCache, cfg *config.Config) http.HandlerFunc {
+func GetFlushCacheByTypeHandler(cfg *config.Config) http.HandlerFunc {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		flushByTypeRequest := struct {
-			Type string `json:"type"`
-			ID   string `json:"id"`
-		}{}
+		cache := graphcache.NewGraphCacheWithOptions(GetCacheOptions(cfg, GetScopeValues(cfg, r)))
+		flushByTypeRequest := FlushCacheByTypeRequest{}
 		err := json.NewDecoder(r.Body).Decode(&flushByTypeRequest)
 		if err != nil {
 			http.Error(w, "error decoding request", http.StatusBadRequest)
 		}
-		Cache.FlushByType(flushByTypeRequest.Type, flushByTypeRequest.ID)
+		cache.FlushByType(flushByTypeRequest.Type, flushByTypeRequest.ID)
 		w.WriteHeader(http.StatusOK)
 		w.Write([]byte("success"))
 	})

api/handlers/debug_handlers.go

@@ -7,9 +7,10 @@ import (
 	"net/http"
 )
 
-func GetDebugHandler(Cache *graphcache.GraphCache, cfg *config.Config) http.HandlerFunc {
+func GetDebugHandler(cfg *config.Config) http.HandlerFunc {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		resp := Cache.Look()
+		cache := graphcache.NewGraphCacheWithOptions(GetCacheOptions(cfg, GetScopeValues(cfg, r)))
+		resp := cache.Look()
 		br, err := json.Marshal(resp)
 		if err != nil {
 			http.Error(w, "error marshalling response", http.StatusInternalServerError)

api/handlers/handlers.go

@@ -1,16 +1,44 @@
 package handlers
 
 import (
+	"encoding/base64"
+	"fmt"
 	"graphql_cache/config"
 	"graphql_cache/graphcache"
 	"net/http"
+	"strings"
 )
 
-func GetHandlers(cache *graphcache.GraphCache, cfg *config.Config) *http.ServeMux {
+func GetHandlers(cfg *config.Config) *http.ServeMux {
 	api := http.NewServeMux()
-	api.Handle(cfg.Handlers.DebugPath, GetDebugHandler(cache, cfg))
-	api.Handle(cfg.Handlers.FlushAllPath, GetFlushCacheHandler(cache, cfg))
-	api.Handle(cfg.Handlers.FlushByTypePath, GetFlushCacheByTypeHandler(cache, cfg))
-	api.Handle(cfg.Handlers.GraphQLPath, GetCacheHandler(cache, cfg))
+	api.Handle(cfg.Handlers.DebugPath, GetDebugHandler(cfg))
+	api.Handle(cfg.Handlers.FlushAllPath, GetFlushCacheHandler(cfg))
+	api.Handle(cfg.Handlers.FlushByTypePath, GetFlushCacheByTypeHandler(cfg))
+	api.Handle(cfg.Handlers.GraphQLPath, GetCacheHandler(cfg))
 	return api
 }
+
+func GetCacheOptions(cfg *config.Config, values []interface{}) *graphcache.GraphCacheOptions {
+	valueStr := make([]string, 0)
+	for _, val := range values {
+		valueStr = append(valueStr, fmt.Sprintf("%v", val))
+	}
+	valueHash := base64.StdEncoding.EncodeToString([]byte(strings.Join(valueStr, "::")))
+
+	return &graphcache.GraphCacheOptions{
+		Backend:   graphcache.CacheBackend(cfg.CacheBackend),
+		RedisHost: cfg.Redis.Host,
+		RedisPort: cfg.Redis.Port,
+		Prefix:    valueHash,
+	}
+}
+
+func GetScopeValues(cfg *config.Config, r *http.Request) []interface{} {
+	values := make([]interface{}, 0)
+	for _, header := range cfg.ScopeHeaders {
+		if header != "" {
+			values = append(values, r.Header.Get(header))
+		}
+	}
+	return values
+}

api/server.go

@@ -14,18 +14,16 @@ type Server struct {
 	cfg        *config.Config
 }
 
-func NewGraphCache(cfg *config.Config) *graphcache.GraphCache {
-	return graphcache.NewGraphCache(cfg)
+func NewGraphCache(opts *graphcache.GraphCacheOptions) *graphcache.GraphCache {
+	return graphcache.NewGraphCacheWithOptions(opts)
 }
 
 func NewServer(cfg *config.Config) *Server {
-	cache := NewGraphCache(cfg)
 	return &Server{
-		cache: cache,
-		cfg:   cfg,
+		cfg: cfg,
 		httpServer: &http.Server{
 			Addr:    ":" + strconv.Itoa(cfg.Port),
-			Handler: handlers.GetHandlers(cache, cfg),
+			Handler: handlers.GetHandlers(cfg),
 		},
 	}
 }

cache/inmemory_cache.go

@@ -9,35 +9,41 @@ import (
 )
 
 type InMemoryCache struct {
-	data map[string]interface{}
+	data   map[string]interface{}
+	prefix string
 }
 
-func NewInMemoryCache() *InMemoryCache {
+func NewInMemoryCache(prefix string) *InMemoryCache {
 	return &InMemoryCache{
-		data: make(map[string]interface{}),
+		data:   make(map[string]interface{}),
+		prefix: prefix,
 	}
 }
 
+func (c *InMemoryCache) Key(key string) string {
+	return c.prefix + key
+}
+
 func (c *InMemoryCache) Set(key string, value interface{}) error {
-	c.data[key] = deepCopy(value)
+	c.data[c.Key(key)] = deepCopy(value)
 	return nil
 }
 
 func (c *InMemoryCache) Get(key string) (interface{}, error) {
-	value, exists := c.data[key]
+	value, exists := c.data[c.Key(key)]
 	if !exists {
 		return nil, errors.New("key not found")
 	}
 	return deepCopy(value), nil
 }
 
 func (c *InMemoryCache) Del(key string) error {
-	c.Set(key, nil)
+	c.Set(c.Key(key), nil)
 	return nil
 }
 
 func (c *InMemoryCache) Exists(key string) (bool, error) {
-	_, exists := c.data[key]
+	_, exists := c.data[c.Key(key)]
 	return exists, nil
 }
 
@@ -67,7 +73,7 @@ func (c *InMemoryCache) Flush() error {
 }
 
 func (c *InMemoryCache) DeleteByPrefix(prefix string) error {
-	var re = regexp.MustCompile(`(?m)` + strings.ReplaceAll(prefix, "*", ".*"))
+	var re = regexp.MustCompile(`(?m)` + strings.ReplaceAll(c.Key(prefix), "*", ".*"))
 
 	for k := range c.data {
 		// regex match the prefix to the key

cache/redis_cache.go

@@ -12,17 +12,23 @@ var ctx = context.Background()
 
 // RedisCache implements the Cache interface and uses Redis as the cache store
 type RedisCache struct {
-	cache *redis.Client
+	cache  *redis.Client
+	prefix string
 }
 
-func NewRedisCache(host, port string) Cache {
+func (c *RedisCache) Key(key string) string {
+	return c.prefix + key
+}
+
+func NewRedisCache(host, port, prefix string) Cache {
 	c := redis.NewClient(&redis.Options{
 		Addr:     host + ":" + port,
 		Password: "", // no password set
 		DB:       0,  // use default DB
 	})
 	return &RedisCache{
-		cache: c,
+		cache:  c,
+		prefix: prefix,
 	}
 }
 
@@ -31,21 +37,21 @@ func (c *RedisCache) Set(key string, value interface{}) error {
 	switch valueType.Kind() {
 	case reflect.Map:
 		br, _ := json.Marshal(value)
-		c.cache.Set(ctx, key, string(br), 0)
-		c.cache.Set(ctx, key+"_type", "reflect.Map", 0)
+		c.cache.Set(ctx, c.Key(key), string(br), 0)
+		c.cache.Set(ctx, c.Key(key+"_type"), "reflect.Map", 0)
 	case reflect.Slice:
 		br, _ := json.Marshal(value)
-		c.cache.Set(ctx, key, string(br), 0)
-		c.cache.Set(ctx, key+"_type", "reflect.Slice", 0)
+		c.cache.Set(ctx, c.Key(key), string(br), 0)
+		c.cache.Set(ctx, c.Key(key+"_type"), "reflect.Slice", 0)
 	default:
-		c.cache.Set(ctx, key, value, 0)
+		c.cache.Set(ctx, c.Key(key), value, 0)
 	}
 	return nil
 }
 
 func (c *RedisCache) Get(key string) (interface{}, error) {
-	typeValue, _ := c.cache.Get(ctx, key+"_type").Result()
-	val, err := c.cache.Get(ctx, key).Result()
+	typeValue, _ := c.cache.Get(ctx, c.Key(key+"_type")).Result()
+	val, err := c.cache.Get(ctx, c.Key(key)).Result()
 	if err != nil {
 		return nil, err
 	}
@@ -65,12 +71,12 @@ func (c *RedisCache) Get(key string) (interface{}, error) {
 }
 
 func (c *RedisCache) Del(key string) error {
-	c.cache.Del(ctx, key)
+	c.cache.Del(ctx, c.Key(key))
 	return nil
 }
 
 func (c *RedisCache) Exists(key string) (bool, error) {
-	val, err := c.cache.Exists(ctx, key).Result()
+	val, err := c.cache.Exists(ctx, c.Key(key)).Result()
 	if err != nil {
 		return false, err
 	}
@@ -95,7 +101,7 @@ func (c *RedisCache) Flush() error {
 }
 
 func (c *RedisCache) DeleteByPrefix(prefix string) error {
-	allKeys := c.cache.Keys(ctx, prefix+"*")
+	allKeys := c.cache.Keys(ctx, c.Key(prefix+"*"))
 	if allKeys == nil {
 		return nil
 	}

config.toml

@@ -31,4 +31,10 @@ port=6379
 # flush_by_type_path="/flush.type"
 # debug_path="/debug"
 # health_path="/health"
-# graphql_path="/graphql"
+# graphql_path="/graphql"
+
+
+# If you have an authenticated API and want to separate the cache based on what the headers are, you can configure the headers here.
+# The system will scope the cache based on the unique values of the headers you provide
+# For example, if you want to scope the cache based on the Authorization header, you can set the following:
+scope_headers=["Authorization", "X-API-Key"]

config/config.go

@@ -23,7 +23,8 @@ type Config struct {
 		Host string `toml:"host"`
 		Port int    `toml:"port"`
 	} `toml:"redis"`
-	CacheHeaderName string `toml:"cache_header_name"`
+	CacheHeaderName string   `toml:"cache_header_name"`
+	ScopeHeaders    []string `toml:"scope_headers"`
 }
 
 const CONFIG_FILE = "./config.toml"

go.mod

@@ -1,8 +1,6 @@
 module graphql_cache
 
-go 1.22
-
-toolchain go1.22.5
+go 1.20
 
 require (
 	github.com/99designs/gqlgen v0.17.49