@tramvai/module-server 2.79.7 → 2.82.0

package/lib/modules/serverTiming.d.ts

@@ -1,6 +1,3 @@
 export declare const ServerTimingModule: import("@tinkoff/dippy/lib/modules/module.h").ModuleClass & Partial<import("@tinkoff/dippy/lib/modules/module.h").ModuleSecretParameters> & {
-    [x: string]: (...args: any[]) => {
-        mainModule: import("@tramvai/core").ModuleType<import("@tinkoff/dippy/lib/modules/module.h").ModuleClass>;
-        providers: import("@tramvai/core").Provider<any, any>[];
-    };
+    [x: string]: (...args: any[]) => import("@tramvai/core").ModuleType<import("@tinkoff/dippy/lib/modules/module.h").ModuleClass>;
 };

package/lib/server/error.d.ts

@@ -1,10 +1,11 @@
 import type { FastifyInstance } from 'fastify';
 import type { LOGGER_TOKEN } from '@tramvai/module-common';
-import type { WEB_FASTIFY_APP_AFTER_ERROR_TOKEN, WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN, WEB_FASTIFY_APP_PROCESS_ERROR_TOKEN } from '@tramvai/tokens-server-private';
+import type { WEB_FASTIFY_APP_AFTER_ERROR_TOKEN, WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN } from '@tramvai/tokens-server-private';
 import type { ExtractDependencyType } from '@tinkoff/dippy';
