add global cache key and prefix

Author: donchev7

config/config.go

@@ -38,6 +38,7 @@ type CacheConfig struct {
 	ShouldHashQuery bool
 	HashQueryIgnore map[string]bool
 	HashHeaders     []string
+	GlobalCacheKeys map[string]string // path pattern -> global key
 }
 
 type Config struct {
@@ -63,6 +64,7 @@ func New() Config {
 		ShouldHashQuery: getEnvAsBool("CACHE_SHOULD_HASH_QUERY", "true"),
 		HashQueryIgnore: hashQueryIgnoreMap(getEnvAsSlice("CACHE_HASH_QUERY_IGNORE")),
 		HashHeaders:     getEnvAsSlice("CACHE_HASH_HEADERS"),
+		GlobalCacheKeys: parseGlobalCacheKeys(getEnv("CACHE_GLOBAL_KEYS", "/public:static-files,/_next:nextjs-assets")),
 	}
 
 	if strings.ToLower(serverConfig.Storage) == "memory" {

config/helpers.go

@@ -18,6 +18,35 @@ func hashQueryIgnoreMap(queryIgnore []string) map[string]bool {
 	return hashQueryIgnoreMap
 }
 
+func parseGlobalCacheKeys(globalKeysStr string) map[string]string {
+	globalKeys := make(map[string]string)
+	if globalKeysStr == "" {
+		return globalKeys
+	}
+
+	// Expected format: "pattern1:key1,pattern2:key2"
+	// Example: "/assets:static-assets,/_next:nextjs-assets,/static:static-files"
+	pairs := strings.SplitSeq(globalKeysStr, ",")
+	for pair := range pairs {
+		trimmedPair := strings.TrimSpace(pair)
+		if trimmedPair == "" {
+			continue
+		}
+
+		// Split on colon and ensure exactly one colon exists
+		parts := strings.Split(trimmedPair, ":")
+		if len(parts) == 2 {
+			pattern := strings.TrimSpace(parts[0])
+			key := strings.TrimSpace(parts[1])
+			if pattern != "" && key != "" {
+				globalKeys[pattern] = key
+			}
+		}
+		// Ignore malformed pairs with 0, 1, or more than 2 parts
+	}
+	return globalKeys
+}
+
 func getEnv(key, defaultVal string) string {
 	if value, exists := os.LookupEnv(key); exists {
 		return strings.TrimSpace(value)

config/helpers_test.go

@@ -158,4 +158,64 @@ func TestConfigHelpers(t *testing.T) {
 			})
 		})
 	})
+	t.Run("parseGlobalCacheKeys", func(t *testing.T) {
+		t.Run("should parse valid global cache keys", func(t *testing.T) {
+			input := "/assets:static-assets,/_next:nextjs-assets,/static:static-files"
+			got := parseGlobalCacheKeys(input)
+
+			expected := map[string]string{
+				"/assets": "static-assets",
+				"/_next":  "nextjs-assets",
+				"/static": "static-files",
+			}
+
+			assert.Equal(t, expected, got)
+		})
+		t.Run("should handle empty string", func(t *testing.T) {
+			got := parseGlobalCacheKeys("")
+			assert.Equal(t, map[string]string{}, got)
+		})
+		t.Run("should handle single pair", func(t *testing.T) {
+			input := "/assets:static-assets"
+			got := parseGlobalCacheKeys(input)
+
+			expected := map[string]string{
+				"/assets": "static-assets",
+			}
+
+			assert.Equal(t, expected, got)
+		})
+		t.Run("should handle spaces around delimiters", func(t *testing.T) {
+			input := " /assets : static-assets , /_next : nextjs-assets "
+			got := parseGlobalCacheKeys(input)
+
+			expected := map[string]string{
+				"/assets": "static-assets",
+				"/_next":  "nextjs-assets",
+			}
+
+			assert.Equal(t, expected, got)
+		})
+		t.Run("should ignore malformed pairs", func(t *testing.T) {
+			input := "/assets:static-assets,invalid,/_next:nextjs-assets,also:invalid:format"
+			got := parseGlobalCacheKeys(input)
+
+			expected := map[string]string{
+				"/assets": "static-assets",
+				"/_next":  "nextjs-assets",
+			}
+
+			assert.Equal(t, expected, got)
+		})
+		t.Run("should ignore empty keys or values", func(t *testing.T) {
+			input := ":empty-key,empty-value:,/assets:static-assets"
+			got := parseGlobalCacheKeys(input)
+
+			expected := map[string]string{
+				"/assets": "static-assets",
+			}
+
+			assert.Equal(t, expected, got)
+		})
+	})
 }

pkg/http/cache.go

