don't remember what I fixed, but it's a little better now

Author: nshntarora

.github/workflows/tests.yml

@@ -24,21 +24,10 @@ jobs:
           cache-dependency-path: |
             go.sum
 
-      - name: Start Todo Server
-        run: |
-          go run test_api/todo/server.go &
-          go run main.go &
-          go install github.com/bitnami/wait-for-port
-          wait-for-port 8080
-          wait-for-port 9090
-          go test -v ./...
-
-      - name: Wait for Todo Server
+      - name: Start Servers and Run Tests
         run: |
+          go run test_api/todo/server.go & go run main.go & sleep 10
           go install github.com/bitnami/wait-for-port
           wait-for-port 8080 --timeout=60
           wait-for-port 9090 --timeout=60
-
-      - name: Run Tests
-        run: |
           go test -v ./...

api/handlers/cache_handlers.go

@@ -3,10 +3,10 @@ package handlers
 import (
 	"bytes"
 	"encoding/json"
+	"fmt"
 	"graphql_cache/config"
 	"graphql_cache/graphcache"
 	"io"
-	"log"
 	"net/http"
 	"net/url"
 	"time"
@@ -19,13 +19,13 @@ func GetCacheHandler(cache *graphcache.GraphCache, cfg *config.Config) http.Hand
 		// Create a new HTTP request with the same method, URL, and body as the original request
 		targetURL, err := url.Parse(cfg.Origin)
 		if err != nil {
-			log.Println(err)
+			fmt.Println(err)
 			http.Error(w, "Error parsing target URL", http.StatusInternalServerError)
 		}
 
 		proxyReq, err := http.NewRequest(r.Method, targetURL.String(), r.Body)
 		if err != nil {
-			log.Println(err)
+			fmt.Println(err)
 			http.Error(w, "Error creating proxy request", http.StatusInternalServerError)
 		}
 
@@ -38,7 +38,7 @@ func GetCacheHandler(cache *graphcache.GraphCache, cfg *config.Config) http.Hand
 
 		requestBody, err := io.ReadAll(proxyReq.Body)
 		if err != nil {
-			log.Println(err)
+			fmt.Println(err)
 			http.Error(w, "error reading request body", http.StatusInternalServerError)
 		}
 
@@ -49,17 +49,17 @@ func GetCacheHandler(cache *graphcache.GraphCache, cfg *config.Config) http.Hand
 
 		astQuery, err := graphcache.GetASTFromQuery(request.Query)
 		if err != nil {
-			log.Println(err)
+			fmt.Println(err)
 			http.Error(w, "error parsing query", http.StatusInternalServerError)
 		}
 
 		transformedBody, err := graphcache.AddTypenameToQuery(request.Query)
 		if err != nil {
-			log.Println(err)
+			fmt.Println(err)
 			http.Error(w, "error transforming body", http.StatusInternalServerError)
 		}
 
-		log.Println("time taken to transform body ", time.Since(start))
+		fmt.Println("time taken to transform body ", time.Since(start))
 
 		transformedRequest := request
 		transformedRequest.Query = transformedBody
@@ -89,30 +89,28 @@ func GetCacheHandler(cache *graphcache.GraphCache, cfg *config.Config) http.Hand
 			// Set the status code of the original response to the status code of the proxy response
 			w.WriteHeader(resp.StatusCode)
 
-			// Copy the body of the proxy response to the original response
-			io.Copy(w, resp.Body)
-
 			responseBody := new(bytes.Buffer)
 			io.Copy(responseBody, resp.Body)
 
 			responseMap := make(map[string]interface{})
 			err = json.Unmarshal(responseBody.Bytes(), &responseMap)
 			if err != nil {
-				log.Println("Error unmarshalling response:", err, string(responseBody.Bytes()))
+				fmt.Println("Error unmarshalling response:", string(responseBody.Bytes()))
 			}
 
 			cache.InvalidateCache("data", responseMap, nil)
+			w.Write(responseBody.Bytes())
 			return
 		}
 
 		cachedResponse, err := cache.ParseASTBuildResponse(astQuery, request)
 		if err == nil && cachedResponse != nil {
-			log.Println("serving response from cache...")
+			fmt.Println("serving response from cache...")
 			br, err := json.Marshal(cachedResponse)
 			if err != nil {
 				http.Error(w, "error marshalling response", http.StatusInternalServerError)
 			}
-			log.Println("time taken to serve response from cache ", time.Since(start))
+			fmt.Println("time taken to serve response from cache ", time.Since(start))
 			graphqlresponse := graphcache.GraphQLResponse{Data: json.RawMessage(br)}
 			res, err := cache.RemoveTypenameFromResponse(&graphqlresponse)
 			if err != nil {
@@ -130,15 +128,17 @@ func GetCacheHandler(cache *graphcache.GraphCache, cfg *config.Config) http.Hand
 		// Send the proxy request using the custom transport
 		resp, err := client.Do(proxyReq)
 		if err != nil {
-			log.Println(err)
+			fmt.Println(err)
 			http.Error(w, "error sending proxy request", http.StatusInternalServerError)
 		}
 		defer resp.Body.Close()
 
-		// Copy the headers from the proxy response to the original response
+		// copy the headers from the proxy response to the original response
 		for name, values := range resp.Header {
-			for _, value := range values {
-				w.Header().Add(name, value)
+			if name != "Content-Length" { // copy all headers except Content-Length
+				for _, value := range values {
+					w.Header().Add(name, value)
+				}
 			}
 		}
 
@@ -148,18 +148,18 @@ func GetCacheHandler(cache *graphcache.GraphCache, cfg *config.Config) http.Hand
 		responseMap := make(map[string]interface{})
 		err = json.Unmarshal(responseBody.Bytes(), &responseMap)
 		if err != nil {
-			log.Println("Error unmarshalling response:", err, string(responseBody.Bytes()))
+			fmt.Println("Error unmarshalling response:", string(responseBody.Bytes()))
 		}
 
-		log.Println("time taken to get response from API ", time.Since(start))
+		fmt.Println("time taken to get response from API ", time.Since(start))
 
 		astWithTypes, err := graphcache.GetASTFromQuery(transformedRequest.Query)
 		if err != nil {
-			log.Println(err)
+			fmt.Println(err)
 			http.Error(w, "error parsing query", http.StatusInternalServerError)
 		}
 
-		log.Println("time taken to generate AST with types ", time.Since(start))
+		fmt.Println("time taken to generate AST with types ", time.Since(start))
 
 		reqVariables := transformedRequest.Variables
 		variables := make(map[string]interface{})
@@ -177,7 +177,7 @@ func GetCacheHandler(cache *graphcache.GraphCache, cfg *config.Config) http.Hand
 			}
 		}
 
-		log.Println("time taken to build response key ", time.Since(start))
+		fmt.Println("time taken to build response key ", time.Since(start))
 
 		// go through the response. Every object that has a __typename field, and an id field cache it in the format of typename:id
 		// for example, if the response has an object with __typename: "Organisation" and id: "1234", cache it as Organisation:1234
@@ -186,23 +186,15 @@ func GetCacheHandler(cache *graphcache.GraphCache, cfg *config.Config) http.Hand
 
 		cache.CacheResponse("data", responseMap, nil)
 
-		log.Println("time taken to cache response ", time.Since(start))
-
-		// Copy the body of the proxy response to the original response
-		// io.Copy(w, resp.Body)
-
-		resBody, err := io.ReadAll(resp.Body)
-		if err != nil {
-			http.Error(w, "error reading response body", http.StatusInternalServerError)
-		}
+		fmt.Println("time taken to cache response ", time.Since(start), responseMap)
 
 		newResponse := &graphcache.GraphQLResponse{}
-		newResponse.FromBytes(resBody)
+		newResponse.FromBytes(responseBody.Bytes())
 		res, err := cache.RemoveTypenameFromResponse(newResponse)
 		if err != nil {
 			http.Error(w, "error removing __typename", http.StatusInternalServerError)
 		}
 		w.Write(res.Bytes())
-		// w.WriteHeader(http.StatusOK)
+		w.Header().Add("graphql_cache", "miss")
 	})
 }

