Added a new 'evaluateRequest(req)' method that is able to support SWR

The implementation of 'satisfiesWithoutRevalidation(req)' using 'evaluateRequest(req)' is trivial.

Author: Steven Goossens

index.js

@@ -225,6 +225,36 @@ module.exports = class CachePolicy {
     }
 
     satisfiesWithoutRevalidation(req) {
+        const result = this.evaluateRequest(req)
+        return !result.revalidation;
+    }
+
+    _evaluateRequestHitResult(stale = false, revalidation = undefined) {
+        return {
+            response: {
+                headers: this.responseHeaders(),
+                stale,
+            },
+            revalidation,
+        }
+    }
+
+    _evaluateRequestRevalidation(request, synchronous= true) {
+        return {
+            synchronous,
+            request: {
+                headers: this.revalidationHeaders(request),
+            },
+        };
+    }
+
+    _evaluateRequestMissResult(request) {
+        return {
+            revalidation: this._evaluateRequestRevalidation(request),
+        }
+    }
+
+    evaluateRequest(req) {
         this._assertRequestHasHeaders(req);
 
         // In all circumstances, a cache MUST NOT ignore the must-revalidate directive
@@ -240,21 +270,24 @@ module.exports = class CachePolicy {
         // the presented request does not contain the no-cache pragma (Section 5.4), nor the no-cache cache directive,
         // unless the stored response is successfully validated (Section 4.3), and
         const requestCC = parseCacheControl(req.headers['cache-control']);
+
         if (requestCC['no-cache'] || /no-cache/.test(req.headers.pragma)) {
-            return false;
+            return this._evaluateRequestMissResult(req);
         }
 
         if (requestCC['max-age'] && this.age() > requestCC['max-age']) {
-            return false;
+            return this._evaluateRequestMissResult(req);
         }
 
         if (requestCC['min-fresh'] && this.maxAge() - this.age() < toNumberOrZero(requestCC['min-fresh'])) {
-            return false;
+            return this._evaluateRequestMissResult(req);
         }
 
         // the stored response is either:
         // fresh, or allowed to be served stale
-        if (this.stale()) {
+        let revalidation;
+        const stale = this.stale();
+        if (stale) {
             let allowsStale = false;
             if (requestCC['max-stale'] && !this._rescc['must-revalidate']) {
                 if (requestCC['max-stale'] === true || requestCC['max-stale'] > this.age() - this.maxAge()) {
@@ -263,15 +296,16 @@ module.exports = class CachePolicy {
             // Allow stale-while-revalidate queries to be served stale
             // even if must-revalidate is set as the revalidation should be happening in the background
             } else if (this.useStaleWhileRevalidate()) {
+                revalidation = this._evaluateRequestRevalidation(req, false);
                 allowsStale = true;
             }
 
             if (!allowsStale) {
-                return false;
+                return this._evaluateRequestMissResult(req);
             }
         }
 
-        return true;
+        return this._evaluateRequestHitResult(stale, revalidation);
     }
 
     _requestMatches(req, allowHeadMethod) {

test/okhttptest.js

@@ -210,7 +210,7 @@ describe('okhttp tests', function() {
         assert.equal(cache.timeToLive(), 260000);
     });
 
-    it('stale-while-revalidate satisfies when stale', function() {
+    it('stale-while-revalidate does not satisfy when stale because it requires revalidation', function() {
         const cache = new CachePolicy(
             { headers: {} },
             {
@@ -224,10 +224,10 @@ describe('okhttp tests', function() {
 
         assert(cache.stale());
         assert(cache.useStaleWhileRevalidate());
-        assert(cache.satisfiesWithoutRevalidation({ headers: {} }));
+        assert(!cache.satisfiesWithoutRevalidation({ headers: {} }));
     });
 
-    it('stale-while-revalidate satisfies when stale and must-revalidate', function() {
+    it('stale-while-revalidate does not satisfy when stale and must-revalidate because it requires revalidation', function() {
         const cache = new CachePolicy(
             { headers: {} },
             {
@@ -240,7 +240,7 @@ describe('okhttp tests', function() {
         );
 
         assert(cache.stale());
-        assert(cache.satisfiesWithoutRevalidation({ headers: {} }));
+        assert(!cache.satisfiesWithoutRevalidation({ headers: {} }));
     });
 
     it('stale-while-revalidate work with max-stale', function() {