@tramvai/module-page-render-mode 2.70.0 → 2.72.0

package/lib/shared.es.js

@@ -0,0 +1,39 @@
+import { LAYOUT_OPTIONS, TRAMVAI_RENDER_MODE } from '@tramvai/tokens-render';
+import { pageRenderHOC } from './PageRenderWrapper.es.js';
+import { PAGE_RENDER_WRAPPER_TYPE, PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_DEFAULT_MODE } from './tokens.es.js';
+
+const sharedProviders = [
+    {
+        provide: LAYOUT_OPTIONS,
+        multi: true,
+        useFactory: ({ wrapperType }) => {
+            return {
+                wrappers: {
+                    [wrapperType]: pageRenderHOC,
+                },
+            };
+        },
+        deps: {
+            wrapperType: PAGE_RENDER_WRAPPER_TYPE,
+        },
+    },
+    {
+        provide: PAGE_RENDER_FALLBACK_COMPONENT_PREFIX,
+        useValue: 'pageRenderFallback',
+    },
+    {
+        provide: PAGE_RENDER_DEFAULT_MODE,
+        useFactory: ({ tramvaiRenderMode }) => {
+            return tramvaiRenderMode;
+        },
+        deps: {
+            tramvaiRenderMode: TRAMVAI_RENDER_MODE,
+        },
+    },
+    {
+        provide: PAGE_RENDER_WRAPPER_TYPE,
+        useValue: 'page',
+    },
+];
+
+export { sharedProviders };

package/lib/shared.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tokensRender = require('@tramvai/tokens-render');
+var PageRenderWrapper = require('./PageRenderWrapper.js');
+var tokens = require('./tokens.js');
+
+const sharedProviders = [
+    {
+        provide: tokensRender.LAYOUT_OPTIONS,
+        multi: true,
+        useFactory: ({ wrapperType }) => {
+            return {
+                wrappers: {
+                    [wrapperType]: PageRenderWrapper.pageRenderHOC,
+                },
+            };
+        },
+        deps: {
+            wrapperType: tokens.PAGE_RENDER_WRAPPER_TYPE,
+        },
+    },
+    {
+        provide: tokens.PAGE_RENDER_FALLBACK_COMPONENT_PREFIX,
+        useValue: 'pageRenderFallback',
+    },
+    {
+        provide: tokens.PAGE_RENDER_DEFAULT_MODE,
+        useFactory: ({ tramvaiRenderMode }) => {
+            return tramvaiRenderMode;
+        },
+        deps: {
+            tramvaiRenderMode: tokensRender.TRAMVAI_RENDER_MODE,
+        },
+    },
+    {
+        provide: tokens.PAGE_RENDER_WRAPPER_TYPE,
+        useValue: 'page',
+    },
+];
+
+exports.sharedProviders = sharedProviders;

package/lib/staticPages/backgroundFetchService.es.js

@@ -0,0 +1,73 @@
+import fetch from 'node-fetch';
+import { format } from '@tinkoff/url';
+
+const userAgentByDeviceType = {
+    /** Chrome on Mobile */
+    'mobile-modern': 'Mozilla/5.0 (Linux; Android 7.0; SM-G930V Build/NRD90M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.3071.125 Mobile Safari/537.36',
+    /** Old Chrome on Mobile */
+    'mobile-default': 'Mozilla/5.0 (Linux; Android 7.0; SM-G930V Build/NRD90M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.3071.125 Mobile Safari/537.36',
+    /** Chrome on Mac OS */
+    'desktop-modern': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.3987.87 Safari/537.36',
+    /** Old Chrome on Mac OS */
+    'desktop-default': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.3987.87 Safari/537.36',
+};
+class BackgroundFetchService {
+    constructor({ logger, backgroundFetchEnabled, }) {
+        this.requests = new Set();
+        this.log = logger('static-pages');
+        this.backgroundFetchEnabled = backgroundFetchEnabled;
+    }
+    enabled() {
+        return this.backgroundFetchEnabled();
+    }
+    async revalidate({ key, path, port, deviceType, modern, }) {
+        if (this.requests.has(key)) {
+            return;
+        }
+        const revalidateUrl = format({
+            hostname: 'localhost',
+            port,
+            path,
+        });
+        this.requests.add(key);
+        this.log.debug({
+            event: 'background-fetch-init',
+            key,
+            revalidateUrl,
+        });
+        return fetch(revalidateUrl, {
+            headers: {
+                'User-Agent': userAgentByDeviceType[`${deviceType}-${modern}`],
+                'X-Tramvai-Static-Page-Revalidate': 'true',
+            },
+            timeout: 10000,
+        })
+            .then(async (response) => {
+            const body = await response.text();
+            const headers = response.headers.raw();
+            const { status } = response;
+            this.log.debug({
+                event: status >= 500 ? 'background-fetch-5xx' : 'background-fetch-success',
+                status,
+                key,
+            });
+            return {
+                body,
+                headers,
+                status,
+            };
+        })
+            .catch((error) => {
+            this.log.warn({
+                event: 'background-fetch-error',
+                error,
+                key,
+            });
+        })
+            .finally(() => {
+            this.requests.delete(key);
+        });
+    }
+}
+
+export { BackgroundFetchService };