api/handlers/debug_handlers.go

@@ -1,15 +1,20 @@
 package handlers
 
 import (
+	"encoding/json"
 	"graphql_cache/config"
 	"graphql_cache/graphcache"
 	"net/http"
 )
 
 func GetDebugHandler(Cache *graphcache.GraphCache, cfg *config.Config) http.HandlerFunc {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		Cache.Debug()
+		resp := Cache.Look()
+		br, err := json.Marshal(resp)
+		if err != nil {
+			http.Error(w, "error marshalling response", http.StatusInternalServerError)
+		}
 		w.WriteHeader(http.StatusOK)
-		w.Write([]byte("success"))
+		w.Write(br)
 	})
 }

api/server.go

@@ -15,7 +15,7 @@ type Server struct {
 }
 
 func NewGraphCache(cfg *config.Config) *graphcache.GraphCache {
-	return graphcache.NewGraphCache(cfg.CacheBackend)
+	return graphcache.NewGraphCache(cfg)
 }
 
 func NewServer(cfg *config.Config) *Server {

cache/inmemory_cache.go

@@ -2,45 +2,54 @@ package cache
 
 import (
 	"encoding/json"
+	"errors"
 	"graphql_cache/utils/file_utils"
+	"strings"
 )
 
-// InMemoryCache implements the Cache interface and uses an in-memory map as the cache store
 type InMemoryCache struct {
-	cache map[string]interface{}
+	data map[string]interface{}
 }
 
 func NewInMemoryCache() *InMemoryCache {
 	return &InMemoryCache{
-		cache: make(map[string]interface{}),
+		data: make(map[string]interface{}),
 	}
 }
 
 func (c *InMemoryCache) Set(key string, value interface{}) error {
-	c.cache[key] = value
+	c.data[key] = deepCopy(value)
 	return nil
 }
 
 func (c *InMemoryCache) Get(key string) (interface{}, error) {
-	return c.cache[key], nil
+	value, exists := c.data[key]
+	if !exists {
+		return nil, errors.New("key not found")
+	}
+	return deepCopy(value), nil
 }
 
 func (c *InMemoryCache) Del(key string) error {
-	delete(c.cache, key)
+	c.Set(key, nil)
 	return nil
 }
 
 func (c *InMemoryCache) Exists(key string) (bool, error) {
-	_, exists := c.cache[key]
+	_, exists := c.data[key]
 	return exists, nil
 }
 
 func (c *InMemoryCache) Map() (map[string]interface{}, error) {
-	return c.cache, nil
+	copy := make(map[string]interface{})
+	for k, v := range c.data {
+		copy[k] = v
+	}
+	return copy, nil
 }
 
 func (c *InMemoryCache) JSON() ([]byte, error) {
-	return json.Marshal(c.cache)
+	return json.Marshal(c.data)
 }
 
 func (c *InMemoryCache) Debug(identifier string) error {
@@ -52,15 +61,38 @@ func (c *InMemoryCache) Debug(identifier string) error {
 }
 
 func (c *InMemoryCache) Flush() error {
-	c.cache = make(map[string]interface{})
+	c.data = make(map[string]interface{})
 	return nil
 }
 
 func (c *InMemoryCache) DeleteByPrefix(prefix string) error {
-	for key := range c.cache {
-		if len(key) >= len(prefix) && key[:len(prefix)] == prefix {
-			delete(c.cache, key)
+	for k := range c.data {
+		if strings.HasPrefix(k, prefix) {
+			c.Del(k)
 		}
 	}
 	return nil
 }
+
+func deepCopy(v interface{}) interface{} {
+	if v == nil {
+		return nil
+	}
+
+	switch val := v.(type) {
+	case map[string]interface{}:
+		newMap := make(map[string]interface{})
+		for k, v := range val {
+			newMap[k] = deepCopy(v)
+		}
+		return newMap
+	case []interface{}:
+		newSlice := make([]interface{}, len(val))
+		for i, v := range val {
+			newSlice[i] = deepCopy(v)
+		}
+		return newSlice
+	default:
+		return v
+	}
+}

cache/redis_cache.go

@@ -15,9 +15,9 @@ type RedisCache struct {
 	cache *redis.Client
 }
 
-func NewRedisCache() Cache {
+func NewRedisCache(host, port string) Cache {
 	c := redis.NewClient(&redis.Options{
-		Addr:     "localhost:6379",
+		Addr:     host + ":" + port,
 		Password: "", // no password set
 		DB:       0,  // use default DB
 	})

config.toml

@@ -3,7 +3,7 @@
 # If your cache is running on https://api.acme.com/api/graphql then you should set the following:
 # origin="https://api.acme.com/api/graphql"
 
-origin="http://localhost:8080"
+origin="http://localhost:8080/graphql"
 
 
 # Next, we need to configure the port that our cache will run on.
@@ -17,7 +17,11 @@ port=9090
 # redis
 # in_memory
 
-cache_backend="redis"
+cache_backend="in_memory"
+
+[redis]
+host="localhost"
+port=6379
 
 
 # If you want to override the API paths for the cache server, you can configure them here.

config/config.go

@@ -19,6 +19,10 @@ type Config struct {
 		DebugPath       string `toml:"debug_path"`
 		HealthPath      string `toml:"health_path"`
 	} `toml:"handlers"`
+	Redis struct {
+		Host string `toml:"host"`
+		Port int    `toml:"port"`
+	} `toml:"redis"`
 }
 
 const CONFIG_FILE = "./config.toml"
@@ -75,5 +79,6 @@ func NewConfig() *Config {
 		Port:         cfg.Port,
 		CacheBackend: cfg.CacheBackend,
 		Handlers:     cfg.Handlers,
+		Redis:        cfg.Redis,
 	}
 }