@tramvai/module-server 3.9.1 → 3.10.0

package/lib/server/{error.d.ts → error/index.d.ts}

@@ -3,10 +3,12 @@ import type { LOGGER_TOKEN } from '@tramvai/module-common';
 import type { FETCH_WEBPACK_STATS_TOKEN } from '@tramvai/tokens-render';
 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, afterError, fetchWebpackStats, }: {
+import type { STATIC_ROOT_ERROR_BOUNDARY_ERROR_TOKEN } from '@tramvai/tokens-server';
+export declare const errorHandler: (app: FastifyInstance, { log, beforeError, afterError, fetchWebpackStats, staticRootErrorBoundaryError, }: {
     log: ReturnType<typeof LOGGER_TOKEN>;
     beforeError: ExtractDependencyType<typeof WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN>;
     afterError: ExtractDependencyType<typeof WEB_FASTIFY_APP_AFTER_ERROR_TOKEN>;
     fetchWebpackStats: ExtractDependencyType<typeof FETCH_WEBPACK_STATS_TOKEN>;
-}) => void;
-//# sourceMappingURL=error.d.ts.map
+    staticRootErrorBoundaryError: ExtractDependencyType<typeof STATIC_ROOT_ERROR_BOUNDARY_ERROR_TOKEN>;
+}) => Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/lib/server/error/index.es.js

@@ -0,0 +1,93 @@
+import isNil from '@tinkoff/utils/is/nil';
+import { isRedirectFoundError } from '@tinkoff/errors';
+import { getRootErrorBoundary, getRequestInfo, runHandlersFactory } from './utils.es.js';
+import { serveRootErrorBoundary } from './serveRootErrorBoundary.es.js';
+import { prepareLogsForError } from './prepareLogsForError.es.js';
+import { renderErrorBoundaryPageToString } from './renderErrorBoundaryPageToString.es.js';
+
+const errorHandler = async (app, { log, beforeError, afterError, fetchWebpackStats, staticRootErrorBoundaryError, }) => {
+    const webpackStats = await fetchWebpackStats();
+    const RootErrorBoundary = getRootErrorBoundary();
+    const isRootErrorBoundaryExist = RootErrorBoundary !== null;
+    if (process.env.TRAMVAI_CLI_COMMAND === 'static' && isRootErrorBoundaryExist) {
+        serveRootErrorBoundary({
+            response: renderErrorBoundaryPageToString({
+                element: RootErrorBoundary,
+                requestUrl: '/5xx.html',
+                error: staticRootErrorBoundaryError !== null && staticRootErrorBoundaryError !== void 0 ? staticRootErrorBoundaryError : {
+                    name: 'STATIC_ROOT_ERROR_BOUNDARY_ERROR',
+                    message: 'Default error for root error boundary',
+                },
+                httpStatus: 500,
+                webpackStats,
+            }),
+            app,
+        });
+    }
+    app.setErrorHandler(async (error, request, reply) => {
+        const runHandlers = runHandlersFactory(error, request, reply);
+        const requestInfo = getRequestInfo(request);
+        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-store, no-cache, must-revalidate')
+                .redirect(error.httpStatus || 307, error.nextUrl);
+            return;
+        }
+        const { logMessage, logLevel, logEvent, httpStatus } = prepareLogsForError({
+            error,
+            isRootErrorBoundaryExist,
+        });
+        log[logLevel]({
+            event: logEvent,
+            message: logMessage,
+            error,
+            requestInfo,
+        });
+        const afterErrorResult = await runHandlers(afterError);
+        if (!isNil(afterErrorResult)) {
+            return afterErrorResult;
+        }
+        reply.status(httpStatus);
+        if (isRootErrorBoundaryExist) {
+            try {
+                const response = renderErrorBoundaryPageToString({
+                    element: RootErrorBoundary,
+                    requestUrl: requestInfo.url,
+                    webpackStats,
+                    error,
+                    httpStatus,
+                });
+                log.info({
+                    event: 'render-root-error-boundary',
+                    message: 'Render Root Error Boundary for the client',
+                });
+                reply
+                    .header('Content-Type', 'text/html; charset=utf-8')
+                    .header('Content-Length', Buffer.byteLength(response, 'utf8'))
+                    .header('Cache-Control', 'no-store, no-cache, must-revalidate');
+                return response;
+            }
+            catch (e) {
+                log.warn({
+                    event: 'failed-root-error-boundary',
+                    message: 'Root Error Boundary rendering failed',
+                    error: e,
+                });
+            }
+        }
+        throw error;
+    });
+};
+
+export { errorHandler };

