bv-ui-core 2.9.6 → 2.9.8

package/lib/bvFetch/README.md

@@ -9,6 +9,8 @@ The BvFetch module provides methods to cache duplicate API calls and interact wi
 `shouldCache (Function):` A function that takes the API response JSON as input and returns a boolean indicating whether to cache the response or not. This allows you to implement custom logic based on the response content. If caching is desired, the function should return true; otherwise, false.
 `cacheName (String):` Optional. Specifies the name of the cache to be used. If not provided, the default cache name 'bvCache' will be used.
 `cacheLimit (Integer)`: Optional. Specifies the cache size limit for the cache storage. Its value should be in MB. Default value is 10 MB.
+`excludeHeaders (Array[String])`: Includes the list of headers that are excluded from the cacheKey
+
 
 ## bvFetchFunc Method Parameters
 `url (String):` The URL of the API endpoint to fetch data from.
@@ -17,17 +19,22 @@ The BvFetch module provides methods to cache duplicate API calls and interact wi
 ## bvFetchFunc Return Value
 `Promise<Response>:` A promise that resolves to the API response. If the response is cached, it returns the cached response. Otherwise, it fetches data from the API endpoint, caches the response according to the caching logic, and returns the fetched response.
 
-## generateCacheKey Method Parameters:
-`url (String):` The URL of the API endpoint.
-`options (Object):` Optional request options.
-## generateCacheKey Return Value:
-`string:` The generated cache key.
+## generateCacheKey Method
+
+Generates a cache key as a Request object for a given URL and options, filtering out any headers specified in `excludeHeaders`.
+
+**Parameters:**
+- `url (String)`: The URL of the API endpoint.
+- `options (Object)`: *(Optional)* Request options (e.g., headers, method, etc.).
+
+**Returns:**  
+`Request`: The generated Request object to be used as a cache key.
 
-## retrieveCachedUrls Method
-Retrieves cached URLs from the cache storage associated with the provided cache name.
-## retrieveCachedUrls Parameters
+## retrievecachedRequests Method
+Retrieves cached Requests from the cache storage associated with the provided cache name.
+## retrievecachedRequests Parameters
 This method takes no parameters.
-## retrieveCachedUrls Return Value
+## retrievecachedRequests Return Value
 `void:` This method does not return anything.
 
 ## fetchDataAndCache Method
@@ -77,8 +84,10 @@ var BvFetch = require('bv-ui-core/lib/bvFetch')
 
 // Initialize BV Fetch instance
 const bvFetch = new BVFetch({
-  canBeCached: canBeCached, // optional
-  cacheName: "bvCache" // optional, default is "bvCache"
+   shouldCache: function(responseJson) => { /* return true or false */ }, // optional, callback function to check if the response is cachable
+   cacheName: "bvCache" // optional, default is "bvCache"
+   cacheLimit: 10, // optional but default is 10
+   excludeHeaders: [], // optional, list of headers to be excluded from cache
 });
 
 // Make API calls using bvFetchFunc method

package/lib/bvFetch/index.js

@@ -5,46 +5,122 @@
 
 const { fetch } = require('../polyfills/fetch')
 
