@tramvai/module-server 2.70.1 → 2.72.0

package/lib/server.js

@@ -11,1050 +11,24 @@ 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 cookie = require('@fastify/cookie');
-var fastifyFormBody = require('@fastify/formbody');
-var dippy = require('@tinkoff/dippy');
-var isNil = require('@tinkoff/utils/is/nil');
-var errors = require('@tinkoff/errors');
-var fastifyCompress = require('@fastify/compress');
-var FastifyStatic = require('@fastify/static');
-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 papi = require('@tramvai/papi');
-var eachObj = require('@tinkoff/utils/object/each');
-var path = require('path');
-var terminus = require('@tinkoff/terminus');
-var url = require('@tinkoff/url');
-var monkeypatch = require('@tinkoff/monkeypatch');
-var https = require('https');
-var isArray = require('@tinkoff/utils/is/array');
-var isObject = require('@tinkoff/utils/is/object');
-var httpProxyMiddleware = require('http-proxy-middleware');
-var moduleCommon = require('@tramvai/module-common');
-var tokensCorePrivate = require('@tramvai/tokens-core-private');
+var server = require('./server/server.js');
+var webApp = require('./server/webApp.js');
+var _static = require('./server/static.js');
+var xHeaders = require('./server/xHeaders.js');
+var papi = require('./modules/papi/papi.js');
+require('./modules/papi/papi.browser.js');
+var statics = require('./modules/statics.js');
+var gracefulShutdown = require('./modules/gracefulShutdown.js');
+var debugRequests = require('./modules/debugRequests.js');
+var proxy = require('./modules/proxy.js');
+var dependenciesVersion = require('./modules/dependenciesVersion.js');
+var utilityServer = require('./modules/utilityServer.js');
+var keepAlive = require('./modules/keepAlive.js');
+var serverTiming = require('./modules/serverTiming.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
-var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
-var fastify__default = /*#__PURE__*/_interopDefaultLegacy(fastify);
-var fastifyFormBody__default = /*#__PURE__*/_interopDefaultLegacy(fastifyFormBody);
-var isNil__default = /*#__PURE__*/_interopDefaultLegacy(isNil);
-var fastifyCompress__default = /*#__PURE__*/_interopDefaultLegacy(fastifyCompress);
-var FastifyStatic__default = /*#__PURE__*/_interopDefaultLegacy(FastifyStatic);
-var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
-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 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 = () => {
-    return http__default["default"].createServer();
-};
-const serverListenCommand = ({ server, logger, envManager, }) => {
-    const log = logger('server');
-    const port = envManager.get('PORT');
-    return function serverListen() {
-        server.listen({
-            host: '',
-            port,
-        }, () => log.warn({ event: 'server-listen-port', message: `Server listen ${port} port` }));
-    };
-};
-
-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: request.ip,
-            requestId: request.headers['x-request-id'],
-            url: request.url,
-        };
-        const beforeErrorResult = await runHandlers(beforeError);
-        if (!isNil__default["default"](beforeErrorResult)) {
-            return beforeErrorResult;
-        }
-        if (errors.isRedirectFoundError(error)) {
-            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 });
-            }
-            reply.status(error.httpStatus);
-            return '';
-        }
-        log.error({ event: 'send-server-error', error, requestInfo });
-        const afterErrorResult = await runHandlers(afterError);
-        if (!isNil__default["default"](afterErrorResult)) {
-            return afterErrorResult;
-        }
-        throw error;
-    });
-};
-
-const webAppFactory = ({ server }) => {
-    const app = fastify__default["default"]({
-        ignoreTrailingSlash: true,
-        bodyLimit: 2097152,
-        serverFactory: (handler) => {
-            server.on('request', handler);
-            return server;
-        },
-    });
-    return app;
-};
-const webAppInitCommand = ({ app, logger, commandLineRunner, executionContextManager, beforeInit, requestMetrics, limiterRequest, init, afterInit, beforeError, processError, afterError, }) => {
-    const log = logger('server:webapp');
-    const runHandlers = (instance, handlers) => {
-        return Promise.all([handlers && Promise.all(handlers.map((handler) => handler(instance)))]);
-    };
-    return async function webAppInit() {
-        errorHandler(app, { log, beforeError, processError, afterError });
-        await app.register(async (instance) => {
-            await runHandlers(instance, beforeInit);
-        });
-        await app.register(async (instance) => {
-            await runHandlers(instance, requestMetrics);
-            await runHandlers(instance, limiterRequest);
-            await app.register(cookie.fastifyCookie);
-            await app.register(fastifyFormBody__default["default"]);
-            await runHandlers(instance, init);
-            // break the cycle of event loop to allow server to handle other requests
-            // while current on is in processing
-            // mainly to prevent problems and response hanging in case the response process
-            // uses only sync and microtask code
-            instance.addHook('preHandler', (req, res, next) => {
-                setImmediate(next);
-            });
-            instance.all('*', async (request, reply) => {
-                try {
-                    log.debug({
-                        event: 'start:request',
-                        message: 'Клиент зашел на страницу',
-                        url: request.url,
-                    });
-                    await executionContextManager.withContext(null, 'root', async (rootExecutionContext) => {
-                        const di = await commandLineRunner.run('server', 'customer', [
-                            dippy.provide({
-                                provide: tokensCommon.ROOT_EXECUTION_CONTEXT_TOKEN,
-                                useValue: rootExecutionContext,
-                            }),
-                            {
-                                provide: tokensServerPrivate.FASTIFY_REQUEST,
-                                scope: core.Scope.REQUEST,
-                                useValue: request,
-                            },
-                            {
-                                provide: tokensServerPrivate.FASTIFY_RESPONSE,
-                                scope: core.Scope.REQUEST,
-                                useValue: reply,
-                            },
-                        ]);
-                        const responseManager = di.get(tokensCommon.RESPONSE_MANAGER_TOKEN);
-                        if (reply.sent) {
-                            log.debug({
-                                event: 'response-ended',
-                                message: 'Response was already ended.',
-                                url: request.url,
-                            });
-                        }
-                        else {
-                            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(tokensCommon.RESPONSE_MANAGER_TOKEN);
-                        if (responseManager && !reply.sent) {
-                            reply.headers(responseManager.getHeaders());
-                        }
-                    }
-                    throw err;
-                }
-            });
-        });
-        await app.register(async (instance) => {
-            await runHandlers(instance, afterInit);
-        });
-        await app.ready();
-    };
-};
-
-const staticAppCommand = ({ logger, envManager, appInfo, }) => {
-    if (!envManager.get('DEV_STATIC')) {
-        return function staticAppNoop() { };
-    }
-    const log = logger('server:static');
-    const port = +envManager.get('PORT_STATIC');
-    const appVersion = envManager.get('APP_VERSION');
-    return async function staticApp() {
-        const appStatic = fastify__default["default"]();
-        await appStatic.register(fastifyCompress__default["default"]);
-        await appStatic.register(FastifyStatic.fastifyStatic, {
-            root: process.cwd(),
-            prefix: '/',
-            setHeaders: (res) => {
-                res.headers({
-                    'Access-Control-Allow-Origin': '*',
-                    'Timing-Allow-Origin': '*',
-                    'X-App-Id': appInfo.appName,
-                    'X-App-Version': appVersion,
-                    'X-Host': os__default["default"].hostname(),
-                });
-            },
-        });
-        appStatic.listen({ port }, () => log.info(`Running static server on port: ${port}`));
-        return appStatic;
-    };
-};
-
-const xHeadersFactory = ({ app, envManager, appInfo, }) => {
-    const xHeaders = filterObj__default["default"]((val) => !!val, {
-        'x-app-id': appInfo.appName,
-        'x-host': encodeURIComponent(os__default["default"].hostname()),
-        'x-app-version': envManager.get('APP_VERSION'),
-        'x-deploy-branch': envManager.get('DEPLOY_BRANCH'),
-        'x-deploy-commit': envManager.get('DEPLOY_COMMIT'),
-        'x-deploy-version': envManager.get('DEPLOY_VERSION'),
-        'x-deploy-repository': envManager.get('DEPLOY_REPOSITORY'),
-    });
-    return async () => {
-        app.addHook('preHandler', async (_, reply) => {
-            reply.headers(xHeaders);
-        });
-    };
-};
-
-function createApi(rootApp, papiList, { baseUrl, di, logger }) {
-    const paths = new Set();
-    const papiLog = logger('papi');
-    rootApp.register(async (app) => {
-        await app.register(cookie.fastifyCookie);
-        await app.register(fastifyFormBody__default["default"], { bodyLimit: 2097152 }); // 2mb
-        for (const papi$1 of papiList) {
-            const papiParams = papi.getPapiParameters(papi$1);
-            if (!papiParams) {
-                throw new Error(`papi should be created using createPapiMethod from @tramvai/papi,
-        got: ${JSON.stringify(papi$1)}`);
-            }
-            const { method, path, options } = papiParams;
-            const { timeout, schema } = options;
-            if (!path) {
-                throw new Error(`No path in papi handler, got: ${JSON.stringify(papi$1)}`);
-            }
-            const key = `${method} ${path}`;
-            if (paths.has(key)) {
-                throw new Error(`papi: route '${key}' already registered`);
-            }
-            paths.add(key);
-            const childLog = papiLog.child(`${papiParams.method}_${papiParams.path}`);
-            app[method](path, {
-                schema,
-                errorHandler: async (error, req, res) => {
-                    var _a;
-                    res.status(error.validation ? 400 : 503);
-                    childLog.error(error);
-                    return {
-                        resultCode: 'INTERNAL_ERROR',
-                        errorMessage: (_a = error.message) !== null && _a !== void 0 ? _a : 'internal error',
-                    };
-                },
-            }, async (req, res) => {
-                const childDi = dippy.createChildContainer(di, [
-                    {
-                        provide: tokensServerPrivate.FASTIFY_REQUEST,
-                        scope: dippy.Scope.REQUEST,
-                        useValue: req,
-                    },
-                    {
-                        provide: tokensServerPrivate.FASTIFY_RESPONSE,
-                        scope: dippy.Scope.REQUEST,
-                        useValue: res,
-                    },
-                ]);
-                const papiExecutor = childDi.get(tokensServerPrivate.PAPI_EXECUTOR);
-                // TODO: use abortSignal
-                const payload = await Promise.race([
-                    papiExecutor(papi$1),
-                    new Promise((resolve, reject) => setTimeout(() => reject(new errors.HttpError({ httpStatus: 503, message: 'Execution timeout' })), timeout)),
-                ]);
-                const responseManager = childDi.get(tokensCommon.RESPONSE_MANAGER_TOKEN);
-                res.headers(responseManager.getHeaders()).status(responseManager.getStatus());
-                if (res.sent) {
-                    return;
-                }
-                if (!payload && responseManager.getBody()) {
-                    res.send(responseManager.getBody());
-                    return res;
-                }
-                return {
-                    resultCode: 'OK',
-                    payload,
-                };
-            });
-        }
-    }, { prefix: baseUrl });
-}
-
-let papis;
-try {
-    // eslint-disable-next-line import/no-extraneous-dependencies
-    papis = require('@tramvai/cli/lib/external/api').default; // eslint-disable-line import/no-unresolved
-}
-catch (e) { }
-const getFileApi = ({ logger }) => {
-    const log = logger('papi:fileApi');
-    const result = [];
-    eachObj__default["default"](({ default: entry }, path) => {
-        if (!papi.isPapiMethod(entry)) {
-            log.error({
-                path,
-                entry,
-                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 serverApiDir in tramvai.json`,
-            });
-            throw new Error('Not a papi');
-        }
-        const papiParameters = papi.getPapiParameters(entry);
-        result.push(papi.createPapiMethod({
-            ...papiParameters,
-            path: `/${path}`,
-        }));
-    }, papis);
-    return result;
-};
-const fileApiProvider = {
-    provide: tokensServer.SERVER_MODULE_PAPI_PUBLIC_ROUTE,
-    multi: true,
-    useFactory: getFileApi,
-    deps: {
-        logger: tokensCommon.LOGGER_TOKEN,
-    },
-};
-
-const sharedProviders = [
-    {
-        provide: tokensServer.SERVER_MODULE_PAPI_PUBLIC_URL,
-        useFactory: ({ appInfo }) => {
-            return `/${appInfo.appName}/papi`;
-        },
-        deps: {
-            appInfo: core.APP_INFO_TOKEN,
-        },
-    },
-    {
-        provide: tokensServer.SERVER_MODULE_PAPI_PRIVATE_URL,
-        useFactory: ({ appInfo }) => {
-            return `/${appInfo.appName}/private/papi`;
-        },
-        deps: {
-            appInfo: core.APP_INFO_TOKEN,
-        },
-    },
-];
-
-const papiExecutorProvider = dippy.provide({
-    provide: tokensServerPrivate.PAPI_EXECUTOR,
-    scope: dippy.Scope.REQUEST,
-    useFactory: ({ di, logger, fastifyRequest, requestManager, responseManager }) => {
-        var _a;
-        const papiLog = logger('papi');
-        const papiOptions = {
-            requestManager,
-            responseManager,
-            params: (_a = fastifyRequest.params) !== null && _a !== void 0 ? _a : {},
-            cookies: requestManager.getCookies(),
-            headers: requestManager.getHeaders(),
-            body: requestManager.getBody(),
-            parsedUrl: requestManager.getParsedUrl(),
-        };
-        return (papi$1) => {
-            const { handler, deps, method, path } = papi.getPapiParameters(papi$1);
-            const papiContext = {
-                deps: di.getOfDeps(deps),
-                log: papiLog.child(`${method}_${path}`),
-            };
-            return handler.call(papiContext, papiOptions);
-        };
-    },
-    deps: {
-        di: dippy.DI_TOKEN,
-        logger: tokensCommon.LOGGER_TOKEN,
-        fastifyRequest: tokensServerPrivate.FASTIFY_REQUEST,
-        requestManager: tokensCommon.REQUEST_MANAGER_TOKEN,
-        responseManager: tokensCommon.RESPONSE_MANAGER_TOKEN,
-    },
-});
-
-let ServerPapiModule = class ServerPapiModule {
-};
-ServerPapiModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            papiExecutorProvider,
-            fileApiProvider,
-            ...sharedProviders,
-            core.provide({
-                provide: tokensServerPrivate.WEB_FASTIFY_APP_BEFORE_INIT_TOKEN,
-                useFactory: ({ di, logger, privateRoutes, publicRoutes, publicBaseUrl, privateBaseUrl }) => (app) => {
-                    if (process.env.NODE_ENV === 'development') {
-                        const papiListRoute = papi.createPapiMethod({
-                            method: 'get',
-                            path: '/papi-list',
-                            async handler() {
-                                return [
-                                    ...flatten__default["default"](privateRoutes).map((papi$1) => {
-                                        const params = papi.getPapiParameters(papi$1);
-                                        return {
-                                            path: params.path,
-                                            method: params.method,
-                                            options: params.options,
-                                            type: 'private',
-                                        };
-                                    }),
-                                    ...flatten__default["default"](publicRoutes).map((papi$1) => {
-                                        const params = papi.getPapiParameters(papi$1);
-                                        return {
-                                            path: params.path,
-                                            method: params.method,
-                                            options: params.options,
-                                            type: 'public',
-                                        };
-                                    }),
-                                ];
-                            },
-                        });
-                        // eslint-disable-next-line no-param-reassign
-                        privateRoutes = privateRoutes
-                            ? [...toArray__default["default"](privateRoutes), papiListRoute]
-                            : [papiListRoute];
-                    }
-                    if (privateRoutes) {
-                        createApi(app, flatten__default["default"](privateRoutes), {
-                            baseUrl: privateBaseUrl,
-                            di,
-                            logger,
-                        });
-                    }
-                    if (publicRoutes) {
-                        createApi(app, flatten__default["default"](publicRoutes), {
-                            baseUrl: publicBaseUrl,
-                            di,
-                            logger,
-                        });
-                    }
-                },
-                deps: {
-                    di: core.DI_TOKEN,
-                    logger: tokensCommon.LOGGER_TOKEN,
-                    privateRoutes: {
-                        token: tokensServer.SERVER_MODULE_PAPI_PRIVATE_ROUTE,
-                        optional: true,
-                        multi: true,
-                    },
-                    publicRoutes: {
-                        token: tokensServer.SERVER_MODULE_PAPI_PUBLIC_ROUTE,
-                        optional: true,
-                        multi: true,
-                    },
-                    privateBaseUrl: tokensServer.SERVER_MODULE_PAPI_PRIVATE_URL,
-                    publicBaseUrl: tokensServer.SERVER_MODULE_PAPI_PUBLIC_URL,
-                },
-                multi: true,
-            }),
-            // необходимо для утилит. Подумать как можно убрать в будующем. Если убрать не будет ломающим изменением
-            core.provide({
-                provide: tokensServer.SERVER_MODULE_PAPI_PUBLIC_ROUTE,
-                multi: true,
-                useValue: papi.createPapiMethod({
-                    method: 'get',
-                    path: '/version',
-                    async handler() {
-                        return {
-                            version: this.deps.envManager.get('APP_VERSION'),
-                        };
-                    },
-                    deps: {
-                        envManager: tokensCommon.ENV_MANAGER_TOKEN,
-                    },
-                }),
-            }),
-        ],
-    })
-], ServerPapiModule);
-
-let BrowserPapiModule = class BrowserPapiModule {
-};
-BrowserPapiModule = tslib.__decorate([
-    core.Module({
-        providers: [...sharedProviders],
-    })
-], BrowserPapiModule);
-
-const ONE_YEAR = 365 * 24 * 60 * 60;
-let ServerStaticsModule = class ServerStaticsModule {
-};
-ServerStaticsModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            core.provide({
-                provide: tokensServerPrivate.WEB_FASTIFY_APP_BEFORE_INIT_TOKEN,
-                useFactory: ({ options }) => {
-                    const path$1 = (options === null || options === void 0 ? void 0 : options.path) || 'public';
-                    return (instance) => {
-                        instance.register(FastifyStatic__default["default"], {
-                            decorateReply: false,
-                            // for backward compatibility, leaving default prefix.
-                            // without `wildcard: false` property, this middleware has conflicts with express compatibility plugin
-                            prefix: `/`,
-                            // prevent errors by use FastifyStatic only for all defined files in the served folder,
-                            // will not serve the newly added file on the filesystem - https://github.com/fastify/fastify-static#wildcard
-                            wildcard: false,
-                            root: path.resolve(process.cwd(), path$1),
-                            setHeaders: (res) => {
-                                const oneYearForward = new Date(Date.now() + ONE_YEAR * 1000);
-                                res.setHeader('cache-control', `public, max-age=${ONE_YEAR}`);
-                                res.setHeader('expires', oneYearForward.toUTCString());
-                            },
-                        });
-                    };
-                },
-                deps: {
-                    options: {
-                        token: tokensServer.SERVER_MODULE_STATICS_OPTIONS,
-                        optional: true,
-                    },
-                },
-                multi: true,
-            }),
-        ],
-    })
-], ServerStaticsModule);
-
-const GRACEFUL_SHUTDOWN_TIMEOUT = 25000;
-const GRACEFUL_READINESS_TIMEOUT = 5000;
-const noopCheck = () => { };
-let ServerGracefulShutdownModule = class ServerGracefulShutdownModule {
-};
-ServerGracefulShutdownModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            core.provide({
-                provide: tokensServerPrivate.WEB_FASTIFY_APP_BEFORE_INIT_TOKEN,
-                multi: true,
-                useFactory: ({ app, server, logger, commandLineRunner, livenessPath, readinessPath, livenessProbe, readinessProbe, }) => {
-                    const log = logger('server');
-                    return function serverListen() {
-                        terminus.createTerminus(server, app, {
-                            signal: 'SIGTERM',
-                            timeout: GRACEFUL_SHUTDOWN_TIMEOUT,
-                            logger: (msg, error) => {
-                                log.error({
-                                    event: 'terminus',
-                                    message: msg,
-                                    error,
-                                });
-                            },
-                            // https://github.com/godaddy/terminus#how-to-set-terminus-up-with-kubernetes
-                            beforeShutdown: () => {
-                                log.warn({
-                                    event: 'terminus-wait',
-                                    message: 'wait for other tasks before shutdown',
-                                });
-                                return new Promise((resolve) => setTimeout(resolve, GRACEFUL_READINESS_TIMEOUT));
-                            },
-                            onSignal: () => {
-                                log.warn({
-                                    event: 'terminus-run-command',
-                                    message: 'run commandLineRunner close line',
-                                });
-                                commandLineRunner.run('server', 'close');
-                            },
-                            onShutdown: () => {
-                                log.warn({
-                                    event: 'terminus-exit',
-                                    message: 'calling process.exit',
-                                });
-                                process.exit();
-                            },
-                            healthChecks: {
-                                [livenessPath]: livenessProbe || noopCheck,
-                                [readinessPath]: readinessProbe || noopCheck,
-                            },
-                        });
-                    };
-                },
-                deps: {
-                    app: tokensServerPrivate.UTILITY_WEB_FASTIFY_APP_TOKEN,
-                    server: tokensServer.SERVER_TOKEN,
-                    logger: tokensCommon.LOGGER_TOKEN,
-                    commandLineRunner: core.COMMAND_LINE_RUNNER_TOKEN,
-                    livenessPath: tokensServer.LIVENESS_PATH_TOKEN,
-                    readinessPath: tokensServer.READINESS_PATH_TOKEN,
-                    readinessProbe: { token: tokensServer.READINESS_PROBE_TOKEN, optional: true },
-                    livenessProbe: { token: tokensServer.LIVENESS_PROBE_TOKEN, optional: true },
-                },
-            }),
-            core.provide({
-                provide: tokensServer.LIVENESS_PATH_TOKEN,
-                useValue: '/healthz',
-            }),
-            core.provide({
-                provide: tokensServer.READINESS_PATH_TOKEN,
-                useValue: '/readyz',
-            }),
-            core.provide({
-                provide: tokensServer.UTILITY_SERVER_PATHS,
-                useFactory: ({ livenessPath }) => {
-                    return livenessPath;
-                },
-                multi: true,
-                deps: {
-                    livenessPath: tokensServer.LIVENESS_PATH_TOKEN,
-                },
-            }),
-            core.provide({
-                provide: tokensServer.UTILITY_SERVER_PATHS,
-                useFactory: ({ readinessPath }) => {
-                    return readinessPath;
-                },
-                multi: true,
-                deps: {
-                    readinessPath: tokensServer.READINESS_PATH_TOKEN,
-                },
-            }),
-        ],
-    })
-], ServerGracefulShutdownModule);
-
-class Interceptor {
-    constructor() {
-        this.intercepted = false;
-        this.delay = 0;
-    }
-    setIntercept(intercept) {
-        this.intercepted = intercept;
-    }
-    setDelay(delay) {
-        this.intercepted = true;
-        this.delay = delay;
-    }
-    clear() {
-        this.intercepted = false;
-        this.delay = 0;
-    }
-    getStatus() {
-        return {
-            intercepted: this.intercepted,
-            delay: this.delay,
-        };
-    }
-}
-const INTERCEPTOR_TOKEN = 'debugRequestsInterceptor';
-let DebugHttpRequestsModule = class DebugHttpRequestsModule {
-};
-DebugHttpRequestsModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            {
-                provide: INTERCEPTOR_TOKEN,
-                useClass: Interceptor,
-                scope: core.Scope.SINGLETON,
-            },
-            {
-                provide: core.commandLineListTokens.init,
-                multi: true,
-                useFactory: ({ logger, interceptor }) => {
-                    const log = logger('server:node-debug:request');
-                    return function debugHttp() {
-                        const handler = (request, options, cb) => {
-                            const parsed = typeof options === 'string' ? url.parse(options) : options;
-                            const wasHandled = typeof cb === 'function';
-                            return request(options, cb)
-                                .on('response', (response) => {
-                                interceptor.intercepted &&
-                                    monkeypatch__default["default"]({
-                                        obj: response,
-                                        method: 'emit',
-                                        handler: (emit, event, ...args) => {
-                                            if (event === 'end') {
-                                                setTimeout(() => {
-                                                    emit(event, ...args);
-                                                }, interceptor.delay);
-                                                return !!response.listenerCount(event);
-                                            }
-                                            return emit(event, ...args);
-                                        },
-                                    });
-                            })
-                                .on('response', (response) => {
-                                // Workaround for res._dump in Node.JS http client
-                                // https://github.com/nodejs/node/blob/20285ad17755187ece16b8a5effeaa87f5407da2/lib/_http_client.js#L421-L427
-                                if (!wasHandled && EventEmitter.EventEmitter.listenerCount(response.req, 'response') === 0) {
-                                    response.resume();
-                                }
-                                log.debug(`${response.statusCode}
-${parsed.href || `${parsed.protocol}//${parsed.hostname}${parsed.path}`}
-`);
-                            })
-                                .on('error', (error) => {
-                                log.error({
-                                    event: 'request-failed',
-                                    error,
-                                    url: parsed.href || options,
-                                });
-                            });
-                        };
-                        monkeypatch__default["default"]({ obj: http__default["default"], method: 'request', handler });
-                        monkeypatch__default["default"]({ obj: https__default["default"], method: 'request', handler });
-                    };
-                },
-                deps: {
-                    logger: tokensCommon.LOGGER_TOKEN,
-                    interceptor: INTERCEPTOR_TOKEN,
-                },
-            },
-            {
-                provide: tokensServer.SERVER_MODULE_PAPI_PRIVATE_ROUTE,
-                multi: true,
-                useFactory: ({ interceptor }) => {
-                    return papi.createPapiMethod({
-                        method: 'post',
-                        path: '/debug-http-request',
-                        async handler({ body }) {
-                            const { delay = 10000 } = body;
-                            if (delay) {
-                                interceptor.setDelay(delay);
-                            }
-                            else {
-                                interceptor.setIntercept(true);
-                            }
-                            return interceptor.getStatus();
-                        },
-                    });
-                },
-                deps: {
-                    interceptor: INTERCEPTOR_TOKEN,
-                },
-            },
-            {
-                provide: tokensServer.SERVER_MODULE_PAPI_PRIVATE_ROUTE,
-                multi: true,
-                useFactory: ({ interceptor }) => {
-                    return papi.createPapiMethod({
-                        method: 'delete',
-                        path: '/debug-http-request',
-                        async handler() {
-                            interceptor.clear();
-                            return interceptor.getStatus();
-                        },
-                    });
-                },
-                deps: {
-                    interceptor: INTERCEPTOR_TOKEN,
-                },
-            },
-        ],
-    })
-], DebugHttpRequestsModule);
-
-const nodeRequire = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require;
-const safeNodeRequire = (path) => {
-    try {
-        return nodeRequire(path);
-    }
-    catch (e) {
-        return null;
-    }
-};
-
-let ServerProxyModule = class ServerProxyModule {
-};
-ServerProxyModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            {
-                provide: tokensServerPrivate.WEB_FASTIFY_APP_INIT_TOKEN,
-                useFactory: ({ defaultProxies }) => {
-                    return (app) => {
-                        const proxyConfig = safeNodeRequire(path.resolve(process.cwd(), 'proxy.conf'));
-                        const proxies = defaultProxies !== null && defaultProxies !== void 0 ? defaultProxies : [];
-                        if (!proxyConfig && proxies.length === 0) {
-                            return;
-                        }
-                        if (isArray__default["default"](proxyConfig)) {
-                            proxies.push(...proxyConfig);
-                        }
-                        else if (proxyConfig === null || proxyConfig === void 0 ? void 0 : proxyConfig.target) {
-                            proxies.push(proxyConfig);
-                        }
-                        else if (isObject__default["default"](proxyConfig)) {
-                            eachObj__default["default"]((target, source) => {
-                                const options = typeof target === 'string' ? { target } : target;
-                                proxies.push({ context: source, ...options });
-                            }, proxyConfig);
-                        }
-                        proxies.forEach((proxy) => {
-                            const middleware = httpProxyMiddleware.createProxyMiddleware(proxy.context, {
-                                changeOrigin: true,
-                                onProxyRes: (proxyRes) => {
-                                    // eslint-disable-next-line no-param-reassign
-                                    proxyRes.headers['x-tramvai-proxied-response'] = '1';
-                                },
-                                ...proxy,
-                            });
-                            app.addHook('onRequest', (req, res, next) => {
-                                middleware(req.raw, res.raw, next);
-                            });
-                        });
-                    };
-                },
-                deps: {
-                    defaultProxies: {
-                        token: tokensServer.PROXY_CONFIG_TOKEN,
-                        optional: true,
-                    },
-                },
-                multi: true,
-            },
-        ],
-    })
-], ServerProxyModule);
-
-const RegExp = /^@tramvai/;
-const tramvaiDepsFilter = (deps) => {
-    return filterObj__default["default"]((v, k) => RegExp.test(k), deps);
-};
-
-let packageJson = {};
-try {
-    // eslint-disable-next-line import/no-unresolved
-    packageJson = require('../../../../package.json');
-}
-catch (e) {
-    packageJson = safeNodeRequire(path.resolve(process.cwd(), 'package.json'));
-}
-let DependenciesVersionModule = class DependenciesVersionModule {
-};
-DependenciesVersionModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            {
-                provide: tokensServer.SERVER_MODULE_PAPI_PRIVATE_ROUTE,
-                multi: true,
-                useFactory: ({ depsFilter }) => {
-                    const { dependencies = [] } = packageJson !== null && packageJson !== void 0 ? packageJson : {};
-                    return papi.createPapiMethod({
-                        path: '/dependenciesVersion',
-                        method: 'get',
-                        handler: async () => {
-                            return depsFilter(dependencies);
-                        },
-                    });
-                },
-                deps: {
-                    depsFilter: tokensServer.DEPENDENCIES_VERSION_FILTER_TOKEN,
-                },
-            },
-            {
-                provide: tokensServer.DEPENDENCIES_VERSION_FILTER_TOKEN,
-                useValue: tramvaiDepsFilter,
-            },
-        ],
-    })
-], DependenciesVersionModule);
-
-const IS_CUSTOM_SERVER_TOKEN = core.createToken('server utility isCustomServer');
-let UtilityServerModule = class UtilityServerModule {
-};
-UtilityServerModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            core.provide({
-                provide: tokensCommon.ENV_USED_TOKEN,
-                multi: true,
-                useValue: [{ key: 'UTILITY_SERVER_PORT', optional: true }],
-            }),
-            core.provide({
-                provide: tokensServer.UTILITY_SERVER_PORT_TOKEN,
-                scope: core.Scope.SINGLETON,
-                useFactory: ({ envManager }) => {
-                    return +(envManager.get('UTILITY_SERVER_PORT') || envManager.get('PORT'));
-                },
-                deps: {
-                    envManager: tokensCommon.ENV_MANAGER_TOKEN,
-                },
-            }),
-            core.provide({
-                provide: IS_CUSTOM_SERVER_TOKEN,
-                scope: core.Scope.SINGLETON,
-                useFactory: ({ port, envManager }) => {
-                    return +envManager.get('PORT') !== port;
-                },
-                deps: {
-                    envManager: tokensCommon.ENV_MANAGER_TOKEN,
-                    port: tokensServer.UTILITY_SERVER_PORT_TOKEN,
-                },
-            }),
-            core.provide({
-                provide: tokensServerPrivate.UTILITY_SERVER_TOKEN,
-                scope: core.Scope.SINGLETON,
-                useFactory: ({ isCustomServer, serverFactory, server }) => {
-                    return isCustomServer ? serverFactory() : server;
-                },
-                deps: {
-                    isCustomServer: IS_CUSTOM_SERVER_TOKEN,
-                    server: tokensServer.SERVER_TOKEN,
-                    serverFactory: tokensServerPrivate.SERVER_FACTORY_TOKEN,
-                },
-            }),
-            core.provide({
-                provide: tokensServerPrivate.UTILITY_WEB_FASTIFY_APP_TOKEN,
-                scope: core.Scope.SINGLETON,
-                useFactory: ({ isCustomServer, app, appFactory, server }) => {
-                    return isCustomServer ? appFactory({ server }) : app;
-                },
-                deps: {
-                    isCustomServer: IS_CUSTOM_SERVER_TOKEN,
-                    app: tokensServerPrivate.WEB_FASTIFY_APP_TOKEN,
-                    appFactory: tokensServerPrivate.WEB_FASTIFY_APP_FACTORY_TOKEN,
-                    server: tokensServerPrivate.UTILITY_SERVER_TOKEN,
-                },
-            }),
-            core.provide({
-                provide: core.commandLineListTokens.listen,
-                multi: true,
-                scope: core.Scope.SINGLETON,
-                useFactory: ({ logger, isCustomServer, port, app, server }) => {
-                    return async function utilityServerListen() {
-                        if (!isCustomServer) {
-                            return;
-                        }
-                        const log = logger('server:utility');
-                        await app.ready();
-                        return new Promise((resolve, reject) => {
-                            server.once('error', (error) => {
-                                log.error({ event: 'server-listen-port', error });
-                                reject(error);
-                            });
-                            server.listen(port, () => {
-                                log.warn({ event: 'server-listen-port', message: `Server listen ${port} port` });
-                                resolve();
-                            });
-                        });
-                    };
-                },
-                deps: {
-                    logger: tokensCommon.LOGGER_TOKEN,
-                    isCustomServer: IS_CUSTOM_SERVER_TOKEN,
-                    port: tokensServer.UTILITY_SERVER_PORT_TOKEN,
-                    app: tokensServerPrivate.UTILITY_WEB_FASTIFY_APP_TOKEN,
-                    server: tokensServerPrivate.UTILITY_SERVER_TOKEN,
-                },
-            }),
-        ],
-    })
-], UtilityServerModule);
-
-let KeepAliveModule = class KeepAliveModule {
-};
-KeepAliveModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            core.provide({
-                provide: tokensCommon.ENV_USED_TOKEN,
-                useValue: [
-                    {
-                        key: 'NODE_KEEPALIVE_TIMEOUT',
-                        optional: true,
-                        validator(keepAliveTimeout) {
-                            const value = Number(keepAliveTimeout);
-                            if (Number.isNaN(value)) {
-                                return 'Env variable NODE_KEEPALIVE_TIMEOUT should be a number';
-                            }
-                            if (value < 0) {
-                                return 'Env variable NODE_KEEPALIVE_TIMEOUT should be greater or equal than 0';
-                            }
-                            return true;
-                        },
-                    },
-                ],
-            }),
-            core.provide({
-                provide: core.commandLineListTokens.init,
-                useFactory: ({ server, envManager, }) => () => {
-                    const externalKeepAliveTimeout = envManager.get('NODE_KEEPALIVE_TIMEOUT');
-                    if (externalKeepAliveTimeout !== 'undefined') {
-                        // eslint-disable-next-line no-param-reassign
-                        server.keepAliveTimeout = Number(externalKeepAliveTimeout);
-                    }
-                },
-                multi: true,
-                deps: { server: tokensServer.SERVER_TOKEN, envManager: moduleCommon.ENV_MANAGER_TOKEN },
-            }),
-        ],
-    })
-], KeepAliveModule);
-
-const ServerTimingModule = core.declareModule({
-    name: 'ServerTiming',
-    providers: [
-        core.provide({
-            provide: tokensCorePrivate.COMMAND_LINE_EXECUTION_END_TOKEN,
-            multi: true,
-            useValue: (di, type, status, timingInfo) => {
-                var _a;
-                if (type === 'server' && status === 'customer') {
-                    const responseManager = di.get(tokensCommon.RESPONSE_MANAGER_TOKEN);
-                    const initialHeader = (_a = responseManager.getHeader('Server-Timing')) !== null && _a !== void 0 ? _a : '';
-                    const entries = [];
-                    // index for custom sort
-                    let index = 0;
-                    for (const line in timingInfo) {
-                        const info = timingInfo[line];
-                        entries.push(`line_${index++}_${line};dur=${info.end - info.start}`);
-                    }
-                    responseManager.setHeader('Server-Timing', `${initialHeader ? `${initialHeader}, ` : ''}${entries.join(', ')}`);
-                }
-            },
-        }),
-    ],
-});
 
 if (typeof dns.setDefaultResultOrder === 'function') {
     dns.setDefaultResultOrder('ipv4first');
@@ -1069,21 +43,21 @@ exports.ServerModule = tslib.__decorate([
         imports: [
             moduleMetrics.MetricsModule,
             moduleCacheWarmup.CacheWarmupModule,
-            ServerPapiModule,
-            ServerStaticsModule,
-            ServerGracefulShutdownModule,
-            ServerProxyModule,
-            DependenciesVersionModule,
-            UtilityServerModule,
-            KeepAliveModule,
-            ServerTimingModule,
-            process.env.NODE_ENV !== 'production' && DebugHttpRequestsModule,
+            papi.ServerPapiModule,
+            statics.ServerStaticsModule,
+            gracefulShutdown.ServerGracefulShutdownModule,
+            proxy.ServerProxyModule,
+            dependenciesVersion.DependenciesVersionModule,
+            utilityServer.UtilityServerModule,
+            keepAlive.KeepAliveModule,
+            serverTiming.ServerTimingModule,
+            process.env.NODE_ENV !== 'production' && debugRequests.DebugHttpRequestsModule,
         ].filter(Boolean),
         providers: [
             core.provide({
                 provide: tokensServerPrivate.SERVER_FACTORY_TOKEN,
                 scope: core.Scope.SINGLETON,
-                useValue: serverFactory,
+                useValue: server.serverFactory,
             }),
             core.provide({
                 provide: tokensServer.SERVER_TOKEN,
@@ -1096,7 +70,7 @@ exports.ServerModule = tslib.__decorate([
             core.provide({
                 provide: tokensServerPrivate.WEB_FASTIFY_APP_FACTORY_TOKEN,
                 scope: core.Scope.SINGLETON,
-                useValue: webAppFactory,
+                useValue: webApp.webAppFactory,
             }),
             core.provide({
                 provide: tokensServerPrivate.WEB_FASTIFY_APP_TOKEN,
@@ -1110,7 +84,7 @@ exports.ServerModule = tslib.__decorate([
             {
                 provide: core.commandLineListTokens.init,
                 multi: true,
-                useFactory: webAppInitCommand,
+                useFactory: webApp.webAppInitCommand,
                 deps: {
                     app: tokensServerPrivate.WEB_FASTIFY_APP_TOKEN,
                     logger: tokensCommon.LOGGER_TOKEN,
@@ -1129,7 +103,7 @@ exports.ServerModule = tslib.__decorate([
             {
                 provide: core.commandLineListTokens.listen,
                 multi: true,
-                useFactory: serverListenCommand,
+                useFactory: server.serverListenCommand,
                 deps: {
                     server: tokensServer.SERVER_TOKEN,
                     logger: tokensCommon.LOGGER_TOKEN,
@@ -1139,7 +113,7 @@ exports.ServerModule = tslib.__decorate([
             {
                 provide: core.commandLineListTokens.listen,
                 multi: true,
-                useFactory: staticAppCommand,
+                useFactory: _static.staticAppCommand,
                 deps: {
                     logger: tokensCommon.LOGGER_TOKEN,
                     envManager: tokensCommon.ENV_MANAGER_TOKEN,
@@ -1169,7 +143,7 @@ exports.ServerModule = tslib.__decorate([
             {
                 provide: tokensServerPrivate.WEB_FASTIFY_APP_INIT_TOKEN,
                 multi: true,
-                useFactory: xHeadersFactory,
+                useFactory: xHeaders.xHeadersFactory,
                 deps: {
                     app: tokensServerPrivate.WEB_FASTIFY_APP_TOKEN,
                     envManager: tokensCommon.ENV_MANAGER_TOKEN,