package/lib/staticPages/backgroundFetchService.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fetch = require('node-fetch');
+var url = require('@tinkoff/url');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
+
+const userAgentByDeviceType = {
+    /** Chrome on Mobile */
+    'mobile-modern': 'Mozilla/5.0 (Linux; Android 7.0; SM-G930V Build/NRD90M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.3071.125 Mobile Safari/537.36',
+    /** Old Chrome on Mobile */
+    'mobile-default': 'Mozilla/5.0 (Linux; Android 7.0; SM-G930V Build/NRD90M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.3071.125 Mobile Safari/537.36',
+    /** Chrome on Mac OS */
+    'desktop-modern': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.3987.87 Safari/537.36',
+    /** Old Chrome on Mac OS */
+    'desktop-default': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.3987.87 Safari/537.36',
+};
+class BackgroundFetchService {
+    constructor({ logger, backgroundFetchEnabled, }) {
+        this.requests = new Set();
+        this.log = logger('static-pages');
+        this.backgroundFetchEnabled = backgroundFetchEnabled;
+    }
+    enabled() {
+        return this.backgroundFetchEnabled();
+    }
+    async revalidate({ key, path, port, deviceType, modern, }) {
+        if (this.requests.has(key)) {
+            return;
+        }
+        const revalidateUrl = url.format({
+            hostname: 'localhost',
+            port,
+            path,
+        });
+        this.requests.add(key);
+        this.log.debug({
+            event: 'background-fetch-init',
+            key,
+            revalidateUrl,
+        });
+        return fetch__default["default"](revalidateUrl, {
+            headers: {
+                'User-Agent': userAgentByDeviceType[`${deviceType}-${modern}`],
+                'X-Tramvai-Static-Page-Revalidate': 'true',
+            },
+            timeout: 10000,
+        })
+            .then(async (response) => {
+            const body = await response.text();
+            const headers = response.headers.raw();
+            const { status } = response;
+            this.log.debug({
+                event: status >= 500 ? 'background-fetch-5xx' : 'background-fetch-success',
+                status,
+                key,
+            });
+            return {
+                body,
+                headers,
+                status,
+            };
+        })
+            .catch((error) => {
+            this.log.warn({
+                event: 'background-fetch-error',
+                error,
+                key,
+            });
+        })
+            .finally(() => {
+            this.requests.delete(key);
+        });
+    }
+}
+
+exports.BackgroundFetchService = BackgroundFetchService;

package/lib/staticPages/staticPagesService.es.js

