@tramvai/module-server 2.70.1 → 2.72.0

package/lib/browser.js

@@ -1,38 +1,9 @@
 import { __decorate } from 'tslib';
-import { APP_INFO_TOKEN, Module } from '@tramvai/core';
+import { Module } from '@tramvai/core';
 import { MetricsModule } from '@tramvai/module-metrics';
-import { SERVER_MODULE_PAPI_PUBLIC_URL, SERVER_MODULE_PAPI_PRIVATE_URL } from '@tramvai/tokens-server';
+import { BrowserPapiModule } from './modules/papi/papi.browser.browser.js';
 export * from '@tramvai/tokens-server';
 
-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,
-        },
-    },
-];
-
-let BrowserPapiModule = class BrowserPapiModule {
-};
-BrowserPapiModule = __decorate([
-    Module({
-        providers: [...sharedProviders],
-    })
-], BrowserPapiModule);
-
 let ServerModule = class ServerModule {
 };
 ServerModule = __decorate([

package/lib/modules/debugRequests.es.js

@@ -0,0 +1,143 @@
+import { __decorate } from 'tslib';
+import { LOGGER_TOKEN } from '@tramvai/tokens-common';
+import { createPapiMethod } from '@tramvai/papi';
+import { SERVER_MODULE_PAPI_PRIVATE_ROUTE } from '@tramvai/tokens-server';
+import { Module, Scope, commandLineListTokens } from '@tramvai/core';
+import { parse } from '@tinkoff/url';
+import { EventEmitter } from 'events';
+import monkeypatch from '@tinkoff/monkeypatch';
+import http from 'http';
+import https from 'https';
+
+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);
+
+export { DebugHttpRequestsModule };

package/lib/modules/debugRequests.js

@@ -0,0 +1,151 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var tokensCommon = require('@tramvai/tokens-common');
+var papi = require('@tramvai/papi');
+var tokensServer = require('@tramvai/tokens-server');
+var core = require('@tramvai/core');
+var url = require('@tinkoff/url');
+var EventEmitter = require('events');
+var monkeypatch = require('@tinkoff/monkeypatch');
+var http = require('http');
+var https = require('https');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var monkeypatch__default = /*#__PURE__*/_interopDefaultLegacy(monkeypatch);
+var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
+var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
+
+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';
+exports.DebugHttpRequestsModule = class DebugHttpRequestsModule {
+};
+exports.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,
+                },
+            },
+        ],
+    })
+], exports.DebugHttpRequestsModule);

package/lib/modules/dependenciesVersion.es.js

@@ -0,0 +1,47 @@
+import { __decorate } from 'tslib';
+import { resolve } from 'path';
+import { Module } from '@tramvai/core';
+import { createPapiMethod } from '@tramvai/papi';
+import { SERVER_MODULE_PAPI_PRIVATE_ROUTE, DEPENDENCIES_VERSION_FILTER_TOKEN } from '@tramvai/tokens-server';
+import { safeNodeRequire } from './utils/require.es.js';
+import { tramvaiDepsFilter } from './utils/tramvaiDepsFilter.es.js';
+
+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);
+
+export { DependenciesVersionModule };

package/lib/modules/dependenciesVersion.js

@@ -0,0 +1,49 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var path = require('path');
+var core = require('@tramvai/core');
+var papi = require('@tramvai/papi');
+var tokensServer = require('@tramvai/tokens-server');
+var require$1 = require('./utils/require.js');
+var tramvaiDepsFilter = require('./utils/tramvaiDepsFilter.js');
+
+let packageJson = {};
+try {
+    // eslint-disable-next-line import/no-unresolved
+    packageJson = require('../../../../package.json');
+}
+catch (e) {
+    packageJson = require$1.safeNodeRequire(path.resolve(process.cwd(), 'package.json'));
+}
+exports.DependenciesVersionModule = class DependenciesVersionModule {
+};
+exports.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.tramvaiDepsFilter,
+            },
+        ],
+    })
+], exports.DependenciesVersionModule);

package/lib/modules/gracefulShutdown.es.js

@@ -0,0 +1,104 @@
+import { __decorate } from 'tslib';
+import { createTerminus } from '@tinkoff/terminus';
+import { SERVER_TOKEN, LIVENESS_PATH_TOKEN, READINESS_PATH_TOKEN, READINESS_PROBE_TOKEN, LIVENESS_PROBE_TOKEN, UTILITY_SERVER_PATHS } from '@tramvai/tokens-server';
+import { WEB_FASTIFY_APP_BEFORE_INIT_TOKEN, UTILITY_WEB_FASTIFY_APP_TOKEN } from '@tramvai/tokens-server-private';
+import { LOGGER_TOKEN } from '@tramvai/tokens-common';
+import { Module, provide, COMMAND_LINE_RUNNER_TOKEN } from '@tramvai/core';
+
+const GRACEFUL_SHUTDOWN_TIMEOUT = 25000;
+const GRACEFUL_READINESS_TIMEOUT = 5000;
+const noopCheck = () => { };
+let ServerGracefulShutdownModule = class ServerGracefulShutdownModule {
+};
+ServerGracefulShutdownModule = __decorate([
+    Module({
+        providers: [
+            provide({
+                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({
+                provide: LIVENESS_PATH_TOKEN,
+                useValue: '/healthz',
+            }),
+            provide({
+                provide: READINESS_PATH_TOKEN,
+                useValue: '/readyz',
+            }),
+            provide({
+                provide: UTILITY_SERVER_PATHS,
+                useFactory: ({ livenessPath }) => {
+                    return livenessPath;
+                },
+                multi: true,
+                deps: {
+                    livenessPath: LIVENESS_PATH_TOKEN,
+                },
+            }),
+            provide({
+                provide: UTILITY_SERVER_PATHS,
+                useFactory: ({ readinessPath }) => {
+                    return readinessPath;
+                },
+                multi: true,
+                deps: {
+                    readinessPath: READINESS_PATH_TOKEN,
+                },
+            }),
+        ],
+    })
+], ServerGracefulShutdownModule);
+
+export { ServerGracefulShutdownModule };

package/lib/modules/gracefulShutdown.js

@@ -0,0 +1,106 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var terminus = require('@tinkoff/terminus');
+var tokensServer = require('@tramvai/tokens-server');
+var tokensServerPrivate = require('@tramvai/tokens-server-private');
+var tokensCommon = require('@tramvai/tokens-common');
+var core = require('@tramvai/core');
+
+const GRACEFUL_SHUTDOWN_TIMEOUT = 25000;
+const GRACEFUL_READINESS_TIMEOUT = 5000;
+const noopCheck = () => { };
+exports.ServerGracefulShutdownModule = class ServerGracefulShutdownModule {
+};
+exports.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,
+                },
+            }),
+        ],
+    })
+], exports.ServerGracefulShutdownModule);