@tramvai/module-server 2.70.1 → 2.72.3

package/lib/modules/utils/tramvaiDepsFilter.es.js

@@ -0,0 +1,8 @@
+import filterObj from '@tinkoff/utils/object/filter';
+
+const RegExp = /^@tramvai/;
+const tramvaiDepsFilter = (deps) => {
+    return filterObj((v, k) => RegExp.test(k), deps);
+};
+
+export { tramvaiDepsFilter };

package/lib/modules/utils/tramvaiDepsFilter.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var filterObj = require('@tinkoff/utils/object/filter');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var filterObj__default = /*#__PURE__*/_interopDefaultLegacy(filterObj);
+
+const RegExp = /^@tramvai/;
+const tramvaiDepsFilter = (deps) => {
+    return filterObj__default["default"]((v, k) => RegExp.test(k), deps);
+};
+
+exports.tramvaiDepsFilter = tramvaiDepsFilter;

package/lib/server/error.es.js

@@ -0,0 +1,54 @@
+import isNil from '@tinkoff/utils/is/nil';
+import { isRedirectFoundError, isNotFoundError, isHttpError } from '@tinkoff/errors';
+
+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;
+    });
+};
+
+export { errorHandler };

package/lib/server/error.js

@@ -0,0 +1,62 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isNil = require('@tinkoff/utils/is/nil');
+var errors = require('@tinkoff/errors');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var isNil__default = /*#__PURE__*/_interopDefaultLegacy(isNil);
+
+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;
+    });
+};
+
+exports.errorHandler = errorHandler;

package/lib/server/server.es.js

@@ -0,0 +1,17 @@
+import http from 'http';
+
+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` }));
+    };
+};
+
+export { serverFactory, serverListenCommand };

package/lib/server/server.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var http = require('http');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
+
+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` }));
+    };
+};
+
+exports.serverFactory = serverFactory;
+exports.serverListenCommand = serverListenCommand;

package/lib/server/static.es.js

@@ -0,0 +1,34 @@
+import fastify from 'fastify';
+import fastifyCompress from '@fastify/compress';
+import { fastifyStatic } from '@fastify/static';
+import os from 'os';
+
+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;
+    };
+};
+
+export { staticAppCommand };

package/lib/server/static.js

@@ -0,0 +1,44 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fastify = require('fastify');
+var fastifyCompress = require('@fastify/compress');
+var FastifyStatic = require('@fastify/static');
+var os = require('os');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fastify__default = /*#__PURE__*/_interopDefaultLegacy(fastify);
+var fastifyCompress__default = /*#__PURE__*/_interopDefaultLegacy(fastifyCompress);
+var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
+
+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;
+    };
+};
+
+exports.staticAppCommand = staticAppCommand;

package/lib/server/webApp.es.js

@@ -0,0 +1,103 @@
+import fastify from 'fastify';
+import { fastifyCookie } from '@fastify/cookie';
+import fastifyFormBody from '@fastify/formbody';
+import { ROOT_EXECUTION_CONTEXT_TOKEN, RESPONSE_MANAGER_TOKEN } from '@tramvai/tokens-common';
+import { Scope } from '@tramvai/core';
+import { FASTIFY_REQUEST, FASTIFY_RESPONSE } from '@tramvai/tokens-server-private';
+import { provide } from '@tinkoff/dippy';
+import { errorHandler } from './error.es.js';
+
+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();
+    };
+};
+
+export { webAppFactory, webAppInitCommand };

package/lib/server/webApp.js

@@ -0,0 +1,113 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fastify = require('fastify');
+var cookie = require('@fastify/cookie');
+var fastifyFormBody = require('@fastify/formbody');
+var tokensCommon = require('@tramvai/tokens-common');
+var core = require('@tramvai/core');
+var tokensServerPrivate = require('@tramvai/tokens-server-private');
+var dippy = require('@tinkoff/dippy');
+var error = require('./error.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fastify__default = /*#__PURE__*/_interopDefaultLegacy(fastify);
+var fastifyFormBody__default = /*#__PURE__*/_interopDefaultLegacy(fastifyFormBody);
+
+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() {
+        error.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();
+    };
+};
+
+exports.webAppFactory = webAppFactory;
+exports.webAppInitCommand = webAppInitCommand;

package/lib/server/xHeaders.es.js

@@ -0,0 +1,21 @@
+import filterObj from '@tinkoff/utils/object/filter';
+import os from 'os';
+
+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);
+        });
+    };
+};
+
+export { xHeadersFactory };

package/lib/server/xHeaders.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var filterObj = require('@tinkoff/utils/object/filter');
+var os = require('os');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var filterObj__default = /*#__PURE__*/_interopDefaultLegacy(filterObj);
+var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
+
+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);
+        });
+    };
+};
+
+exports.xHeadersFactory = xHeadersFactory;