swimple 0.11.0 → 0.12.0

package/README.md

@@ -359,6 +359,8 @@ Explicitly invalidate specific cache entries. Can be set multiple times for mult
 
 **Important:** When `X-SW-Cache-Invalidate` headers are present, they **take precedence** over automatically inferred invalidation paths. If headers are provided, only the header-specified paths are invalidated - inferred paths are not added. This allows you to have fine-grained control over invalidation even when `inferInvalidation: true`.
 
+**Query Parameter Handling:** Invalidating a path (e.g., `/api/users`) will invalidate all cache entries with that pathname, regardless of query parameters. For example, invalidating `/api/users` will also invalidate `/api/users?org_id=123`, `/api/users?status=active`, and any other query parameter variants.
+
 **Example:**
 
 ```javascript
@@ -531,6 +533,8 @@ When `inferInvalidation: true` (default), the library automatically invalidates
 
 The library strips the last path segment to find the collection endpoint. This works for most REST API patterns, but may not handle all edge cases (e.g., nested resources like `/api/users/123/avatar`). For edge cases, you can manually specify invalidation paths using the `X-SW-Cache-Invalidate` header.
 
+**Query Parameter Handling:** Cache invalidation matches entries by pathname (ignoring query parameters). This means when you invalidate a path, all cache entries with that pathname are invalidated, regardless of their query parameters. For example, invalidating `/api/users` will also invalidate `/api/users?org_id=123`, `/api/users?status=active`, and any other query parameter variants. This ensures that when you update a resource (e.g., `PATCH /api/users/456`), all filtered views of the collection (e.g., `/api/users?org_id=123`) are also invalidated.
+
 **Note:** If you provide `X-SW-Cache-Invalidate` headers, they take precedence over inferred paths. Only the header-specified paths will be invalidated, not the inferred ones.
 
 **Example: Handling nested resources**
@@ -550,6 +554,26 @@ fetch("/api/users/123/avatar", {
 });
 ```
 
