@tramvai/module-server 2.70.1 → 2.72.3

package/lib/server.es.js

@@ -1,1045 +1,34 @@
 import { __decorate } from 'tslib';
 import { setDefaultResultOrder } from 'dns';
-import EventEmitter$1, { EventEmitter } from 'events';
-import { Scope, APP_INFO_TOKEN, Module, provide as provide$1, DI_TOKEN as DI_TOKEN$1, COMMAND_LINE_RUNNER_TOKEN, commandLineListTokens, createToken, declareModule } from '@tramvai/core';
-import { SERVER_MODULE_PAPI_PUBLIC_ROUTE, SERVER_MODULE_PAPI_PUBLIC_URL, SERVER_MODULE_PAPI_PRIVATE_URL, SERVER_MODULE_PAPI_PRIVATE_ROUTE, SERVER_MODULE_STATICS_OPTIONS, SERVER_TOKEN, LIVENESS_PATH_TOKEN, READINESS_PATH_TOKEN, READINESS_PROBE_TOKEN, LIVENESS_PROBE_TOKEN, UTILITY_SERVER_PATHS, PROXY_CONFIG_TOKEN, DEPENDENCIES_VERSION_FILTER_TOKEN, UTILITY_SERVER_PORT_TOKEN } from '@tramvai/tokens-server';
+import EventEmitter from 'events';
+import { Module, provide, Scope, commandLineListTokens, COMMAND_LINE_RUNNER_TOKEN, APP_INFO_TOKEN } from '@tramvai/core';
+import { SERVER_TOKEN } from '@tramvai/tokens-server';
 export * from '@tramvai/tokens-server';
