@tramvai/module-server 1.84.2 → 1.90.1

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,24 +23,22 @@ 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 { resolve } from 'path';
+import FastifyStatic from 'fastify-static';
+import { createTerminus } from '@tinkoff/terminus';
 import { parse } from '@tinkoff/url';
 import { EventEmitter } from 'events';
 import monkeypatch from '@tinkoff/monkeypatch';
 import https from 'https';
 import isArray from '@tinkoff/utils/is/array';
 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 +51,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, requestInfo });
+        const afterErrorResult = await runHandlers(afterError);
+        if (!isNil(afterErrorResult)) {
+            return afterErrorResult;
         }
-        log.error({ event: 'send-server-error', error: err, requestInfo });
-        finalhandler(req, res)(err);
+        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 +272,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();
     };
 };
 
@@ -189,9 +324,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);
         });
     };
 };
@@ -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 };
@@ -235,10 +369,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((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 = getPapiParameters(handler);
         result.push(createPapiMethod({
             ...v,
@@ -252,7 +396,10 @@ const getFileApi = () => {
 const fileApiProvider = {
     provide: SERVER_MODULE_PAPI_PUBLIC_ROUTE,
     multi: true,
-    useValue: getFileApi(),
+    useFactory: getFileApi,
+    deps: {
+        logger: LOGGER_TOKEN,
+    },
 };
 
 const sharedProviders = [
@@ -387,29 +534,32 @@ let ServerStaticsModule = class ServerStaticsModule {
 ServerStaticsModule = __decorate([
     Module({
         providers: [
-            {
-                provide: WEB_APP_BEFORE_INIT_TOKEN,
+            provide({
+                provide: WEB_FASTIFY_APP_BEFORE_INIT_TOKEN,
                 useFactory: ({ app, options }) => {
                     const path = (options === null || options === void 0 ? void 0 : options.path) || 'public';
                     return () => {
-                        app.use(express.static(path, {
+                        app.register(FastifyStatic, {
+                            decorateReply: false,
+                            prefix: `/${path}`,
+                            root: resolve(process.cwd(), path),
                             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: WEB_APP_TOKEN,
+                    app: WEB_FASTIFY_APP_TOKEN,
                     options: {
                         token: SERVER_MODULE_STATICS_OPTIONS,
                         optional: true,
                     },
                 },
                 multi: true,
-            },
+            }),
         ],
     })
 ], ServerStaticsModule);
@@ -425,9 +575,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 +620,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 },
@@ -634,6 +784,8 @@ ServerProxyModule = __decorate([
     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: WEB_APP_BEFORE_INIT_TOKEN,
                 useFactory: ({ app, defaultProxies }) => {
                     return () => {
@@ -737,31 +889,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 +939,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 +948,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,
                 },
             },
@@ -805,12 +974,12 @@ ServerModule = __decorate([
                 ],
             },
             {
-                provide: WEB_APP_BEFORE_INIT_TOKEN,
+                provide: WEB_FASTIFY_APP_INIT_TOKEN,
                 multi: true,
                 useFactory: xHeadersFactory,
                 deps: {
-                    app: WEB_APP_TOKEN,
-                    envManager: ENV_MANAGER_TOKEN$1,
+                    app: WEB_FASTIFY_APP_TOKEN,
+                    envManager: ENV_MANAGER_TOKEN,
                     appInfo: APP_INFO_TOKEN,
                 },
             },