@@ -0,0 +1,109 @@
+class StaticPagesService {
+    constructor({ getCacheKey, requestManager, response, responseManager, environmentManager, userAgent, modern, logger, cache, modifyCache, shouldUseCache, shouldSetToCache, backgroundFetchService, options, cache5xxResponse, }) {
+        this.key = getCacheKey();
+        this.path = requestManager.getParsedUrl().pathname;
+        this.port = environmentManager.get('PORT');
+        this.deviceType = userAgent.mobileOS ? 'mobile' : 'desktop';
+        this.modern = modern ? 'modern' : 'default';
+        this.log = logger('static-pages');
+        this.responseManager = responseManager;
+        this.response = response;
+        this.cache = cache;
+        this.modifyCache = modifyCache;
+        this.shouldUseCache = shouldUseCache;
+        this.shouldSetToCache = shouldSetToCache;
+        this.backgroundFetchService = backgroundFetchService;
+        this.options = options;
+        this.cache5xxResponse = cache5xxResponse;
+    }
+    respond(onSuccess) {
+        if (!this.hasCache()) {
+            return;
+        }
+        const { ttl } = this.options;
+        let cacheEntry = this.getCache();
+        if (Array.isArray(this.modifyCache)) {
+            cacheEntry = this.modifyCache.reduce((result, modifier) => {
+                return modifier(result);
+            }, cacheEntry);
+        }
+        const { updatedAt, status, headers, body } = cacheEntry;
+        const isOutdated = updatedAt + ttl <= Date.now();
+        if (!isOutdated) {
+            this.log.debug({
+                event: 'cache-hit',
+                key: this.key,
+            });
+            this.response
+                .header('content-type', 'text/html')
+                .header('X-Tramvai-Static-Page-From-Cache', 'true')
+                .headers(headers)
+                .status(status)
+                .send(body);
+            onSuccess();
+        }
+        else {
+            this.log.debug({
+                event: 'cache-outdated',
+                key: this.key,
+            });
+        }
+    }
+    saveResponse() {
+        if (!this.cache5xxResponse() && this.responseManager.getStatus() >= 500) {
+            this.log.debug({
+                event: 'cache-set-5xx',
+                key: this.key,
+            });
+            return;
+        }
+        this.log.debug({
+            event: 'cache-set',
+            key: this.key,
+        });
+        this.setCache({
+            status: this.responseManager.getStatus(),
+            headers: this.responseManager.getHeaders(),
+            body: this.responseManager.getBody(),
+        });
+    }
+    async revalidate() {
+        if (!this.backgroundFetchService.enabled()) {
+            return;
+        }
+        await this.backgroundFetchService
+            .revalidate({
+            key: this.key,
+            path: this.path,
+            port: this.port,
+            deviceType: this.deviceType,
+            modern: this.modern,
+        })
+            .then((response) => {
+            if (!response) {
+                return;
+            }
+            if (!this.cache5xxResponse() && response.status >= 500) {
+                return;
+            }
+            this.setCache(response);
+        });
+    }
+    hasCache() {
+        return this.cache.has(this.path) && this.cache.get(this.path).has(this.key);
+    }
+    getCache() {
+        return this.cache.get(this.path).get(this.key);
+    }
+    setCache(cacheEntry) {
+        if (!this.cache.has(this.path)) {
+            this.cache.set(this.path, new Map());
+        }
+        this.cache.get(this.path).set(this.key, {
+            ...cacheEntry,
+            updatedAt: Date.now(),
+        });
+    }
+}
+
+export { StaticPagesService };

package/lib/staticPages/staticPagesService.js

