@tramvai/module-page-render-mode 7.5.3 → 7.7.0

package/lib/staticPages/staticPagesService.js

@@ -2,72 +2,115 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-// It is critical to ignore cached Set-Cookie header and use fresh one from current request
-// COMMAND_LINE_EXECUTION_END_TOKEN with fresh server timings will not works for responses from cache
-const HEADERS_BLACKLIST = ['Set-Cookie', 'server-timing'];
+var cacheKey = require('../utils/cacheKey.js');
+
+// `Location` is required for 3xx responses
+const DEFAULT_HEADERS_WHITELIST = ['Location', 'Content-Type', 'Content-Length', 'X-App-Id'];
 class StaticPagesService {
     key;
-    path;
+    pathname;
+    cacheKey;
     port;
-    deviceType;
     responseManager;
+    requestManager;
     response;
     log;
     cache;
+    fsCache;
+    fsCacheEnabled;
     modifyCache;
     backgroundFetchService;
     options;
     cache5xxResponse;
+    cacheControlFactory;
     shouldUseCache;
-    constructor({ getCacheKey, requestManager, response, responseManager, environmentManager, userAgent, logger, cache, modifyCache, shouldUseCache, backgroundFetchService, options, cache5xxResponse, }) {
-        this.key = getCacheKey();
-        this.path = requestManager.getParsedUrl().pathname;
+    constructor({ staticPagesKey, requestManager, response, responseManager, environmentManager, logger, cache, fsCache, fsCacheEnabled, modifyCache, shouldUseCache, backgroundFetchService, options, cache5xxResponse, cacheControlFactory, }) {
+        this.key = staticPagesKey();
+        this.pathname = requestManager.getParsedUrl().pathname;
+        this.cacheKey = cacheKey.getCacheKey({ pathname: this.pathname, key: this.key });
         this.port = environmentManager.get('PORT');
-        this.deviceType = userAgent.mobileOS ? 'mobile' : 'desktop';
         this.log = logger('static-pages');
         this.responseManager = responseManager;
+        this.requestManager = requestManager;
         this.response = response;
         this.cache = cache;
+        this.fsCacheEnabled = fsCacheEnabled();
+        this.fsCache = fsCache;
         this.modifyCache = modifyCache;
         this.shouldUseCache = () => shouldUseCache.every((fn) => fn());
         this.backgroundFetchService = backgroundFetchService;
         this.options = options;
         this.cache5xxResponse = cache5xxResponse;
+        this.cacheControlFactory = cacheControlFactory;
     }
-    respond(onSuccess) {
+    async respond(onSuccess) {
         if (!this.hasCache()) {
             this.log.debug({
                 event: 'no-cache',
-                key: this.key,
+                cacheKey: this.cacheKey,
             });
+            setTimeout(() => {
+                // async revalidation, response is not delayed
+                this.revalidate();
+            }, 1).unref();
             return;
         }
-        let cacheEntry = this.getCache();
+        let cacheEntry = await this.getCache();
         if (Array.isArray(this.modifyCache)) {
             cacheEntry = this.modifyCache.reduce((result, modifier) => {
                 return modifier(result);
             }, cacheEntry);
         }
-        const { status, headers, body } = cacheEntry;
+        const { ttl, allowStale } = this.options;
+        const { status, headers, body, source, updatedAt } = cacheEntry;
         const isOutdated = this.cacheOutdated(cacheEntry);
-        const currentHeaders = this.responseManager.getHeaders();
-        if (!isOutdated) {
+        if (!this.cache5xxResponse() && status >= 500) {
+            this.log.debug({
+                event: 'cache-5xx',
+                cacheKey: this.cacheKey,
+                status,
+            });
+            setTimeout(() => {
+                // it is possible that 5xx response is generated while "tramvai static" command,
+                // we can just remove it when `STATIC_PAGES_CACHE_5xx_RESPONSE` is disabled
+                // async revalidation, response is not delayed
+                this.revalidate();
+            }, 1).unref();
+            return;
+        }
+        const isStale = isOutdated && allowStale;
+        if (!isOutdated || isStale) {
             this.log.debug({
                 event: 'cache-hit',
-                key: this.key,
+                cacheKey: this.cacheKey,
+                stale: isStale,
             });
-            HEADERS_BLACKLIST.forEach((header) => {
+            if (isStale) {
+                setTimeout(() => {
+                    // async revalidation, response is not delayed
+                    this.revalidate();
+                }, 1).unref();
+            }
+            const allowedHeaders = {};
+            this.options.allowedHeaders.concat(DEFAULT_HEADERS_WHITELIST).forEach((header) => {
+                const lowercaseHeader = header.toLowerCase();
                 if (headers[header]) {
-                    delete headers[header];
+                    allowedHeaders[header] = headers[header];
                 }
-                if (currentHeaders[header]) {
-                    headers[header] = currentHeaders[header];
+                else if (headers[lowercaseHeader]) {
+                    allowedHeaders[lowercaseHeader] = headers[lowercaseHeader];
                 }
             });
             this.response
+                .headers(allowedHeaders)
                 .header('content-type', 'text/html')
+                .header('cache-control', this.cacheControlFactory({ ttl, updatedAt }))
+                // Vary header is required for correct cache behavior in CDNs and browsers,
+                // it indicates that response may vary based on `X-Tramvai-Static-Page-Key` header
+                .header('Vary', 'X-Tramvai-Static-Page-Key')
+                .header('X-Tramvai-Static-Page-Key', this.key)
                 .header('X-Tramvai-Static-Page-From-Cache', 'true')
-                .headers(headers)
+                .header('X-Tramvai-Static-Page-Cache-Source', source)
                 .status(status)
                 .send(body);
             onSuccess();
@@ -75,8 +118,12 @@ class StaticPagesService {
         else {
             this.log.debug({
                 event: 'cache-outdated',
-                key: this.key,
+                cacheKey: this.cacheKey,
             });
+            setTimeout(() => {
+                // async revalidation, response is not delayed
+                this.revalidate();
+            }, 1).unref();
         }
     }
     async revalidate() {
@@ -84,18 +131,28 @@ class StaticPagesService {
             return;
         }
         if (this.hasCache()) {
-            const cacheEntry = this.getCache();
+            const cacheEntry = await this.getCache();
             const isOutdated = this.cacheOutdated(cacheEntry);
             if (!isOutdated) {
                 return;
             }
         }
+        const incomingHeaders = this.requestManager.getHeaders();
+        const revalidateHeaders = {};
+        this.options.allowedHeaders.concat(DEFAULT_HEADERS_WHITELIST).forEach((header) => {
+            const lowercaseHeader = header.toLowerCase();
+            if (incomingHeaders[header]) {
+                revalidateHeaders[header] = incomingHeaders[header];
+            }
+            else if (incomingHeaders[lowercaseHeader]) {
+                revalidateHeaders[lowercaseHeader] = incomingHeaders[lowercaseHeader];
+            }
+        });
         await this.backgroundFetchService
             .revalidate({
-            key: this.key,
-            path: this.path,
-            port: this.port,
-            deviceType: this.deviceType,
+            cacheKey: this.cacheKey,
+            pathname: this.pathname,
+            headers: revalidateHeaders,
         })
             .then((response) => {
             if (!response) {
@@ -104,31 +161,59 @@ class StaticPagesService {
             if (!this.cache5xxResponse() && response.status >= 500) {
                 this.log.debug({
                     event: 'cache-set-5xx',
-                    key: this.key,
+                    cacheKey: this.cacheKey,
                 });
                 return;
             }
-            this.setCache(response);
+            const cachedHeaders = {};
+            const responseHeaders = response.headers;
+            this.options.allowedHeaders.concat(DEFAULT_HEADERS_WHITELIST).forEach((header) => {
+                const lowercaseHeader = header.toLowerCase();
+                if (responseHeaders[header]) {
+                    cachedHeaders[header] = responseHeaders[header];
+                }
+                else if (responseHeaders[lowercaseHeader]) {
+                    cachedHeaders[lowercaseHeader] = responseHeaders[lowercaseHeader];
+                }
+            });
+            return this.setCache({ ...response, headers: cachedHeaders });
         });
     }
     hasCache() {
-        return this.cache.has(this.path) && this.cache.get(this.path).has(this.key);
+        let result = this.cache.has(this.cacheKey);
+        if (!result && this.fsCacheEnabled) {
+            result = this.fsCache.has(this.cacheKey);
+        }
+        return result;
     }
-    getCache() {
-        return this.cache.get(this.path).get(this.key);
+    async getCache() {
+        let result = this.cache.get(this.cacheKey);
+        // update item recency in FS-cache
+        if (result && this.fsCacheEnabled) {
+            this.fsCache.moveToHead(this.cacheKey);
+        }
+        if (!result && this.fsCacheEnabled) {
+            result = await this.fsCache.get(this.cacheKey);
+            // always fill memory cache
+            if (result) {
+                this.cache.set(this.cacheKey, { ...result, source: 'memory' });
+            }
+        }
+        return result;
     }
-    setCache(cacheEntry) {
+    async setCache(cacheEntry) {
         this.log.debug({
             event: 'cache-set',
-            key: this.key,
+            cacheKey: this.cacheKey,
         });
-        if (!this.cache.has(this.path)) {
-            this.cache.set(this.path, new Map());
-        }
-        this.cache.get(this.path).set(this.key, {
+        const entry = {
             ...cacheEntry,
             updatedAt: Date.now(),
-        });
+        };
+        this.cache.set(this.cacheKey, { ...entry, source: 'memory' });
+        if (this.fsCacheEnabled) {
+            await this.fsCache.set(this.cacheKey, { ...entry, source: 'fs' });
+        }
     }
     cacheOutdated(cacheEntry) {
         const { ttl } = this.options;