-import { FASTIFY_REQUEST, FASTIFY_RESPONSE, PAPI_EXECUTOR, WEB_FASTIFY_APP_BEFORE_INIT_TOKEN, UTILITY_WEB_FASTIFY_APP_TOKEN, WEB_FASTIFY_APP_INIT_TOKEN, UTILITY_SERVER_TOKEN, SERVER_FACTORY_TOKEN, WEB_FASTIFY_APP_TOKEN, WEB_FASTIFY_APP_FACTORY_TOKEN, WEB_FASTIFY_APP_AFTER_INIT_TOKEN, WEB_FASTIFY_APP_METRICS_TOKEN, WEB_FASTIFY_APP_LIMITER_TOKEN, WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN, WEB_FASTIFY_APP_PROCESS_ERROR_TOKEN, WEB_FASTIFY_APP_AFTER_ERROR_TOKEN } from '@tramvai/tokens-server-private';
-import { ROOT_EXECUTION_CONTEXT_TOKEN, RESPONSE_MANAGER_TOKEN, LOGGER_TOKEN, REQUEST_MANAGER_TOKEN, ENV_MANAGER_TOKEN, ENV_USED_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN } from '@tramvai/tokens-common';
+import { SERVER_FACTORY_TOKEN, WEB_FASTIFY_APP_FACTORY_TOKEN, WEB_FASTIFY_APP_TOKEN, WEB_FASTIFY_APP_BEFORE_INIT_TOKEN, WEB_FASTIFY_APP_INIT_TOKEN, WEB_FASTIFY_APP_AFTER_INIT_TOKEN, WEB_FASTIFY_APP_METRICS_TOKEN, WEB_FASTIFY_APP_LIMITER_TOKEN, WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN, WEB_FASTIFY_APP_PROCESS_ERROR_TOKEN, WEB_FASTIFY_APP_AFTER_ERROR_TOKEN } from '@tramvai/tokens-server-private';
+import { LOGGER_TOKEN, EXECUTION_CONTEXT_MANAGER_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 { fastifyCookie } from '@fastify/cookie';
-import fastifyFormBody from '@fastify/formbody';
-import { provide, createChildContainer, Scope as Scope$1, DI_TOKEN } from '@tinkoff/dippy';
-import isNil from '@tinkoff/utils/is/nil';
-import { isRedirectFoundError, isNotFoundError, isHttpError, HttpError } from '@tinkoff/errors';
-import fastifyCompress from '@fastify/compress';
-import FastifyStatic, { fastifyStatic } from '@fastify/static';
-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 { getPapiParameters, isPapiMethod, createPapiMethod } from '@tramvai/papi';
-import eachObj from '@tinkoff/utils/object/each';
-import { resolve } from 'path';
-import { createTerminus } from '@tinkoff/terminus';
-import { parse } from '@tinkoff/url';
-import monkeypatch from '@tinkoff/monkeypatch';
-import https from 'https';
-import isArray from '@tinkoff/utils/is/array';
-import isObject from '@tinkoff/utils/is/object';
-import { createProxyMiddleware } from 'http-proxy-middleware';
-import { ENV_MANAGER_TOKEN as ENV_MANAGER_TOKEN$1 } from '@tramvai/module-common';
-import { COMMAND_LINE_EXECUTION_END_TOKEN } from '@tramvai/tokens-core-private';
-
-const serverFactory = () => {
-    return http.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(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 });
-            }
-            reply.status(error.httpStatus);
-            return '';
-        }
-        log.error({ event: 'send-server-error', error, requestInfo });
-        const afterErrorResult = await runHandlers(afterError);
-        if (!isNil(afterErrorResult)) {
-            return afterErrorResult;
-        }
-        throw error;
-    });
-};
-
-const webAppFactory = ({ server }) => {
-    const app = fastify({
-        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(fastifyCookie);
-            await app.register(fastifyFormBody);
-            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', [
-                            provide({
-                                provide: ROOT_EXECUTION_CONTEXT_TOKEN,
-                                useValue: rootExecutionContext,
-                            }),
-                            {
-                                provide: FASTIFY_REQUEST,
-                                scope: Scope.REQUEST,
-                                useValue: request,
-                            },
-                            {
-                                provide: FASTIFY_RESPONSE,
-                                scope: Scope.REQUEST,
-                                useValue: reply,
-                            },
-                        ]);
-                        const responseManager = di.get(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(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();
-        await appStatic.register(fastifyCompress);
-        await appStatic.register(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.hostname(),
-                });
-            },
-        });
-        appStatic.listen({ port }, () => log.info(`Running static server on port: ${port}`));
-        return appStatic;
-    };
-};
-
-const xHeadersFactory = ({ app, envManager, appInfo, }) => {
-    const xHeaders = filterObj((val) => !!val, {
-        'x-app-id': appInfo.appName,
-        'x-host': encodeURIComponent(os.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(fastifyCookie);
-        await app.register(fastifyFormBody, { bodyLimit: 2097152 }); // 2mb
-        for (const papi of papiList) {
-            const papiParams = getPapiParameters(papi);
-            if (!papiParams) {
-                throw new Error(`papi should be created using createPapiMethod from @tramvai/papi,
-        got: ${JSON.stringify(papi)}`);
-            }
-            const { method, path, options } = papiParams;
-            const { timeout, schema } = options;
-            if (!path) {
-                throw new Error(`No path in papi handler, got: ${JSON.stringify(papi)}`);
-            }
-            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 = createChildContainer(di, [
-                    {
-                        provide: FASTIFY_REQUEST,
-                        scope: Scope$1.REQUEST,
-                        useValue: req,
-                    },
-                    {
-                        provide: FASTIFY_RESPONSE,
-                        scope: Scope$1.REQUEST,
-                        useValue: res,
-                    },
-                ]);
-                const papiExecutor = childDi.get(PAPI_EXECUTOR);
-                // TODO: use abortSignal
-                const payload = await Promise.race([
-                    papiExecutor(papi),
-                    new Promise((resolve, reject) => setTimeout(() => reject(new HttpError({ httpStatus: 503, message: 'Execution timeout' })), timeout)),
-                ]);
-                const responseManager = childDi.get(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: entry }, path) => {
-        if (!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 = getPapiParameters(entry);
-        result.push(createPapiMethod({
-            ...papiParameters,
-            path: `/${path}`,
-        }));
-    }, papis);
-    return result;
-};
-const fileApiProvider = {
-    provide: SERVER_MODULE_PAPI_PUBLIC_ROUTE,
-    multi: true,
-    useFactory: getFileApi,
-    deps: {
-        logger: LOGGER_TOKEN,
-    },
-};
-
-const sharedProviders = [
-    {
-        provide: SERVER_MODULE_PAPI_PUBLIC_URL,
-        useFactory: ({ appInfo }) => {
-            return `/${appInfo.appName}/papi`;
-        },
-        deps: {
-            appInfo: APP_INFO_TOKEN,
-        },
-    },
-    {
-        provide: SERVER_MODULE_PAPI_PRIVATE_URL,
-        useFactory: ({ appInfo }) => {
-            return `/${appInfo.appName}/private/papi`;
-        },
-        deps: {
-            appInfo: APP_INFO_TOKEN,
-        },
-    },
-];
-
-const papiExecutorProvider = provide({
-    provide: PAPI_EXECUTOR,
-    scope: Scope$1.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) => {
-            const { handler, deps, method, path } = getPapiParameters(papi);
-            const papiContext = {
-                deps: di.getOfDeps(deps),
-                log: papiLog.child(`${method}_${path}`),
-            };
-            return handler.call(papiContext, papiOptions);
-        };
-    },
-    deps: {
-        di: DI_TOKEN,
-        logger: LOGGER_TOKEN,
-        fastifyRequest: FASTIFY_REQUEST,
-        requestManager: REQUEST_MANAGER_TOKEN,
-        responseManager: RESPONSE_MANAGER_TOKEN,
-    },
-});
-
-let ServerPapiModule = class ServerPapiModule {
-};
-ServerPapiModule = __decorate([
-    Module({
-        providers: [
-            papiExecutorProvider,
-            fileApiProvider,
-            ...sharedProviders,
-            provide$1({
-                provide: WEB_FASTIFY_APP_BEFORE_INIT_TOKEN,
-                useFactory: ({ di, logger, privateRoutes, publicRoutes, publicBaseUrl, privateBaseUrl }) => (app) => {
-                    if (process.env.NODE_ENV === 'development') {
-                        const papiListRoute = createPapiMethod({
-                            method: 'get',
-                            path: '/papi-list',
-                            async handler() {
-                                return [
-                                    ...flatten(privateRoutes).map((papi) => {
-                                        const params = getPapiParameters(papi);
-                                        return {
-                                            path: params.path,
-                                            method: params.method,
-                                            options: params.options,
-                                            type: 'private',
-                                        };
-                                    }),
-                                    ...flatten(publicRoutes).map((papi) => {
-                                        const params = getPapiParameters(papi);
-                                        return {
-                                            path: params.path,
-                                            method: params.method,
-                                            options: params.options,
-                                            type: 'public',
-                                        };
-                                    }),
-                                ];
-                            },
-                        });
-                        // eslint-disable-next-line no-param-reassign
-                        privateRoutes = privateRoutes
-                            ? [...toArray(privateRoutes), papiListRoute]
-                            : [papiListRoute];
-                    }
-                    if (privateRoutes) {
-                        createApi(app, flatten(privateRoutes), {
-                            baseUrl: privateBaseUrl,
-                            di,
-                            logger,
-                        });
-                    }
-                    if (publicRoutes) {
-                        createApi(app, flatten(publicRoutes), {
-                            baseUrl: publicBaseUrl,
-                            di,
-                            logger,
-                        });
-                    }
-                },
-                deps: {
-                    di: DI_TOKEN$1,
-                    logger: LOGGER_TOKEN,
-                    privateRoutes: {
-                        token: SERVER_MODULE_PAPI_PRIVATE_ROUTE,
-                        optional: true,
-                        multi: true,
-                    },
-                    publicRoutes: {
-                        token: SERVER_MODULE_PAPI_PUBLIC_ROUTE,
-                        optional: true,
-                        multi: true,
-                    },
-                    privateBaseUrl: SERVER_MODULE_PAPI_PRIVATE_URL,
-                    publicBaseUrl: SERVER_MODULE_PAPI_PUBLIC_URL,
-                },
-                multi: true,
-            }),
-            // необходимо для утилит. Подумать как можно убрать в будующем. Если убрать не будет ломающим изменением
-            provide$1({
-                provide: SERVER_MODULE_PAPI_PUBLIC_ROUTE,
-                multi: true,
-                useValue: createPapiMethod({
-                    method: 'get',
-                    path: '/version',
-                    async handler() {
-                        return {
-                            version: this.deps.envManager.get('APP_VERSION'),
-                        };
-                    },
-                    deps: {
-                        envManager: ENV_MANAGER_TOKEN,
-                    },
-                }),
-            }),
-        ],
-    })
-], ServerPapiModule);
-
-let BrowserPapiModule = class BrowserPapiModule {
-};
-BrowserPapiModule = __decorate([
-    Module({
-        providers: [...sharedProviders],
-    })
-], BrowserPapiModule);
-
-const ONE_YEAR = 365 * 24 * 60 * 60;
-let ServerStaticsModule = class ServerStaticsModule {
-};
-ServerStaticsModule = __decorate([
-    Module({
-        providers: [
-            provide$1({
-                provide: WEB_FASTIFY_APP_BEFORE_INIT_TOKEN,
-                useFactory: ({ options }) => {
-                    const path = (options === null || options === void 0 ? void 0 : options.path) || 'public';
-                    return (instance) => {
-                        instance.register(FastifyStatic, {
-                            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: resolve(process.cwd(), path),
-                            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: 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 = __decorate([
-    Module({
-        providers: [
-            provide$1({
-                provide: WEB_FASTIFY_APP_BEFORE_INIT_TOKEN,
-                multi: true,
-                useFactory: ({ app, server, logger, commandLineRunner, livenessPath, readinessPath, livenessProbe, readinessProbe, }) => {
-                    const log = logger('server');
-                    return function serverListen() {
-                        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: UTILITY_WEB_FASTIFY_APP_TOKEN,
-                    server: SERVER_TOKEN,
-                    logger: LOGGER_TOKEN,
-                    commandLineRunner: COMMAND_LINE_RUNNER_TOKEN,
-                    livenessPath: LIVENESS_PATH_TOKEN,
-                    readinessPath: READINESS_PATH_TOKEN,
-                    readinessProbe: { token: READINESS_PROBE_TOKEN, optional: true },
-                    livenessProbe: { token: LIVENESS_PROBE_TOKEN, optional: true },
-                },
-            }),
-            provide$1({
-                provide: LIVENESS_PATH_TOKEN,
-                useValue: '/healthz',
-            }),
-            provide$1({
-                provide: READINESS_PATH_TOKEN,
-                useValue: '/readyz',
-            }),
-            provide$1({
-                provide: UTILITY_SERVER_PATHS,
-                useFactory: ({ livenessPath }) => {
-                    return livenessPath;
-                },
-                multi: true,
-                deps: {
-                    livenessPath: LIVENESS_PATH_TOKEN,
-                },
-            }),
-            provide$1({
-                provide: UTILITY_SERVER_PATHS,
-                useFactory: ({ readinessPath }) => {
-                    return readinessPath;
-                },
-                multi: true,
-                deps: {
-                    readinessPath: 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 = __decorate([
-    Module({
-        providers: [
-            {
-                provide: INTERCEPTOR_TOKEN,
-                useClass: Interceptor,
-                scope: Scope.SINGLETON,
-            },
-            {
-                provide: 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' ? parse(options) : options;
-                            const wasHandled = typeof cb === 'function';
-                            return request(options, cb)
-                                .on('response', (response) => {
-                                interceptor.intercepted &&
-                                    monkeypatch({
-                                        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.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({ obj: http, method: 'request', handler });
-                        monkeypatch({ obj: https, method: 'request', handler });
-                    };
-                },
-                deps: {
-                    logger: LOGGER_TOKEN,
-                    interceptor: INTERCEPTOR_TOKEN,
-                },
-            },
-            {
-                provide: SERVER_MODULE_PAPI_PRIVATE_ROUTE,
-                multi: true,
-                useFactory: ({ interceptor }) => {
-                    return 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: SERVER_MODULE_PAPI_PRIVATE_ROUTE,
-                multi: true,
-                useFactory: ({ interceptor }) => {
-                    return 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 = __decorate([
-    Module({
-        providers: [
-            {
-                provide: WEB_FASTIFY_APP_INIT_TOKEN,
-                useFactory: ({ defaultProxies }) => {
-                    return (app) => {
-                        const proxyConfig = safeNodeRequire(resolve(process.cwd(), 'proxy.conf'));
-                        const proxies = defaultProxies !== null && defaultProxies !== void 0 ? defaultProxies : [];
-                        if (!proxyConfig && proxies.length === 0) {
-                            return;
-                        }
-                        if (isArray(proxyConfig)) {
-                            proxies.push(...proxyConfig);
-                        }
-                        else if (proxyConfig === null || proxyConfig === void 0 ? void 0 : proxyConfig.target) {
-                            proxies.push(proxyConfig);
-                        }
-                        else if (isObject(proxyConfig)) {
-                            eachObj((target, source) => {
-                                const options = typeof target === 'string' ? { target } : target;
-                                proxies.push({ context: source, ...options });
-                            }, proxyConfig);
-                        }
-                        proxies.forEach((proxy) => {
-                            const middleware = 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: PROXY_CONFIG_TOKEN,
-                        optional: true,
-                    },
-                },
-                multi: true,
-            },
-        ],
-    })
-], ServerProxyModule);
-
-const RegExp = /^@tramvai/;
-const tramvaiDepsFilter = (deps) => {
-    return filterObj((v, k) => RegExp.test(k), deps);
-};
-
-let packageJson = {};
-try {
-    // eslint-disable-next-line import/no-unresolved
-    packageJson = require('../../../../package.json');
-}
-catch (e) {
-    packageJson = safeNodeRequire(resolve(process.cwd(), 'package.json'));
-}
-let DependenciesVersionModule = class DependenciesVersionModule {
-};
-DependenciesVersionModule = __decorate([
-    Module({
-        providers: [
-            {
-                provide: SERVER_MODULE_PAPI_PRIVATE_ROUTE,
-                multi: true,
-                useFactory: ({ depsFilter }) => {
-                    const { dependencies = [] } = packageJson !== null && packageJson !== void 0 ? packageJson : {};
-                    return createPapiMethod({
-                        path: '/dependenciesVersion',
-                        method: 'get',
-                        handler: async () => {
-                            return depsFilter(dependencies);
-                        },
-                    });
-                },
-                deps: {
-                    depsFilter: DEPENDENCIES_VERSION_FILTER_TOKEN,
-                },
-            },
-            {
-                provide: DEPENDENCIES_VERSION_FILTER_TOKEN,
-                useValue: tramvaiDepsFilter,
-            },
-        ],
-    })
-], DependenciesVersionModule);
-
-const IS_CUSTOM_SERVER_TOKEN = createToken('server utility isCustomServer');
-let UtilityServerModule = class UtilityServerModule {
-};
-UtilityServerModule = __decorate([
-    Module({
-        providers: [
-            provide$1({
-                provide: ENV_USED_TOKEN,
-                multi: true,
-                useValue: [{ key: 'UTILITY_SERVER_PORT', optional: true }],
-            }),
-            provide$1({
-                provide: UTILITY_SERVER_PORT_TOKEN,
-                scope: Scope.SINGLETON,
-                useFactory: ({ envManager }) => {
-                    return +(envManager.get('UTILITY_SERVER_PORT') || envManager.get('PORT'));
-                },
-                deps: {
-                    envManager: ENV_MANAGER_TOKEN,
-                },
-            }),
-            provide$1({
-                provide: IS_CUSTOM_SERVER_TOKEN,
-                scope: Scope.SINGLETON,
-                useFactory: ({ port, envManager }) => {
-                    return +envManager.get('PORT') !== port;
-                },
-                deps: {
-                    envManager: ENV_MANAGER_TOKEN,
-                    port: UTILITY_SERVER_PORT_TOKEN,
-                },
-            }),
-            provide$1({
-                provide: UTILITY_SERVER_TOKEN,
-                scope: Scope.SINGLETON,
-                useFactory: ({ isCustomServer, serverFactory, server }) => {
-                    return isCustomServer ? serverFactory() : server;
-                },
-                deps: {
-                    isCustomServer: IS_CUSTOM_SERVER_TOKEN,
-                    server: SERVER_TOKEN,
-                    serverFactory: SERVER_FACTORY_TOKEN,
-                },
-            }),
-            provide$1({
-                provide: UTILITY_WEB_FASTIFY_APP_TOKEN,
-                scope: Scope.SINGLETON,
-                useFactory: ({ isCustomServer, app, appFactory, server }) => {
-                    return isCustomServer ? appFactory({ server }) : app;
-                },
-                deps: {
-                    isCustomServer: IS_CUSTOM_SERVER_TOKEN,
-                    app: WEB_FASTIFY_APP_TOKEN,
-                    appFactory: WEB_FASTIFY_APP_FACTORY_TOKEN,
-                    server: UTILITY_SERVER_TOKEN,
-                },
-            }),
-            provide$1({
-                provide: commandLineListTokens.listen,
-                multi: true,
-                scope: 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: LOGGER_TOKEN,
-                    isCustomServer: IS_CUSTOM_SERVER_TOKEN,
-                    port: UTILITY_SERVER_PORT_TOKEN,
-                    app: UTILITY_WEB_FASTIFY_APP_TOKEN,
-                    server: UTILITY_SERVER_TOKEN,
-                },
-            }),
-        ],
-    })
-], UtilityServerModule);
-
-let KeepAliveModule = class KeepAliveModule {
-};
-KeepAliveModule = __decorate([
-    Module({
-        providers: [
-            provide$1({
-                provide: 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;
-                        },
-                    },
-                ],
-            }),
-            provide$1({
-                provide: 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: SERVER_TOKEN, envManager: ENV_MANAGER_TOKEN$1 },
-            }),
-        ],
-    })
-], KeepAliveModule);
-
-const ServerTimingModule = declareModule({
-    name: 'ServerTiming',
-    providers: [
-        provide$1({
-            provide: COMMAND_LINE_EXECUTION_END_TOKEN,
-            multi: true,
-            useValue: (di, type, status, timingInfo) => {
-                var _a;
-                if (type === 'server' && status === 'customer') {
-                    const responseManager = di.get(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(', ')}`);
-                }
-            },
-        }),
-    ],
-});
+import { serverFactory, serverListenCommand } from './server/server.es.js';
+import { webAppFactory, webAppInitCommand } from './server/webApp.es.js';
+import { staticAppCommand } from './server/static.es.js';
+import { xHeadersFactory } from './server/xHeaders.es.js';
+import { ServerPapiModule } from './modules/papi/papi.es.js';
+import './modules/papi/papi.browser.es.js';
+import { ServerStaticsModule } from './modules/statics.es.js';
+import { ServerGracefulShutdownModule } from './modules/gracefulShutdown.es.js';
+import { DebugHttpRequestsModule } from './modules/debugRequests.es.js';
+import { ServerProxyModule } from './modules/proxy.es.js';
+import { DependenciesVersionModule } from './modules/dependenciesVersion.es.js';
+import { UtilityServerModule } from './modules/utilityServer.es.js';
+import { KeepAliveModule } from './modules/keepAlive.es.js';
+import { ServerTimingModule } from './modules/serverTiming.es.js';
 
 if (typeof setDefaultResultOrder === 'function') {
     setDefaultResultOrder('ipv4first');
 }
 // tramvai add a lot of "abort" event listeners to AbortSignal, but we can't configure only AbortSignal max listeners,
 // because AbortSignal is not instance of EventEmitter - https://github.com/southpolesteve/node-abort-controller/blob/master/index.js
-EventEmitter$1.defaultMaxListeners = 50;
+EventEmitter.defaultMaxListeners = 50;
 let ServerModule = class ServerModule {
 };
 ServerModule = __decorate([
@@ -1058,12 +47,12 @@ ServerModule = __decorate([
             process.env.NODE_ENV !== 'production' && DebugHttpRequestsModule,
         ].filter(Boolean),
         providers: [
-            provide$1({
+            provide({
                 provide: SERVER_FACTORY_TOKEN,
                 scope: Scope.SINGLETON,
                 useValue: serverFactory,
             }),
-            provide$1({
+            provide({
                 provide: SERVER_TOKEN,
                 scope: Scope.SINGLETON,
                 useFactory: ({ factory }) => factory(),
@@ -1071,12 +60,12 @@ ServerModule = __decorate([
                     factory: SERVER_FACTORY_TOKEN,
                 },
             }),
-            provide$1({
+            provide({
                 provide: WEB_FASTIFY_APP_FACTORY_TOKEN,
                 scope: Scope.SINGLETON,
                 useValue: webAppFactory,
             }),
-            provide$1({
+            provide({
                 provide: WEB_FASTIFY_APP_TOKEN,
                 useFactory: ({ factory, server }) => factory({ server }),
                 scope: Scope.SINGLETON,