@@ -0,0 +1,113 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class StaticPagesService {
+    constructor({ getCacheKey, requestManager, response, responseManager, environmentManager, userAgent, modern, logger, cache, modifyCache, shouldUseCache, shouldSetToCache, backgroundFetchService, options, cache5xxResponse, }) {
+        this.key = getCacheKey();
+        this.path = requestManager.getParsedUrl().pathname;
+        this.port = environmentManager.get('PORT');
+        this.deviceType = userAgent.mobileOS ? 'mobile' : 'desktop';
+        this.modern = modern ? 'modern' : 'default';
+        this.log = logger('static-pages');
+        this.responseManager = responseManager;
+        this.response = response;
+        this.cache = cache;
+        this.modifyCache = modifyCache;
+        this.shouldUseCache = shouldUseCache;
+        this.shouldSetToCache = shouldSetToCache;
+        this.backgroundFetchService = backgroundFetchService;
+        this.options = options;
+        this.cache5xxResponse = cache5xxResponse;
+    }
+    respond(onSuccess) {
+        if (!this.hasCache()) {
+            return;
+        }
+        const { ttl } = this.options;
+        let cacheEntry = this.getCache();
+        if (Array.isArray(this.modifyCache)) {
+            cacheEntry = this.modifyCache.reduce((result, modifier) => {
+                return modifier(result);
+            }, cacheEntry);
+        }
+        const { updatedAt, status, headers, body } = cacheEntry;
+        const isOutdated = updatedAt + ttl <= Date.now();
+        if (!isOutdated) {
+            this.log.debug({
+                event: 'cache-hit',
+                key: this.key,
+            });
+            this.response
+                .header('content-type', 'text/html')
+                .header('X-Tramvai-Static-Page-From-Cache', 'true')
+                .headers(headers)
+                .status(status)
+                .send(body);
+            onSuccess();
+        }
+        else {
+            this.log.debug({
+                event: 'cache-outdated',
+                key: this.key,
+            });
+        }
+    }
+    saveResponse() {
+        if (!this.cache5xxResponse() && this.responseManager.getStatus() >= 500) {
+            this.log.debug({
+                event: 'cache-set-5xx',
+                key: this.key,
+            });
+            return;
+        }
+        this.log.debug({
+            event: 'cache-set',
+            key: this.key,
+        });
+        this.setCache({
+            status: this.responseManager.getStatus(),
+            headers: this.responseManager.getHeaders(),
+            body: this.responseManager.getBody(),
+        });
+    }
+    async revalidate() {
+        if (!this.backgroundFetchService.enabled()) {
+            return;
+        }
+        await this.backgroundFetchService
+            .revalidate({
+            key: this.key,
+            path: this.path,
+            port: this.port,
+            deviceType: this.deviceType,
+            modern: this.modern,
+        })
+            .then((response) => {
+            if (!response) {
+                return;
+            }
+            if (!this.cache5xxResponse() && response.status >= 500) {
+                return;
+            }
+            this.setCache(response);
+        });
+    }
+    hasCache() {
+        return this.cache.has(this.path) && this.cache.get(this.path).has(this.key);
+    }
+    getCache() {
+        return this.cache.get(this.path).get(this.key);
+    }
+    setCache(cacheEntry) {
+        if (!this.cache.has(this.path)) {
+            this.cache.set(this.path, new Map());
+        }
+        this.cache.get(this.path).set(this.key, {
+            ...cacheEntry,
+            updatedAt: Date.now(),
+        });
+    }
+}
+
+exports.StaticPagesService = StaticPagesService;

package/lib/staticPages.es.js

