@tramvai/module-server 1.82.3 → 1.85.0

package/lib/server/error.d.ts

@@ -1,6 +1,9 @@
-import type express from 'express';
+import type { FastifyInstance } from 'fastify';
 import type { LOGGER_TOKEN } from '@tramvai/module-common';
-export declare const routerErrorHandler: (app: express.Application) => void;
-export declare const errorHandler: (app: express.Application, { log, }: {
+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';
+export declare const errorHandler: (app: FastifyInstance, { log, beforeError, processError, afterError, }: {
     log: ReturnType<typeof LOGGER_TOKEN>;
+    beforeError: typeof WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN;
+    processError: typeof WEB_FASTIFY_APP_PROCESS_ERROR_TOKEN;
+    afterError: typeof WEB_FASTIFY_APP_AFTER_ERROR_TOKEN;
 }) => void;

package/lib/server/express-compatibility.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Fork of https://github.com/fastify/fastify-express
+ */
+/// <reference types="node" />
+import express from 'express';
+import type { FastifyPluginCallback } from 'fastify';
+declare module 'fastify' {
+    interface FastifyInstance {
+        /**
+         * Express middleware function
+         */
+        use: express.Application['use'];
+        /**
+         * Express application instance
+         */
+        express: express.Application;
+    }
+}
+interface Options {
+    express: {
+        instance: express.Application;
+    };
+}
+export declare const fastifyExpressCompatibility: FastifyPluginCallback<Options, import("http").Server>;
+export {};

package/lib/server/server.d.ts

@@ -1,11 +1,9 @@
 /// <reference types="node" />
 import http from 'http';
-import type { SERVER_TOKEN, WEB_APP_TOKEN } from '@tramvai/tokens-server';
+import type { SERVER_TOKEN } from '@tramvai/tokens-server';
 import type { LOGGER_TOKEN } from '@tramvai/tokens-common';
 import type { ENV_MANAGER_TOKEN } from '@tramvai/module-environment';
-export declare const serverFactory: ({ webApp }: {
-    webApp: typeof WEB_APP_TOKEN;
-}) => http.Server;
+export declare const serverFactory: () => http.Server;
 export declare const serverListenCommand: ({ server, logger, envManager, }: {
     server: typeof SERVER_TOKEN;
     logger: typeof LOGGER_TOKEN;

package/lib/server/webApp.d.ts

@@ -1,13 +1,29 @@
-import type { LOGGER_TOKEN } from '@tramvai/module-common';
+/// <reference types="node" />
+import type { LOGGER_TOKEN } from '@tramvai/tokens-common';
 import type { COMMAND_LINE_RUNNER_TOKEN } from '@tramvai/core';
-import type { WEB_APP_TOKEN, WEB_APP_BEFORE_INIT_TOKEN, WEB_APP_INIT_TOKEN, WEB_APP_AFTER_INIT_TOKEN, WEB_APP_LIMITER_TOKEN } from '@tramvai/tokens-server';
-export declare const webAppFactory: () => import("express-serve-static-core").Express;
-export declare const webAppInitCommand: ({ app, logger, commandLineRunner, beforeInit, init, afterInit, limiterRequest, }: {
-    app: typeof WEB_APP_TOKEN;
+import type { WEB_APP_TOKEN, WEB_APP_BEFORE_INIT_TOKEN, WEB_APP_INIT_TOKEN, WEB_APP_AFTER_INIT_TOKEN, WEB_APP_LIMITER_TOKEN, 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 } from '@tramvai/tokens-server-private';
+export declare const webAppFactory: ({ server, expressApp, }: {
+    server: typeof SERVER_TOKEN;
+    expressApp: typeof WEB_APP_TOKEN;
+}) => import("fastify").FastifyInstance<import("http").Server, import("http").IncomingMessage, import("http").ServerResponse, import("fastify").FastifyLoggerInstance> & PromiseLike<import("fastify").FastifyInstance<import("http").Server, import("http").IncomingMessage, import("http").ServerResponse, import("fastify").FastifyLoggerInstance>>;
+export declare const webAppExpressFactory: ({ webApp }: {
+    webApp: typeof WEB_FASTIFY_APP_TOKEN;
+}) => import("express-serve-static-core").Express;
+export declare const webAppInitCommand: ({ app, expressApp, logger, commandLineRunner, beforeInit, init, afterInit, limiterRequest, expressBeforeInit, expressInit, expressAfterInit, expressLimiterRequest, beforeError, processError, afterError, }: {
+    app: typeof WEB_FASTIFY_APP_TOKEN;
+    expressApp: typeof WEB_APP_TOKEN;
     logger: typeof LOGGER_TOKEN;
     commandLineRunner: typeof COMMAND_LINE_RUNNER_TOKEN;
-    beforeInit: typeof WEB_APP_BEFORE_INIT_TOKEN;
-    init: typeof WEB_APP_INIT_TOKEN;
-    afterInit: typeof WEB_APP_AFTER_INIT_TOKEN;
-    limiterRequest: typeof WEB_APP_LIMITER_TOKEN;
+    beforeInit: typeof WEB_FASTIFY_APP_BEFORE_INIT_TOKEN;
+    init: typeof WEB_FASTIFY_APP_INIT_TOKEN;
+    afterInit: typeof WEB_FASTIFY_APP_AFTER_INIT_TOKEN;
+    limiterRequest: typeof WEB_FASTIFY_APP_LIMITER_TOKEN;
+    expressBeforeInit: typeof WEB_APP_BEFORE_INIT_TOKEN;
+    expressInit: typeof WEB_APP_INIT_TOKEN;
+    expressAfterInit: typeof WEB_APP_AFTER_INIT_TOKEN;
+    expressLimiterRequest: typeof WEB_APP_LIMITER_TOKEN;
+    beforeError: typeof WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN;
+    processError: typeof WEB_FASTIFY_APP_PROCESS_ERROR_TOKEN;
+    afterError: typeof WEB_FASTIFY_APP_AFTER_ERROR_TOKEN;
 }) => () => Promise<void>;

package/lib/server.es.js

@@ -2,14 +2,20 @@ import { __decorate } from 'tslib';
 import { Scope, APP_INFO_TOKEN, Module, provide, DI_TOKEN, COMMAND_LINE_RUNNER_TOKEN, commandLineListTokens } from '@tramvai/core';
 import { SERVER_MODULE_PAPI_PUBLIC_ROUTE, SERVER_MODULE_PAPI_PUBLIC_URL, SERVER_MODULE_PAPI_PRIVATE_URL, WEB_APP_BEFORE_INIT_TOKEN, WEB_APP_TOKEN, SERVER_MODULE_PAPI_PRIVATE_ROUTE, SERVER_MODULE_STATICS_OPTIONS, SERVER_TOKEN, READINESS_PROBE_TOKEN, LIVENESS_PROBE_TOKEN, SPECIAL_SERVER_PATHS, PROXY_CONFIG_TOKEN, DEPENDENCIES_VERSION_FILTER_TOKEN, WEB_APP_INIT_TOKEN, WEB_APP_AFTER_INIT_TOKEN, WEB_APP_LIMITER_TOKEN } from '@tramvai/tokens-server';
 export * from '@tramvai/tokens-server';
-import { REQUEST, RESPONSE, RESPONSE_MANAGER_TOKEN, LOGGER_TOKEN as LOGGER_TOKEN$1, ENV_MANAGER_TOKEN as ENV_MANAGER_TOKEN$1, ENV_USED_TOKEN } from '@tramvai/module-common';
+import { WEB_FASTIFY_APP_BEFORE_INIT_TOKEN, WEB_FASTIFY_APP_TOKEN, WEB_FASTIFY_APP_INIT_TOKEN, WEB_FASTIFY_APP_AFTER_INIT_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 { REQUEST, RESPONSE, FASTIFY_REQUEST, FASTIFY_RESPONSE, RESPONSE_MANAGER_TOKEN, LOGGER_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 http from 'http';
+import fastify from 'fastify';
 import express from 'express';
 import cookieParser from 'cookie-parser';
 import bodyParser from 'body-parser';
-import finalhandler from 'finalhandler';
+import { fastifyCookie } from 'fastify-cookie';
+import fastifyFormBody from 'fastify-formbody';
+import fp from 'fastify-plugin';
+import symbols from 'fastify/lib/symbols';
+import isNil from '@tinkoff/utils/is/nil';
 import { isRedirectFoundError, isNotFoundError, isHttpError } from '@tinkoff/errors';
 import zlib from 'zlib';
 import compression from 'compression';
@@ -17,11 +23,10 @@ import os from 'os';
 import filterObj from '@tinkoff/utils/object/filter';
 import flatten from '@tinkoff/utils/array/flatten';
 import toArray from '@tinkoff/utils/array/toArray';
-import { REQUEST as REQUEST$1, RESPONSE as RESPONSE$1, LOGGER_TOKEN, ENV_MANAGER_TOKEN } from '@tramvai/tokens-common';
 import { create, middlewares, getPapiParameters, createPapiMethod } from '@tramvai/papi';
 import { createChildContainer } from '@tinkoff/dippy';
 import eachObj from '@tinkoff/utils/object/each';
-import { createTerminus } from '@tinkoff/express-terminus';
+import { createTerminus } from '@tinkoff/terminus';
 import { parse } from '@tinkoff/url';
 import { EventEmitter } from 'events';
 import monkeypatch from '@tinkoff/monkeypatch';
@@ -31,10 +36,8 @@ import isObject from '@tinkoff/utils/is/object';
 import { resolve } from 'path';
 import { createProxyMiddleware } from 'http-proxy-middleware';
 
-const serverFactory = ({ webApp }) => {
-    const server = http.createServer();
-    server.on('request', webApp);
-    return server;
+const serverFactory = () => {
+    return http.createServer();
 };
 const serverListenCommand = ({ server, logger, envManager, }) => {
     const log = logger('server');
@@ -47,88 +50,220 @@ const serverListenCommand = ({ server, logger, envManager, }) => {
     };
 };
 
-const routerErrorHandler = (app) => {
-    app.use((err, req, res, next) => {
-        if (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());
+    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.kRoutePrefix];
+            // eslint-disable-next-line no-param-reassign
+            path = prefix + (path === '/' && prefix.length > 0 ? '' : path);
         }
-        if (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());
+        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(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 (isHttpError(err)) {
-            if (err.httpStatus >= 500) {
-                log.error({ event: 'send-server-error', error: err, requestInfo });
+        const beforeErrorResult = await runHandlers(beforeError);
+        if (!isNil(beforeErrorResult)) {
+            return beforeErrorResult;
+        }
+        if (isRedirectFoundError(error)) {
+            reply.header('cache-control', 'no-cache, no-store, must-revalidate');
+            reply.redirect(error.httpStatus || 307, error.nextUrl);
+            return;
+        }
+        if (isNotFoundError(error)) {
+            reply.status(404);
+            return '';
+        }
+        const processErrorResult = await runHandlers(processError);
+        if (!isNil(processErrorResult)) {
+            return processErrorResult;
+        }
+        if (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(req, res)(err);
+        log.error({ event: 'send-server-error', error, requestInfo });
+        const afterErrorResult = await runHandlers(afterError);
+        if (!isNil(afterErrorResult)) {
+            return afterErrorResult;
+        }
+        throw error;
     });
 };
 
-const webAppFactory = () => {
+const webAppFactory = ({ server, expressApp, }) => {
+    const app = fastify({
+        serverFactory: (handler) => {
+            server.on('request', handler);
+            return server;
+        },
+    });
+    return app;
+};
+const webAppExpressFactory = ({ webApp }) => {
     const app = express();
     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.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);
+        await app.register(fastifyFormBody);
+        expressApp.use(bodyParser.urlencoded({
             limit: '2mb',
             extended: false,
         }), cookieParser());
-        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: REQUEST,
                         scope: Scope.REQUEST,
-                        useValue: req,
+                        useValue: request.raw,
                     },
                     {
                         provide: RESPONSE,
                         scope: Scope.REQUEST,
-                        useValue: res,
+                        useValue: reply.raw,
+                    },
+                    // TODO: перевести использование на новые
+                    // TODO: добавить для papi
+                    {
+                        provide: FASTIFY_REQUEST,
+                        scope: Scope.REQUEST,
+                        useValue: request,
+                    },
+                    {
+                        provide: FASTIFY_RESPONSE,
+                        scope: Scope.REQUEST,
+                        useValue: reply,
                     },
                 ]);
                 const responseManager = di.get(RESPONSE_MANAGER_TOKEN);
-                if (res.writableEnded) {
+                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());
                 }
@@ -136,16 +271,15 @@ const webAppInitCommand = ({ app, logger, commandLineRunner, beforeInit, init, a
             catch (err) {
                 if (err.di) {
                     const responseManager = err.di.get(RESPONSE_MANAGER_TOKEN);
-                    if (responseManager && !res.writableEnded) {
-                        res.set(responseManager.getHeaders());
+                    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();
     };
 };
 
@@ -213,11 +347,11 @@ function createApi(papiList, { di, logger }) {
                     var _a;
                     const childDI = createChildContainer(di);
                     childDI.register({
-                        provide: REQUEST$1,
+                        provide: REQUEST,
                         useValue: req,
                     });
                     childDI.register({
-                        provide: RESPONSE$1,
+                        provide: RESPONSE,
                         useValue: res,
                     });
                     return { ...rootDeps, ...childDI.getOfDeps((_a = papi.deps) !== null && _a !== void 0 ? _a : {}), req, res };
@@ -425,9 +559,9 @@ ServerGracefulShutdownModule = __decorate([
     Module({
         providers: [
             {
-                provide: WEB_APP_BEFORE_INIT_TOKEN,
+                provide: 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() {
                         createTerminus(server, app, {
@@ -470,8 +604,8 @@ ServerGracefulShutdownModule = __decorate([
                     };
                 },
                 deps: {
+                    app: WEB_FASTIFY_APP_TOKEN,
                     server: SERVER_TOKEN,
-                    app: WEB_APP_TOKEN,
                     logger: LOGGER_TOKEN,
                     commandLineRunner: COMMAND_LINE_RUNNER_TOKEN,
                     readinessProbe: { token: READINESS_PROBE_TOKEN, optional: true },
@@ -737,31 +871,48 @@ ServerModule = __decorate([
             process.env.NODE_ENV !== 'production' && DebugHttpRequestsModule,
         ].filter(Boolean),
         providers: [
-            {
-                provide: WEB_APP_TOKEN,
+            provide({
+                provide: SERVER_TOKEN,
                 scope: Scope.SINGLETON,
+                useFactory: serverFactory,
+            }),
+            provide({
+                provide: WEB_FASTIFY_APP_TOKEN,
                 useFactory: webAppFactory,
-            },
+                scope: Scope.SINGLETON,
+                deps: {
+                    server: SERVER_TOKEN,
+                },
+            }),
+            provide({
+                // BACKWARD: provide the express app as before
+                provide: WEB_APP_TOKEN,
+                scope: Scope.SINGLETON,
+                useFactory: webAppExpressFactory,
+                deps: {
+                    webApp: WEB_FASTIFY_APP_TOKEN,
+                },
+            }),
             {
                 provide: commandLineListTokens.init,
                 multi: true,
                 useFactory: webAppInitCommand,
                 deps: {
-                    app: WEB_APP_TOKEN,
-                    logger: LOGGER_TOKEN$1,
+                    app: WEB_FASTIFY_APP_TOKEN,
+                    expressApp: WEB_APP_TOKEN,
+                    logger: LOGGER_TOKEN,
                     commandLineRunner: COMMAND_LINE_RUNNER_TOKEN,
-                    beforeInit: { token: WEB_APP_BEFORE_INIT_TOKEN, optional: true },
-                    init: { token: WEB_APP_INIT_TOKEN, optional: true },
-                    afterInit: { token: WEB_APP_AFTER_INIT_TOKEN, optional: true },
-                    limiterRequest: { token: WEB_APP_LIMITER_TOKEN, optional: true },
-                },
-            },
-            {
-                provide: SERVER_TOKEN,
-                scope: Scope.SINGLETON,
-                useFactory: serverFactory,
-                deps: {
-                    webApp: WEB_APP_TOKEN,
+                    beforeInit: { token: WEB_FASTIFY_APP_BEFORE_INIT_TOKEN, optional: true },
+                    init: { token: WEB_FASTIFY_APP_INIT_TOKEN, optional: true },
+                    afterInit: { token: WEB_FASTIFY_APP_AFTER_INIT_TOKEN, optional: true },
+                    limiterRequest: { token: WEB_FASTIFY_APP_LIMITER_TOKEN, optional: true },
+                    expressBeforeInit: { token: WEB_APP_BEFORE_INIT_TOKEN, optional: true },
+                    expressInit: { token: WEB_APP_INIT_TOKEN, optional: true },
+                    expressAfterInit: { token: WEB_APP_AFTER_INIT_TOKEN, optional: true },
+                    expressLimiterRequest: { token: WEB_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 },
                 },
             },
             {
@@ -770,8 +921,8 @@ ServerModule = __decorate([
                 useFactory: serverListenCommand,
                 deps: {
                     server: SERVER_TOKEN,
-                    logger: LOGGER_TOKEN$1,
-                    envManager: ENV_MANAGER_TOKEN$1,
+                    logger: LOGGER_TOKEN,
+                    envManager: ENV_MANAGER_TOKEN,
                 },
             },
             {
@@ -779,8 +930,8 @@ ServerModule = __decorate([
                 multi: true,
                 useFactory: staticAppCommand,
                 deps: {
-                    logger: LOGGER_TOKEN$1,
-                    envManager: ENV_MANAGER_TOKEN$1,
+                    logger: LOGGER_TOKEN,
+                    envManager: ENV_MANAGER_TOKEN,
                     appInfo: APP_INFO_TOKEN,
                 },
             },
@@ -810,7 +961,7 @@ ServerModule = __decorate([
                 useFactory: xHeadersFactory,
                 deps: {
                     app: WEB_APP_TOKEN,
-                    envManager: ENV_MANAGER_TOKEN$1,
+                    envManager: ENV_MANAGER_TOKEN,
                     appInfo: APP_INFO_TOKEN,
                 },
             },

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,11 +26,10 @@ 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 terminus = require('@tinkoff/terminus');
 var url = require('@tinkoff/url');
 var events = require('events');
 var monkeypatch = require('@tinkoff/monkeypatch');
@@ -37,10 +42,14 @@ 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);
@@ -53,10 +62,8 @@ 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 +76,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: tokensCommon.RESPONSE,
+                        scope: core.Scope.REQUEST,
+                        useValue: reply.raw,
                     },
+                    // TODO: перевести использование на новые
+                    // TODO: добавить для papi
                     {
-                        provide: moduleCommon.RESPONSE,
+                        provide: tokensCommon.FASTIFY_REQUEST,
                         scope: core.Scope.REQUEST,
-                        useValue: res,
+                        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();
     };
 };
 
@@ -447,12 +585,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 +630,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 },
@@ -759,31 +897,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 +947,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 +956,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 },
@@ -832,7 +987,7 @@ exports.ServerModule = tslib.__decorate([
                 useFactory: xHeadersFactory,
                 deps: {
                     app: tokensServer.WEB_APP_TOKEN,
-                    envManager: moduleCommon.ENV_MANAGER_TOKEN,
+                    envManager: tokensCommon.ENV_MANAGER_TOKEN,
                     appInfo: core.APP_INFO_TOKEN,
                 },
             },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-server",
-  "version": "1.82.3",
+  "version": "1.85.0",
   "description": "",
   "browser": "lib/browser.js",
   "main": "lib/server.js",
@@ -20,34 +20,37 @@
   },
   "dependencies": {
     "@tinkoff/errors": "0.2.20",
-    "@tinkoff/express-terminus": "0.1.13",
+    "@tinkoff/terminus": "0.0.1",
     "@tinkoff/monkeypatch": "1.3.3",
     "@tinkoff/url": "0.7.37",
-    "@tramvai/module-cache-warmup": "1.82.3",
-    "@tramvai/module-metrics": "1.82.3",
-    "@tramvai/papi": "1.82.3",
-    "@tramvai/tokens-server": "1.82.3",
+    "@tramvai/module-cache-warmup": "1.85.0",
+    "@tramvai/module-metrics": "1.85.0",
+    "@tramvai/papi": "1.85.0",
+    "@tramvai/tokens-server": "1.85.0",
+    "@tramvai/tokens-server-private": "1.85.0",
     "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",
     "http-proxy-middleware": "^2.0.2"
   },
   "peerDependencies": {
-    "@tinkoff/utils": "^2.1.2",
-    "@tramvai/cli": "1.82.3",
-    "@tramvai/core": "1.82.3",
-    "@tramvai/module-common": "1.82.3",
-    "@tramvai/module-environment": "1.82.3",
-    "@tramvai/tokens-common": "1.82.3",
     "@tinkoff/dippy": "0.7.39",
+    "@tinkoff/utils": "^2.1.2",
+    "@tramvai/cli": "1.85.0",
+    "@tramvai/core": "1.85.0",
+    "@tramvai/module-common": "1.85.0",
+    "@tramvai/module-environment": "1.85.0",
+    "@tramvai/tokens-common": "1.85.0",
     "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",