cache status header, and bypass multipart requests

Author: nshntarora

api/handlers/cache_handlers.go

@@ -13,8 +13,13 @@ import (
 	"time"
 )
 
+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 {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+
 		w.Header().Add("Content-Type", "application/json")
 
 		// Create a new HTTP request with the same method, URL, and body as the original request
@@ -24,17 +29,34 @@ func GetCacheHandler(cache *graphcache.GraphCache, cfg *config.Config) http.Hand
 			http.Error(w, "Error parsing target URL", http.StatusInternalServerError)
 		}
 
-		proxyReq, err := http.NewRequest(r.Method, targetURL.String(), r.Body)
-		if err != nil {
-			fmt.Println(err)
-			http.Error(w, "Error creating proxy request", http.StatusInternalServerError)
-		}
+		// only handle if the request is of content type application/json
+		// for all other content types, pass the request to the origin server
+		if r.Header.Get("Content-Type") != "application/json" {
+			proxyReq, err := CopyRequest(r, cfg.Origin)
+			if err != nil {
+				fmt.Println(err)
+				http.Error(w, "Error copying request", http.StatusInternalServerError)
+			}
 
-		// Copy the headers from the original request to the proxy request
-		for name, values := range r.Header {
-			for _, value := range values {
-				proxyReq.Header.Add(name, value)
+			resp, err := SendRequest(proxyReq, w, map[string]interface{}{
+				cfg.CacheHeaderName: CACHE_STATUS_BYPASS,
+			})
+			if err != nil {
+				fmt.Println(err)
+				http.Error(w, "error sending proxy request", http.StatusInternalServerError)
 			}
+			defer resp.Body.Close()
+
+			responseBody := new(bytes.Buffer)
+			io.Copy(responseBody, resp.Body)
+			w.Write(responseBody.Bytes())
+			return
+		}
+
+		proxyReq, err := CopyRequest(r, targetURL.String())
+		if err != nil {
+			fmt.Println(err)
+			http.Error(w, "Error copying request", http.StatusInternalServerError)
 		}
 
 		requestBody, err := io.ReadAll(proxyReq.Body)
@@ -78,27 +100,15 @@ func GetCacheHandler(cache *graphcache.GraphCache, cfg *config.Config) http.Hand
 			proxyReq.Body = io.NopCloser(bytes.NewBuffer(transformedRequest.Bytes()))
 			proxyReq.ContentLength = -1
 
-			client := http.Client{}
-			// Send the proxy request using the custom transport
-			resp, err := client.Do(proxyReq)
-			if err != nil || resp == nil {
-				http.Error(w, "Error sending proxy request", http.StatusInternalServerError)
-
+			resp, err := SendRequest(proxyReq, w, map[string]interface{}{
+				cfg.CacheHeaderName: CACHE_STATUS_BYPASS,
+			})
+			if err != nil {
+				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
-			for name, values := range resp.Header {
-				if name != "Content-Length" {
-					for _, value := range values {
-						w.Header().Add(name, value)
-					}
-				}
-			}
-
-			// Set the status code of the original response to the status code of the proxy response
-			w.WriteHeader(resp.StatusCode)
-
 			responseBody := new(bytes.Buffer)
 			io.Copy(responseBody, resp.Body)
 
@@ -116,6 +126,7 @@ func GetCacheHandler(cache *graphcache.GraphCache, cfg *config.Config) http.Hand
 			if err != nil {
 				http.Error(w, "error removing __typename", http.StatusInternalServerError)
 			}
+
 			w.Write(res.Bytes())
 			return
 		}
@@ -133,32 +144,23 @@ func GetCacheHandler(cache *graphcache.GraphCache, cfg *config.Config) http.Hand
 			if err != nil {
 				http.Error(w, "error removing __typename", http.StatusInternalServerError)
 			}
+			w.Header().Add(cfg.CacheHeaderName, CACHE_STATUS_HIT)
 			w.Write(res.Bytes())
 			return
 		}
 
 		proxyReq.Body = io.NopCloser(bytes.NewBuffer(transformedRequest.Bytes()))
 		proxyReq.ContentLength = -1
 
-		client := http.Client{}
-
-		// Send the proxy request using the custom transport
-		resp, err := client.Do(proxyReq)
+		resp, err := SendRequest(proxyReq, w, map[string]interface{}{
+			cfg.CacheHeaderName: CACHE_STATUS_MISS,
+		})
 		if err != nil {
 			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
-		for name, values := range resp.Header {
-			if name != "Content-Length" { // copy all headers except Content-Length
-				for _, value := range values {
-					w.Header().Add(name, value)
-				}
-			}
-		}
-
 		responseBody := new(bytes.Buffer)
 		io.Copy(responseBody, resp.Body)
 
@@ -211,7 +213,54 @@ func GetCacheHandler(cache *graphcache.GraphCache, cfg *config.Config) http.Hand
 		if err != nil {
 			http.Error(w, "error removing __typename", http.StatusInternalServerError)
 		}
+
 		w.Write(res.Bytes())
-		w.Header().Add("graphql_cache", "miss")
 	})
 }