@@ -94,6 +94,13 @@ func cloneHeaders(src http.Header) http.Header {
 }
 
 func (h handler) getCacheKey(req *http.Request) string {
+	// Check for global cache keys first
+	for pattern, globalKey := range h.cfg.GlobalCacheKeys {
+		if strings.HasPrefix(req.URL.Path, pattern) {
+			return globalKey
+		}
+	}
+
 	hash := sha256.New()
 	hash.Write([]byte(req.Method))
 	hash.Write([]byte(":"))
@@ -240,12 +247,13 @@ func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	ctx := logger.WithContext(r.Context())
 
 	if strings.ToUpper(r.Method) != http.MethodGet || r.Header.Get("Range") != "" {
+		logger.Debug().Msg("skipping cache")
 		h.proxy.ServeHTTP(w, r)
 		return
 	}
 
 	if isWebSocket(r) {
-		logger.Info().Msg("skip cache: websocket")
+		logger.Debug().Msg("skipping cache: websocket")
 		h.proxy.ServeHTTP(w, r)
 		return
 	}
@@ -282,10 +290,11 @@ func (h handler) cacheResponse(ctx context.Context, key string) func(*http.Respo
 		if !(resp.StatusCode == http.StatusOK || resp.StatusCode == http.StatusNoContent) {
 			return nil
 		}
-		cc := resp.Header.Get("Cache-Control")
-		if strings.Contains(cc, "no-store") || strings.Contains(cc, "private") {
-			return nil
-		}
+		// TODO: add cache control back in
+		// cc := resp.Header.Get("Cache-Control")
+		// if strings.Contains(cc, "no-store") || strings.Contains(cc, "private") {
+		// 	return nil
+		// }
 		if resp.Header.Get("Set-Cookie") != "" {
 			return nil
 		}

pkg/http/cache_test.go

@@ -465,3 +465,139 @@ func TestGetCacheKey(t *testing.T) {
 		})
 	}
 }
+
+func TestGetCacheKeyWithGlobalKeys(t *testing.T) {
+	tests := []struct {
+		name            string
+		path            string
+		method          string
+		query           string
+		headers         map[string]string
+		globalCacheKeys map[string]string
+		want            string
+	}{
+		{
+			name:   "global key for assets path",
+			path:   "/assets/script.js",
+			method: "GET",
+			globalCacheKeys: map[string]string{
+				"/assets": "static-assets",
+			},
+			want: "static-assets",
+		},
+		{
+			name:   "global key for _next path",
+			path:   "/_next/static/chunk.js",
+			method: "GET",
+			globalCacheKeys: map[string]string{
+				"/_next": "nextjs-assets",
+			},
+			want: "nextjs-assets",
+		},
+		{
+			name:   "global key for static path",
+			path:   "/static/images/logo.png",
+			method: "GET",
+			globalCacheKeys: map[string]string{
+				"/static": "static-files",
+			},
+			want: "static-files",
+		},
+		{
+			name:   "multiple global keys - first match wins",
+			path:   "/assets/css/style.css",
+			method: "GET",
+			globalCacheKeys: map[string]string{
+				"/assets":     "assets-key",
+				"/assets/css": "css-key",
+			},
+			want: "assets-key", // First match based on map iteration
+		},
+		{
+			name:   "no matching global key - falls back to hash",
+			path:   "/api/users",
+			method: "GET",
+			query:  "id=1",
+			globalCacheKeys: map[string]string{
+				"/assets": "static-assets",
+				"/_next":  "nextjs-assets",
+			},
+			want: "hashed", // Will be calculated as hash
+		},
+		{
+			name:   "global key ignores query parameters and headers",
+			path:   "/assets/script.js",
+			method: "GET",
+			query:  "version=1.0&cache=false",
+			headers: map[string]string{
+				"Authorization": "Bearer token123",
+			},
+			globalCacheKeys: map[string]string{
+				"/assets": "static-assets",
+			},
+			want: "static-assets",
+		},
+		{
+			name:   "partial path match - should not match",
+			path:   "/asset", // Missing 's' from '/assets'
+			method: "GET",
+			globalCacheKeys: map[string]string{
+				"/assets": "static-assets",
+			},
+			want: "hashed", // Will be calculated as hash
+		},
+		{
+			name:   "exact prefix match",
+			path:   "/assets",
+			method: "GET",
+			globalCacheKeys: map[string]string{
+				"/assets": "static-assets",
+			},
+			want: "static-assets",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create request
+			req, err := http.NewRequest(tt.method, tt.path, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			// Add query parameters if any
+			if tt.query != "" {
+				req.URL.RawQuery = tt.query
+			}
+
+			// Add headers
+			for key, value := range tt.headers {
+				req.Header.Set(key, value)
+			}
+
+			// Create handler with config
+			h := handler{
+				cfg: config.CacheConfig{
+					ShouldHashQuery: true,
+					HashQueryIgnore: make(map[string]bool),
+					HashHeaders:     []string{},
+					GlobalCacheKeys: tt.globalCacheKeys,
+				},
+			}
+
+			// Get cache key
+			got := h.getCacheKey(req)
+
+			if tt.want == "hashed" {
+				// For non-global keys, verify it's a proper hash
+				assert.Len(t, got, 64, "should be a SHA256 hash (64 chars)")
+				assert.NotEqual(t, "static-assets", got)
+				assert.NotEqual(t, "nextjs-assets", got)
+				assert.NotEqual(t, "static-files", got)
+			} else {
+				// For global keys, should match exactly
+				assert.Equal(t, tt.want, got, "cache key mismatch")
+			}
+		})
+	}
+}