@tramvai/module-server 1.84.2 → 1.90.1

package/lib/server.js

@@ -5,14 +5,20 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var tslib = require('tslib');
 var core = require('@tramvai/core');
 var tokensServer = require('@tramvai/tokens-server');
-var moduleCommon = require('@tramvai/module-common');
+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 http = require('http');
+var fastify = require('fastify');
 var express = require('express');
 var cookieParser = require('cookie-parser');
 var bodyParser = require('body-parser');
-var finalhandler = require('finalhandler');
+var fastifyCookie = require('fastify-cookie');
+var fastifyFormBody = require('fastify-formbody');
+var fp = require('fastify-plugin');
+var symbols = require('fastify/lib/symbols');
+var isNil = require('@tinkoff/utils/is/nil');
 var errors = require('@tinkoff/errors');
 var zlib = require('zlib');
 var compression = require('compression');
@@ -20,27 +26,31 @@ var os = require('os');
 var filterObj = require('@tinkoff/utils/object/filter');
 var flatten = require('@tinkoff/utils/array/flatten');
 var toArray = require('@tinkoff/utils/array/toArray');
-var tokensCommon = require('@tramvai/tokens-common');
 var papi = require('@tramvai/papi');
 var dippy = require('@tinkoff/dippy');
 var eachObj = require('@tinkoff/utils/object/each');
-var expressTerminus = require('@tinkoff/express-terminus');
+var path = require('path');
+var FastifyStatic = require('fastify-static');
+var terminus = require('@tinkoff/terminus');
 var url = require('@tinkoff/url');
 var events = require('events');
 var monkeypatch = require('@tinkoff/monkeypatch');
 var https = require('https');
 var isArray = require('@tinkoff/utils/is/array');
 var isObject = require('@tinkoff/utils/is/object');
-var path = require('path');
 var httpProxyMiddleware = require('http-proxy-middleware');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
+var fastify__default = /*#__PURE__*/_interopDefaultLegacy(fastify);
 var express__default = /*#__PURE__*/_interopDefaultLegacy(express);
 var cookieParser__default = /*#__PURE__*/_interopDefaultLegacy(cookieParser);
 var bodyParser__default = /*#__PURE__*/_interopDefaultLegacy(bodyParser);
-var finalhandler__default = /*#__PURE__*/_interopDefaultLegacy(finalhandler);
+var fastifyFormBody__default = /*#__PURE__*/_interopDefaultLegacy(fastifyFormBody);
+var fp__default = /*#__PURE__*/_interopDefaultLegacy(fp);
+var symbols__default = /*#__PURE__*/_interopDefaultLegacy(symbols);
+var isNil__default = /*#__PURE__*/_interopDefaultLegacy(isNil);
 var zlib__default = /*#__PURE__*/_interopDefaultLegacy(zlib);
 var compression__default = /*#__PURE__*/_interopDefaultLegacy(compression);
 var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
@@ -48,15 +58,14 @@ var filterObj__default = /*#__PURE__*/_interopDefaultLegacy(filterObj);
 var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
 var toArray__default = /*#__PURE__*/_interopDefaultLegacy(toArray);
 var eachObj__default = /*#__PURE__*/_interopDefaultLegacy(eachObj);
+var FastifyStatic__default = /*#__PURE__*/_interopDefaultLegacy(FastifyStatic);
 var monkeypatch__default = /*#__PURE__*/_interopDefaultLegacy(monkeypatch);
 var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
 var isArray__default = /*#__PURE__*/_interopDefaultLegacy(isArray);
 var isObject__default = /*#__PURE__*/_interopDefaultLegacy(isObject);
 