package/lib/server/error/index.js

@@ -0,0 +1,101 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isNil = require('@tinkoff/utils/is/nil');
+var errors = require('@tinkoff/errors');
+var utils = require('./utils.js');
+var serveRootErrorBoundary = require('./serveRootErrorBoundary.js');
+var prepareLogsForError = require('./prepareLogsForError.js');
+var renderErrorBoundaryPageToString = require('./renderErrorBoundaryPageToString.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var isNil__default = /*#__PURE__*/_interopDefaultLegacy(isNil);
+
+const errorHandler = async (app, { log, beforeError, afterError, fetchWebpackStats, staticRootErrorBoundaryError, }) => {
+    const webpackStats = await fetchWebpackStats();
+    const RootErrorBoundary = utils.getRootErrorBoundary();
+    const isRootErrorBoundaryExist = RootErrorBoundary !== null;
+    if (process.env.TRAMVAI_CLI_COMMAND === 'static' && isRootErrorBoundaryExist) {
+        serveRootErrorBoundary.serveRootErrorBoundary({
+            response: renderErrorBoundaryPageToString.renderErrorBoundaryPageToString({
+                element: RootErrorBoundary,
+                requestUrl: '/5xx.html',
+                error: staticRootErrorBoundaryError !== null && staticRootErrorBoundaryError !== void 0 ? staticRootErrorBoundaryError : {
+                    name: 'STATIC_ROOT_ERROR_BOUNDARY_ERROR',
+                    message: 'Default error for root error boundary',
+                },
+                httpStatus: 500,
+                webpackStats,
+            }),
+            app,
+        });
+    }
+    app.setErrorHandler(async (error, request, reply) => {
+        const runHandlers = utils.runHandlersFactory(error, request, reply);
+        const requestInfo = utils.getRequestInfo(request);
+        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-store, no-cache, must-revalidate')
+                .redirect(error.httpStatus || 307, error.nextUrl);
+            return;
+        }
+        const { logMessage, logLevel, logEvent, httpStatus } = prepareLogsForError.prepareLogsForError({
+            error,
+            isRootErrorBoundaryExist,
+        });
+        log[logLevel]({
+            event: logEvent,
+            message: logMessage,
+            error,
+            requestInfo,
+        });
+        const afterErrorResult = await runHandlers(afterError);
+        if (!isNil__default["default"](afterErrorResult)) {
+            return afterErrorResult;
+        }
+        reply.status(httpStatus);
+        if (isRootErrorBoundaryExist) {
+            try {
+                const response = renderErrorBoundaryPageToString.renderErrorBoundaryPageToString({
+                    element: RootErrorBoundary,
+                    requestUrl: requestInfo.url,
+                    webpackStats,
+                    error,
+                    httpStatus,
+                });
+                log.info({
+                    event: 'render-root-error-boundary',
+                    message: 'Render Root Error Boundary for the client',
+                });
+                reply
+                    .header('Content-Type', 'text/html; charset=utf-8')
+                    .header('Content-Length', Buffer.byteLength(response, 'utf8'))
+                    .header('Cache-Control', 'no-store, no-cache, must-revalidate');
+                return response;
+            }
+            catch (e) {
+                log.warn({
+                    event: 'failed-root-error-boundary',
+                    message: 'Root Error Boundary rendering failed',
+                    error: e,
+                });
+            }
+        }
+        throw error;
+    });
+};
+
+exports.errorHandler = errorHandler;

package/lib/server/error/prepareLogsForError.d.ts

@@ -0,0 +1,11 @@
+import type { FastifyError } from 'fastify';
+export declare const prepareLogsForError: ({ error, isRootErrorBoundaryExist, }: {
+    error: FastifyError;
+    isRootErrorBoundaryExist: boolean;
+}) => {
+    logMessage: string;
+    logLevel: string;
+    logEvent: string;
+    httpStatus: number;
+};
+//# sourceMappingURL=prepareLogsForError.d.ts.map

