jhaadu pocha 🧹

Author: nshntarora

README.md

@@ -10,19 +10,16 @@ Because all GraphQL requests are on a single endpoint and resources are differen
 
 This package takes a GraphQL request, caches the response - if the same request is repeated again, we can serve the response directly from cache without hitting the origin server.
 
-## Why can I just use a key value store to cache?
+## Why can't I just use a key value store for caching my GraphQL requests?
 
 You can, but the challenge comes with cache invalidation. How do you identify what fields have changed or have been added so you can invalidate your cache? One way is to invalidate everything for the user - but if you have updates happening often, it becomes as good as no cache.
 
 Since all requests to your GraphQL server pass through `graphql_cache` (including mutations), it can automatically invalidate objects and entire queries for which data has changed. Basically, it supports partial cache invalidation.
 
 ## What's the current status of this project?
 
-This currently an experiment, and still a work in progress.
+This is still a work in progress, and is not yet ready for production use.
 
-1. Automatic partial cache invalidation doesn't exist
-2. Query caching is tested for only the test API and not for all possible query formats/types.
-3. Limited to one operation per request.
-4. More limitations that I can't even think of now.
+## Is there a hosted version?
 
-Once the project is feature complete, it will be open sourced. Once it is ready enough to handle hobby project workloads, it will be open sourced as a complete package.
+No. But there will be a Dockerfile you can use to run the Cache server.

cache/cache.go

@@ -1,5 +1,7 @@
 package cache
 