-export declare const errorHandler: (app: FastifyInstance, { log, beforeError, processError, afterError, }: {
+import type { ROOT_ERROR_BOUNDARY_COMPONENT_TOKEN } from '@tramvai/react';
+export declare const errorHandler: (app: FastifyInstance, { log, beforeError, afterError, RootErrorBoundary, }: {
     log: ReturnType<typeof LOGGER_TOKEN>;
     beforeError: ExtractDependencyType<typeof WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN>;
-    processError: ExtractDependencyType<typeof WEB_FASTIFY_APP_PROCESS_ERROR_TOKEN>;
     afterError: ExtractDependencyType<typeof WEB_FASTIFY_APP_AFTER_ERROR_TOKEN>;
+    RootErrorBoundary?: ExtractDependencyType<typeof ROOT_ERROR_BOUNDARY_COMPONENT_TOKEN>;
 }) => void;

package/lib/server/error.es.js

@@ -1,7 +1,11 @@
 import isNil from '@tinkoff/utils/is/nil';
+import { createElement } from 'react';
+import { renderToString } from 'react-dom/server';
+import { parse } from '@tinkoff/url';
 import { isRedirectFoundError, isNotFoundError, isHttpError } from '@tinkoff/errors';
 
-const errorHandler = (app, { log, beforeError, processError, afterError, }) => {
+const errorHandler = (app, { log, beforeError, afterError, RootErrorBoundary, }) => {
+    // eslint-disable-next-line max-statements
     app.setErrorHandler(async (error, request, reply) => {
         const runHandlers = async (handlers) => {
             if (handlers) {
@@ -13,40 +17,113 @@ const errorHandler = (app, { log, beforeError, processError, afterError, }) => {
                 }
             }
         };
+        const beforeErrorResult = await runHandlers(beforeError);
+        if (!isNil(beforeErrorResult)) {
+            return beforeErrorResult;
+        }
         const requestInfo = {
             ip: request.ip,
             requestId: request.headers['x-request-id'],
             url: request.url,
         };
-        const beforeErrorResult = await runHandlers(beforeError);
-        if (!isNil(beforeErrorResult)) {
-            return beforeErrorResult;
-        }
         if (isRedirectFoundError(error)) {
+            log.info({
+                event: 'redirect-found-error',
+                message: `RedirectFoundError, redirect to ${error.nextUrl}, action execution will be aborted.
+More information about redirects - https://tramvai.dev/docs/features/routing/redirects`,
+                error,
+                requestInfo,
+            });
             reply.header('cache-control', 'no-cache, no-store, must-revalidate');
             reply.redirect(error.httpStatus || 307, error.nextUrl);
             return;
         }
+        let httpStatus;
+        let logLevel;
+        let logEvent;
+        let logMessage;
         if (isNotFoundError(error)) {
-            reply.status(404);
-            return '';
-        }
-        const processErrorResult = await runHandlers(processError);
-        if (!isNil(processErrorResult)) {
-            return processErrorResult;
+            httpStatus = error.httpStatus || 404;
+            logLevel = 'info';
+            logEvent = 'not-found-error';
+            logMessage = `NotFoundError, action execution will be aborted.
+Not Found page is common use-case with this error - https://tramvai.dev/docs/features/routing/wildcard-routes/#not-found-page`;
         }
-        if (isHttpError(error)) {
+        else if (isHttpError(error)) {
+            httpStatus = error.httpStatus || 500;
             if (error.httpStatus >= 500) {
-                log.error({ event: 'send-server-error', error, requestInfo });
+                logLevel = 'error';
+                logEvent = 'send-server-error';
+                logMessage = `This is expected server error, here is most common cases:
+- Router Guard blocked request - https://tramvai.dev/docs/features/routing/hooks-and-guards#guards
+- Forced Page Error Boundary render with 5xx code in Guard or Action - https://tramvai.dev/docs/features/error-boundaries#force-render-page-error-boundary-in-action`;
+            }
+            else {
+                logLevel = 'info';
+                logEvent = 'http-error';
+                logMessage = `This is expected server error, here is most common cases:
+  - Route is not found - https://tramvai.dev/docs/features/routing/flow#server-navigation
+  - Forced Page Error Boundary render with 4xx code in Guard or Action - https://tramvai.dev/docs/features/error-boundaries#force-render-page-error-boundary-in-action
+  - Request Limiter blocked request with 429 code - https://tramvai.dev/docs/references/modules/request-limiter/`;
+            }
+        }
+        else {
+            httpStatus = error.statusCode || 500;
+            if (error.statusCode >= 500) {
+                logLevel = 'error';
+                logEvent = 'send-server-error';
+                logMessage = `This is Fastify 5xx error, you can check ${error.code} code in https://www.fastify.io/docs/latest/Reference/Errors/#${error.code.toLowerCase()} page`;
+            }
+            else if (error.statusCode >= 400) {
+                // a lot of noise with FST_ERR_CTP_INVALID_MEDIA_TYPE 4xx logs from Fastify,
+                // when somebody tries to scan our site and send some unsupported content types
+                logLevel = 'info';
+                logEvent = 'fastify-error-4xx';
+                logMessage = `This is Fastify 4xx error, you can check ${error.code} code in https://www.fastify.io/docs/latest/Reference/Errors/#${error.code.toLowerCase()} page`;
+            }
+            else {
+                logLevel = 'error';
+                logEvent = 'send-server-error';
+                logMessage = `Unexpected server error. Error cause will be in "error" parameter.
+  Most likely an error has occurred in the rendering of the current React page component
+  You can try to find relative logs by using "x-request-id" header`;
             }
-            reply.status(error.httpStatus);
-            return '';
         }
-        log.error({ event: 'send-server-error', error, requestInfo });
+        logMessage = `${logMessage}
+${RootErrorBoundary
+            ? 'Root Error Boundary will be rendered for the client'
+            : 'You can add Error Boundary for better UX - https://tramvai.dev/docs/features/error-boundaries'}'`;
+        log[logLevel]({
+            event: logEvent,
+            message: logMessage,
+            error,
+            requestInfo,
+        });
         const afterErrorResult = await runHandlers(afterError);
         if (!isNil(afterErrorResult)) {
             return afterErrorResult;
         }
+        reply.status(httpStatus);
+        if (RootErrorBoundary) {
+            try {
+                const body = renderToString(createElement(RootErrorBoundary, { error, url: parse(request.url) }));
+                log.info({
+                    event: 'render-root-error-boundary',
+                    message: 'Render Root Error Boundary for the client',
+                });
+                reply.header('Content-Type', 'text/html; charset=utf-8');
+                reply.header('Content-Length', Buffer.byteLength(body, 'utf8'));
+                reply.header('Cache-Control', 'no-cache, no-store, must-revalidate');
+                return body;
+            }
+            catch (e) {
+                log.warn({
+                    event: 'failed-root-error-boundary',
+                    message: 'Root Error Boundary rendering failed',
+                    error: e,
+                });
+            }
+        }
         throw error;
     });
 };

package/lib/server/error.js

@@ -3,13 +3,17 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var isNil = require('@tinkoff/utils/is/nil');
+var react = require('react');
+var server = require('react-dom/server');
+var url = require('@tinkoff/url');
 var errors = require('@tinkoff/errors');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var isNil__default = /*#__PURE__*/_interopDefaultLegacy(isNil);
 
-const errorHandler = (app, { log, beforeError, processError, afterError, }) => {
+const errorHandler = (app, { log, beforeError, afterError, RootErrorBoundary, }) => {
+    // eslint-disable-next-line max-statements
     app.setErrorHandler(async (error, request, reply) => {
         const runHandlers = async (handlers) => {
             if (handlers) {
@@ -21,40 +25,113 @@ const errorHandler = (app, { log, beforeError, processError, afterError, }) => {
                 }
             }
         };
+        const beforeErrorResult = await runHandlers(beforeError);
+        if (!isNil__default["default"](beforeErrorResult)) {
+            return beforeErrorResult;
+        }
         const requestInfo = {
             ip: request.ip,
             requestId: request.headers['x-request-id'],
             url: request.url,
         };
-        const beforeErrorResult = await runHandlers(beforeError);
-        if (!isNil__default["default"](beforeErrorResult)) {
-            return beforeErrorResult;
-        }
         if (errors.isRedirectFoundError(error)) {
+            log.info({
+                event: 'redirect-found-error',
+                message: `RedirectFoundError, redirect to ${error.nextUrl}, action execution will be aborted.
+More information about redirects - https://tramvai.dev/docs/features/routing/redirects`,
+                error,
+                requestInfo,
+            });
             reply.header('cache-control', 'no-cache, no-store, must-revalidate');
             reply.redirect(error.httpStatus || 307, error.nextUrl);
             return;
         }
+        let httpStatus;
+        let logLevel;
+        let logEvent;
+        let logMessage;
         if (errors.isNotFoundError(error)) {
-            reply.status(404);
-            return '';
-        }
-        const processErrorResult = await runHandlers(processError);
-        if (!isNil__default["default"](processErrorResult)) {
-            return processErrorResult;
+            httpStatus = error.httpStatus || 404;
+            logLevel = 'info';
+            logEvent = 'not-found-error';
+            logMessage = `NotFoundError, action execution will be aborted.
+Not Found page is common use-case with this error - https://tramvai.dev/docs/features/routing/wildcard-routes/#not-found-page`;
         }
-        if (errors.isHttpError(error)) {
+        else if (errors.isHttpError(error)) {
+            httpStatus = error.httpStatus || 500;
             if (error.httpStatus >= 500) {
-                log.error({ event: 'send-server-error', error, requestInfo });
+                logLevel = 'error';
+                logEvent = 'send-server-error';
+                logMessage = `This is expected server error, here is most common cases:
+- Router Guard blocked request - https://tramvai.dev/docs/features/routing/hooks-and-guards#guards
+- Forced Page Error Boundary render with 5xx code in Guard or Action - https://tramvai.dev/docs/features/error-boundaries#force-render-page-error-boundary-in-action`;
+            }
+            else {
+                logLevel = 'info';
+                logEvent = 'http-error';
+                logMessage = `This is expected server error, here is most common cases:
+  - Route is not found - https://tramvai.dev/docs/features/routing/flow#server-navigation
+  - Forced Page Error Boundary render with 4xx code in Guard or Action - https://tramvai.dev/docs/features/error-boundaries#force-render-page-error-boundary-in-action
+  - Request Limiter blocked request with 429 code - https://tramvai.dev/docs/references/modules/request-limiter/`;
+            }
+        }
+        else {
+            httpStatus = error.statusCode || 500;
+            if (error.statusCode >= 500) {
+                logLevel = 'error';
+                logEvent = 'send-server-error';
+                logMessage = `This is Fastify 5xx error, you can check ${error.code} code in https://www.fastify.io/docs/latest/Reference/Errors/#${error.code.toLowerCase()} page`;
+            }
+            else if (error.statusCode >= 400) {
+                // a lot of noise with FST_ERR_CTP_INVALID_MEDIA_TYPE 4xx logs from Fastify,
+                // when somebody tries to scan our site and send some unsupported content types
+                logLevel = 'info';
+                logEvent = 'fastify-error-4xx';
+                logMessage = `This is Fastify 4xx error, you can check ${error.code} code in https://www.fastify.io/docs/latest/Reference/Errors/#${error.code.toLowerCase()} page`;
+            }
+            else {
+                logLevel = 'error';
+                logEvent = 'send-server-error';
+                logMessage = `Unexpected server error. Error cause will be in "error" parameter.
+  Most likely an error has occurred in the rendering of the current React page component
+  You can try to find relative logs by using "x-request-id" header`;
             }
-            reply.status(error.httpStatus);
-            return '';
         }
-        log.error({ event: 'send-server-error', error, requestInfo });
+        logMessage = `${logMessage}
+${RootErrorBoundary
+            ? 'Root Error Boundary will be rendered for the client'
+            : 'You can add Error Boundary for better UX - https://tramvai.dev/docs/features/error-boundaries'}'`;
+        log[logLevel]({
+            event: logEvent,
+            message: logMessage,
+            error,
+            requestInfo,
+        });
         const afterErrorResult = await runHandlers(afterError);
         if (!isNil__default["default"](afterErrorResult)) {
             return afterErrorResult;
         }
+        reply.status(httpStatus);
+        if (RootErrorBoundary) {
+            try {
+                const body = server.renderToString(react.createElement(RootErrorBoundary, { error, url: url.parse(request.url) }));
+                log.info({
+                    event: 'render-root-error-boundary',
+                    message: 'Render Root Error Boundary for the client',
+                });
+                reply.header('Content-Type', 'text/html; charset=utf-8');
+                reply.header('Content-Length', Buffer.byteLength(body, 'utf8'));
+                reply.header('Cache-Control', 'no-cache, no-store, must-revalidate');
+                return body;
+            }
+            catch (e) {
+                log.warn({
+                    event: 'failed-root-error-boundary',
+                    message: 'Root Error Boundary rendering failed',
+                    error: e,
+                });
+            }
+        }
         throw error;
     });
 };

package/lib/server/webApp.d.ts

@@ -1,12 +1,13 @@
 import type { EXECUTION_CONTEXT_MANAGER_TOKEN, LOGGER_TOKEN } from '@tramvai/tokens-common';
 import type { COMMAND_LINE_RUNNER_TOKEN } from '@tramvai/core';
 import type { SERVER_TOKEN } from '@tramvai/tokens-server';
-import type { WEB_FASTIFY_APP_TOKEN, WEB_FASTIFY_APP_AFTER_INIT_TOKEN, WEB_FASTIFY_APP_BEFORE_INIT_TOKEN, WEB_FASTIFY_APP_INIT_TOKEN, WEB_FASTIFY_APP_LIMITER_TOKEN, WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN, WEB_FASTIFY_APP_AFTER_ERROR_TOKEN, WEB_FASTIFY_APP_PROCESS_ERROR_TOKEN, WEB_FASTIFY_APP_METRICS_TOKEN } from '@tramvai/tokens-server-private';
+import type { WEB_FASTIFY_APP_TOKEN, WEB_FASTIFY_APP_AFTER_INIT_TOKEN, WEB_FASTIFY_APP_BEFORE_INIT_TOKEN, WEB_FASTIFY_APP_INIT_TOKEN, WEB_FASTIFY_APP_LIMITER_TOKEN, WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN, WEB_FASTIFY_APP_AFTER_ERROR_TOKEN, WEB_FASTIFY_APP_METRICS_TOKEN } from '@tramvai/tokens-server-private';
 import type { ExtractDependencyType } from '@tinkoff/dippy';
+import type { ROOT_ERROR_BOUNDARY_COMPONENT_TOKEN } from '@tramvai/react';
 export declare const webAppFactory: ({ server }: {
     server: typeof SERVER_TOKEN;
 }) => import("fastify").FastifyInstance<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault> & PromiseLike<import("fastify").FastifyInstance<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>>;
-export declare const webAppInitCommand: ({ app, logger, commandLineRunner, executionContextManager, beforeInit, requestMetrics, limiterRequest, init, afterInit, beforeError, processError, afterError, }: {
+export declare const webAppInitCommand: ({ app, logger, commandLineRunner, executionContextManager, beforeInit, requestMetrics, limiterRequest, init, afterInit, beforeError, afterError, RootErrorBoundary, }: {
     app: ExtractDependencyType<typeof WEB_FASTIFY_APP_TOKEN>;
     logger: ExtractDependencyType<typeof LOGGER_TOKEN>;
     commandLineRunner: ExtractDependencyType<typeof COMMAND_LINE_RUNNER_TOKEN>;
@@ -17,6 +18,6 @@ export declare const webAppInitCommand: ({ app, logger, commandLineRunner, execu
     init: ExtractDependencyType<typeof WEB_FASTIFY_APP_INIT_TOKEN>;
     afterInit: ExtractDependencyType<typeof WEB_FASTIFY_APP_AFTER_INIT_TOKEN>;
     beforeError: ExtractDependencyType<typeof WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN>;
-    processError: ExtractDependencyType<typeof WEB_FASTIFY_APP_PROCESS_ERROR_TOKEN>;
     afterError: ExtractDependencyType<typeof WEB_FASTIFY_APP_AFTER_ERROR_TOKEN>;
+    RootErrorBoundary?: ExtractDependencyType<typeof ROOT_ERROR_BOUNDARY_COMPONENT_TOKEN>;
 }) => () => Promise<void>;

package/lib/server/webApp.es.js

@@ -18,13 +18,13 @@ const webAppFactory = ({ server }) => {
     });
     return app;
 };
-const webAppInitCommand = ({ app, logger, commandLineRunner, executionContextManager, beforeInit, requestMetrics, limiterRequest, init, afterInit, beforeError, processError, afterError, }) => {
+const webAppInitCommand = ({ app, logger, commandLineRunner, executionContextManager, beforeInit, requestMetrics, limiterRequest, init, afterInit, beforeError, afterError, RootErrorBoundary, }) => {
     const log = logger('server:webapp');
     const runHandlers = (instance, handlers) => {
         return Promise.all([handlers && Promise.all(handlers.map((handler) => handler(instance)))]);
     };
     return async function webAppInit() {
-        errorHandler(app, { log, beforeError, processError, afterError });
+        errorHandler(app, { log, beforeError, afterError, RootErrorBoundary });
         await app.register(async (instance) => {
             await runHandlers(instance, beforeInit);
         });

package/lib/server/webApp.js

@@ -27,13 +27,13 @@ const webAppFactory = ({ server }) => {
     });
     return app;
 };
-const webAppInitCommand = ({ app, logger, commandLineRunner, executionContextManager, beforeInit, requestMetrics, limiterRequest, init, afterInit, beforeError, processError, afterError, }) => {
+const webAppInitCommand = ({ app, logger, commandLineRunner, executionContextManager, beforeInit, requestMetrics, limiterRequest, init, afterInit, beforeError, afterError, RootErrorBoundary, }) => {
     const log = logger('server:webapp');
     const runHandlers = (instance, handlers) => {
         return Promise.all([handlers && Promise.all(handlers.map((handler) => handler(instance)))]);
     };
     return async function webAppInit() {
-        error.errorHandler(app, { log, beforeError, processError, afterError });
+        error.errorHandler(app, { log, beforeError, afterError, RootErrorBoundary });
         await app.register(async (instance) => {
             await runHandlers(instance, beforeInit);
         });

package/lib/server.es.js

@@ -4,10 +4,11 @@ import EventEmitter from 'events';
 import { Module, provide, Scope, commandLineListTokens, COMMAND_LINE_RUNNER_TOKEN, APP_INFO_TOKEN } from '@tramvai/core';
 import { SERVER_TOKEN } from '@tramvai/tokens-server';
 export * from '@tramvai/tokens-server';
-import { SERVER_FACTORY_TOKEN, WEB_FASTIFY_APP_FACTORY_TOKEN, WEB_FASTIFY_APP_TOKEN, WEB_FASTIFY_APP_BEFORE_INIT_TOKEN, WEB_FASTIFY_APP_INIT_TOKEN, WEB_FASTIFY_APP_AFTER_INIT_TOKEN, WEB_FASTIFY_APP_METRICS_TOKEN, WEB_FASTIFY_APP_LIMITER_TOKEN, WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN, WEB_FASTIFY_APP_PROCESS_ERROR_TOKEN, WEB_FASTIFY_APP_AFTER_ERROR_TOKEN } from '@tramvai/tokens-server-private';
+import { SERVER_FACTORY_TOKEN, WEB_FASTIFY_APP_FACTORY_TOKEN, WEB_FASTIFY_APP_TOKEN, WEB_FASTIFY_APP_BEFORE_INIT_TOKEN, WEB_FASTIFY_APP_INIT_TOKEN, WEB_FASTIFY_APP_AFTER_INIT_TOKEN, WEB_FASTIFY_APP_METRICS_TOKEN, WEB_FASTIFY_APP_LIMITER_TOKEN, WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN, WEB_FASTIFY_APP_AFTER_ERROR_TOKEN } from '@tramvai/tokens-server-private';
 import { LOGGER_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN, ENV_MANAGER_TOKEN, ENV_USED_TOKEN } from '@tramvai/tokens-common';
 import { MetricsModule } from '@tramvai/module-metrics';
 import { CacheWarmupModule } from '@tramvai/module-cache-warmup';
+import { ROOT_ERROR_BOUNDARY_COMPONENT_TOKEN } from '@tramvai/react';
 import { serverFactory, serverListenCommand } from './server/server.es.js';
 import { webAppFactory, webAppInitCommand } from './server/webApp.es.js';
 import { staticAppCommand } from './server/static.es.js';
@@ -91,8 +92,8 @@ ServerModule = __decorate([
                     requestMetrics: { token: WEB_FASTIFY_APP_METRICS_TOKEN, optional: true },
                     limiterRequest: { token: WEB_FASTIFY_APP_LIMITER_TOKEN, optional: true },
                     beforeError: { token: WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN, optional: true },
-                    processError: { token: WEB_FASTIFY_APP_PROCESS_ERROR_TOKEN, optional: true },
                     afterError: { token: WEB_FASTIFY_APP_AFTER_ERROR_TOKEN, optional: true },
+                    RootErrorBoundary: { token: ROOT_ERROR_BOUNDARY_COMPONENT_TOKEN, optional: true },
                 },
             },
             {

package/lib/server.js

@@ -11,6 +11,7 @@ var tokensServerPrivate = require('@tramvai/tokens-server-private');
 var tokensCommon = require('@tramvai/tokens-common');
 var moduleMetrics = require('@tramvai/module-metrics');
 var moduleCacheWarmup = require('@tramvai/module-cache-warmup');
+var react = require('@tramvai/react');
 var server = require('./server/server.js');
 var webApp = require('./server/webApp.js');
 var _static = require('./server/static.js');
@@ -98,8 +99,8 @@ exports.ServerModule = tslib.__decorate([
                     requestMetrics: { token: tokensServerPrivate.WEB_FASTIFY_APP_METRICS_TOKEN, optional: true },
                     limiterRequest: { token: tokensServerPrivate.WEB_FASTIFY_APP_LIMITER_TOKEN, optional: true },
                     beforeError: { token: tokensServerPrivate.WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN, optional: true },
-                    processError: { token: tokensServerPrivate.WEB_FASTIFY_APP_PROCESS_ERROR_TOKEN, optional: true },
                     afterError: { token: tokensServerPrivate.WEB_FASTIFY_APP_AFTER_ERROR_TOKEN, optional: true },
+                    RootErrorBoundary: { token: react.ROOT_ERROR_BOUNDARY_COMPONENT_TOKEN, optional: true },
                 },
             },
             {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-server",
-  "version": "2.79.7",
+  "version": "2.82.0",
   "description": "",
   "browser": "lib/browser.js",
   "main": "lib/server.js",
@@ -25,11 +25,11 @@
     "@tinkoff/monkeypatch": "2.0.5",
     "@tinkoff/terminus": "0.1.8",
     "@tinkoff/url": "0.8.6",
-    "@tramvai/module-cache-warmup": "2.79.7",
-    "@tramvai/module-metrics": "2.79.7",
-    "@tramvai/papi": "2.79.7",
-    "@tramvai/tokens-server": "2.79.7",
-    "@tramvai/tokens-server-private": "2.79.7",
+    "@tramvai/module-cache-warmup": "2.82.0",
+    "@tramvai/module-metrics": "2.82.0",
+    "@tramvai/papi": "2.82.0",
+    "@tramvai/tokens-server": "2.82.0",
+    "@tramvai/tokens-server-private": "2.82.0",
     "fastify": "^4.14.1",
     "@fastify/cookie": "^8.3.0",
     "@fastify/compress": "^6.2.0",
@@ -38,15 +38,18 @@
     "http-proxy-middleware": "^2.0.2"
   },
   "peerDependencies": {
-    "@tinkoff/dippy": "0.8.14",
+    "@tinkoff/dippy": "0.8.15",
     "@tinkoff/utils": "^2.1.2",
-    "@tramvai/cli": "2.79.7",
-    "@tramvai/core": "2.79.7",
-    "@tramvai/module-common": "2.79.7",
-    "@tramvai/module-environment": "2.79.7",
-    "@tramvai/tokens-common": "2.79.7",
-    "@tramvai/tokens-core-private": "2.79.7",
-    "@tramvai/tokens-render": "2.79.7",
+    "@tramvai/cli": "2.82.0",
+    "@tramvai/core": "2.82.0",
+    "@tramvai/react": "2.82.0",
+    "@tramvai/module-common": "2.82.0",
+    "@tramvai/module-environment": "2.82.0",
+    "@tramvai/tokens-common": "2.82.0",
+    "@tramvai/tokens-core-private": "2.82.0",
+    "@tramvai/tokens-render": "2.82.0",
+    "react": ">=16.14.0",
+    "react-dom": ">=16.14.0",
     "tslib": "^2.4.0"
   },
   "devDependencies": {