package/lib/server/error/prepareLogsForError.es.js

@@ -0,0 +1,63 @@
+import { isNotFoundError, isHttpError } from '@tinkoff/errors';
+
+// eslint-disable-next-line max-statements
+const prepareLogsForError = ({ error, isRootErrorBoundaryExist, }) => {
+    let httpStatus;
+    let logLevel;
+    let logEvent;
+    let logMessage;
+    if (isNotFoundError(error)) {
+        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`;
+    }
+    else if (isHttpError(error)) {
+        httpStatus = error.httpStatus || 500;
+        if (error.httpStatus >= 500) {
+            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`;
+        }
+    }
+    logMessage = `${logMessage}
+${isRootErrorBoundaryExist
+        ? 'Root Error Boundary will be rendered for the client'
+        : 'You can add Error Boundary for better UX - https://tramvai.dev/docs/features/error-boundaries'}'`;
+    return { logMessage, logLevel, logEvent, httpStatus };
+};
+
+export { prepareLogsForError };

package/lib/server/error/prepareLogsForError.js

@@ -0,0 +1,67 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var errors = require('@tinkoff/errors');
+
+// eslint-disable-next-line max-statements
+const prepareLogsForError = ({ error, isRootErrorBoundaryExist, }) => {
+    let httpStatus;
+    let logLevel;
+    let logEvent;
+    let logMessage;
+    if (errors.isNotFoundError(error)) {
+        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`;
+    }
+    else if (errors.isHttpError(error)) {
+        httpStatus = error.httpStatus || 500;
+        if (error.httpStatus >= 500) {
+            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`;
+        }
+    }
+    logMessage = `${logMessage}
+${isRootErrorBoundaryExist
+        ? 'Root Error Boundary will be rendered for the client'
+        : 'You can add Error Boundary for better UX - https://tramvai.dev/docs/features/error-boundaries'}'`;
+    return { logMessage, logLevel, logEvent, httpStatus };
+};
+
+exports.prepareLogsForError = prepareLogsForError;

package/lib/server/error/renderErrorBoundaryPageToString.d.ts

@@ -0,0 +1,11 @@
+import type { AnyError } from '@tramvai/safe-strings';
+import type { WebpackStats } from '@tramvai/tokens-render';
+import type { ErrorBoundaryComponent } from '@tramvai/react';
+export declare const renderErrorBoundaryPageToString: ({ element, webpackStats, requestUrl, httpStatus, error, }: {
+    element: ErrorBoundaryComponent;
+    webpackStats: WebpackStats;
+    requestUrl: string;
+    httpStatus: number;
+    error: AnyError;
+}) => string;
+//# sourceMappingURL=renderErrorBoundaryPageToString.d.ts.map

package/lib/server/error/renderErrorBoundaryPageToString.es.js

@@ -0,0 +1,30 @@
+import { ChunkExtractor } from '@loadable/server';
+import { parse } from '@tinkoff/url';
+import { renderToString } from 'react-dom/server';
+import { createElement } from 'react';
+import { safeStringify } from '@tramvai/safe-strings';
+
+const renderErrorBoundaryPageToString = ({ element, webpackStats, requestUrl, httpStatus, error, }) => {
+    const extractor = new ChunkExtractor({ stats: webpackStats, entrypoints: ['rootErrorBoundary'] });
+    const url = parse(requestUrl);
+    const serializedError = {
+        name: error.name,
+        status: httpStatus,
+        message: error.message,
+        stack: error.stack,
+    };
+    return renderToString(createElement(element, { error: serializedError, url })).replace('</head>', [
+        '<script>' +
+            `window.serverUrl = ${safeStringify(url)};` +
+            `window.serverError = new Error(${safeStringify(serializedError.message)});` +
+            `Object.assign(window.serverError, ${safeStringify(serializedError)});` +
+            '</script>',
+        extractor.getStyleTags(),
+        extractor.getScriptTags(),
+        '</head>',
+    ]
+        .filter(Boolean)
+        .join('\n'));
+};
+
+export { renderErrorBoundaryPageToString };