+**Example: Query parameter invalidation**
+
+```javascript
+// Cache multiple filtered views of the users list
+fetch("/api/users"); // Cached
+fetch("/api/users?org_id=123"); // Cached separately
+fetch("/api/users?org_id=456&status=active"); // Cached separately
+
+// PATCH /api/users/789 - automatically invalidates:
+// - /api/users/789 (exact item path)
+// - /api/users (collection, no query params)
+// - /api/users?org_id=123 (collection with query params)
+// - /api/users?org_id=456&status=active (collection with different query params)
+// All cache entries with pathname /api/users are invalidated
+fetch("/api/users/789", {
+  method: "PATCH",
+  body: JSON.stringify({ name: "Updated User" })
+});
+```
+
 You can disable automatic invalidation:
 
 ```javascript
@@ -744,7 +768,7 @@ self.addEventListener("fetch", (event) => {
 - Only 2xx (OK) GET responses are cached. Non-OK responses (4xx, 5xx, etc.) are not cached
 - **Cross-origin requests are not cached** - Only requests to the same origin as the service worker are cached. Requests to different origins will return `null` and are not processed by the cache handler.
 - Non-GET and non-mutating requests (POST/PATCH/PUT/DELETE) are not processed by the cache handler - it will return null. Practically, this means HEAD requests are not handled by the cache handler.
-- Query strings are part of the cache key. Different query strings create different cache entries (e.g., `/api/users?page=1` and `/api/users?page=2` are separate cache entries)
+- Query strings are part of the cache key. Different query strings create different cache entries (e.g., `/api/users?page=1` and `/api/users?page=2` are separate cache entries). However, cache invalidation matches by pathname (ignoring query parameters), so invalidating `/api/users` will invalidate all query variants like `/api/users?page=1`, `/api/users?org_id=123`, etc.
 - Cache invalidation happens automatically for mutations when `inferInvalidation: true`
 - All headers are case-insensitive (per HTTP spec)
 - TTL of `0` completely opts out of caching for a request - the handler returns `null` immediately without checking cache, making network requests, or processing the request.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swimple",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "A simple service worker library for request caching",
   "type": "module",
   "main": "./src/index.js",

package/src/helpers.js

@@ -239,20 +239,94 @@ export function matchesScope(url, scope, defaultTTLSeconds) {
 
 /**
  * Invalidate cache entries
+ * Matches cache entries by pathname (ignoring query parameters), so invalidating
+ * "/api/users" will also invalidate "/api/users?org_id=123" and other query variants.
  * @param {string} cacheName
  * @param {string[]} urls
  * @returns {Promise<void>}
  */
 export async function invalidateCache(cacheName, urls) {
   const cache = await caches.open(cacheName);
-  const deletePromises = urls.map(async (url) => {
-    const deleted = await cache.delete(url);
-    if (deleted) {
-      logInfo(`Cache invalidated: ${url}`);
+  const deletePromises = [];
+  const invalidatedUrls = [];
+
+  // Determine origin for constructing full URLs from relative paths
+  // Try self.location.origin first (service worker context)
+  // Otherwise, extract from URLs array if any are full URLs
+  let cacheOrigin = null;
+  if (typeof self !== "undefined" && self.location && self.location.origin) {
+    cacheOrigin = self.location.origin;
+  } else {
+    // Try to extract origin from URLs array
+    for (const url of urls) {
+      try {
+        const urlObj = new URL(url);
+        cacheOrigin = urlObj.origin;
+        break; // Use first valid origin found
+      } catch {
+        // Not a full URL, continue
+      }
     }
-    return deleted;
-  });
+  }
+
+  if (!cacheOrigin) {
+    throw new Error(
+      "Cannot determine origin for relative paths. self.location.origin is not available and no full URLs provided."
+    );
+  }
+
+  // Iterate over URLs to invalidate (typically much smaller than cache size)
+  // Use matchAll with ignoreSearch to avoid loading all cache keys into memory
+  for (const url of urls) {
+    try {
+      // Create a Request object for matching
+      // If URL is relative, construct a full URL using the cache origin
+      let requestUrl = url;
+      try {
+        // Try to parse as URL - if it fails, it might be relative
+        new URL(url);
+      } catch {
+        // If relative, construct a full URL
+        requestUrl = new URL(url, cacheOrigin).toString();
+      }
+
+      // Create a GET request for matching (cached entries are always GET requests)
+      const request = new Request(requestUrl, { method: "GET" });
+
+      // Use matchAll with ignoreSearch to find all cache entries matching this pathname
+      // (ignoring query parameters). This avoids loading all cache keys into memory.
+      const matchingResponses = await cache.matchAll(request, {
+        ignoreSearch: true
+      });
+
+      // Delete all matching entries
+      // matchAll returns Response objects; construct Request objects for delete()
+      for (const response of matchingResponses) {
+        const responseUrl = response.url;
+        const requestToDelete = new Request(responseUrl);
+        deletePromises.push(cache.delete(requestToDelete));
+        invalidatedUrls.push(responseUrl);
+      }
+    } catch (error) {
+      // If URL parsing or matching fails, try exact match as fallback
+      try {
+        const request = new Request(url);
+        const deleted = await cache.delete(request);
+        if (deleted) {
+          invalidatedUrls.push(url);
+        }
+      } catch {
+        // Ignore errors for invalid URLs
+      }
+    }
+  }
+
   await Promise.allSettled(deletePromises);
+
+  // Log each invalidated URL
+  invalidatedUrls.forEach((url) => {
+    logInfo(`Cache invalidated: ${url}`);
+  });
 }
 
 /**

package/src/index.js

@@ -108,7 +108,25 @@ export function createHandleRequest(config) {
           pathsToInvalidate.push(...getInferredInvalidationPaths(url));
         }
 
+        // Normalize relative paths to full URLs using the mutation request's origin
         if (pathsToInvalidate.length > 0) {
+          try {
+            const requestUrlObj = new URL(url);
+            const requestOrigin = requestUrlObj.origin;
+            pathsToInvalidate = pathsToInvalidate.map((path) => {
+              try {
+                // Try to parse as URL - if it fails, it's relative
+                new URL(path);
+                return path; // Already a full URL
+              } catch {
+                // Relative path - construct full URL using request origin
+                return new URL(path, requestOrigin).toString();
+              }
+            });
+          } catch {
+            // If we can't parse the request URL, leave paths as-is
+            // invalidateCache will handle it
+          }
           await invalidateCache(cacheName, pathsToInvalidate);
         }
 

package/types/helpers.d.ts

@@ -88,6 +88,8 @@ export function getStaleTTL(headers: Headers, defaultStaleTTL: number, url?: str
 export function matchesScope(url: string, scope: string[], defaultTTLSeconds: number): boolean;
 /**
  * Invalidate cache entries
+ * Matches cache entries by pathname (ignoring query parameters), so invalidating
+ * "/api/users" will also invalidate "/api/users?org_id=123" and other query variants.
  * @param {string} cacheName
  * @param {string[]} urls
  * @returns {Promise<void>}