@@ -0,0 +1,226 @@
+import isEmpty from '@tinkoff/utils/is/empty';
+import { createToken, provide, Scope, commandLineListTokens, DI_TOKEN } from '@tramvai/core';
+import { CREATE_CACHE_TOKEN, REQUEST_MANAGER_TOKEN, LOGGER_TOKEN, RESPONSE_MANAGER_TOKEN, ENV_MANAGER_TOKEN } from '@tramvai/tokens-common';
+import { FASTIFY_RESPONSE } from '@tramvai/tokens-server-private';
+import { MODERN_SATISFIES_TOKEN } from '@tramvai/tokens-render';
+import { PAGE_SERVICE_TOKEN } from '@tramvai/tokens-router';
+import { USER_AGENT_TOKEN } from '@tramvai/module-client-hints';
+import { SERVER_MODULE_PAPI_PRIVATE_ROUTE } from '@tramvai/tokens-server';
+import { METRICS_MODULE_TOKEN } from '@tramvai/tokens-metrics';
+import { createPapiMethod } from '@tramvai/papi';
+import { StopCommandLineRunnerError } from './error.es.js';
+import { STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_SHOULD_SET_TO_CACHE, STATIC_PAGES_SHOULD_USE_CACHE, STATIC_PAGES_BACKGROUND_FETCH_ENABLED, STATIC_PAGES_CACHE_5xx_RESPONSE, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_COMMAND_LINE, PAGE_RENDER_DEFAULT_MODE } from './tokens.es.js';
+import { getPageRenderMode } from './utils/getPageRenderMode.es.js';
+import { getCacheKey } from './utils/cacheKey.es.js';
+import { BackgroundFetchService } from './staticPages/backgroundFetchService.es.js';
+import { StaticPagesService } from './staticPages/staticPagesService.es.js';
+
+const STATIC_PAGES_BACKGROUND_FETCH_SERVICE = createToken();
+const STATIC_PAGES_GET_CACHE_KEY_TOKEN = createToken();
+const STATIC_PAGES_CACHE_HIT_METRIC_TOKEN = createToken();
+const STATIC_PAGES_SERVICE = createToken();
+const staticPagesProviders = [
+    provide({
+        provide: STATIC_PAGES_CACHE_HIT_METRIC_TOKEN,
+        scope: Scope.SINGLETON,
+        useFactory: ({ metrics }) => {
+            return metrics.counter({
+                name: 'static_pages_cache_hit',
+                help: 'Total static pages returned from cache',
+                labelNames: [],
+            });
+        },
+        deps: {
+            metrics: METRICS_MODULE_TOKEN,
+        },
+    }),
+    provide({
+        provide: STATIC_PAGES_CACHE_TOKEN,
+        scope: Scope.SINGLETON,
+        useFactory: ({ createCache, staticPagesOptions }) => {
+            return createCache('memory', {
+                max: staticPagesOptions.maxSize,
+            });
+        },
+        deps: {
+            createCache: CREATE_CACHE_TOKEN,
+            staticPagesOptions: STATIC_PAGES_OPTIONS_TOKEN,
+        },
+    }),
+    provide({
+        provide: STATIC_PAGES_OPTIONS_TOKEN,
+        useValue: {
+            // @TODO: свой ttl для отдельных страниц
+            ttl: 60 * 1000,
+            maxSize: 1000,
+        },
+    }),
+    provide({
+        provide: STATIC_PAGES_GET_CACHE_KEY_TOKEN,
+        useFactory: ({ requestManager, userAgent, modern }) => {
+            return () => {
+                const deviceType = userAgent.mobileOS ? 'mobile' : 'desktop';
+                return getCacheKey({
+                    method: requestManager.getMethod(),
+                    host: requestManager.getHost(),
+                    path: requestManager.getParsedUrl().pathname,
+                    deviceType,
+                    modern,
+                });
+            };
+        },
+        deps: {
+            requestManager: REQUEST_MANAGER_TOKEN,
+            userAgent: USER_AGENT_TOKEN,
+            modern: MODERN_SATISFIES_TOKEN,
+        },
+    }),
+    provide({
+        provide: STATIC_PAGES_SHOULD_SET_TO_CACHE,
+        useFactory: ({ requestManager }) => {
+            return () => {
+                return isEmpty(requestManager.getCookies());
+            };
+        },
+        deps: {
+            requestManager: REQUEST_MANAGER_TOKEN,
+        },
+    }),
+    provide({
+        provide: STATIC_PAGES_SHOULD_USE_CACHE,
+        useFactory: ({ requestManager }) => {
+            return () => {
+                return !requestManager.getHeader('x-tramvai-static-page-revalidate');
+            };
+        },
+        deps: {
+            requestManager: REQUEST_MANAGER_TOKEN,
+        },
+    }),
+    provide({
+        provide: STATIC_PAGES_BACKGROUND_FETCH_ENABLED,
+        useValue: () => {
+            return true;
+        },
+    }),
+    provide({
+        provide: STATIC_PAGES_CACHE_5xx_RESPONSE,
+        useValue: () => {
+            return false;
+        },
+    }),
+    provide({
+        provide: STATIC_PAGES_BACKGROUND_FETCH_SERVICE,
+        scope: Scope.REQUEST,
+        useClass: BackgroundFetchService,
+        deps: {
+            logger: LOGGER_TOKEN,
+            backgroundFetchEnabled: STATIC_PAGES_BACKGROUND_FETCH_ENABLED,
+        },
+    }),
+    provide({
+        provide: STATIC_PAGES_SERVICE,
+        scope: Scope.REQUEST,
+        useClass: StaticPagesService,
+        deps: {
+            getCacheKey: STATIC_PAGES_GET_CACHE_KEY_TOKEN,
+            requestManager: REQUEST_MANAGER_TOKEN,
+            responseManager: RESPONSE_MANAGER_TOKEN,
+            response: FASTIFY_RESPONSE,
+            environmentManager: ENV_MANAGER_TOKEN,
+            userAgent: USER_AGENT_TOKEN,
+            modern: MODERN_SATISFIES_TOKEN,
+            logger: LOGGER_TOKEN,
+            cache: STATIC_PAGES_CACHE_TOKEN,
+            modifyCache: { token: STATIC_PAGES_MODIFY_CACHE, optional: true },
+            shouldUseCache: STATIC_PAGES_SHOULD_USE_CACHE,
+            shouldSetToCache: STATIC_PAGES_SHOULD_SET_TO_CACHE,
+            backgroundFetchService: STATIC_PAGES_BACKGROUND_FETCH_SERVICE,
+            options: STATIC_PAGES_OPTIONS_TOKEN,
+            cache5xxResponse: STATIC_PAGES_CACHE_5xx_RESPONSE,
+        },
+    }),
+    provide({
+        provide: commandLineListTokens.init,
+        multi: true,
+        scope: Scope.SINGLETON,
+        useFactory: ({ di, staticPagesCommandLine }) => {
+            return function registerResponseCacheHandler() {
+                di.register({
+                    provide: staticPagesCommandLine
+                        ? commandLineListTokens[staticPagesCommandLine]
+                        : commandLineListTokens.customerStart,
+                    useFactory: ({ staticPagesService, staticPagesCacheHitMetric, logger }) => {
+                        logger('static-pages');
+                        return function staticPagesFromCache() {
+                            if (staticPagesService.shouldUseCache()) {
+                                staticPagesService.respond(() => {
+                                    // @TODO: маска урла на этом этапе?
+                                    staticPagesCacheHitMetric.inc();
+                                    throw new StopCommandLineRunnerError();
+                                });
+                            }
+                        };
+                    },
+                    deps: {
+                        staticPagesService: STATIC_PAGES_SERVICE,
+                        staticPagesCacheHitMetric: STATIC_PAGES_CACHE_HIT_METRIC_TOKEN,
+                        logger: LOGGER_TOKEN,
+                    },
+                });
+            };
+        },
+        deps: {
+            di: DI_TOKEN,
+            staticPagesCommandLine: { token: STATIC_PAGES_COMMAND_LINE, optional: true },
+        },
+    }),
+    provide({
+        provide: commandLineListTokens.clear,
+        useFactory: ({ staticPagesService, pageService, defaultRenderMode }) => {
+            return function cacheStaticPages() {
+                const isStaticPage = getPageRenderMode({ pageService, defaultRenderMode }) === 'static';
+                if (!isStaticPage) {
+                    return;
+                }
+                if (staticPagesService.shouldSetToCache()) {
+                    staticPagesService.saveResponse();
+                }
+                else {
+                    staticPagesService.revalidate();
+                }
+            };
+        },
+        deps: {
+            staticPagesService: STATIC_PAGES_SERVICE,
+            pageService: PAGE_SERVICE_TOKEN,
+            defaultRenderMode: PAGE_RENDER_DEFAULT_MODE,
+        },
+    }),
+    provide({
+        provide: SERVER_MODULE_PAPI_PRIVATE_ROUTE,
+        useFactory: ({ staticPagesCache }) => {
+            return createPapiMethod({
+                path: '/revalidate/',
+                method: 'post',
+                async handler({ body = {} }) {
+                    const { path } = body;
+                    const pathKey = `/${path}/`;
+                    if (!path) {
+                        staticPagesCache.clear();
+                    }
+                    else if (staticPagesCache.has(pathKey)) {
+                        staticPagesCache.set(pathKey, new Map());
+                        // @TODO: revalidate request with background fetch?
+                    }
+                    return 'Success';
+                },
+            });
+        },
+        deps: {
+            staticPagesCache: STATIC_PAGES_CACHE_TOKEN,
+        },
+    }),
+];
+
+export { STATIC_PAGES_BACKGROUND_FETCH_SERVICE, STATIC_PAGES_CACHE_HIT_METRIC_TOKEN, STATIC_PAGES_GET_CACHE_KEY_TOKEN, STATIC_PAGES_SERVICE, staticPagesProviders };