package/lib/server/error/renderErrorBoundaryPageToString.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var server = require('@loadable/server');
+var url = require('@tinkoff/url');
+var server$1 = require('react-dom/server');
+var react = require('react');
+var safeStrings = require('@tramvai/safe-strings');
+
+const renderErrorBoundaryPageToString = ({ element, webpackStats, requestUrl, httpStatus, error, }) => {
+    const extractor = new server.ChunkExtractor({ stats: webpackStats, entrypoints: ['rootErrorBoundary'] });
+    const url$1 = url.parse(requestUrl);
+    const serializedError = {
+        name: error.name,
+        status: httpStatus,
+        message: error.message,
+        stack: error.stack,
+    };
+    return server$1.renderToString(react.createElement(element, { error: serializedError, url: url$1 })).replace('</head>', [
+        '<script>' +
+            `window.serverUrl = ${safeStrings.safeStringify(url$1)};` +
+            `window.serverError = new Error(${safeStrings.safeStringify(serializedError.message)});` +
+            `Object.assign(window.serverError, ${safeStrings.safeStringify(serializedError)});` +
+            '</script>',
+        extractor.getStyleTags(),
+        extractor.getScriptTags(),
+        '</head>',
+    ]
+        .filter(Boolean)
+        .join('\n'));
+};
+
+exports.renderErrorBoundaryPageToString = renderErrorBoundaryPageToString;

package/lib/server/error/serveRootErrorBoundary.d.ts

@@ -0,0 +1,6 @@
+import type { FastifyInstance } from 'fastify';
+export declare function serveRootErrorBoundary({ response, app, }: {
+    response: string;
+    app: FastifyInstance;
+}): void;
+//# sourceMappingURL=serveRootErrorBoundary.d.ts.map

package/lib/server/error/serveRootErrorBoundary.es.js

@@ -0,0 +1,13 @@
+function serveRootErrorBoundary({ response, app, }) {
+    app.register(async (instance) => {
+        instance.all('/_errors/5xx', (request, reply) => {
+            reply.status(200);
+            reply.header('Content-Type', 'text/html; charset=utf-8');
+            reply.header('Content-Length', Buffer.byteLength(response, 'utf8'));
+            reply.header('Cache-Control', 'no-store, no-cache, must-revalidate');
+            return response;
+        });
+    });
+}
+
+export { serveRootErrorBoundary };

package/lib/server/error/serveRootErrorBoundary.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function serveRootErrorBoundary({ response, app, }) {
+    app.register(async (instance) => {
+        instance.all('/_errors/5xx', (request, reply) => {
+            reply.status(200);
+            reply.header('Content-Type', 'text/html; charset=utf-8');
+            reply.header('Content-Length', Buffer.byteLength(response, 'utf8'));
+            reply.header('Cache-Control', 'no-store, no-cache, must-revalidate');
+            return response;
+        });
+    });
+}
+
+exports.serveRootErrorBoundary = serveRootErrorBoundary;

package/lib/server/error/utils.d.ts

@@ -0,0 +1,12 @@
+import type { ErrorBoundaryComponent } from '@tramvai/react';
+import type { ExtractDependencyType } from '@tinkoff/dippy';
+import type { WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN } from '@tramvai/tokens-server-private';
+import type { FastifyError, FastifyReply, FastifyRequest } from 'fastify';
+export declare const getRootErrorBoundary: () => ErrorBoundaryComponent | null;
+export declare const runHandlersFactory: (error: FastifyError, request: FastifyRequest, reply: FastifyReply) => (handlers: ExtractDependencyType<typeof WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN>) => Promise<string>;
+export declare const getRequestInfo: (request: FastifyRequest) => {
+    ip: string;
+    requestId: string | string[];
+    url: string;
+};
+//# sourceMappingURL=utils.d.ts.map

package/lib/server/error/utils.es.js

@@ -0,0 +1,32 @@
+const getRootErrorBoundary = () => {
+    try {
+        // In case of direct `require` by path, e.g.
+        // `require(path.resolve(process.cwd(), 'src', 'error.tsx'))` file
+        // doesn't include in the bundle, that is why we are using a
+        // path alias here along with webpack config option.
+        // See usage of `ROOT_ERROR_BOUNDARY_ALIAS`.
+        // eslint-disable-next-line import/no-unresolved, import/extensions
+        const RootErrorBoundary = require('@/__private__/error').default;
+        return RootErrorBoundary;
+    }
+    catch {
+        return null;
+    }
+};
+const runHandlersFactory = (error, request, reply) => async (handlers) => {
+    if (handlers) {
+        for (const handler of handlers) {
+            const result = await handler(error, request, reply);
+            if (result) {
+                return result;
+            }
+        }
+    }
+};
+const getRequestInfo = (request) => ({
+    ip: request.ip,
+    requestId: request.headers['x-request-id'],
+    url: request.url,
+});
+
+export { getRequestInfo, getRootErrorBoundary, runHandlersFactory };

