@tramvai/module-page-render-mode 2.70.1 → 2.72.3

package/lib/server.es.js

@@ -1,582 +1,8 @@
-import { declareModule, provide, commandLineListTokens, createToken as createToken$1, Scope, DI_TOKEN } from '@tramvai/core';
-import { ENV_USED_TOKEN, ENV_MANAGER_TOKEN, COMPONENT_REGISTRY_TOKEN, CREATE_CACHE_TOKEN, REQUEST_MANAGER_TOKEN, LOGGER_TOKEN, RESPONSE_MANAGER_TOKEN } from '@tramvai/tokens-common';
-import { TRAMVAI_RENDER_MODE, LAYOUT_OPTIONS, MODERN_SATISFIES_TOKEN } from '@tramvai/tokens-render';
-import { ROUTER_TOKEN, PAGE_SERVICE_TOKEN } from '@tramvai/tokens-router';
-import { createToken } from '@tinkoff/dippy';
-import { jsx, Fragment } from 'react/jsx-runtime';
-import { useState, useEffect } from 'react';
-import { useDi } from '@tramvai/react';
-import isEmpty from '@tinkoff/utils/is/empty';
-import { FASTIFY_RESPONSE } from '@tramvai/tokens-server-private';
-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 { SilentError } from '@tinkoff/errors';
-import fetch from 'node-fetch';
-import { format } from '@tinkoff/url';
-
-const PAGE_RENDER_FALLBACK_COMPONENT_PREFIX = createToken('pageRenderFallbackComponentName');
-/**
- * @deprecated Use token `TRAMVAI_RENDER_MODE` from `@tramvai/tokens-render`
- */
-const PAGE_RENDER_DEFAULT_MODE = createToken('pageRenderDefaultMode');
-const PAGE_RENDER_WRAPPER_TYPE = createToken('pageRenderWrapperType');
-const PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT = createToken('pageRenderDefaultFallbackComponent');
-const STATIC_PAGES_CACHE_TOKEN = createToken('static pages cache');
-const STATIC_PAGES_SHOULD_USE_CACHE = createToken('static pages should use cache');
-const STATIC_PAGES_SHOULD_SET_TO_CACHE = createToken('static pages should set to cache');
-const STATIC_PAGES_BACKGROUND_FETCH_ENABLED = createToken('static pages can fetch page');
-const STATIC_PAGES_OPTIONS_TOKEN = createToken('static pages options');
-const STATIC_PAGES_COMMAND_LINE = createToken('static pages command line');
-const STATIC_PAGES_MODIFY_CACHE = createToken('static pages modify cache', { multi: true });
-const STATIC_PAGES_CACHE_5xx_RESPONSE = createToken('static pages cache 5xx response');
-
-// default internal bundle, used for File-System components
-const FALLBACK_GROUP = '__default';
-// just some unic name
-const FALLBACK_NAME = '__csr_fallback__';
-// just some unic path
-const FALLBACK_PATH = '/__csr_fallback__/';
-// env for force CSR mode
-const FORCE_RENDER_ENV_KEY = 'TRAMVAI_FORCE_CLIENT_SIDE_RENDERING';
-const FALLBACK_ROUTE = {
-    name: FALLBACK_NAME,
-    path: FALLBACK_PATH,
-    config: {
-        bundle: FALLBACK_GROUP,
-        pageComponent: FALLBACK_NAME,
-    },
-};
-/**
- * Module for force CSR mode, only add logic when `TRAMVAI_FORCE_CLIENT_SIDE_RENDERING=true` env variable is set
- */
-const ForceCSRModule = declareModule({
-    name: 'ForceCSRModule',
-    providers: [
-        provide({
-            provide: ENV_USED_TOKEN,
-            useValue: [{ key: FORCE_RENDER_ENV_KEY, optional: true }],
-        }),
-        // set CSR mode globally
-        provide({
-            provide: TRAMVAI_RENDER_MODE,
-            useFactory: ({ envManager }) => envManager.get(FORCE_RENDER_ENV_KEY) === 'true' ? 'client' : 'ssr',
-            deps: {
-                envManager: ENV_MANAGER_TOKEN,
-            },
-        }),
-        // register CSR fallback component
-        provide({
-            provide: commandLineListTokens.listen,
-            useFactory: ({ componentRegistry, fallback, envManager }) => {
-                return function addCSRFallbackCompnent() {
-                    if (envManager.get(FORCE_RENDER_ENV_KEY) === 'true') {
-                        componentRegistry.add(FALLBACK_NAME, fallback, FALLBACK_GROUP);
-                    }
-                };
-            },
-            deps: {
-                componentRegistry: COMPONENT_REGISTRY_TOKEN,
-                fallback: { token: PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT, optional: true },
-                envManager: ENV_MANAGER_TOKEN,
-            },
-        }),
-        // add CSR fallback route
-        provide({
-            provide: commandLineListTokens.customerStart,
-            useFactory: ({ router, envManager }) => {
-                return function addCSRFallbackRoute() {
-                    if (envManager.get(FORCE_RENDER_ENV_KEY) === 'true') {
-                        router.registerHook('beforeResolve', async () => {
-                            router.addRoute(FALLBACK_ROUTE);
-                        });
-                    }
-                };
-            },
-            deps: {
-                router: ROUTER_TOKEN,
-                envManager: ENV_MANAGER_TOKEN,
-            },
-        }),
-        // tramvai static will not generate CSR fallback if /bundleInfo is not contains this route
-        {
-            provide: 'router bundleInfoAdditional',
-            useFactory: ({ envManager }) => () => envManager.get(FORCE_RENDER_ENV_KEY) === 'true' ? FALLBACK_ROUTE : null,
-            deps: {
-                envManager: ENV_MANAGER_TOKEN,
-            },
-        },
-    ],
-});
-
-const getPageRenderMode = ({ pageService, defaultRenderMode, }) => {
-    var _a;
-    const { pageComponent, pageRenderMode } = pageService.getConfig();
-    const { renderMode } = (_a = pageService.getComponent(pageComponent)) !== null && _a !== void 0 ? _a : {};
-    const mode = pageRenderMode || renderMode || defaultRenderMode;
-    return mode;
-};
-
-const PageRenderWrapper = ({ children }) => {
-    const [mounted, setMounted] = useState(false);
-    const pageService = useDi(PAGE_SERVICE_TOKEN);
-    const fallbackKey = useDi(PAGE_RENDER_FALLBACK_COMPONENT_PREFIX);
-    const defaultRenderMode = useDi(PAGE_RENDER_DEFAULT_MODE);
-    const DefaultFallbackComponent = useDi({
-        token: PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT,
-        optional: true,
-    });
-    const FallbackComponent = pageService.resolveComponentFromConfig(fallbackKey) || DefaultFallbackComponent;
-    const mode = getPageRenderMode({ pageService, defaultRenderMode });
-    useEffect(() => {
-        if (mode === 'client') {
-            setMounted(true);
-        }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, []);
-    if (mode === 'client' && !mounted) {
-        if (FallbackComponent) {
-            return jsx(FallbackComponent, {});
-        }
-        return null;
-    }
-    return jsx(Fragment, { children: children });
-};
-const pageRenderHOC = (WrapperPage) => (props) => {
-    return (jsx(PageRenderWrapper, { children: jsx(WrapperPage, { ...props }) }));
-};
-
-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',
-    },
-];
-
-class StopCommandLineRunnerError extends SilentError {
-    constructor() {
-        super('Prevent CommandLineRunner from execution');
-        this.name = StopCommandLineRunnerError.errorName;
-    }
-}
-StopCommandLineRunnerError.errorName = 'StopCommandLineRunnerError';
-
-const getCacheKey = ({ method, host, path, deviceType, modern, }) => {
-    return `${method}=${host}=${path}=${deviceType}=${modern ? 'modern' : 'default'}`;
-};
-
-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);
-        });
-    }
-}
-
-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(),
-        });
-    }
-}
-
-const STATIC_PAGES_BACKGROUND_FETCH_SERVICE = createToken$1();
-const STATIC_PAGES_GET_CACHE_KEY_TOKEN = createToken$1();
-const STATIC_PAGES_CACHE_HIT_METRIC_TOKEN = createToken$1();
-const STATIC_PAGES_SERVICE = createToken$1();
-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,
-        },
-    }),
-];
+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_TOKEN, STATIC_PAGES_COMMAND_LINE, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_SHOULD_SET_TO_CACHE, STATIC_PAGES_SHOULD_USE_CACHE } from './tokens.es.js';
 
 // @todo: перенести в @tramvai/module-render
 const PageRenderModeModule = declareModule({
@@ -585,4 +11,4 @@ const PageRenderModeModule = declareModule({
     providers: [...sharedProviders, ...staticPagesProviders],
 });
 
-export { PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT, PAGE_RENDER_DEFAULT_MODE, PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_WRAPPER_TYPE, PageRenderModeModule, STATIC_PAGES_BACKGROUND_FETCH_ENABLED, STATIC_PAGES_CACHE_5xx_RESPONSE, STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_COMMAND_LINE, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_SHOULD_SET_TO_CACHE, STATIC_PAGES_SHOULD_USE_CACHE };
+export { PageRenderModeModule };