+// Cache is an interface that defines the methods that a cache should implement
+// we can have different cache implementations like Redis, Memcached, etc.
 type Cache interface {
 	Set(key string, value interface{}) error
 	Get(key string) (interface{}, error)

cache/cache_response.go

@@ -5,6 +5,7 @@ import (
 	"graphql_cache/utils/file_utils"
 )
 
+// InMemoryCache implements the Cache interface and uses an in-memory map as the cache store
 type InMemoryCache struct {
 	cache map[string]interface{}
 }

cache/inmemory_cache.go

@@ -10,20 +10,11 @@ import (
 
 var ctx = context.Background()
 
+// RedisCache implements the Cache interface and uses Redis as the cache store
 type RedisCache struct {
 	cache *redis.Client
 }
 
-// var client *redis.Client
-
-// func init() {
-// 	client = redis.NewClient(&redis.Options{
-// 		Addr:     "localhost:6379",
-// 		Password: "", // no password set
-// 		DB:       1,  // use default DB
-// 	})
-// }
-
 func NewRedisCache() Cache {
 	c := redis.NewClient(&redis.Options{
 		Addr:     "localhost:6379",

cache/redis_cache.go

@@ -5,6 +5,7 @@ import (
 	"github.com/labstack/echo/v4/middleware"
 )
 
+// DefaultProxyBalancer is a simple proxy balancer that always proxies to a single target instead of load balancing
 type DefaultProxyBalancer struct {
 	target *middleware.ProxyTarget
 }

cache_proxy/balancer/balancer.go

@@ -4,57 +4,54 @@ import (
 	"bufio"
 	"bytes"
 	"encoding/json"
-	"fmt"
 	"graphql_cache/graphcache"
-	"graphql_cache/transformer"
-	"graphql_cache/utils/ast_utils"
 	"io"
 	"net"
 	"net/http"
 	"time"
 
+	"log"
+
 	"github.com/labstack/echo/v4"
 )
 
 var Cache = graphcache.NewGraphCache("redis")
 
+// CacheMiddleware is a middleware that intercepts the request and response
+// and caches the response if it is a query
+// if it is a mutation, it does not cache the response, but invalidates the objects which have been mutated
 func CacheMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
 	return func(c echo.Context) error {
 		start := time.Now()
 
 		requestBytes, err := io.ReadAll(c.Request().Body)
 		if err != nil {
-			fmt.Println("Error reading request body:", err)
+			log.Println("Error reading request body:", err)
 			return nil
 		}
 
-		fmt.Println("request content length ", c.Request().ContentLength)
-		fmt.Println("request body length", len(requestBytes))
-
 		var request graphcache.GraphQLRequest
 		err = json.Unmarshal(requestBytes, &request)
 		if err != nil {
-			fmt.Println("Error unmarshalling request:", err)
+			log.Println("Error unmarshalling request:", err)
 			return nil
 		}
 
-		astQuery, err := ast_utils.GetASTFromQuery(request.Query)
+		astQuery, err := graphcache.GetASTFromQuery(request.Query)
 		if err != nil {
-			fmt.Println("Error parsing query:", err)
+			log.Println("Error parsing query:", err)
 			return nil
 		}
 
 		if astQuery.Operations[0].Operation == "mutation" {
 			// if the operation is a mutation, we don't cache it
-			// c.Request().Body = io.NopCloser(bytes.NewBuffer(requestBytes))
-			// c.Request().ContentLength = -1
-			transformedBody, err := transformer.TransformBody(request.Query, astQuery)
+			transformedBody, err := graphcache.AddTypenameToQuery(request.Query)
 			if err != nil {
-				fmt.Println("Error transforming body:", err)
+				log.Println("Error transforming body:", err)
 				return nil
 			}
 
-			fmt.Println("time taken to transform body ", time.Since(start))
+			log.Println("time taken to transform body ", time.Since(start))
 
 			transformedRequest := request
 			transformedRequest.Query = transformedBody
@@ -70,58 +67,41 @@ func CacheMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
 			if err != nil {
 				return err
 			}
-			fmt.Println("found a mutation, invalidating cache...")
 
 			responseMap := make(map[string]interface{})
 			err = json.Unmarshal(resBody.Bytes(), &responseMap)
 			if err != nil {
-				fmt.Println("Error unmarshalling response:", err)
+				log.Println("Error unmarshalling response:", err)
 			}
 
-			// 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
-			// if the object has a nested object with __typename: "User" and id: "5678", cache
-			// it as User:5678
-
 			Cache.InvalidateCache("data", responseMap, nil)
-
-			// newResponse := &graphcache.GraphQLResponse{}
-			// newResponse.FromBytes(resBody.Bytes())
-			// res, err := Cache.RemoveTypenameFromResponse(newResponse)
-			// if err != nil {
-			// 	fmt.Println("Error removing __typename:", err)
-			// 	return nil
-			// }
-			// fmt.Println("response bytes ", string(res.Bytes()))
-			// c.Response().Write(res.Bytes())
-			// c.Response().Header().Set("X-Proxy", "GraphQL Cache")
 			return nil
 		}
 
 		cachedResponse, err := Cache.ParseASTBuildResponse(astQuery, request)
 		if err == nil && cachedResponse != nil {
-			fmt.Println("serving response from cache...")
+			log.Println("serving response from cache...")
 			br, err := json.Marshal(cachedResponse)
 			if err != nil {
 				return err
 			}
-			fmt.Println("time taken to serve response from cache ", time.Since(start))
+			log.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 {
-				fmt.Println("Error removing __typename:", err)
+				log.Println("Error removing __typename:", err)
 				return nil
 			}
 			return c.JSON(200, res)
 		}
 
-		transformedBody, err := transformer.TransformBody(request.Query, astQuery)
+		transformedBody, err := graphcache.AddTypenameToQuery(request.Query)
 		if err != nil {
-			fmt.Println("Error transforming body:", err)
+			log.Println("Error transforming body:", err)
 			return nil
 		}
 
-		fmt.Println("time taken to transform body ", time.Since(start))
+		log.Println("time taken to transform body ", time.Since(start))
 
 		transformedRequest := request
 		transformedRequest.Query = transformedBody
@@ -140,18 +120,18 @@ func CacheMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
 		responseMap := make(map[string]interface{})
 		err = json.Unmarshal(resBody.Bytes(), &responseMap)
 		if err != nil {
-			fmt.Println("Error unmarshalling response:", err)
+			log.Println("Error unmarshalling response:", err)
 		}
 
-		fmt.Println("time taken to get response from API ", time.Since(start))
+		log.Println("time taken to get response from API ", time.Since(start))
 
-		astWithTypes, err := ast_utils.GetASTFromQuery(transformedRequest.Query)
+		astWithTypes, err := graphcache.GetASTFromQuery(transformedRequest.Query)
 		if err != nil {
-			fmt.Println("Error parsing query:", err)
+			log.Println("Error parsing query:", err)
 			return nil
 		}
 
-		fmt.Println("time taken to generate AST with types ", time.Since(start))
+		log.Println("time taken to generate AST with types ", time.Since(start))
 
 		reqVariables := transformedRequest.Variables
 		variables := make(map[string]interface{})
@@ -160,9 +140,7 @@ func CacheMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
 		}
 
 		for _, op := range astWithTypes.Operations {
-			// for the operation op we need to traverse the response and the ast together to build a graph of the relations
-
-			// build the relation graph
+			// for the operation op we need to traverse the response and build the relationship map where key is the requested field and value is the key where the actual response is stored in the cache
 			responseKey := Cache.GetQueryResponseKey(op, responseMap, variables)
 			for key, value := range responseKey {
 				if value != nil {
@@ -171,7 +149,7 @@ func CacheMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
 			}
 		}
 
-		fmt.Println("time taken to build response key ", time.Since(start))
+		log.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
@@ -180,22 +158,9 @@ func CacheMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
 
 		Cache.CacheResponse("data", responseMap, nil)
 
-		fmt.Println("time taken to cache response ", time.Since(start))
-
-		// cacheStore.Debug("cacheStore")
-		// recordCacheStore.Debug("recordCacheStore")
-		// queryCacheStore.Debug("queryCacheStore")
-
-		// cacheState, _ := cacheStore.JSON()
-		// fmt.Println(string(cacheState))
-
-		// recordCacheState, _ := recordCacheStore.JSON()
-		// fmt.Println(string(recordCacheState))
-
-		// queryCacheState, _ := queryCacheStore.JSON()
-		// fmt.Println(string(queryCacheState))
+		log.Println("time taken to cache response ", time.Since(start))
 
-		fmt.Println("time taken to finish completely ", time.Since(start))
+		// remove __typename from the response
 		newResponse := &graphcache.GraphQLResponse{}
 		newResponse.FromBytes(resBody.Bytes())
 		Cache.RemoveTypenameFromResponse(newResponse)
@@ -204,6 +169,9 @@ func CacheMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
 	}
 }
 
+// bodyDumpResponseWrite is a custom response writer that writes the response body to a buffer
+// and also writes it to the actual response writer
+// this is used to read the response body after it has been written to the response writer
 type bodyDumpResponseWriter struct {
 	io.Writer
 	http.ResponseWriter

cache_proxy/cache_middleware/cache_middleware.go

@@ -18,7 +18,6 @@ func main() {
 	e.Use(middleware.Recover())
 	e.Use(middleware.Logger())
 
-	// e.Use(cache_middleware.NewCacheMiddleware(gc))
 	apiSever, err := url.Parse(API_URL)
 	if err != nil {
 		e.Logger.Fatal(err)
@@ -53,25 +52,6 @@ func main() {
 
 	g.Use(middleware.ProxyWithConfig(middleware.ProxyConfig{
 		Balancer: balancer,
-		ModifyResponse: func(resp *http.Response) error {
-			// responseBody, err := io.ReadAll(resp.Body)
-			// if err != nil {
-			// 	fmt.Println("Error reading response body:", err)
-			// 	return err
-			// }
-			// newResponse := &graphcache.GraphQLResponse{}
-			// newResponse.FromBytes(responseBody)
-			// res, err := cache_middleware.Cache.RemoveTypenameFromResponse(newResponse)
-			// if err != nil {
-			// 	fmt.Println("Error removing __typename:", err)
-			// 	return nil
-			// }
-			// body := io.NopCloser(bytes.NewReader(res.Bytes()))
-			// resp.Body = body
-			// resp.ContentLength = int64(len(res.Bytes()))
-			// resp.Header.Set("Content-Length", strconv.Itoa(len(res.Bytes())))
-			return nil
-		},
 	}))
 
 	e.Logger.Fatal(e.Start(":9090"))

cache_proxy/main.go

@@ -1,4 +1,4 @@
-package ast_utils
+package graphcache
 
 import (
 	"github.com/vektah/gqlparser/ast"

utils/ast_utils/ast_utils.go renamed to graphcache/ast.go

@@ -12,50 +12,13 @@ import (
 	"github.com/vektah/gqlparser/ast"
 )
 
+// GraphCache is a struct that holds the cache stores for the GraphQL cache
 type GraphCache struct {
 	cacheStore       cache.Cache
 	recordCacheStore cache.Cache
 	queryCacheStore  cache.Cache
 }
 
-type GraphQLRequest struct {
-	Query     string                 `json:"query"`
-	Variables map[string]interface{} `json:"variables"`
-}
-
-func (gr *GraphQLRequest) Map() map[string]interface{} {
-	return map[string]interface{}{
-		"query":     gr.Query,
-		"variables": gr.Variables,
-	}
-}
-
-func (gr *GraphQLRequest) Bytes() []byte {
-	bytes, _ := json.Marshal(gr)
-	return bytes
-}
-
-type GraphQLResponse struct {
-	Data   json.RawMessage `json:"data"`
-	Errors []interface{}   `json:"errors"`
-}
-
-func (gr *GraphQLResponse) Map() map[string]interface{} {
-	return map[string]interface{}{
-		"data":   gr.Data,
-		"errors": gr.Errors,
-	}
-}
-
-func (gr *GraphQLResponse) Bytes() []byte {
-	bytes, _ := json.Marshal(gr)
-	return bytes
-}
-
-func (gr *GraphQLResponse) FromBytes(bytes []byte) {
-	json.Unmarshal(bytes, gr)
-}
-
 func NewGraphCache(backend string) *GraphCache {
 	if backend == "redis" {
 		return &GraphCache{
@@ -399,8 +362,6 @@ func (gc *GraphCache) CacheResponse(field string, object map[string]interface{},
 	cacheKey := gc.CacheObject(field, object, parent)
 
 	return object, cacheKey
-
-	// return parent
 }
 
 func (gc *GraphCache) GetQueryResponseKey(queryDoc *ast.OperationDefinition, response map[string]interface{}, variables map[string]interface{}) map[string]interface{} {