package/lib/server/error/utils.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const getRootErrorBoundary = () => {
+    try {
+        // In case of direct `require` by path, e.g.
+        // `require(path.resolve(process.cwd(), 'src', 'error.tsx'))` file
+        // doesn't include in the bundle, that is why we are using a
+        // path alias here along with webpack config option.
+        // See usage of `ROOT_ERROR_BOUNDARY_ALIAS`.
+        // eslint-disable-next-line import/no-unresolved, import/extensions
+        const RootErrorBoundary = require('@/__private__/error').default;
+        return RootErrorBoundary;
+    }
+    catch {
+        return null;
+    }
+};
+const runHandlersFactory = (error, request, reply) => async (handlers) => {
+    if (handlers) {
+        for (const handler of handlers) {
+            const result = await handler(error, request, reply);
+            if (result) {
+                return result;
+            }
+        }
+    }
+};
+const getRequestInfo = (request) => ({
+    ip: request.ip,
+    requestId: request.headers['x-request-id'],
+    url: request.url,
+});
+
+exports.getRequestInfo = getRequestInfo;
+exports.getRootErrorBoundary = getRootErrorBoundary;
+exports.runHandlersFactory = runHandlersFactory;

package/lib/server/webApp.d.ts

@@ -5,10 +5,11 @@ 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_METRICS_TOKEN } from '@tramvai/tokens-server-private';
 import { type FETCH_WEBPACK_STATS_TOKEN } from '@tramvai/tokens-render';
 import type { ExtractDependencyType } from '@tinkoff/dippy';