+
+func CopyRequest(r *http.Request, targetURL string) (*http.Request, error) {
+	proxyReq, err := http.NewRequest(r.Method, targetURL, r.Body)
+	if err != nil {
+		fmt.Println(err)
+		// http.Error(w, "Error creating proxy request", http.StatusInternalServerError)
+		return nil, err
+	}
+
+	// Copy the headers from the original request to the proxy request
+	for name, values := range r.Header {
+		for _, value := range values {
+			proxyReq.Header.Add(name, value)
+		}
+	}
+
+	proxyReq.ContentLength = -1
+
+	return proxyReq, nil
+}
+
+func SendRequest(proxyReq *http.Request, w http.ResponseWriter, headers map[string]interface{}) (*http.Response, error) {
+	client := http.Client{}
+	// Send the proxy request using the custom transport
+	resp, err := client.Do(proxyReq)
+	if err != nil || resp == nil {
+		http.Error(w, "Error sending proxy request", http.StatusInternalServerError)
+		return resp, err
+	}
+
+	// Copy the headers from the proxy response to the original response
+	for name, values := range resp.Header {
+		if name != "Content-Length" {
+			for _, value := range values {
+				w.Header().Add(name, value)
+			}
+		}
+	}
+
+	for key, value := range headers {
+		w.Header().Add(key, fmt.Sprintf("%v", value))
+	}
+
+	w.WriteHeader(resp.StatusCode)
+
+	return resp, nil
+}

config/config.go

@@ -23,6 +23,7 @@ type Config struct {
 		Host string `toml:"host"`
 		Port int    `toml:"port"`
 	} `toml:"redis"`
+	CacheHeaderName string `toml:"cache_header_name"`
 }
 
 const CONFIG_FILE = "./config.toml"
@@ -74,11 +75,9 @@ func NewConfig() *Config {
 		cfg.Handlers.HealthPath = "/health"
 	}
 
-	return &Config{
-		Origin:       cfg.Origin,
-		Port:         cfg.Port,
-		CacheBackend: cfg.CacheBackend,
-		Handlers:     cfg.Handlers,
-		Redis:        cfg.Redis,
+	if cfg.CacheHeaderName == "" {
+		cfg.CacheHeaderName = "x-orbit-cache"
 	}
+
+	return &cfg
 }

graphcache/graphcache.go

@@ -103,6 +103,10 @@ func (gc *GraphCache) deleteTypename(data interface{}) interface{} {
 
 func (gc *GraphCache) ParseASTBuildResponse(queryPrefix string, astQuery *ast.QueryDocument, requestBody GraphQLRequest) (interface{}, error) {
 
+	if len(astQuery.Operations) == 0 {
+		return nil, errors.New("no operations found in query")
+	}
+
 	queryDoc := astQuery.Operations[0]
 
 	reqVariables := requestBody.Variables

logo.svg

@@ -263,3 +263,14 @@ func TestWithTodoOperations(t *testing.T) {
 	assert.NotNil(t, todoResponse.User)
 	assert.Equal(t, userID, todoResponse.User.ID.String())
 }
+
+func TestMultipartRequestsBypass(t *testing.T) {
+	client := test_client.NewGraphQLClient("http://localhost:9090/graphql", "http://localhost:9090")
+
+	resp, headers, _, err := client.UploadImage("./logo.svg")
+	assert.Nil(t, err)
+	assert.NotNil(t, resp)
+	assert.NotNil(t, headers)
+
+	assert.Equal(t, "BYPASS", headers["X-Orbit-Cache"])
+}