@tramvai/module-page-render-mode 7.11.0 → 7.16.0

package/lib/browser.js

@@ -6,7 +6,7 @@ import { sharedProviders } from './shared.browser.js';
 import { STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE } from './private-tokens.browser.js';
 import { getPageRenderMode } from './utils/getPageRenderMode.browser.js';
 import { PAGE_RENDER_DEFAULT_MODE } from './tokens.browser.js';
-export { PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT, PAGE_RENDER_DEFAULT_MODE, PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_WRAPPER_TYPE, STATIC_PAGES_BACKGROUND_FETCH_ENABLED, STATIC_PAGES_CACHE_5xx_RESPONSE, STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN, STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_COMMAND_LINE, STATIC_PAGES_FS_CACHE_ENABLED, STATIC_PAGES_FS_CACHE_OPTIONS_TOKEN, STATIC_PAGES_KEY_TOKEN, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_SERVICE, STATIC_PAGES_SHOULD_USE_CACHE } from './tokens.browser.js';
+export { PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT, PAGE_RENDER_DEFAULT_MODE, PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_WRAPPER_TYPE, STATIC_PAGES_BACKGROUND_FETCH_ENABLED, STATIC_PAGES_CACHE_5xx_RESPONSE, STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN, STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_COMMAND_LINE, STATIC_PAGES_FS_CACHE_ENABLED, STATIC_PAGES_FS_CACHE_OPTIONS_TOKEN, STATIC_PAGES_KEY_TOKEN, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_ROUTE_TREE, STATIC_PAGES_SERVICE, STATIC_PAGES_SHOULD_USE_CACHE } from './tokens.browser.js';
 
 // @todo: перенести в @tramvai/module-render
 const PageRenderModeModule = declareModule({

package/lib/private-tokens.d.ts

@@ -1,5 +1,6 @@
 import type { Counter, Gauge } from 'prom-client';
 import { TramvaiRenderMode } from '@tramvai/tokens-render';
+import { Route } from '@tinkoff/router';
 import { BackgroundFetchService } from './staticPages/backgroundFetchService';
 import { FileSystemCache } from './staticPages/fileSystemCache';
 export declare const STATIC_PAGES_BACKGROUND_FETCH_SERVICE: BackgroundFetchService & {
@@ -21,7 +22,7 @@ export declare const STATIC_PAGES_FS_CACHE_METRICS_TOKEN: {
 } & {
     __type?: "base token" | undefined;
 };
-export declare const STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE: (() => TramvaiRenderMode) & {
+export declare const STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE: ((route?: Route) => TramvaiRenderMode) & {
     __type?: "base token" | undefined;
 };
 //# sourceMappingURL=private-tokens.d.ts.map

package/lib/server.es.js

@@ -2,7 +2,7 @@ import { declareModule } from '@tramvai/core';
 import { ForceCSRModule } from './ForceCSRModule.es.js';
 import { sharedProviders } from './shared.es.js';
 import { staticPagesProviders } from './staticPages.es.js';
-export { PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT, PAGE_RENDER_DEFAULT_MODE, PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_WRAPPER_TYPE, STATIC_PAGES_BACKGROUND_FETCH_ENABLED, STATIC_PAGES_CACHE_5xx_RESPONSE, STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN, STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_COMMAND_LINE, STATIC_PAGES_FS_CACHE_ENABLED, STATIC_PAGES_FS_CACHE_OPTIONS_TOKEN, STATIC_PAGES_KEY_TOKEN, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_SERVICE, STATIC_PAGES_SHOULD_USE_CACHE } from './tokens.es.js';
+export { PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT, PAGE_RENDER_DEFAULT_MODE, PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_WRAPPER_TYPE, STATIC_PAGES_BACKGROUND_FETCH_ENABLED, STATIC_PAGES_CACHE_5xx_RESPONSE, STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN, STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_COMMAND_LINE, STATIC_PAGES_FS_CACHE_ENABLED, STATIC_PAGES_FS_CACHE_OPTIONS_TOKEN, STATIC_PAGES_KEY_TOKEN, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_ROUTE_TREE, STATIC_PAGES_SERVICE, STATIC_PAGES_SHOULD_USE_CACHE } from './tokens.es.js';
 
 // @todo: перенести в @tramvai/module-render
 const PageRenderModeModule = declareModule({

package/lib/server.js

@@ -29,6 +29,7 @@ exports.STATIC_PAGES_FS_CACHE_OPTIONS_TOKEN = tokens.STATIC_PAGES_FS_CACHE_OPTIO
 exports.STATIC_PAGES_KEY_TOKEN = tokens.STATIC_PAGES_KEY_TOKEN;
 exports.STATIC_PAGES_MODIFY_CACHE = tokens.STATIC_PAGES_MODIFY_CACHE;
 exports.STATIC_PAGES_OPTIONS_TOKEN = tokens.STATIC_PAGES_OPTIONS_TOKEN;
+exports.STATIC_PAGES_ROUTE_TREE = tokens.STATIC_PAGES_ROUTE_TREE;
 exports.STATIC_PAGES_SERVICE = tokens.STATIC_PAGES_SERVICE;
 exports.STATIC_PAGES_SHOULD_USE_CACHE = tokens.STATIC_PAGES_SHOULD_USE_CACHE;
 exports.PageRenderModeModule = PageRenderModeModule;

package/lib/staticPages/backgroundFetchService.d.ts

@@ -15,10 +15,11 @@ export declare class BackgroundFetchService {
         backgroundFetchEnabled: BackgroundCacheEnabled;
     });
     enabled(): boolean;
-    revalidate({ cacheKey, pathname, headers, }: {
+    revalidate({ cacheKey, pathname, headers, query, }: {
         cacheKey: string;
         pathname: string;
         headers: Record<string, string | string[] | undefined>;
+        query?: Record<string, string | string[]>;
     }): Promise<void | {
         body: string;
         headers: {

package/lib/staticPages/backgroundFetchService.es.js

@@ -15,14 +15,16 @@ class BackgroundFetchService {
     enabled() {
         return this.backgroundFetchEnabled();
     }
-    async revalidate({ cacheKey, pathname, headers, }) {
+    async revalidate({ cacheKey, pathname, headers, query, }) {
         if (this.requests.has(cacheKey)) {
             return;
         }
+        // TODO: support --https
         const revalidateUrl = format({
             hostname: this.hostname,
             port: this.port,
             path: pathname,
+            query,
         });
         this.requests.add(cacheKey);
         this.log.debug({
@@ -34,6 +36,7 @@ class BackgroundFetchService {
             headers: {
                 ...headers,
                 'X-Tramvai-Static-Page-Revalidate': 'true',
+                'X-Tramvai-Service-Name': 'BACKGROUND_STATIC_PAGE_REVALIDATE',
             },
             signal: AbortSignal.timeout(10000),
             // we need to save raw redirect response status code and headers

package/lib/staticPages/backgroundFetchService.js

@@ -19,14 +19,16 @@ class BackgroundFetchService {
     enabled() {
         return this.backgroundFetchEnabled();
     }
-    async revalidate({ cacheKey, pathname, headers, }) {
+    async revalidate({ cacheKey, pathname, headers, query, }) {
         if (this.requests.has(cacheKey)) {
             return;
         }
+        // TODO: support --https
         const revalidateUrl = url.format({
             hostname: this.hostname,
             port: this.port,
             path: pathname,
+            query,
         });
         this.requests.add(cacheKey);
         this.log.debug({
@@ -38,6 +40,7 @@ class BackgroundFetchService {
             headers: {
                 ...headers,
                 'X-Tramvai-Static-Page-Revalidate': 'true',
+                'X-Tramvai-Service-Name': 'BACKGROUND_STATIC_PAGE_REVALIDATE',
             },
             signal: AbortSignal.timeout(10000),
             // we need to save raw redirect response status code and headers

package/lib/staticPages/fileSystemCache.es.js

@@ -18,7 +18,7 @@ class FileSystemCache {
     metrics;
     limit = pLimit(8);
     constructor({ directory, maxSize, ttl, allowStale, logger, metrics, }) {
-        this.directory = directory;
+        this.directory = path.isAbsolute(directory) ? directory : path.join(process.cwd(), directory);
         this.maxSize = maxSize;
         this.ttl = ttl;
         this.allowStale = allowStale;
@@ -35,6 +35,8 @@ class FileSystemCache {
             directory: this.directory,
         });
         try {
+            // fill zero values for metrics
+            this.updateMetrics();
             await this.scanDirectory();
             this.log.info({
                 event: 'init-complete',
@@ -44,11 +46,19 @@ class FileSystemCache {
             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 promises.mkdir(this.directory, { recursive: true });
+            if (error?.code === 'ENOENT') {
+                // static directory path can be missing on first run, so always create it
+                await promises.mkdir(this.directory, { recursive: true }).catch((mkdirError) => {
+                    this.log.warn({
+                        event: 'mkdir-error',
+                        message: `Failed to create static cache directory ${this.directory}, maybe read-only file system is used.
+In k8s environment, it means that "readOnlyRootFilesystem" option is enabled for deployment, to fix this issue, add 'dist' directory as a emptyDir volume mount.`,
+                        error: mkdirError,
+                    });
+                });
             }
-            else {
+            // static directory path includes unique build id in development mode, so warn only in production
+            if (process.env.NODE_ENV !== 'development') {
                 this.log.warn({
                     event: 'init-error',
                     message: error?.code === 'ENOENT'
@@ -253,7 +263,7 @@ and copy "dist/static" folder into the Docker image, to ensure the pages cache i
         }
         catch (error) {
             if (process.env.NODE_ENV !== 'development') {
-                this.log.warn({
+                this.log.info({
                     event: 'meta-read-error',
                     error: error,
                 });

package/lib/staticPages/fileSystemCache.js

@@ -27,7 +27,7 @@ class FileSystemCache {
     metrics;
     limit = pLimit__default["default"](8);
     constructor({ directory, maxSize, ttl, allowStale, logger, metrics, }) {
-        this.directory = directory;
+        this.directory = path__default["default"].isAbsolute(directory) ? directory : path__default["default"].join(process.cwd(), directory);
         this.maxSize = maxSize;
         this.ttl = ttl;
         this.allowStale = allowStale;
@@ -44,6 +44,8 @@ class FileSystemCache {
             directory: this.directory,
         });
         try {
+            // fill zero values for metrics
+            this.updateMetrics();
             await this.scanDirectory();
             this.log.info({
                 event: 'init-complete',
@@ -53,11 +55,19 @@ class FileSystemCache {
             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 });
+            if (error?.code === 'ENOENT') {
+                // static directory path can be missing on first run, so always create it
+                await node_fs.promises.mkdir(this.directory, { recursive: true }).catch((mkdirError) => {
+                    this.log.warn({
+                        event: 'mkdir-error',
+                        message: `Failed to create static cache directory ${this.directory}, maybe read-only file system is used.
+In k8s environment, it means that "readOnlyRootFilesystem" option is enabled for deployment, to fix this issue, add 'dist' directory as a emptyDir volume mount.`,
+                        error: mkdirError,
+                    });
+                });
             }
-            else {
+            // static directory path includes unique build id in development mode, so warn only in production
+            if (process.env.NODE_ENV !== 'development') {
                 this.log.warn({
                     event: 'init-error',
                     message: error?.code === 'ENOENT'
@@ -262,7 +272,7 @@ and copy "dist/static" folder into the Docker image, to ensure the pages cache i
         }
         catch (error) {
             if (process.env.NODE_ENV !== 'development') {
-                this.log.warn({
+                this.log.info({
                     event: 'meta-read-error',
                     error: error,
                 });

package/lib/staticPages/staticPagesService.es.js

@@ -1,7 +1,17 @@
 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'];
+// `X-Original-Host` and `Host` are required for RequestManager and Router
+const DEFAULT_HEADERS_WHITELIST = [
+    'Location',
+    'Content-Type',
+    'Content-Length',
+    'X-App-Id',
+    'X-Original-Host',
+    'Host',
+    'X-Forwarded-Host',
+    'X-Forwarded-Proto',
+];
 class StaticPagesService {
     key;
     pathname;
@@ -39,6 +49,7 @@ class StaticPagesService {
         this.cache5xxResponse = cache5xxResponse;
         this.cacheControlFactory = cacheControlFactory;
     }
+    // eslint-disable-next-line max-statements
     async respond(onSuccess) {
         if (!this.hasCache()) {
             this.log.debug({
@@ -134,7 +145,9 @@ class StaticPagesService {
             }
         }
         const incomingHeaders = this.requestManager.getHeaders();
+        const incomingQuery = this.requestManager.getParsedUrl().query;
         const revalidateHeaders = {};
+        const revalidateQuery = {};
         this.options.allowedHeaders.concat(DEFAULT_HEADERS_WHITELIST).forEach((header) => {
             const lowercaseHeader = header.toLowerCase();
             if (incomingHeaders[header]) {
@@ -144,11 +157,17 @@ class StaticPagesService {
                 revalidateHeaders[lowercaseHeader] = incomingHeaders[lowercaseHeader];
             }
         });
+        this.options.allowedQuery.forEach((query) => {
+            if (incomingQuery[query]) {
+                revalidateQuery[query] = incomingQuery[query];
+            }
+        });
         await this.backgroundFetchService
             .revalidate({
             cacheKey: this.cacheKey,
             pathname: this.pathname,
             headers: revalidateHeaders,
+            query: revalidateQuery,
         })
             .then((response) => {
             if (!response) {
@@ -161,6 +180,16 @@ class StaticPagesService {
                 });
                 return;
             }
+            // for 4xx responses we want to cache only HTML pages
+            if (response.status >= 400 &&
+                response.status < 500 &&
+                !response.headers['content-type']?.includes('text/html')) {
+                this.log.debug({
+                    event: 'cache-set-4xx',
+                    cacheKey: this.cacheKey,
+                });
+                return;
+            }
             const cachedHeaders = {};
             const responseHeaders = response.headers;
             this.options.allowedHeaders.concat(DEFAULT_HEADERS_WHITELIST).forEach((header) => {

package/lib/staticPages/staticPagesService.js

@@ -5,7 +5,17 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var cacheKey = require('../utils/cacheKey.js');
 
 // `Location` is required for 3xx responses
-const DEFAULT_HEADERS_WHITELIST = ['Location', 'Content-Type', 'Content-Length', 'X-App-Id'];
+// `X-Original-Host` and `Host` are required for RequestManager and Router
+const DEFAULT_HEADERS_WHITELIST = [
+    'Location',
+    'Content-Type',
+    'Content-Length',
+    'X-App-Id',
+    'X-Original-Host',
+    'Host',
+    'X-Forwarded-Host',
+    'X-Forwarded-Proto',
+];
 class StaticPagesService {
     key;
     pathname;
@@ -43,6 +53,7 @@ class StaticPagesService {
         this.cache5xxResponse = cache5xxResponse;
         this.cacheControlFactory = cacheControlFactory;
     }
+    // eslint-disable-next-line max-statements
     async respond(onSuccess) {
         if (!this.hasCache()) {
             this.log.debug({
@@ -138,7 +149,9 @@ class StaticPagesService {
             }
         }
         const incomingHeaders = this.requestManager.getHeaders();
+        const incomingQuery = this.requestManager.getParsedUrl().query;
         const revalidateHeaders = {};
+        const revalidateQuery = {};
         this.options.allowedHeaders.concat(DEFAULT_HEADERS_WHITELIST).forEach((header) => {
             const lowercaseHeader = header.toLowerCase();
             if (incomingHeaders[header]) {
@@ -148,11 +161,17 @@ class StaticPagesService {
                 revalidateHeaders[lowercaseHeader] = incomingHeaders[lowercaseHeader];
             }
         });
+        this.options.allowedQuery.forEach((query) => {
+            if (incomingQuery[query]) {
+                revalidateQuery[query] = incomingQuery[query];
+            }
+        });
         await this.backgroundFetchService
             .revalidate({
             cacheKey: this.cacheKey,
             pathname: this.pathname,
             headers: revalidateHeaders,
+            query: revalidateQuery,
         })
             .then((response) => {
             if (!response) {
@@ -165,6 +184,16 @@ class StaticPagesService {
                 });
                 return;
             }
+            // for 4xx responses we want to cache only HTML pages
+            if (response.status >= 400 &&
+                response.status < 500 &&
+                !response.headers['content-type']?.includes('text/html')) {
+                this.log.debug({
+                    event: 'cache-set-4xx',
+                    cacheKey: this.cacheKey,
+                });
+                return;
+            }
             const cachedHeaders = {};
             const responseHeaders = response.headers;
             this.options.allowedHeaders.concat(DEFAULT_HEADERS_WHITELIST).forEach((header) => {

package/lib/staticPages.d.ts

@@ -1,8 +1,15 @@
 /// <reference types="node" />
+import { Route, RouteTree } from '@tinkoff/router';
 import { BackgroundFetchService } from './staticPages/backgroundFetchService';
 import { StaticPagesService } from './staticPages/staticPagesService';
 import { FileSystemCache } from './staticPages/fileSystemCache';
-export declare const staticPagesProviders: (import("@tinkoff/dippy/lib/Provider").ValueProvider<{
+export declare const staticPagesProviders: (import("@tinkoff/dippy/lib/Provider").ValueProvider<((route?: Route | undefined) => import("@tramvai/tokens-render").TramvaiRenderMode) & {
+    __type?: "base token" | undefined;
+}> | import("@tinkoff/dippy/lib/Provider").ClassProviderWithoutDeps<((route?: Route | undefined) => import("@tramvai/tokens-render").TramvaiRenderMode) & {
+    __type?: "base token" | undefined;
+}> | import("@tinkoff/dippy/lib/Provider").FactoryProviderWithoutDeps<((route?: Route | undefined) => import("@tramvai/tokens-render").TramvaiRenderMode) & {
+    __type?: "base token" | undefined;
+}> | import("@tinkoff/dippy/lib/Provider").ValueProvider<{
     hit: import("prom-client").Counter<any>;
 } & {
     __type?: "base token" | undefined;
@@ -228,7 +235,7 @@ export declare const staticPagesProviders: (import("@tinkoff/dippy/lib/Provider"
         }) | null;
         optional: true;
     };
-}, (() => import("@tramvai/tokens-render").TramvaiRenderMode) & {
+}, ((route?: Route | undefined) => import("@tramvai/tokens-render").TramvaiRenderMode) & {
     __type?: "base token" | undefined;
 }> | import("@tinkoff/dippy/lib/Provider").FactoryProviderWithDeps<{
     requestManager: import("@tramvai/tokens-common").RequestManager & {
@@ -261,7 +268,7 @@ export declare const staticPagesProviders: (import("@tinkoff/dippy/lib/Provider"
         }) | null;
         optional: true;
     };
-}, (() => import("@tramvai/tokens-render").TramvaiRenderMode) & {
+}, ((route?: Route | undefined) => import("@tramvai/tokens-render").TramvaiRenderMode) & {
     __type?: "base token" | undefined;
 }> | import("@tinkoff/dippy/lib/Provider").ValueProvider<BackgroundFetchService & {
     __type?: "base token" | undefined;
@@ -531,5 +538,41 @@ export declare const staticPagesProviders: (import("@tinkoff/dippy/lib/Provider"
     __papi_parameters__: import("@tramvai/papi").NormalizedPapiParameters<any, any>;
 } & {
     __type?: "multi token" | undefined;
+}> | import("@tinkoff/dippy/lib/Provider").ValueProvider<RouteTree & {
+    __type?: "base token" | undefined;
+}> | import("@tinkoff/dippy/lib/Provider").ClassProviderWithDeps<{
+    di: import("@tinkoff/dippy").Container & {
+        __type?: "base token" | undefined;
+    };
+}, RouteTree & {
+    __type?: "base token" | undefined;
+}> | import("@tinkoff/dippy/lib/Provider").ClassProviderWithoutDeps<RouteTree & {
+    __type?: "base token" | undefined;
+}> | import("@tinkoff/dippy/lib/Provider").FactoryProviderWithDeps<{
+    di: import("@tinkoff/dippy").Container & {
+        __type?: "base token" | undefined;
+    };
+}, RouteTree & {
+    __type?: "base token" | undefined;
+}> | import("@tinkoff/dippy/lib/Provider").FactoryProviderWithoutDeps<RouteTree & {
+    __type?: "base token" | undefined;
+}> | import("@tinkoff/dippy/lib/Provider").ClassProviderWithDeps<{
+    router: import("@tinkoff/router").AbstractRouter & {
+        __type?: "base token" | undefined;
+    };
+    routeTree: RouteTree & {
+        __type?: "base token" | undefined;
+    };
+}, import("@tramvai/core").Command & {
+    __type?: "multi token" | undefined;
+}> | import("@tinkoff/dippy/lib/Provider").FactoryProviderWithDeps<{
+    router: import("@tinkoff/router").AbstractRouter & {
+        __type?: "base token" | undefined;
+    };
+    routeTree: RouteTree & {
+        __type?: "base token" | undefined;
+    };
+}, import("@tramvai/core").Command & {
+    __type?: "multi token" | undefined;
 }>)[];
 //# sourceMappingURL=staticPages.d.ts.map

package/lib/staticPages.es.js

@@ -1,12 +1,14 @@
+import flatten from '@tinkoff/utils/array/flatten';
 import { provide, Scope, commandLineListTokens, optional, DI_TOKEN } from '@tramvai/core';
 import { CREATE_CACHE_TOKEN, LOGGER_TOKEN, REQUEST_MANAGER_TOKEN, ENV_MANAGER_TOKEN, RESPONSE_MANAGER_TOKEN } from '@tramvai/tokens-common';
 import { FASTIFY_RESPONSE } from '@tramvai/tokens-server-private';
-import { ROUTER_TOKEN, PAGE_SERVICE_TOKEN, LINK_PREFETCH_MANAGER_TOKEN, PAGE_REGISTRY_TOKEN } from '@tramvai/tokens-router';
+import { ROUTER_TOKEN, PAGE_SERVICE_TOKEN, LINK_PREFETCH_MANAGER_TOKEN, PAGE_REGISTRY_TOKEN, ROUTES_TOKEN } from '@tramvai/tokens-router';
 import { SERVER_MODULE_PAPI_PRIVATE_ROUTE } from '@tramvai/tokens-server';
 import { METRICS_MODULE_TOKEN } from '@tramvai/tokens-metrics';
 import { createPapiMethod } from '@tramvai/papi';
+import { isWildcard, RouteTree } from '@tinkoff/router';
 import { StopCommandLineRunnerError } from './error.es.js';
-import { STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_KEY_TOKEN, STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN, STATIC_PAGES_FS_CACHE_ENABLED, STATIC_PAGES_FS_CACHE_OPTIONS_TOKEN, STATIC_PAGES_SHOULD_USE_CACHE, PAGE_RENDER_DEFAULT_MODE, STATIC_PAGES_BACKGROUND_FETCH_ENABLED, STATIC_PAGES_CACHE_5xx_RESPONSE, STATIC_PAGES_SERVICE, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_COMMAND_LINE } from './tokens.es.js';
+import { STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_KEY_TOKEN, STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN, STATIC_PAGES_FS_CACHE_ENABLED, STATIC_PAGES_FS_CACHE_OPTIONS_TOKEN, STATIC_PAGES_SHOULD_USE_CACHE, PAGE_RENDER_DEFAULT_MODE, STATIC_PAGES_BACKGROUND_FETCH_ENABLED, STATIC_PAGES_CACHE_5xx_RESPONSE, STATIC_PAGES_SERVICE, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_ROUTE_TREE, STATIC_PAGES_COMMAND_LINE } 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';
@@ -14,6 +16,11 @@ import { StaticPagesService } from './staticPages/staticPagesService.es.js';
 import { FileSystemCache } from './staticPages/fileSystemCache.es.js';
 import { STATIC_PAGES_CACHE_METRICS_TOKEN, STATIC_PAGES_FS_CACHE_METRICS_TOKEN, STATIC_PAGES_FS_CACHE_TOKEN, STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE, STATIC_PAGES_BACKGROUND_FETCH_SERVICE } from './private-tokens.es.js';
 
+// small performance optimization to prevent stack trace generation for static StopCommandLineRunnerError
+const { stackTraceLimit } = Error;
+Error.stackTraceLimit = 0;
+const STOP_COMMAND_LINE_ERROR = new StopCommandLineRunnerError();
+Error.stackTraceLimit = stackTraceLimit;
 const staticPagesProviders = [
     provide({
         provide: STATIC_PAGES_CACHE_METRICS_TOKEN,
@@ -48,11 +55,14 @@ const staticPagesProviders = [
     provide({
         provide: STATIC_PAGES_OPTIONS_TOKEN,
         useValue: {
-            // @TODO: unique ttl per pages
+            // @TODO: unique cache parameters per pages
             ttl: 5 * 60 * 1000,
             maxSize: 100,
             allowStale: true,
+            // @TODO: unique headers per pages
             allowedHeaders: [],
+            // @TODO: unique query per pages
+            allowedQuery: [],
         },
     }),
     provide({
@@ -170,9 +180,10 @@ const staticPagesProviders = [
     provide({
         provide: STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE,
         useFactory: ({ requestManager, pageService, router, defaultRenderMode, fileSystemCache }) => {
-            return () => getPageRenderMode({
+            return (route) => getPageRenderMode({
                 pageService,
                 router,
+                route,
                 requestManager,
                 defaultRenderMode,
                 fileSystemCache,
@@ -240,12 +251,13 @@ const staticPagesProviders = [
                     provide: staticPagesCommandLine
                         ? commandLineListTokens[staticPagesCommandLine]
                         : commandLineListTokens.customerStart,
-                    useFactory: ({ staticPagesService, staticPagesCacheMetrics, logger, requestManager, responseManager, staticPagesKey, linkPrefetchManager, resolvePageRenderMode, router, pageRegistry, }) => {
+                    useFactory: ({ staticPagesService, staticPagesCacheMetrics, logger, requestManager, responseManager, staticPagesKey, linkPrefetchManager, resolvePageRenderMode, router, pageRegistry, routeTree, }) => {
                         const log = logger('static-pages');
+                        // eslint-disable-next-line max-statements
                         return async function staticPagesFromCache() {
                             const isPrerenderRequest = !!requestManager.getHeader('x-tramvai-prerender');
                             const { pathname } = requestManager.getParsedUrl();
-                            const route = router?.getCurrentRoute() ?? router?.resolve(pathname);
+                            let route = router?.getCurrentRoute() ?? router?.resolve(pathname);
                             // prefetch route only for `tramvai static` because it can be async and slow in runtime
                             if (isPrerenderRequest) {
                                 log.debug(`Should prefetch route and component to determine if page is static: ${pathname}`);
@@ -260,8 +272,22 @@ const staticPagesProviders = [
                                     }
                                 });
                             }
-                            const isStatic = resolvePageRenderMode() === 'static';
+                            // dynamic route will be resolved after prefetch
+                            if (isPrerenderRequest && !route) {
+                                route = router?.getCurrentRoute() ?? router?.resolve(pathname);
+                            }
+                            const isStatic = resolvePageRenderMode(route) === 'static';
                             const shouldUseCache = staticPagesService.shouldUseCache();
+                            // we can't use cache for wildcard routes,
+                            // because wildcard routes can match any possible urls
+                            const isWildcardRoute = route
+                                ? isWildcard(route.path)
+                                : routeTree.getWildcard(pathname);
+                            // routes can be resolved in runtime with ROUTE_RESOLVE_TOKEN,
+                            // but this routes exists only in Request scope, so we use STATIC_PAGES_ROUTE_TREE
+                            // to save minimal info about resolved routes between requests, because
+                            // we want to be sure that we use cache and revalidation only for resolved routes
+                            const isUnknownRoute = !route && !routeTree.getRoute(pathname);
                             if (isStatic) {
                                 responseManager.setHeader('X-Tramvai-Static-Page-Key', staticPagesKey());
                                 // we need to tell for `tramvai static` prerendering command that this page has `static` render mode,
@@ -270,16 +296,23 @@ const staticPagesProviders = [
                                 if (isPrerenderRequest && route) {
                                     responseManager.setHeader('X-Tramvai-Static-Page-Route', JSON.stringify(route));
                                 }
-                                if (shouldUseCache) {
-                                    log.debug(`Should use static pages cache: ${pathname}`);
+                                if (shouldUseCache && !isWildcardRoute && !isUnknownRoute) {
+                                    log.info(`Should use static pages cache: ${pathname}`);
                                     await staticPagesService.respond(() => {
-                                        log.debug(`Successful static page response from cache: ${pathname}`);
+                                        log.info(`Successful static page response from cache: ${pathname}`);
                                         staticPagesCacheMetrics.hit.inc();
-                                        throw new StopCommandLineRunnerError();
+                                        throw STOP_COMMAND_LINE_ERROR;
                                     });
                                 }
                                 else {
-                                    log.debug(`Static pages cache is not used for this request: ${pathname}`);
+                                    let msg = `Static pages cache is not used for this request: ${pathname}`;
+                                    if (shouldUseCache && isWildcardRoute) {
+                                        msg += `, because wildcard route was resolved`;
+                                    }
+                                    else if (shouldUseCache && isUnknownRoute) {
+                                        msg += `, because route for this url was never resolved`;
+                                    }
+                                    log.info(msg);
                                 }
                             }
                         };
@@ -295,6 +328,7 @@ const staticPagesProviders = [
                         resolvePageRenderMode: STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE,
                         router: optional(ROUTER_TOKEN),
                         pageRegistry: optional(PAGE_REGISTRY_TOKEN),
+                        routeTree: STATIC_PAGES_ROUTE_TREE,
                     },
                 });
             };
@@ -367,6 +401,37 @@ const staticPagesProviders = [
             logger: LOGGER_TOKEN,
         },
     }),
+    provide({
+        provide: STATIC_PAGES_ROUTE_TREE,
+        scope: Scope.SINGLETON,
+        useFactory: ({ di }) => {
+            const staticRoutes = di.get(optional(ROUTES_TOKEN)) ?? [];
+            return new RouteTree(flatten(staticRoutes).map((route) => ({ name: route.name, path: route.path })));
+        },
+        deps: {
+            di: DI_TOKEN,
+        },
+    }),
+    provide({
+        provide: commandLineListTokens.clear,
+        useFactory: ({ router, routeTree }) => {
+            return () => {
+                const currentUrl = router.getCurrentUrl();
+                const currentRoute = router.getCurrentRoute();
+                // save dynamically resolved route in route tree to use it in next requests before route resolving
+                if (currentRoute && currentUrl && !routeTree.getRoute(currentUrl.pathname)) {
+                    routeTree.addRoute({
+                        name: currentRoute.name,
+                        path: currentRoute.path,
+                    });
+                }
+            };
+        },
+        deps: {
+            router: ROUTER_TOKEN,
+            routeTree: STATIC_PAGES_ROUTE_TREE,
+        },
+    }),
 ];
 
 export { staticPagesProviders };

package/lib/staticPages.js

@@ -2,6 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var flatten = require('@tinkoff/utils/array/flatten');
 var core = require('@tramvai/core');
 var tokensCommon = require('@tramvai/tokens-common');
 var tokensServerPrivate = require('@tramvai/tokens-server-private');
@@ -9,6 +10,7 @@ var tokensRouter = require('@tramvai/tokens-router');
 var tokensServer = require('@tramvai/tokens-server');
 var tokensMetrics = require('@tramvai/tokens-metrics');
 var papi = require('@tramvai/papi');
+var router = require('@tinkoff/router');
 var error = require('./error.js');
 var tokens = require('./tokens.js');
 var getPageRenderMode = require('./utils/getPageRenderMode.js');
@@ -18,6 +20,15 @@ var staticPagesService = require('./staticPages/staticPagesService.js');
 var fileSystemCache = require('./staticPages/fileSystemCache.js');
 var privateTokens = require('./private-tokens.js');
 
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
+
+// small performance optimization to prevent stack trace generation for static StopCommandLineRunnerError
+const { stackTraceLimit } = Error;
+Error.stackTraceLimit = 0;
+const STOP_COMMAND_LINE_ERROR = new error.StopCommandLineRunnerError();
+Error.stackTraceLimit = stackTraceLimit;
 const staticPagesProviders = [
     core.provide({
         provide: privateTokens.STATIC_PAGES_CACHE_METRICS_TOKEN,
@@ -52,11 +63,14 @@ const staticPagesProviders = [
     core.provide({
         provide: tokens.STATIC_PAGES_OPTIONS_TOKEN,
         useValue: {
-            // @TODO: unique ttl per pages
+            // @TODO: unique cache parameters per pages
             ttl: 5 * 60 * 1000,
             maxSize: 100,
             allowStale: true,
+            // @TODO: unique headers per pages
             allowedHeaders: [],
+            // @TODO: unique query per pages
+            allowedQuery: [],
         },
     }),
     core.provide({
@@ -174,9 +188,10 @@ const staticPagesProviders = [
     core.provide({
         provide: privateTokens.STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE,
         useFactory: ({ requestManager, pageService, router, defaultRenderMode, fileSystemCache }) => {
-            return () => getPageRenderMode.getPageRenderMode({
+            return (route) => getPageRenderMode.getPageRenderMode({
                 pageService,
                 router,
+                route,
                 requestManager,
                 defaultRenderMode,
                 fileSystemCache,
@@ -244,12 +259,13 @@ const staticPagesProviders = [
                     provide: staticPagesCommandLine
                         ? core.commandLineListTokens[staticPagesCommandLine]
                         : core.commandLineListTokens.customerStart,
-                    useFactory: ({ staticPagesService, staticPagesCacheMetrics, logger, requestManager, responseManager, staticPagesKey, linkPrefetchManager, resolvePageRenderMode, router, pageRegistry, }) => {
+                    useFactory: ({ staticPagesService, staticPagesCacheMetrics, logger, requestManager, responseManager, staticPagesKey, linkPrefetchManager, resolvePageRenderMode, router: router$1, pageRegistry, routeTree, }) => {
                         const log = logger('static-pages');
+                        // eslint-disable-next-line max-statements
                         return async function staticPagesFromCache() {
                             const isPrerenderRequest = !!requestManager.getHeader('x-tramvai-prerender');
                             const { pathname } = requestManager.getParsedUrl();
-                            const route = router?.getCurrentRoute() ?? router?.resolve(pathname);
+                            let route = router$1?.getCurrentRoute() ?? router$1?.resolve(pathname);
                             // prefetch route only for `tramvai static` because it can be async and slow in runtime
                             if (isPrerenderRequest) {
                                 log.debug(`Should prefetch route and component to determine if page is static: ${pathname}`);
@@ -264,8 +280,22 @@ const staticPagesProviders = [
                                     }
                                 });
                             }
-                            const isStatic = resolvePageRenderMode() === 'static';
+                            // dynamic route will be resolved after prefetch
+                            if (isPrerenderRequest && !route) {
+                                route = router$1?.getCurrentRoute() ?? router$1?.resolve(pathname);
+                            }
+                            const isStatic = resolvePageRenderMode(route) === 'static';
                             const shouldUseCache = staticPagesService.shouldUseCache();
+                            // we can't use cache for wildcard routes,
+                            // because wildcard routes can match any possible urls
+                            const isWildcardRoute = route
+                                ? router.isWildcard(route.path)
+                                : routeTree.getWildcard(pathname);
+                            // routes can be resolved in runtime with ROUTE_RESOLVE_TOKEN,
+                            // but this routes exists only in Request scope, so we use STATIC_PAGES_ROUTE_TREE
+                            // to save minimal info about resolved routes between requests, because
+                            // we want to be sure that we use cache and revalidation only for resolved routes
+                            const isUnknownRoute = !route && !routeTree.getRoute(pathname);
                             if (isStatic) {
                                 responseManager.setHeader('X-Tramvai-Static-Page-Key', staticPagesKey());
                                 // we need to tell for `tramvai static` prerendering command that this page has `static` render mode,
@@ -274,16 +304,23 @@ const staticPagesProviders = [
                                 if (isPrerenderRequest && route) {
                                     responseManager.setHeader('X-Tramvai-Static-Page-Route', JSON.stringify(route));
                                 }
-                                if (shouldUseCache) {
-                                    log.debug(`Should use static pages cache: ${pathname}`);
+                                if (shouldUseCache && !isWildcardRoute && !isUnknownRoute) {
+                                    log.info(`Should use static pages cache: ${pathname}`);
                                     await staticPagesService.respond(() => {
-                                        log.debug(`Successful static page response from cache: ${pathname}`);
+                                        log.info(`Successful static page response from cache: ${pathname}`);
                                         staticPagesCacheMetrics.hit.inc();
-                                        throw new error.StopCommandLineRunnerError();
+                                        throw STOP_COMMAND_LINE_ERROR;
                                     });
                                 }
                                 else {
-                                    log.debug(`Static pages cache is not used for this request: ${pathname}`);
+                                    let msg = `Static pages cache is not used for this request: ${pathname}`;
+                                    if (shouldUseCache && isWildcardRoute) {
+                                        msg += `, because wildcard route was resolved`;
+                                    }
+                                    else if (shouldUseCache && isUnknownRoute) {
+                                        msg += `, because route for this url was never resolved`;
+                                    }
+                                    log.info(msg);
                                 }
                             }
                         };
@@ -299,6 +336,7 @@ const staticPagesProviders = [
                         resolvePageRenderMode: privateTokens.STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE,
                         router: core.optional(tokensRouter.ROUTER_TOKEN),
                         pageRegistry: core.optional(tokensRouter.PAGE_REGISTRY_TOKEN),
+                        routeTree: tokens.STATIC_PAGES_ROUTE_TREE,
                     },
                 });
             };
@@ -371,6 +409,37 @@ const staticPagesProviders = [
             logger: tokensCommon.LOGGER_TOKEN,
         },
     }),
+    core.provide({
+        provide: tokens.STATIC_PAGES_ROUTE_TREE,
+        scope: core.Scope.SINGLETON,
+        useFactory: ({ di }) => {
+            const staticRoutes = di.get(core.optional(tokensRouter.ROUTES_TOKEN)) ?? [];
+            return new router.RouteTree(flatten__default["default"](staticRoutes).map((route) => ({ name: route.name, path: route.path })));
+        },
+        deps: {
+            di: core.DI_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: core.commandLineListTokens.clear,
+        useFactory: ({ router, routeTree }) => {
+            return () => {
+                const currentUrl = router.getCurrentUrl();
+                const currentRoute = router.getCurrentRoute();
+                // save dynamically resolved route in route tree to use it in next requests before route resolving
+                if (currentRoute && currentUrl && !routeTree.getRoute(currentUrl.pathname)) {
+                    routeTree.addRoute({
+                        name: currentRoute.name,
+                        path: currentRoute.path,
+                    });
+                }
+            };
+        },
+        deps: {
+            router: tokensRouter.ROUTER_TOKEN,
+            routeTree: tokens.STATIC_PAGES_ROUTE_TREE,
+        },
+    }),
 ];
 
 exports.staticPagesProviders = staticPagesProviders;

package/lib/tokens.browser.js

@@ -28,5 +28,8 @@ const STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN = createToken('static pages cache-
     scope: Scope.REQUEST,
 });
 const STATIC_PAGES_SERVICE = createToken('static pages service');
+const STATIC_PAGES_ROUTE_TREE = createToken('static pages route tree', {
+    scope: Scope.SINGLETON,
+});
 
-export { PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT, PAGE_RENDER_DEFAULT_MODE, PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_WRAPPER_TYPE, STATIC_PAGES_BACKGROUND_FETCH_ENABLED, STATIC_PAGES_CACHE_5xx_RESPONSE, STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN, STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_COMMAND_LINE, STATIC_PAGES_FS_CACHE_ENABLED, STATIC_PAGES_FS_CACHE_OPTIONS_TOKEN, STATIC_PAGES_KEY_TOKEN, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_SERVICE, STATIC_PAGES_SHOULD_USE_CACHE };
+export { PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT, PAGE_RENDER_DEFAULT_MODE, PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_WRAPPER_TYPE, STATIC_PAGES_BACKGROUND_FETCH_ENABLED, STATIC_PAGES_CACHE_5xx_RESPONSE, STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN, STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_COMMAND_LINE, STATIC_PAGES_FS_CACHE_ENABLED, STATIC_PAGES_FS_CACHE_OPTIONS_TOKEN, STATIC_PAGES_KEY_TOKEN, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_ROUTE_TREE, STATIC_PAGES_SERVICE, STATIC_PAGES_SHOULD_USE_CACHE };

package/lib/tokens.d.ts

@@ -1,5 +1,6 @@
 import type { TramvaiRenderMode } from '@tramvai/tokens-render';
 import type { Cache, ResponseManager } from '@tramvai/tokens-common';
+import { RouteTree } from '@tinkoff/router';
 import { StaticPagesService } from './staticPages/staticPagesService';
 export declare const PAGE_RENDER_FALLBACK_COMPONENT_PREFIX: string & {
     __type?: "base token" | undefined;
@@ -53,10 +54,18 @@ export interface StaticPagesOptions {
     allowStale: boolean;
     /**
      * Whitelist of headers, that are allowed to be passed from client request to backround cache revalidation request,
-     * and allowed to be cached and returned with the cached response
+     * and allowed to be cached and returned with the cached response.
+     * Some headers are required and can't be removed from this list:
+     * ['Location', 'Content-Type', 'Content-Length', 'X-App-Id', 'X-Original-Host', 'Host', 'X-Forwarded-Host', 'X-Forwarded-Proto']
      * @default []
      */
     allowedHeaders: string[];
+    /**
+     * Whitelist of query parameters, that are allowed to be passed from client request to backround cache revalidation request,
+     * and allowed to be cached and returned with the cached response
+     * @default []
+     */
+    allowedQuery: string[];
 }
 export declare const STATIC_PAGES_CACHE_TOKEN: Cache<StaticPagesCacheEntry> & {
     __type?: "base token" | undefined;
@@ -142,4 +151,7 @@ export declare const STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN: ((entry: {
 export declare const STATIC_PAGES_SERVICE: StaticPagesService & {
     __type?: "base token" | undefined;
 };
+export declare const STATIC_PAGES_ROUTE_TREE: RouteTree & {
+    __type?: "base token" | undefined;
+};
 //# sourceMappingURL=tokens.d.ts.map

package/lib/tokens.es.js

@@ -28,5 +28,8 @@ const STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN = createToken('static pages cache-
     scope: Scope.REQUEST,
 });
 const STATIC_PAGES_SERVICE = createToken('static pages service');
+const STATIC_PAGES_ROUTE_TREE = createToken('static pages route tree', {
+    scope: Scope.SINGLETON,
+});
 
-export { PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT, PAGE_RENDER_DEFAULT_MODE, PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_WRAPPER_TYPE, STATIC_PAGES_BACKGROUND_FETCH_ENABLED, STATIC_PAGES_CACHE_5xx_RESPONSE, STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN, STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_COMMAND_LINE, STATIC_PAGES_FS_CACHE_ENABLED, STATIC_PAGES_FS_CACHE_OPTIONS_TOKEN, STATIC_PAGES_KEY_TOKEN, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_SERVICE, STATIC_PAGES_SHOULD_USE_CACHE };
+export { PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT, PAGE_RENDER_DEFAULT_MODE, PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_WRAPPER_TYPE, STATIC_PAGES_BACKGROUND_FETCH_ENABLED, STATIC_PAGES_CACHE_5xx_RESPONSE, STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN, STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_COMMAND_LINE, STATIC_PAGES_FS_CACHE_ENABLED, STATIC_PAGES_FS_CACHE_OPTIONS_TOKEN, STATIC_PAGES_KEY_TOKEN, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_ROUTE_TREE, STATIC_PAGES_SERVICE, STATIC_PAGES_SHOULD_USE_CACHE };

package/lib/tokens.js

@@ -32,6 +32,9 @@ const STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN = dippy.createToken('static pages
     scope: dippy.Scope.REQUEST,
 });
 const STATIC_PAGES_SERVICE = dippy.createToken('static pages service');
+const STATIC_PAGES_ROUTE_TREE = dippy.createToken('static pages route tree', {
+    scope: dippy.Scope.SINGLETON,
+});
 
 exports.PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT = PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT;
 exports.PAGE_RENDER_DEFAULT_MODE = PAGE_RENDER_DEFAULT_MODE;
@@ -47,5 +50,6 @@ exports.STATIC_PAGES_FS_CACHE_OPTIONS_TOKEN = STATIC_PAGES_FS_CACHE_OPTIONS_TOKE
 exports.STATIC_PAGES_KEY_TOKEN = STATIC_PAGES_KEY_TOKEN;
 exports.STATIC_PAGES_MODIFY_CACHE = STATIC_PAGES_MODIFY_CACHE;
 exports.STATIC_PAGES_OPTIONS_TOKEN = STATIC_PAGES_OPTIONS_TOKEN;
+exports.STATIC_PAGES_ROUTE_TREE = STATIC_PAGES_ROUTE_TREE;
 exports.STATIC_PAGES_SERVICE = STATIC_PAGES_SERVICE;
 exports.STATIC_PAGES_SHOULD_USE_CACHE = STATIC_PAGES_SHOULD_USE_CACHE;

package/lib/utils/getPageRenderMode.browser.js

@@ -1,5 +1,5 @@
-const getPageRenderMode = ({ requestManager, router, pageService, defaultRenderMode, fileSystemCache, }) => {
-    const resolvedRoute = router?.getCurrentRoute() ?? router?.resolve(requestManager.getParsedUrl().pathname);
+const getPageRenderMode = ({ requestManager, router, route, pageService, defaultRenderMode, fileSystemCache, }) => {
+    const resolvedRoute = route ?? router?.getCurrentRoute() ?? router?.resolve(requestManager.getParsedUrl().pathname);
     // if we can't resolve route, it means that we are on 404 page, or has dynamic routing,
     // so we can't determine render mode by page config or page component property, and should fallback to default render mode
     if (!resolvedRoute) {

package/lib/utils/getPageRenderMode.d.ts

@@ -2,11 +2,13 @@ import type { ExtractDependencyType } from '@tinkoff/dippy';
 import type { TramvaiRenderMode } from '@tramvai/tokens-render';
 import type { PAGE_SERVICE_TOKEN, ROUTER_TOKEN } from '@tramvai/tokens-router';
 import { REQUEST_MANAGER_TOKEN } from '@tramvai/tokens-common';
+import { Route } from '@tinkoff/router';
 import type { PAGE_RENDER_DEFAULT_MODE } from '../tokens';
 import { STATIC_PAGES_FS_CACHE_TOKEN } from '../private-tokens';
-export declare const getPageRenderMode: ({ requestManager, router, pageService, defaultRenderMode, fileSystemCache, }: {
+export declare const getPageRenderMode: ({ requestManager, router, route, pageService, defaultRenderMode, fileSystemCache, }: {
     requestManager: ExtractDependencyType<typeof REQUEST_MANAGER_TOKEN>;
     router: ExtractDependencyType<typeof ROUTER_TOKEN> | null;
+    route?: Route | undefined;
     pageService: ExtractDependencyType<typeof PAGE_SERVICE_TOKEN> | null;
     defaultRenderMode: ExtractDependencyType<typeof PAGE_RENDER_DEFAULT_MODE>;
     fileSystemCache?: import("../staticPages/fileSystemCache").FileSystemCache | null | undefined;

package/lib/utils/getPageRenderMode.es.js

@@ -1,5 +1,5 @@
-const getPageRenderMode = ({ requestManager, router, pageService, defaultRenderMode, fileSystemCache, }) => {
-    const resolvedRoute = router?.getCurrentRoute() ?? router?.resolve(requestManager.getParsedUrl().pathname);
+const getPageRenderMode = ({ requestManager, router, route, pageService, defaultRenderMode, fileSystemCache, }) => {
+    const resolvedRoute = route ?? router?.getCurrentRoute() ?? router?.resolve(requestManager.getParsedUrl().pathname);
     // if we can't resolve route, it means that we are on 404 page, or has dynamic routing,
     // so we can't determine render mode by page config or page component property, and should fallback to default render mode
     if (!resolvedRoute) {

package/lib/utils/getPageRenderMode.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const getPageRenderMode = ({ requestManager, router, pageService, defaultRenderMode, fileSystemCache, }) => {
-    const resolvedRoute = router?.getCurrentRoute() ?? router?.resolve(requestManager.getParsedUrl().pathname);
+const getPageRenderMode = ({ requestManager, router, route, pageService, defaultRenderMode, fileSystemCache, }) => {
+    const resolvedRoute = route ?? router?.getCurrentRoute() ?? router?.resolve(requestManager.getParsedUrl().pathname);
     // if we can't resolve route, it means that we are on 404 page, or has dynamic routing,
     // so we can't determine render mode by page config or page component property, and should fallback to default render mode
     if (!resolvedRoute) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-page-render-mode",
-  "version": "7.11.0",
+  "version": "7.16.0",
   "description": "Enable different rendering modes for pages",
   "main": "./lib/server.js",
   "module": "./lib/server.es.js",
@@ -28,21 +28,21 @@
     "p-limit": "^3"
   },
   "peerDependencies": {
-    "@tinkoff/dippy": "0.13.2",
-    "@tinkoff/router": "0.7.32",
+    "@tinkoff/dippy": "^1.0.0",
+    "@tinkoff/router": "0.7.55",
     "@tinkoff/utils": "^2.1.2",
-    "@tramvai/core": "7.11.0",
-    "@tramvai/module-client-hints": "7.11.0",
-    "@tramvai/module-router": "7.11.0",
-    "@tramvai/papi": "7.11.0",
-    "@tramvai/react": "7.11.0",
-    "@tramvai/tokens-common": "7.11.0",
-    "@tramvai/tokens-core": "7.11.0",
-    "@tramvai/tokens-metrics": "7.11.0",
-    "@tramvai/tokens-render": "7.11.0",
-    "@tramvai/tokens-router": "7.11.0",
-    "@tramvai/tokens-server": "7.11.0",
-    "@tramvai/tokens-server-private": "7.11.0",
+    "@tramvai/core": "7.16.0",
+    "@tramvai/module-client-hints": "7.16.0",
+    "@tramvai/module-router": "7.16.0",
+    "@tramvai/papi": "7.16.0",
+    "@tramvai/react": "7.16.0",
+    "@tramvai/tokens-common": "7.16.0",
+    "@tramvai/tokens-core": "7.16.0",
+    "@tramvai/tokens-metrics": "7.16.0",
+    "@tramvai/tokens-render": "7.16.0",
+    "@tramvai/tokens-router": "7.16.0",
+    "@tramvai/tokens-server": "7.16.0",
+    "@tramvai/tokens-server-private": "7.16.0",
     "prom-client": "^14.2.0",
     "react": ">=16.14.0",
     "tslib": "^2.4.0"