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

package/lib/staticPages/fileSystemCache.js

@@ -0,0 +1,376 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var node_fs = require('node:fs');
+var path = require('node:path');
+var pLimit = require('p-limit');
+var core = require('@tramvai/core');
+var cacheKey = require('../utils/cacheKey.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+var pLimit__default = /*#__PURE__*/_interopDefaultLegacy(pLimit);
+
+class FileSystemCache {
+    directory;
+    maxSize;
+    ttl;
+    allowStale;
+    log;
+    cache;
+    list;
+    // save double linked list nodes for O(1) access when moving nodes
+    nodes;
+    staticPages;
+    metrics;
+    limit = pLimit__default["default"](8);
+    constructor({ directory, maxSize, ttl, allowStale, logger, metrics, }) {
+        this.directory = directory;
+        this.maxSize = maxSize;
+        this.ttl = ttl;
+        this.allowStale = allowStale;
+        this.log = logger('static-pages:fs-cache');
+        this.cache = new Map();
+        this.list = new core.DoubleLinkedList();
+        this.nodes = new Map();
+        this.staticPages = [];
+        this.metrics = metrics;
+    }
+    async init() {
+        this.log.info({
+            event: 'init-start',
+            directory: this.directory,
+        });
+        try {
+            await this.scanDirectory();
+            this.log.info({
+                event: 'init-complete',
+                size: this.cache.size,
+                totalBytes: this.getTotalBytes(),
+            });
+            this.updateMetrics();
+        }
+        catch (error) {
+            if (process.env.NODE_ENV === 'development' && error?.code === 'ENOENT') {
+                // in development mode, static directory path includes unique build id and can be missing on first run, so just create it
+                await node_fs.promises.mkdir(this.directory, { recursive: true });
+            }
+            else {
+                this.log.warn({
+                    event: 'init-error',
+                    message: error?.code === 'ENOENT'
+                        ? `"${this.directory}" directory is not found. To effectively use file system cache, run "tramvai static {appName} --buildType=none" after application build,
+and copy "dist/static" folder into the Docker image, to ensure the pages cache is populated on the first run.`
+                        : 'Failed to initialize file system cache',
+                    error: error,
+                });
+            }
+        }
+    }
+    // eslint-disable-next-line max-statements
+    async get(cacheKey) {
+        const metadata = this.cache.get(cacheKey);
+        if (!metadata) {
+            this.metrics.miss.inc();
+            this.log.debug({
+                event: 'get-miss',
+                cacheKey,
+            });
+            return;
+        }
+        const isStale = Date.now() - metadata.mtime > this.ttl;
+        if (isStale && !this.allowStale) {
+            this.log.debug({
+                event: 'get-miss',
+                stale: true,
+                cacheKey,
+            });
+            this.metrics.miss.inc();
+            return;
+        }
+        // TODO: race condition protection, lock file or just return null?
+        try {
+            const html = await node_fs.promises.readFile(metadata.filePath, 'utf-8');
+            const response = JSON.parse(await node_fs.promises.readFile(metadata.filePath.replace(/\.html$/, '.json'), 'utf-8'));
+            // async cleanup stale entry, don't block response
+            if (isStale) {
+                setTimeout(() => {
+                    this.log.debug({
+                        event: 'delete-stale',
+                        cacheKey,
+                    });
+                    // eslint-disable-next-line @typescript-eslint/no-shadow
+                    const metadata = this.cache.get(cacheKey);
+                    if (metadata) {
+                        // eslint-disable-next-line @typescript-eslint/no-shadow
+                        const isStale = Date.now() - metadata.mtime > this.ttl;
+                        // prevent to delete entry if it was updated while timeout was waiting
+                        if (isStale) {
+                            this.delete(cacheKey);
+                        }
+                    }
+                }, 1).unref();
+            }
+            this.log.debug({
+                event: 'get-hit',
+                cacheKey,
+            });
+            this.metrics.hit.inc();
+            this.moveToHead(metadata.cacheKey);
+            return {
+                body: html,
+                updatedAt: metadata.mtime,
+                headers: response.headers,
+                status: response.status,
+                source: 'fs',
+            };
+        }
+        catch (error) {
+            this.log.warn({
+                event: 'get-error',
+                cacheKey,
+                error: error,
+            });
+            // if file is missing or corrupted, remove from cache
+            setTimeout(() => {
+                this.log.debug({
+                    event: 'delete-broken',
+                    cacheKey,
+                });
+                this.delete(cacheKey);
+            }, 1).unref();
+        }
+    }
+    async set(cacheKey$1, cacheEntry) {
+        this.log.debug({
+            event: 'set-start',
+            cacheKey: cacheKey$1,
+        });
+        const [pathname, key] = cacheKey.parseCacheKey(cacheKey$1);
+        const filename = key ? `index.${key}.html` : 'index.html';
+        const metaFilename = key ? `index.${key}.json` : 'index.json';
+        const filePath = path__default["default"].join(this.directory, pathname, filename);
+        const metaFilePath = path__default["default"].join(this.directory, pathname, metaFilename);
+        try {
+            await node_fs.promises.mkdir(path__default["default"].dirname(filePath), { recursive: true });
+            await node_fs.promises.writeFile(filePath, cacheEntry.body, 'utf-8');
+            await node_fs.promises.writeFile(metaFilePath, JSON.stringify({
+                headers: cacheEntry.headers,
+                status: cacheEntry.status,
+            }, null, 2), 'utf-8');
+            const metadata = {
+                filePath,
+                pathname,
+                key,
+                cacheKey: cacheKey$1,
+                size: Buffer.byteLength(cacheEntry.body, 'utf-8'),
+                mtime: cacheEntry.updatedAt,
+            };
+            this.cache.set(cacheKey$1, metadata);
+            this.moveToHead(metadata.cacheKey);
+            this.updateMetrics();
+            if (this.cache.size > this.maxSize) {
+                setTimeout(() => {
+                    this.evictTail();
+                }, 1).unref();
+            }
+            this.log.debug({
+                event: 'set-success',
+                cacheKey: cacheKey$1,
+            });
+        }
+        catch (error) {
+            this.log.warn({
+                event: 'set-error',
+                cacheKey: cacheKey$1,
+                error: error,
+            });
+        }
+    }
+    has(cacheKey) {
+        if (!this.cache.has(cacheKey)) {
+            return false;
+        }
+        const metadata = this.cache.get(cacheKey);
+        const isStale = Date.now() - metadata.mtime > this.ttl;
+        if (isStale && !this.allowStale) {
+            return false;
+        }
+        return true;
+    }
+    async delete(cacheKey) {
+        const metadata = this.cache.get(cacheKey);
+        if (!metadata) {
+            return false;
+        }
+        this.log.debug({
+            event: 'delete-start',
+            filePath: metadata.filePath,
+        });
+        const node = this.nodes.get(cacheKey);
+        this.cache.delete(cacheKey);
+        this.removeNode(node);
+        this.updateMetrics();
+        try {
+            await node_fs.promises.unlink(metadata.filePath);
+            await node_fs.promises.unlink(metadata.filePath.replace(/\.html$/, '.json'));
+            this.log.debug({
+                event: 'delete-success',
+                filePath: metadata.filePath,
+            });
+        }
+        catch (error) {
+            this.log.debug({
+                event: 'delete-error',
+                filePath: metadata.filePath,
+                error: error,
+            });
+        }
+        return true;
+    }
+    async clear() {
+        this.log.debug({
+            event: 'clear-start',
+        });
+        await Promise.allSettled(Array.from(this.cache.keys()).map((cacheKey) => {
+            return this.limit(() => this.delete(cacheKey));
+        }));
+        this.log.debug({
+            event: 'clear-success',
+        });
+        this.updateMetrics();
+    }
+    get size() {
+        return this.cache.size;
+    }
+    dump() {
+        return Array.from(this.cache.entries());
+    }
+    async scanDirectory() {
+        try {
+            this.log.debug({
+                event: 'meta-read-start',
+            });
+            const meta = await node_fs.promises.readFile(path__default["default"].join(this.directory, 'meta.json'), 'utf-8');
+            this.staticPages = JSON.parse(meta).staticPages;
+            this.log.debug({
+                event: 'meta-read-success',
+                staticPages: this.staticPages,
+            });
+        }
+        catch (error) {
+            if (process.env.NODE_ENV !== 'development') {
+                this.log.warn({
+                    event: 'meta-read-error',
+                    error: error,
+                });
+            }
+        }
+        const entries = await node_fs.promises.readdir(this.directory, { withFileTypes: true, recursive: true });
+        const promises = [];
+        let pages = entries.filter((entry) => entry.isFile() && entry.name.endsWith('.html'));
+        if (pages.length > this.maxSize) {
+            this.log.info({
+                event: 'too-many-pages-prerendered',
+                pagesCount: pages.length,
+            });
+            pages = pages.slice(0, this.maxSize);
+        }
+        for (const entry of pages) {
+            const fullPath = path__default["default"].join(entry.parentPath, entry.name);
+            promises.push(this.limit(() => this.addFileToCache(fullPath)));
+        }
+        await Promise.all(promises);
+    }
+    async addFileToCache(filePath) {
+        try {
+            const stats = await node_fs.promises.stat(filePath);
+            const relativePath = path__default["default"].relative(this.directory, filePath);
+            // foo/index.html -> 'index'
+            // foo/index.mobile.html -> 'index.mobile'
+            const filename = path__default["default"].basename(filePath, '.html');
+            // index -> ['index', '']
+            // index.mobile -> ['index', 'mobile']
+            const [, key = ''] = filename.split('.');
+            // index.html -> '/'
+            // foo/bar/index.html -> '/foo/bar/'
+            // foo/bar/index.mobile.html -> '/foo/bar/'
+            const pathname = path__default["default"].join('/', relativePath.replace(path__default["default"].basename(relativePath), ''), '/');
+            const cacheKey$1 = cacheKey.getCacheKey({ pathname, key });
+            const metadata = {
+                filePath,
+                pathname,
+                key,
+                cacheKey: cacheKey$1,
+                size: stats.size,
+                // TODO: if file already stale on init, what to do?
+                mtime: stats.mtimeMs,
+            };
+            this.cache.set(cacheKey$1, metadata);
+            // order doesn't matter when initializing
+            const node = this.list.push(cacheKey$1);
+            this.nodes.set(cacheKey$1, node);
+        }
+        catch (error) {
+            this.log.warn({
+                event: 'process-file-error',
+                filePath,
+                error: error,
+            });
+        }
+    }
+    moveToHead(cacheKey) {
+        if (this.list.start?.value === cacheKey) {
+            return;
+        }
+        const currentNode = this.nodes.get(cacheKey);
+        if (currentNode) {
+            this.removeNode(currentNode);
+        }
+        const node = this.list.unshift(cacheKey);
+        this.nodes.set(cacheKey, node);
+    }
+    removeNode(node) {
+        if (this.list.start?.value === node.value) {
+            this.list.start = node.next;
+        }
+        if (this.list.end?.value === node.value) {
+            this.list.end = node.prev;
+        }
+        if (node.prev) {
+            node.prev.next = node.next;
+        }
+        if (node.next) {
+            node.next.prev = node.prev;
+        }
+        this.list.length--;
+        this.nodes.delete(node.value);
+    }
+    async evictTail() {
+        if (!this.list.end) {
+            return;
+        }
+        const node = this.list.end;
+        const cacheKey = node.value;
+        this.log.debug({
+            event: 'evict',
+            cacheKey,
+        });
+        await this.delete(cacheKey);
+    }
+    getTotalBytes() {
+        let total = 0;
+        for (const metadata of this.cache.values()) {
+            total += metadata.size;
+        }
+        return total;
+    }
+    updateMetrics() {
+        this.metrics.size.set(this.cache.size);
+        this.metrics.bytes.set(this.getTotalBytes());
+    }
+}
+
+exports.FileSystemCache = FileSystemCache;

package/lib/staticPages/staticPagesService.d.ts

@@ -1,9 +1,9 @@
 import type { ExtractDependencyType } from '@tinkoff/dippy';
-import type { USER_AGENT_TOKEN } from '@tramvai/module-client-hints';
 import type { ENV_MANAGER_TOKEN, LOGGER_TOKEN, REQUEST_MANAGER_TOKEN, RESPONSE_MANAGER_TOKEN } from '@tramvai/tokens-common';
 import type { FASTIFY_RESPONSE } from '@tramvai/tokens-server-private';
-import type { STATIC_PAGES_BACKGROUND_FETCH_SERVICE, STATIC_PAGES_GET_CACHE_KEY_TOKEN } from '../staticPages';
-import type { STATIC_PAGES_SHOULD_USE_CACHE, STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_CACHE_5xx_RESPONSE } from '../tokens';
+import type { STATIC_PAGES_BACKGROUND_FETCH_SERVICE } from '../private-tokens';
+import type { STATIC_PAGES_SHOULD_USE_CACHE, STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_CACHE_5xx_RESPONSE, STATIC_PAGES_KEY_TOKEN, STATIC_PAGES_FS_CACHE_ENABLED, STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN } from '../tokens';
+import type { FileSystemCache } from './fileSystemCache';
 type ResponseManager = ExtractDependencyType<typeof RESPONSE_MANAGER_TOKEN>;
 type Response = ExtractDependencyType<typeof FASTIFY_RESPONSE>;
 type Logger = ExtractDependencyType<typeof LOGGER_TOKEN>;
@@ -13,36 +13,43 @@ type Cache = ExtractDependencyType<typeof STATIC_PAGES_CACHE_TOKEN>;
 type ModifyCache = ExtractDependencyType<typeof STATIC_PAGES_MODIFY_CACHE> | null;
 type Options = ExtractDependencyType<typeof STATIC_PAGES_OPTIONS_TOKEN>;
 type Cache5xxResponse = ExtractDependencyType<typeof STATIC_PAGES_CACHE_5xx_RESPONSE>;
+type CacheControlFactory = ExtractDependencyType<typeof STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN>;
 export declare class StaticPagesService {
     readonly key: string;
-    readonly path: string;
+    readonly pathname: string;
+    readonly cacheKey: string;
     readonly port: string;
-    readonly deviceType: string;
     private responseManager;
+    private requestManager;
     private response;
     private log;
     private cache;
+    private fsCache;
+    private fsCacheEnabled;
     private modifyCache;
     private backgroundFetchService;
     private options;
     private cache5xxResponse;
+    private cacheControlFactory;
     shouldUseCache: () => boolean;
-    constructor({ getCacheKey, requestManager, response, responseManager, environmentManager, userAgent, logger, cache, modifyCache, shouldUseCache, backgroundFetchService, options, cache5xxResponse, }: {
-        getCacheKey: ExtractDependencyType<typeof STATIC_PAGES_GET_CACHE_KEY_TOKEN>;
+    constructor({ staticPagesKey, requestManager, response, responseManager, environmentManager, logger, cache, fsCache, fsCacheEnabled, modifyCache, shouldUseCache, backgroundFetchService, options, cache5xxResponse, cacheControlFactory, }: {
+        staticPagesKey: ExtractDependencyType<typeof STATIC_PAGES_KEY_TOKEN>;
         requestManager: ExtractDependencyType<typeof REQUEST_MANAGER_TOKEN>;
         responseManager: ResponseManager;
         response: Response;
         environmentManager: ExtractDependencyType<typeof ENV_MANAGER_TOKEN>;
-        userAgent: ExtractDependencyType<typeof USER_AGENT_TOKEN>;
         logger: Logger;
         cache: Cache;
+        fsCache: FileSystemCache | null;
+        fsCacheEnabled: ExtractDependencyType<typeof STATIC_PAGES_FS_CACHE_ENABLED>;
         modifyCache: ModifyCache;
         shouldUseCache: ShouldUseCache;
         backgroundFetchService: BackgroundFetchService;
         options: Options;
         cache5xxResponse: Cache5xxResponse;
+        cacheControlFactory: CacheControlFactory;
     });
-    respond(onSuccess: () => void): void;
+    respond(onSuccess: () => void): Promise<void>;
     revalidate(): Promise<void>;
     private hasCache;
     private getCache;

package/lib/staticPages/staticPagesService.es.js

@@ -1,69 +1,112 @@
-// 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'];
+import { getCacheKey } from '../utils/cacheKey.es.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 = 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();
@@ -71,8 +114,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() {
@@ -80,18 +127,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) {
@@ -100,31 +157,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;