+import type { STATIC_ROOT_ERROR_BOUNDARY_ERROR_TOKEN } from '@tramvai/tokens-server';
 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, afterError, fetchWebpackStats, }: {
+export declare const webAppInitCommand: ({ app, logger, commandLineRunner, executionContextManager, beforeInit, requestMetrics, limiterRequest, init, afterInit, beforeError, afterError, fetchWebpackStats, staticRootErrorBoundaryError, }: {
     app: ExtractDependencyType<typeof WEB_FASTIFY_APP_TOKEN>;
     logger: ExtractDependencyType<typeof LOGGER_TOKEN>;
     commandLineRunner: ExtractDependencyType<typeof COMMAND_LINE_RUNNER_TOKEN>;
@@ -21,5 +22,6 @@ export declare const webAppInitCommand: ({ app, logger, commandLineRunner, execu
     beforeError: ExtractDependencyType<typeof WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN>;
     afterError: ExtractDependencyType<typeof WEB_FASTIFY_APP_AFTER_ERROR_TOKEN>;
     fetchWebpackStats: ExtractDependencyType<typeof FETCH_WEBPACK_STATS_TOKEN>;
+    staticRootErrorBoundaryError: ExtractDependencyType<typeof STATIC_ROOT_ERROR_BOUNDARY_ERROR_TOKEN>;
 }) => () => Promise<void>;
 //# sourceMappingURL=webApp.d.ts.map

package/lib/server/webApp.es.js

@@ -6,7 +6,7 @@ import { Scope } from '@tramvai/core';
 import { FASTIFY_REQUEST, FASTIFY_RESPONSE, SERVER_RESPONSE_STREAM, SERVER_RESPONSE_TASK_MANAGER } from '@tramvai/tokens-server-private';
 import { REACT_SERVER_RENDER_MODE } from '@tramvai/tokens-render';
 import { provide, optional } from '@tinkoff/dippy';
-import { errorHandler } from './error.es.js';
+import { errorHandler } from './error/index.es.js';
 
 const webAppFactory = ({ server }) => {
     const app = fastify({
@@ -19,13 +19,19 @@ const webAppFactory = ({ server }) => {
     });
     return app;
 };
-const webAppInitCommand = ({ app, logger, commandLineRunner, executionContextManager, beforeInit, requestMetrics, limiterRequest, init, afterInit, beforeError, afterError, fetchWebpackStats, }) => {
+const webAppInitCommand = ({ app, logger, commandLineRunner, executionContextManager, beforeInit, requestMetrics, limiterRequest, init, afterInit, beforeError, afterError, fetchWebpackStats, staticRootErrorBoundaryError, }) => {
     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, afterError, fetchWebpackStats });
+        await errorHandler(app, {
+            log,
+            beforeError,
+            afterError,
+            fetchWebpackStats,
+            staticRootErrorBoundaryError,
+        });
         await app.register(async (instance) => {
             await runHandlers(instance, beforeInit);
         });

package/lib/server/webApp.js

@@ -10,7 +10,7 @@ var core = require('@tramvai/core');
 var tokensServerPrivate = require('@tramvai/tokens-server-private');
 var tokensRender = require('@tramvai/tokens-render');
 var dippy = require('@tinkoff/dippy');
-var error = require('./error.js');
+var index = require('./error/index.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -28,13 +28,19 @@ const webAppFactory = ({ server }) => {
     });
     return app;
 };
-const webAppInitCommand = ({ app, logger, commandLineRunner, executionContextManager, beforeInit, requestMetrics, limiterRequest, init, afterInit, beforeError, afterError, fetchWebpackStats, }) => {
+const webAppInitCommand = ({ app, logger, commandLineRunner, executionContextManager, beforeInit, requestMetrics, limiterRequest, init, afterInit, beforeError, afterError, fetchWebpackStats, staticRootErrorBoundaryError, }) => {
     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, afterError, fetchWebpackStats });
+        await index.errorHandler(app, {
+            log,
+            beforeError,
+            afterError,
+            fetchWebpackStats,
+            staticRootErrorBoundaryError,
+        });
         await app.register(async (instance) => {
             await runHandlers(instance, beforeInit);
         });

package/lib/server.es.js

@@ -2,7 +2,7 @@ import { __decorate } from 'tslib';
 import { setDefaultResultOrder } from 'dns';
 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';
+import { SERVER_TOKEN, STATIC_ROOT_ERROR_BOUNDARY_ERROR_TOKEN } from '@tramvai/tokens-server';
 export * from '@tramvai/tokens-server';
 import { FETCH_WEBPACK_STATS_TOKEN } from '@tramvai/tokens-render';
 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, SERVER_RESPONSE_STREAM, SERVER_RESPONSE_TASK_MANAGER } from '@tramvai/tokens-server-private';
@@ -97,6 +97,10 @@ ServerModule = __decorate([
                     beforeError: { token: WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN, optional: true },
                     afterError: { token: WEB_FASTIFY_APP_AFTER_ERROR_TOKEN, optional: true },
                     fetchWebpackStats: FETCH_WEBPACK_STATS_TOKEN,
+                    staticRootErrorBoundaryError: {
+                        token: STATIC_ROOT_ERROR_BOUNDARY_ERROR_TOKEN,
+                        optional: true,
+                    },
                 },
             },
             provide({

package/lib/server.js

@@ -104,6 +104,10 @@ exports.ServerModule = tslib.__decorate([
                     beforeError: { token: tokensServerPrivate.WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN, optional: true },
                     afterError: { token: tokensServerPrivate.WEB_FASTIFY_APP_AFTER_ERROR_TOKEN, optional: true },
                     fetchWebpackStats: tokensRender.FETCH_WEBPACK_STATS_TOKEN,
+                    staticRootErrorBoundaryError: {
+                        token: tokensServer.STATIC_ROOT_ERROR_BOUNDARY_ERROR_TOKEN,
+                        optional: true,
+                    },
                 },
             },
             core.provide({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-server",
-  "version": "3.9.1",
+  "version": "3.10.0",
   "description": "",
   "browser": "lib/browser.js",
   "main": "lib/server.js",
@@ -26,12 +26,12 @@
     "@tinkoff/monkeypatch": "3.0.1",
     "@tinkoff/terminus": "0.2.1",
     "@tinkoff/url": "0.9.1",
-    "@tramvai/module-cache-warmup": "3.9.1",
-    "@tramvai/module-metrics": "3.9.1",
-    "@tramvai/papi": "3.9.1",
-    "@tramvai/tokens-server": "3.9.1",
-    "@tramvai/tokens-router": "3.9.1",
-    "@tramvai/tokens-server-private": "3.9.1",
+    "@tramvai/module-cache-warmup": "3.10.0",
+    "@tramvai/module-metrics": "3.10.0",
+    "@tramvai/papi": "3.10.0",
+    "@tramvai/tokens-server": "3.10.0",
+    "@tramvai/tokens-router": "3.10.0",
+    "@tramvai/tokens-server-private": "3.10.0",
     "@tramvai/safe-strings": "0.6.1",
     "fastify": "^4.14.1",
     "@fastify/cookie": "^8.3.0",
@@ -44,14 +44,14 @@
   "peerDependencies": {
     "@tinkoff/dippy": "0.9.1",
     "@tinkoff/utils": "^2.1.2",
-    "@tramvai/cli": "3.9.1",
-    "@tramvai/core": "3.9.1",
-    "@tramvai/react": "3.9.1",
-    "@tramvai/module-common": "3.9.1",
-    "@tramvai/module-environment": "3.9.1",
-    "@tramvai/tokens-common": "3.9.1",
-    "@tramvai/tokens-core-private": "3.9.1",
-    "@tramvai/tokens-render": "3.9.1",
+    "@tramvai/cli": "3.10.0",
+    "@tramvai/core": "3.10.0",
+    "@tramvai/react": "3.10.0",
+    "@tramvai/module-common": "3.10.0",
+    "@tramvai/module-environment": "3.10.0",
+    "@tramvai/tokens-common": "3.10.0",
+    "@tramvai/tokens-core-private": "3.10.0",
+    "@tramvai/tokens-render": "3.10.0",
     "react": ">=16.14.0",
     "react-dom": ">=16.14.0",
     "tslib": "^2.4.0"

package/lib/server/error.es.js

@@ -1,163 +0,0 @@
-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';
-import { safeStringify } from '@tramvai/safe-strings';
-import { ChunkExtractor } from '@loadable/server';
-
-const errorHandler = (app, { log, beforeError, afterError, fetchWebpackStats, }) => {
-    // eslint-disable-next-line max-statements
-    app.setErrorHandler(async (error, request, reply) => {
-        const runHandlers = async (handlers) => {
-            if (handlers) {
-                for (const handler of handlers) {
-                    const result = await handler(error, request, reply);
-                    if (result) {
-                        return result;
-                    }
-                }
-            }
-        };
-        const beforeErrorResult = await runHandlers(beforeError);
-        if (!isNil(beforeErrorResult)) {
-            return beforeErrorResult;
-        }
-        const requestInfo = {
-            ip: request.ip,
-            requestId: request.headers['x-request-id'],
-            url: request.url,
-        };
-        let RootErrorBoundary = null;
-        try {
-            // In case of direct `require` by path, e.g.
-            // `require(path.resolve(process.cwd(), 'src', 'error.tsx'))` file
-            // doesn't include in the bundle, that is why we are using a
-            // path alias here along with webpack config option.
-            // See usage of `ROOT_ERROR_BOUNDARY_ALIAS`.
-            // eslint-disable-next-line import/no-unresolved, import/extensions
-            RootErrorBoundary = require('@/__private__/error').default;
-        }
-        catch { }
-        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-store, no-cache, must-revalidate');
-            reply.redirect(error.httpStatus || 307, error.nextUrl);
-            return;
-        }
-        let httpStatus;
-        let logLevel;
-        let logEvent;
-        let logMessage;
-        if (isNotFoundError(error)) {
-            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`;
-        }
-        else if (isHttpError(error)) {
-            httpStatus = error.httpStatus || 500;
-            if (error.httpStatus >= 500) {
-                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`;
-            }
-        }
-        logMessage = `${logMessage}
-${RootErrorBoundary !== null
-            ? '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 !== null) {
-            try {
-                const stats = await fetchWebpackStats();
-                const extractor = new ChunkExtractor({ stats, entrypoints: ['rootErrorBoundary'] });
-                const url = parse(requestInfo.url);
-                const serializedError = {
-                    status: httpStatus,
-                    message: error.message,
-                    stack: error.stack,
-                };
-                const body = renderToString(createElement(RootErrorBoundary, { error: serializedError, url })).replace('</head>', [
-                    '<script>' +
-                        `window.serverUrl = ${safeStringify(url)};` +
-                        `window.serverError = new Error(${safeStringify(serializedError.message)});` +
-                        `Object.assign(window.serverError, ${safeStringify(serializedError)});` +
-                        '</script>',
-                    extractor.getStyleTags(),
-                    extractor.getScriptTags(),
-                    '</head>',
-                ]
-                    .filter(Boolean)
-                    .join('\n'));
-                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-store, no-cache, must-revalidate');
-                return body;
-            }
-            catch (e) {
-                log.warn({
-                    event: 'failed-root-error-boundary',
-                    message: 'Root Error Boundary rendering failed',
-                    error: e,
-                });
-            }
-        }
-        throw error;
-    });
-};
-
-export { errorHandler };

package/lib/server/error.js

@@ -1,171 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var isNil = require('@tinkoff/utils/is/nil');
-var react = require('react');
-var server$1 = require('react-dom/server');
-var url = require('@tinkoff/url');
-var errors = require('@tinkoff/errors');
-var safeStrings = require('@tramvai/safe-strings');
-var server = require('@loadable/server');
-
-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, afterError, fetchWebpackStats, }) => {
-    // eslint-disable-next-line max-statements
-    app.setErrorHandler(async (error, request, reply) => {
-        const runHandlers = async (handlers) => {
-            if (handlers) {
-                for (const handler of handlers) {
-                    const result = await handler(error, request, reply);
-                    if (result) {
-                        return result;
-                    }
-                }
-            }
-        };
-        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,
-        };
-        let RootErrorBoundary = null;
-        try {
-            // In case of direct `require` by path, e.g.
-            // `require(path.resolve(process.cwd(), 'src', 'error.tsx'))` file
-            // doesn't include in the bundle, that is why we are using a
-            // path alias here along with webpack config option.
-            // See usage of `ROOT_ERROR_BOUNDARY_ALIAS`.
-            // eslint-disable-next-line import/no-unresolved, import/extensions
-            RootErrorBoundary = require('@/__private__/error').default;
-        }
-        catch { }
-        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-store, no-cache, must-revalidate');
-            reply.redirect(error.httpStatus || 307, error.nextUrl);
-            return;
-        }
-        let httpStatus;
-        let logLevel;
-        let logEvent;
-        let logMessage;
-        if (errors.isNotFoundError(error)) {
-            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`;
-        }
-        else if (errors.isHttpError(error)) {
-            httpStatus = error.httpStatus || 500;
-            if (error.httpStatus >= 500) {
-                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`;
-            }
-        }
-        logMessage = `${logMessage}
-${RootErrorBoundary !== null
-            ? '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 !== null) {
-            try {
-                const stats = await fetchWebpackStats();
-                const extractor = new server.ChunkExtractor({ stats, entrypoints: ['rootErrorBoundary'] });
-                const url$1 = url.parse(requestInfo.url);
-                const serializedError = {
-                    status: httpStatus,
-                    message: error.message,
-                    stack: error.stack,
-                };
-                const body = server$1.renderToString(react.createElement(RootErrorBoundary, { error: serializedError, url: url$1 })).replace('</head>', [
-                    '<script>' +
-                        `window.serverUrl = ${safeStrings.safeStringify(url$1)};` +
-                        `window.serverError = new Error(${safeStrings.safeStringify(serializedError.message)});` +
-                        `Object.assign(window.serverError, ${safeStrings.safeStringify(serializedError)});` +
-                        '</script>',
-                    extractor.getStyleTags(),
-                    extractor.getScriptTags(),
-                    '</head>',
-                ]
-                    .filter(Boolean)
-                    .join('\n'));
-                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-store, no-cache, must-revalidate');
-                return body;
-            }
-            catch (e) {
-                log.warn({
-                    event: 'failed-root-error-boundary',
-                    message: 'Root Error Boundary rendering failed',
-                    error: e,
-                });
-            }
-        }
-        throw error;
-    });
-};
-
-exports.errorHandler = errorHandler;