-const serverFactory = ({ webApp }) => {
-    const server = http__default["default"].createServer();
-    server.on('request', webApp);
-    return server;
+const serverFactory = () => {
+    return http__default["default"].createServer();
 };
 const serverListenCommand = ({ server, logger, envManager, }) => {
     const log = logger('server');
@@ -69,105 +78,236 @@ const serverListenCommand = ({ server, logger, envManager, }) => {
     };
 };
 
-const routerErrorHandler = (app) => {
-    app.use((err, req, res, next) => {
-        if (errors.isRedirectFoundError(err)) {
-            res.setHeader('cache-control', 'no-cache, no-store, must-revalidate');
-            return res.redirect(err.httpStatus || 307, err.nextUrl);
+/**
+ * Fork of https://github.com/fastify/fastify-express
+ */
+const kMiddlewares = Symbol('fastify-express-middlewares');
+const expressPlugin = (fastify, options, next) => {
+    var _a, _b;
+    fastify.decorate('use', use);
+    // eslint-disable-next-line no-param-reassign
+    fastify[kMiddlewares] = [];
+    fastify.decorate('express', (_b = (_a = options.express) === null || _a === void 0 ? void 0 : _a.instance) !== null && _b !== void 0 ? _b : express__default["default"]());
+    fastify.express.disable('x-powered-by');
+    fastify
+        .addHook('onRequest', enhanceRequest)
+        .addHook('onRequest', runConnect)
+        .addHook('onRegister', onRegister);
+    function use(path, fn) {
+        if (typeof path === 'string') {
+            const prefix = this[symbols__default["default"].kRoutePrefix];
+            // eslint-disable-next-line no-param-reassign
+            path = prefix + (path === '/' && prefix.length > 0 ? '' : path);
         }
-        if (errors.isNotFoundError(err)) {
-            return res.status(404).end();
+        this[kMiddlewares].push([path, fn]);
+        if (fn == null) {
+            this.express.use(path);
         }
-        next(err);
-    });
+        else {
+            this.express.use(path, fn);
+        }
+        return this;
+    }
+    function enhanceRequest(req, reply, next) {
+        req.raw.originalUrl = req.raw.url;
+        req.raw.id = req.id;
+        req.raw.hostname = req.hostname;
+        req.raw.ip = req.ip;
+        req.raw.ips = req.ips;
+        req.raw.log = req.log;
+        // eslint-disable-next-line no-param-reassign
+        reply.raw.log = req.log;
+        const originalProtocol = req.raw.protocol;
+        // Make it lazy as it does a bit of work
+        Object.defineProperty(req.raw, 'protocol', {
+            get() {
+                // added in Fastify@3.5, so handle it missing
+                return req.protocol || originalProtocol;
+            },
+        });
+        next();
+    }
+    function runConnect(req, reply, next) {
+        if (this[kMiddlewares].length > 0) {
+            for (const [headerName, headerValue] of Object.entries(reply.getHeaders())) {
+                reply.raw.setHeader(headerName, headerValue);
+            }
+            this.express(req.raw, reply.raw, next);
+        }
+        else {
+            next();
+        }
+    }
+    function onRegister(instance) {
+        const middlewares = instance[kMiddlewares].slice();
+        // eslint-disable-next-line no-param-reassign
+        instance[kMiddlewares] = [];
+        instance.decorate('express', express__default["default"]());
+        instance.express.disable('x-powered-by');
+        instance.decorate('use', use);
+        for (const middleware of middlewares) {
+            instance.use(...middleware);
+        }
+    }
+    next();
 };
-const errorHandler = (app, { log, }) => {
-    app.use(async (err, req, res, next) => {
+const fastifyExpressCompatibility = fp__default["default"](expressPlugin, {
+    fastify: '>=3.0.0',
+    name: 'fastify-express',
+});
+
+const errorHandler = (app, { log, beforeError, processError, afterError, }) => {
+    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 requestInfo = {
-            ip: req.ip,
-            requestId: req.headers['x-request-id'],
-            url: req.url,
+            ip: request.ip,
+            requestId: request.headers['x-request-id'],
+            url: request.url,
         };
-        if (errors.isHttpError(err)) {
-            if (err.httpStatus >= 500) {
-                log.error({ event: 'send-server-error', error: err, requestInfo });
+        const beforeErrorResult = await runHandlers(beforeError);
+        if (!isNil__default["default"](beforeErrorResult)) {
+            return beforeErrorResult;
+        }
+        if (errors.isRedirectFoundError(error)) {
+            reply.header('cache-control', 'no-cache, no-store, must-revalidate');
+            reply.redirect(error.httpStatus || 307, error.nextUrl);
+            return;
+        }
+        if (errors.isNotFoundError(error)) {
+            reply.status(404);
+            return '';
+        }
+        const processErrorResult = await runHandlers(processError);
+        if (!isNil__default["default"](processErrorResult)) {
+            return processErrorResult;
+        }
+        if (errors.isHttpError(error)) {
+            if (error.httpStatus >= 500) {
+                log.error({ event: 'send-server-error', error, requestInfo });
             }
-            return res.status(err.httpStatus).end();
+            reply.status(error.httpStatus);
+            return '';
         }
-        log.error({ event: 'send-server-error', error: err, requestInfo });
-        finalhandler__default["default"](req, res)(err);
+        log.error({ event: 'send-server-error', error, requestInfo });
+        const afterErrorResult = await runHandlers(afterError);
+        if (!isNil__default["default"](afterErrorResult)) {
+            return afterErrorResult;
+        }
+        throw error;
     });
 };
 
-const webAppFactory = () => {
+const webAppFactory = ({ server, expressApp, }) => {
+    const app = fastify__default["default"]({
+        serverFactory: (handler) => {
+            server.on('request', handler);
+            return server;
+        },
+    });
+    return app;
+};
+const webAppExpressFactory = ({ webApp }) => {
     const app = express__default["default"]();
     app.disable('etag');
     app.disable('x-powered-by');
     return app;
 };
-const webAppInitCommand = ({ app, logger, commandLineRunner, beforeInit, init, afterInit, limiterRequest, }) => {
+const webAppInitCommand = ({ app, expressApp, logger, commandLineRunner, beforeInit, init, afterInit, limiterRequest, expressBeforeInit, expressInit, expressAfterInit, expressLimiterRequest, beforeError, processError, afterError, }) => {
     const log = logger('server:webapp');
-    const runHandlers = (handlers) => {
-        if (handlers) {
-            return Promise.all(handlers.map((handler) => handler(app)));
-        }
+    const runHandlers = (handlers, expressHandlers) => {
+        return Promise.all([
+            handlers && Promise.all(handlers.map((handler) => handler(app))),
+            expressHandlers && Promise.all(expressHandlers.map((handler) => handler(expressApp))),
+        ]);
     };
     return async function webAppInit() {
-        await runHandlers(beforeInit);
-        await runHandlers(limiterRequest);
-        app.use(bodyParser__default["default"].urlencoded({
+        errorHandler(app, { log, beforeError, processError, afterError });
+        await app.register(fastifyExpressCompatibility, {
+            express: {
+                instance: expressApp,
+            },
+        });
+        await runHandlers(beforeInit, expressBeforeInit);
+        await runHandlers(limiterRequest, expressLimiterRequest);
+        await app.register(fastifyCookie.fastifyCookie);
+        await app.register(fastifyFormBody__default["default"]);
+        expressApp.use(bodyParser__default["default"].urlencoded({
             limit: '2mb',
             extended: false,
         }), cookieParser__default["default"]());
-        await runHandlers(init);
-        app.use(async (req, res, next) => {
+        await runHandlers(init, expressInit);
+        // force express to execute to update server's request and response instances
+        app.use((req, res, next) => {
+            next();
+        });
+        app.all('*', async (request, reply) => {
             try {
                 log.debug({
                     event: 'start:request',
                     message: 'Клиент зашел на страницу',
-                    url: req.url,
+                    url: request.url,
                 });
                 const di = await commandLineRunner.run('server', 'customer', [
                     {
-                        provide: moduleCommon.REQUEST,
+                        provide: tokensCommon.REQUEST,
                         scope: core.Scope.REQUEST,
-                        useValue: req,
+                        useValue: request.raw,
                     },
                     {
-                        provide: moduleCommon.RESPONSE,
+                        provide: tokensCommon.RESPONSE,
                         scope: core.Scope.REQUEST,
-                        useValue: res,
+                        useValue: reply.raw,
+                    },
+                    // TODO: перевести использование на новые
+                    // TODO: добавить для papi
+                    {
+                        provide: tokensCommon.FASTIFY_REQUEST,
+                        scope: core.Scope.REQUEST,
+                        useValue: request,
+                    },
+                    {
+                        provide: tokensCommon.FASTIFY_RESPONSE,
+                        scope: core.Scope.REQUEST,
+                        useValue: reply,
                     },
                 ]);
-                const responseManager = di.get(moduleCommon.RESPONSE_MANAGER_TOKEN);
-                if (res.writableEnded) {
+                const responseManager = di.get(tokensCommon.RESPONSE_MANAGER_TOKEN);
+                if (reply.sent) {
                     log.debug({
                         event: 'response-ended',
                         message: 'Response was already ended.',
-                        url: req.url,
+                        url: request.url,
                     });
                 }
                 else {
-                    res
-                        .set('content-type', 'text/html')
-                        .set(responseManager.getHeaders())
+                    reply
+                        .header('content-type', 'text/html')
+                        .headers(responseManager.getHeaders())
                         .status(responseManager.getStatus())
                         .send(responseManager.getBody());
                 }
             }
             catch (err) {
                 if (err.di) {
-                    const responseManager = err.di.get(moduleCommon.RESPONSE_MANAGER_TOKEN);
-                    if (responseManager && !res.writableEnded) {
-                        res.set(responseManager.getHeaders());
+                    const responseManager = err.di.get(tokensCommon.RESPONSE_MANAGER_TOKEN);
+                    if (responseManager && !reply.sent) {
+                        reply.headers(responseManager.getHeaders());
                     }
                 }
-                next(err);
+                throw err;
             }
         });
-        routerErrorHandler(app);
-        await runHandlers(afterInit);
-        errorHandler(app, { log });
+        await runHandlers(afterInit, expressAfterInit);
+        await app.ready();
     };
 };
 
@@ -211,9 +351,8 @@ const xHeadersFactory = ({ app, envManager, appInfo, }) => {
         'x-deploy-repository': envManager.get('DEPLOY_REPOSITORY'),
     });
     return async () => {
-        app.use((req, res, next) => {
-            res.set(xHeaders);
-            next();
+        app.addHook('preHandler', async (_, reply) => {
+            reply.headers(xHeaders);
         });
     };
 };
@@ -257,10 +396,20 @@ try {
     Api = require('@tramvai/cli/lib/external/api').default; // eslint-disable-line import/no-unresolved
 }
 catch (e) { }
-const getFileApi = () => {
+const getFileApi = ({ logger }) => {
+    const log = logger('papi:fileApi');
     const result = [];
     eachObj__default["default"]((v, k) => {
         const handler = (v.handler || v.default);
+        if (!handler) {
+            log.error({
+                message: `Cannot resolve a papi handler.
+Check that you are using file based papi right way by docs https://tramvai.dev/docs/how-to/how-create-papi#automatic-handler-creation
+In case you have not added any file papi handler, consider renaming directory ./src/api (by default) to the other name to resolve conflicts with papi, or
+change settings application.commands.build.options.serverApiDir in tramvai.json`,
+            });
+            throw new Error('Not a papi');
+        }
         const papiParameters = papi.getPapiParameters(handler);
         result.push(papi.createPapiMethod({
             ...v,
@@ -274,7 +423,10 @@ const getFileApi = () => {
 const fileApiProvider = {
     provide: tokensServer.SERVER_MODULE_PAPI_PUBLIC_ROUTE,
     multi: true,
-    useValue: getFileApi(),
+    useFactory: getFileApi,
+    deps: {
+        logger: tokensCommon.LOGGER_TOKEN,
+    },
 };
 
 const sharedProviders = [
@@ -409,29 +561,32 @@ let ServerStaticsModule = class ServerStaticsModule {
 ServerStaticsModule = tslib.__decorate([
     core.Module({
         providers: [
-            {
-                provide: tokensServer.WEB_APP_BEFORE_INIT_TOKEN,
+            core.provide({
+                provide: tokensServerPrivate.WEB_FASTIFY_APP_BEFORE_INIT_TOKEN,
                 useFactory: ({ app, options }) => {
-                    const path = (options === null || options === void 0 ? void 0 : options.path) || 'public';
+                    const path$1 = (options === null || options === void 0 ? void 0 : options.path) || 'public';
                     return () => {
-                        app.use(express__default["default"].static(path, {
+                        app.register(FastifyStatic__default["default"], {
+                            decorateReply: false,
+                            prefix: `/${path$1}`,
+                            root: path.resolve(process.cwd(), path$1),
                             setHeaders: (res) => {
                                 const oneYearForward = new Date(Date.now() + ONE_YEAR * 1000);
-                                res.set('cache-control', `public, max-age=${ONE_YEAR}`);
-                                res.set('expires', oneYearForward.toUTCString());
+                                res.setHeader('cache-control', `public, max-age=${ONE_YEAR}`);
+                                res.setHeader('expires', oneYearForward.toUTCString());
                             },
-                        }));
+                        });
                     };
                 },
                 deps: {
-                    app: tokensServer.WEB_APP_TOKEN,
+                    app: tokensServerPrivate.WEB_FASTIFY_APP_TOKEN,
                     options: {
                         token: tokensServer.SERVER_MODULE_STATICS_OPTIONS,
                         optional: true,
                     },
                 },
                 multi: true,
-            },
+            }),
         ],
     })
 ], ServerStaticsModule);
@@ -447,12 +602,12 @@ ServerGracefulShutdownModule = tslib.__decorate([
     core.Module({
         providers: [
             {
-                provide: tokensServer.WEB_APP_BEFORE_INIT_TOKEN,
+                provide: tokensServerPrivate.WEB_FASTIFY_APP_BEFORE_INIT_TOKEN,
                 multi: true,
-                useFactory: ({ server, app, logger, commandLineRunner, livenessProbe, readinessProbe, }) => {
+                useFactory: ({ app, server, logger, commandLineRunner, livenessProbe, readinessProbe, }) => {
                     const log = logger('server');
                     return function serverListen() {
-                        expressTerminus.createTerminus(server, app, {
+                        terminus.createTerminus(server, app, {
                             signal: 'SIGTERM',
                             timeout: GRACEFUL_SHUTDOWN_TIMEOUT,
                             logger: (msg, error) => {
@@ -492,8 +647,8 @@ ServerGracefulShutdownModule = tslib.__decorate([
                     };
                 },
                 deps: {
+                    app: tokensServerPrivate.WEB_FASTIFY_APP_TOKEN,
                     server: tokensServer.SERVER_TOKEN,
-                    app: tokensServer.WEB_APP_TOKEN,
                     logger: tokensCommon.LOGGER_TOKEN,
                     commandLineRunner: core.COMMAND_LINE_RUNNER_TOKEN,
                     readinessProbe: { token: tokensServer.READINESS_PROBE_TOKEN, optional: true },
@@ -656,6 +811,8 @@ ServerProxyModule = tslib.__decorate([
     core.Module({
         providers: [
             {
+                // TODO: tramvai@2 migrate to `fastify` and `fastify-http-proxy`
+                // interfaces for the proxies are not compatible so some migration from the app is needed
                 provide: tokensServer.WEB_APP_BEFORE_INIT_TOKEN,
                 useFactory: ({ app, defaultProxies }) => {
                     return () => {
@@ -759,31 +916,48 @@ exports.ServerModule = tslib.__decorate([
             process.env.NODE_ENV !== 'production' && DebugHttpRequestsModule,
         ].filter(Boolean),
         providers: [
-            {
-                provide: tokensServer.WEB_APP_TOKEN,
+            core.provide({
+                provide: tokensServer.SERVER_TOKEN,
                 scope: core.Scope.SINGLETON,
+                useFactory: serverFactory,
+            }),
+            core.provide({
+                provide: tokensServerPrivate.WEB_FASTIFY_APP_TOKEN,
                 useFactory: webAppFactory,
-            },
+                scope: core.Scope.SINGLETON,
+                deps: {
+                    server: tokensServer.SERVER_TOKEN,
+                },
+            }),
+            core.provide({
+                // BACKWARD: provide the express app as before
+                provide: tokensServer.WEB_APP_TOKEN,
+                scope: core.Scope.SINGLETON,
+                useFactory: webAppExpressFactory,
+                deps: {
+                    webApp: tokensServerPrivate.WEB_FASTIFY_APP_TOKEN,
+                },
+            }),
             {
                 provide: core.commandLineListTokens.init,
                 multi: true,
                 useFactory: webAppInitCommand,
                 deps: {
-                    app: tokensServer.WEB_APP_TOKEN,
-                    logger: moduleCommon.LOGGER_TOKEN,
+                    app: tokensServerPrivate.WEB_FASTIFY_APP_TOKEN,
+                    expressApp: tokensServer.WEB_APP_TOKEN,
+                    logger: tokensCommon.LOGGER_TOKEN,
                     commandLineRunner: core.COMMAND_LINE_RUNNER_TOKEN,
-                    beforeInit: { token: tokensServer.WEB_APP_BEFORE_INIT_TOKEN, optional: true },
-                    init: { token: tokensServer.WEB_APP_INIT_TOKEN, optional: true },
-                    afterInit: { token: tokensServer.WEB_APP_AFTER_INIT_TOKEN, optional: true },
-                    limiterRequest: { token: tokensServer.WEB_APP_LIMITER_TOKEN, optional: true },
-                },
-            },
-            {
-                provide: tokensServer.SERVER_TOKEN,
-                scope: core.Scope.SINGLETON,
-                useFactory: serverFactory,
-                deps: {
-                    webApp: tokensServer.WEB_APP_TOKEN,
+                    beforeInit: { token: tokensServerPrivate.WEB_FASTIFY_APP_BEFORE_INIT_TOKEN, optional: true },
+                    init: { token: tokensServerPrivate.WEB_FASTIFY_APP_INIT_TOKEN, optional: true },
+                    afterInit: { token: tokensServerPrivate.WEB_FASTIFY_APP_AFTER_INIT_TOKEN, optional: true },
+                    limiterRequest: { token: tokensServerPrivate.WEB_FASTIFY_APP_LIMITER_TOKEN, optional: true },
+                    expressBeforeInit: { token: tokensServer.WEB_APP_BEFORE_INIT_TOKEN, optional: true },
+                    expressInit: { token: tokensServer.WEB_APP_INIT_TOKEN, optional: true },
+                    expressAfterInit: { token: tokensServer.WEB_APP_AFTER_INIT_TOKEN, optional: true },
+                    expressLimiterRequest: { token: tokensServer.WEB_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 },
                 },
             },
             {
@@ -792,8 +966,8 @@ exports.ServerModule = tslib.__decorate([
                 useFactory: serverListenCommand,
                 deps: {
                     server: tokensServer.SERVER_TOKEN,
-                    logger: moduleCommon.LOGGER_TOKEN,
-                    envManager: moduleCommon.ENV_MANAGER_TOKEN,
+                    logger: tokensCommon.LOGGER_TOKEN,
+                    envManager: tokensCommon.ENV_MANAGER_TOKEN,
                 },
             },
             {
@@ -801,13 +975,13 @@ exports.ServerModule = tslib.__decorate([
                 multi: true,
                 useFactory: staticAppCommand,
                 deps: {
-                    logger: moduleCommon.LOGGER_TOKEN,
-                    envManager: moduleCommon.ENV_MANAGER_TOKEN,
+                    logger: tokensCommon.LOGGER_TOKEN,
+                    envManager: tokensCommon.ENV_MANAGER_TOKEN,
                     appInfo: core.APP_INFO_TOKEN,
                 },
             },
             {
-                provide: moduleCommon.ENV_USED_TOKEN,
+                provide: tokensCommon.ENV_USED_TOKEN,
                 multi: true,
                 useValue: [
                     { key: 'DEV_STATIC', optional: true, dehydrate: false },
@@ -827,12 +1001,12 @@ exports.ServerModule = tslib.__decorate([
                 ],
             },
             {
-                provide: tokensServer.WEB_APP_BEFORE_INIT_TOKEN,
+                provide: tokensServerPrivate.WEB_FASTIFY_APP_INIT_TOKEN,
                 multi: true,
                 useFactory: xHeadersFactory,
                 deps: {
-                    app: tokensServer.WEB_APP_TOKEN,
-                    envManager: moduleCommon.ENV_MANAGER_TOKEN,
+                    app: tokensServerPrivate.WEB_FASTIFY_APP_TOKEN,
+                    envManager: tokensCommon.ENV_MANAGER_TOKEN,
                     appInfo: core.APP_INFO_TOKEN,
                 },
             },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-server",
-  "version": "1.84.2",
+  "version": "1.90.1",
   "description": "",
   "browser": "lib/browser.js",
   "main": "lib/server.js",
@@ -20,34 +20,38 @@
   },
   "dependencies": {
     "@tinkoff/errors": "0.2.20",
-    "@tinkoff/express-terminus": "0.1.13",
     "@tinkoff/monkeypatch": "1.3.3",
+    "@tinkoff/terminus": "0.0.1",
     "@tinkoff/url": "0.7.37",
-    "@tramvai/module-cache-warmup": "1.84.2",
-    "@tramvai/module-metrics": "1.84.2",
-    "@tramvai/papi": "1.84.2",
-    "@tramvai/tokens-server": "1.84.2",
+    "@tramvai/module-cache-warmup": "1.90.1",
+    "@tramvai/module-metrics": "1.90.1",
+    "@tramvai/papi": "1.90.1",
+    "@tramvai/tokens-server": "1.90.1",
+    "@tramvai/tokens-server-private": "1.90.1",
     "body-parser": "^1.19.0",
     "compression": "^1.7.4",
     "cookie-parser": "^1.4.3",
     "express": "^4.17.1",
-    "finalhandler": "^1.1.2",
+    "fastify": "^3.27.4",
+    "fastify-cookie": "^5.6.0",
+    "fastify-formbody": "^5.2.0",
+    "fastify-plugin": "^3.0.1",
+    "fastify-static": "^4.6.1",
     "http-proxy-middleware": "^2.0.2"
   },
   "peerDependencies": {
-    "@tinkoff/utils": "^2.1.2",
-    "@tramvai/cli": "1.84.2",
-    "@tramvai/core": "1.84.2",
-    "@tramvai/module-common": "1.84.2",
-    "@tramvai/module-environment": "1.84.2",
-    "@tramvai/tokens-common": "1.84.2",
     "@tinkoff/dippy": "0.7.39",
+    "@tinkoff/utils": "^2.1.2",
+    "@tramvai/cli": "1.90.1",
+    "@tramvai/core": "1.90.1",
+    "@tramvai/module-common": "1.90.1",
+    "@tramvai/module-environment": "1.90.1",
+    "@tramvai/tokens-common": "1.90.1",
     "tslib": "^2.0.3"
   },
   "devDependencies": {
     "@types/compression": "^1.7.0",
     "@types/express": "^4.17.9",
-    "@types/finalhandler": "^1.1.0",
     "@types/http-proxy-middleware": "^0.19.3"
   },
   "module": "lib/server.es.js",