-module.exports = function BvFetch ({ shouldCache, cacheName, cacheLimit }) {
+module.exports = function BvFetch ({ shouldCache, cacheName, cacheLimit, excludeHeaders = [] }) {
   this.shouldCache = shouldCache;
   this.cacheName = cacheName || 'bvCache';
   this.cacheLimit = cacheLimit * 1024 * 1024 || 10 * 1024 * 1024;
   this.fetchPromises = new Map();
-  this.cachedUrls = new Set();
+  this.cachedRequests = new Set();
+  this.excludeHeaders = excludeHeaders;
 
   /**
-   * Generates a unique cache key for the given URL and options.
-   * @param {string} url - The URL of the API endpoint.
-   * @param {Object} options - Optional request options.
-   * @returns {string} The generated cache key.
+   * Checks if a request is present in a set of cached URLs.
+   *
+   * @param {Set} cachedRequests - A set of cached request objects.
+   * @param {Object} cacheKey - The request object to check for in the cachedRequests set.
+   * @param {string} cacheKey.url - The URL of the request.
+   * @param {Headers} cacheKey.headers - The headers of the request.
+   * @returns {boolean} - Returns true if the request is found in the cachedRequests set, otherwise false.
    */
+  function isRequestInSet (cachedRequests, cacheKey) {
+    try {
+      // Convert the Set to an array and check if any request matches
+      return [...cachedRequests].some((cachedRequest) => {
+        // Compare URLs
+        if (cachedRequest.url !== cacheKey.url) {
+          return false;
+        }
+    
+        // Compare headers
+        const cachedHeaders = [...cachedRequest.headers.entries()];
+        const keyHeaders = [...cacheKey.headers.entries()];
+    
+        if (cachedHeaders.length !== keyHeaders.length) {
+          return false; // Different number of headers
+        }
+        // Check if all headers match
+        return cachedHeaders.every(([key, value]) => {
+          return cacheKey.headers.get(key) === value;
+        });
+      });
+    } 
+    catch (error) {
+      console.warn('Error checking in if request is in cache: ', error);
+      return false;
+    }
+  }
+  
 
+  /**
+     * Creates a new Request object with the given URL and options.
+     *
+     * @param {string} url - The URL to which the request is sent.
+     * @param {Object} options - The options to apply to the request.
+     * @returns {Request} The created Request object.
+     */
+
+  /**
+   * Generates a cache key as a Request object for the given URL and options.
+   * Filters out headers specified in `excludeHeaders` from the options before creating the Request.
+   *
+   * @param {string} url - The URL of the API endpoint.
+   * @param {Object} options - Optional request options (e.g., headers, method, etc.).
+   * @returns {Request} The generated Request object to be used as a cache key.
+   */
   this.generateCacheKey =  (url, options) => {
-    const optionsString = (Object.keys(options).length > 0) ? JSON.stringify(options) : '';
-    const key = url + optionsString;
+    const filteredOptions = Object.assign({}, options);
+    this.excludeHeaders.forEach(header => {
+      if (filteredOptions.headers && filteredOptions.headers[header]) {
+        delete filteredOptions.headers[header];
+      }
+    }
+    );
+    const key = new Request(url, filteredOptions);
     return key;
   };
 
+   /**
+   * Serializes a request object into a JSON string for use as a cache key.
+   * The serialization includes the URL, method, and sorted headers of the request.
+   * @param {Request} request - The request object to serialize.
+   * @returns {string} A JSON string representing the serialized request.
+   */
+  this.serializeRequestKey = (request) => {
+    const url = request.url;
+    const method = request.method || 'GET';
+    // Convert headers to a sorted array of [key, value] pairs for consistency
+    const headersArr = Array.from(request.headers.entries()).sort(([a], [b]) => a.localeCompare(b));
+    return JSON.stringify([url, method, { headers: headersArr }]);
+  }
+
   /**
-  * Retrieves cached URLs from the cache storage associated with the provided cache name.
+  * Retrieves cached Requests from the cache storage associated with the provided cache name.
   * @returns {void}
   */
 
-  this.retrieveCachedUrls = () => {
+  this.retrievecachedRequests = () => {
     // Open the Cache Storage
     caches.open(this.cacheName).then(cache => {
     // Get all cache keys
       cache.keys().then(keys => {
         keys.forEach(request => {
-          this.cachedUrls.add(request.url);
+          const headers = {};
+          request.headers.forEach((value, key) => {
+            if (!this.excludeHeaders.includes(key)) {
+              headers[key] = value;
+            }
+          });
+
+          // Generate the cache key with headers and URL
+          const cacheKey = this.generateCacheKey(request.url, { headers });
+          this.cachedRequests.add(cacheKey); // Add to the set
         });
       });
     });
-
   }
 
-  //callretrieveCachedUrls function to set the cache URL set with the cached URLS
-  this.retrieveCachedUrls();
+  //callretrievecachedRequests function to set the cache URL set with the cached URLS
+  this.retrievecachedRequests();
 
   /**
     * Fetches data from the specified URL, caches the response, and returns the response.
@@ -75,6 +151,11 @@ module.exports = function BvFetch ({ shouldCache, cacheName, cacheLimit }) {
   this.cacheData = (response, cacheKey) => {
     const errJson = response.clone();
     let canBeCached = true;
+    if (!response.ok) {
+      // If the response is not ok, we don't cache it
+      canBeCached = false;
+      return;
+    }
     // Check for error in response obj
     errJson.json().then(json => {
       if (typeof this.shouldCache === 'function') {
@@ -106,8 +187,8 @@ module.exports = function BvFetch ({ shouldCache, cacheName, cacheLimit }) {
           // Cache the response
           caches.open(this.cacheName).then(cache => {
             cache.put(cacheKey, newResponse);
-            //add key to cachedUrls set
-            this.cachedUrls.add(cacheKey);
+            //add key to cachedRequests set
+            this.cachedRequests.add(cacheKey);
           });
         });
       }
@@ -122,8 +203,8 @@ module.exports = function BvFetch ({ shouldCache, cacheName, cacheLimit }) {
     * @throws {Error} Throws an error if there's any problem fetching from cache.
   */
   this.fetchFromCache = (cacheKey) => {
-    // Check if the URL is in the set of cached URLs
-    if (!this.cachedUrls.has(cacheKey)) {
+    // Check if the URL is in the set of cached requests set
+    if (!isRequestInSet(this.cachedRequests, cacheKey)) {
       return Promise.resolve(null);
     }
 
@@ -133,7 +214,7 @@ module.exports = function BvFetch ({ shouldCache, cacheName, cacheLimit }) {
         return cache.match(cacheKey)
           .then((cachedResponse) => {
             if (!cachedResponse) {
-              this.cachedUrls.delete(cacheKey)
+              this.cachedRequests.delete(cacheKey)
               return Promise.resolve(null);
             }         
             const cachedTime = cachedResponse.headers.get('X-Bazaarvoice-Cached-Time');
@@ -162,11 +243,11 @@ module.exports = function BvFetch ({ shouldCache, cacheName, cacheLimit }) {
 
     const cacheKey = this.generateCacheKey(url, options);
   // If an ongoing fetch promise exists for the URL, return it
-    if (this.fetchPromises.has(cacheKey)) {
-      return this.fetchPromises.get(cacheKey).then(res => res.clone());
+    if (this.fetchPromises.has(this.serializeRequestKey(cacheKey))) {
+      return this.fetchPromises.get(this.serializeRequestKey(cacheKey)).then(res => res.clone());
     }
 
-  // Check if response is available in cache
+    // Check if response is available in cache
     const newPromise = this.fetchFromCache(cacheKey)
       .then((cachedResponse) => {
           // If response found in cache, return it
@@ -178,14 +259,14 @@ module.exports = function BvFetch ({ shouldCache, cacheName, cacheLimit }) {
       });
 
     // Store the ongoing fetch promise
-    this.fetchPromises.set(cacheKey, newPromise);
+    this.fetchPromises.set(this.serializeRequestKey(cacheKey), newPromise);
 
     //initiate cache cleanUp
     this.debounceCleanupExpiredCache();
 
     // When fetch completes or fails, remove the promise from the store
     newPromise.finally(() => {
-      this.fetchPromises.delete(cacheKey);
+      this.fetchPromises.delete(this.serializeRequestKey(cacheKey));
     });
 
     return newPromise.then(res => res.clone());
@@ -218,7 +299,7 @@ module.exports = function BvFetch ({ shouldCache, cacheName, cacheLimit }) {
             const cacheAge = (currentTimestamp - cachedTime) / 1000;
             if (cacheAge >= ttl) {
               cache.delete(key);
-              this.cachedUrls.delete(key);
+              this.cachedRequests.delete(key);
             }
           });
         });
@@ -266,7 +347,7 @@ module.exports = function BvFetch ({ shouldCache, cacheName, cacheLimit }) {
               cacheEntries.forEach(entry => {
                 if (currentSize > this.cacheLimit) {
                   cache.delete(entry.key);
-                  this.cachedUrls.delete(entry.key);
+                  this.cachedRequests.delete(entry.key);
                   currentSize -= entry.size;
                 }
               });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bv-ui-core",
-  "version": "2.9.6",
+  "version": "2.9.8",
   "license": "Apache 2.0",
   "description": "Bazaarvoice UI-related JavaScript",
   "repository": {

package/test/unit/bvFetch/index.spec.js

@@ -38,16 +38,27 @@ describe('BvFetch', function () {
   
   it('should generate correct cache key', function () {
     const url = 'https://jsonplaceholder.typicode.com/todos';
-    const options = {};
-    const expectedKey = 'https://jsonplaceholder.typicode.com/todos';
+    const options = {
+      method: 'GET',
+      headers: {
+        'X-Header-1': 'Value 1',
+      }
+    };
+    const expectedKey = new Request(url, options)
     const generatedKey = bvFetchInstance.generateCacheKey(url, options);
-    expect(generatedKey).to.equal(expectedKey);
+    expect(generatedKey.url).to.equal(expectedKey.url);
+    expect(generatedKey.headers).to.deep.equal(expectedKey.headers);
   });
 
   
   it('should fetch from cache when the response is cached', function (done) {
     const url = 'https://jsonplaceholder.typicode.com/todos';
-    const options = {};
+    const options = {
+      method: 'GET',
+      headers: {
+        'X-Header-1': 'Value 1',
+      }
+    };
   
     // Mocking cache response
     const mockResponse = new Response('Mock Data', {
@@ -64,7 +75,8 @@ describe('BvFetch', function () {
     // Overriding the stub for this specific test case
     caches.open.resolves({
       match: (key) => {
-        expect(key).to.equal(cacheKey); 
+        expect(key.url).to.equal(cacheKey.url); 
+        expect(key.headers).to.deep.equal(cacheKey.headers);
         return Promise.resolve(mockResponse)
       },
       put: (key, response) => {
@@ -74,7 +86,7 @@ describe('BvFetch', function () {
     });
   
     // Simulate that the response is cached
-    bvFetchInstance.cachedUrls.add(cacheKey);
+    bvFetchInstance.cachedRequests.add(cacheKey);
     
     // Call the function under test
     bvFetchInstance.bvFetchFunc(url, options)