@tramvai/module-server 1.95.1 → 1.97.0

package/README.md

@@ -183,6 +183,31 @@ By default server starts at `3000` port. You have next options to override this
 - **in dev environment** port in fully controlled by `@tramvai/cli` and should be specified by [`-p` option](references/cli/start.md#-p---port)
 - **in prod environment** it can be specified explicitly as an environment variable `PORT` e.g. `PORT=8080`
 
+### Specify port for utility paths
+
+It includes: health checks, liveness checks, metrics.
+
+By default port for utility paths equals [base server port](#specify-server-port) and they will use the same http server.
+
+If you want to change this and run utility routes on different server with different port, use token `UTILITY_SERVER_PORT_TOKEN`:
+
+```ts
+import { UTILITY_SERVER_PORT_TOKEN } from '@tramvai/tokens-server';
+
+const providers = [
+  {
+    provide: UTILITY_SERVER_PORT_TOKEN,
+    useValue: 6532,
+  },
+];
+```
+
+Or use env variable `UTILITY_SERVER_PORT` with defined value.
+
+```sh
+env UTILITY_SERVER_PORT=6532 tramvai start app
+```
+
 ## Exportable tokens
 
 [Link](references/tokens/server.md)

package/lib/modules/index.d.ts

@@ -4,3 +4,4 @@ export * from './gracefulShutdown';
 export * from './debugRequests';
 export * from './proxy';
 export * from './dependenciesVersion';
+export * from './utilityServer';

package/lib/modules/utilityServer.d.ts

@@ -0,0 +1,2 @@
+export declare class UtilityServerModule {
+}

package/lib/server.es.js

@@ -1,8 +1,8 @@
 import { __decorate } from 'tslib';
-import { Scope, APP_INFO_TOKEN, Module, provide, DI_TOKEN, COMMAND_LINE_RUNNER_TOKEN, commandLineListTokens } from '@tramvai/core';
-import { SERVER_MODULE_PAPI_PUBLIC_ROUTE, SERVER_MODULE_PAPI_PUBLIC_URL, SERVER_MODULE_PAPI_PRIVATE_URL, WEB_APP_BEFORE_INIT_TOKEN, WEB_APP_TOKEN, SERVER_MODULE_PAPI_PRIVATE_ROUTE, SERVER_MODULE_STATICS_OPTIONS, SERVER_TOKEN, READINESS_PROBE_TOKEN, LIVENESS_PROBE_TOKEN, SPECIAL_SERVER_PATHS, PROXY_CONFIG_TOKEN, DEPENDENCIES_VERSION_FILTER_TOKEN, WEB_APP_INIT_TOKEN, WEB_APP_AFTER_INIT_TOKEN, WEB_APP_LIMITER_TOKEN } from '@tramvai/tokens-server';
+import { Scope, APP_INFO_TOKEN, Module, provide, DI_TOKEN, COMMAND_LINE_RUNNER_TOKEN, commandLineListTokens, createToken } from '@tramvai/core';
+import { SERVER_MODULE_PAPI_PUBLIC_ROUTE, SERVER_MODULE_PAPI_PUBLIC_URL, SERVER_MODULE_PAPI_PRIVATE_URL, WEB_APP_BEFORE_INIT_TOKEN, WEB_APP_TOKEN, SERVER_MODULE_PAPI_PRIVATE_ROUTE, SERVER_MODULE_STATICS_OPTIONS, SERVER_TOKEN, READINESS_PROBE_TOKEN, LIVENESS_PROBE_TOKEN, UTILITY_SERVER_PATHS, PROXY_CONFIG_TOKEN, DEPENDENCIES_VERSION_FILTER_TOKEN, UTILITY_SERVER_PORT_TOKEN, WEB_APP_INIT_TOKEN, WEB_APP_AFTER_INIT_TOKEN, WEB_APP_LIMITER_TOKEN } from '@tramvai/tokens-server';
 export * from '@tramvai/tokens-server';
-import { WEB_FASTIFY_APP_BEFORE_INIT_TOKEN, SERVER_FACTORY_TOKEN, WEB_FASTIFY_APP_FACTORY_TOKEN, WEB_FASTIFY_APP_TOKEN, WEB_FASTIFY_APP_INIT_TOKEN, WEB_FASTIFY_APP_AFTER_INIT_TOKEN, WEB_FASTIFY_APP_LIMITER_TOKEN, WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN, WEB_FASTIFY_APP_PROCESS_ERROR_TOKEN, WEB_FASTIFY_APP_AFTER_ERROR_TOKEN } from '@tramvai/tokens-server-private';
+import { WEB_FASTIFY_APP_BEFORE_INIT_TOKEN, UTILITY_WEB_FASTIFY_APP_TOKEN, UTILITY_SERVER_TOKEN, SERVER_FACTORY_TOKEN, WEB_FASTIFY_APP_TOKEN, WEB_FASTIFY_APP_FACTORY_TOKEN, WEB_FASTIFY_APP_INIT_TOKEN, WEB_FASTIFY_APP_AFTER_INIT_TOKEN, WEB_FASTIFY_APP_LIMITER_TOKEN, WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN, WEB_FASTIFY_APP_PROCESS_ERROR_TOKEN, WEB_FASTIFY_APP_AFTER_ERROR_TOKEN } from '@tramvai/tokens-server-private';
 import { REQUEST, RESPONSE, FASTIFY_REQUEST, FASTIFY_RESPONSE, RESPONSE_MANAGER_TOKEN, LOGGER_TOKEN, ENV_MANAGER_TOKEN, ENV_USED_TOKEN } from '@tramvai/tokens-common';
 import { MetricsModule } from '@tramvai/module-metrics';
 import { CacheWarmupModule } from '@tramvai/module-cache-warmup';
@@ -579,13 +579,13 @@ let ServerGracefulShutdownModule = class ServerGracefulShutdownModule {
 ServerGracefulShutdownModule = __decorate([
     Module({
         providers: [
-            {
+            provide({
                 provide: WEB_FASTIFY_APP_BEFORE_INIT_TOKEN,
                 multi: true,
-                useFactory: ({ server, logger, commandLineRunner, livenessProbe, readinessProbe, }) => {
+                useFactory: ({ app, server, logger, commandLineRunner, livenessProbe, readinessProbe, }) => {
                     const log = logger('server');
-                    return function serverListen(instance) {
-                        createTerminus(server, instance, {
+                    return function serverListen() {
+                        createTerminus(server, app, {
                             signal: 'SIGTERM',
                             timeout: GRACEFUL_SHUTDOWN_TIMEOUT,
                             logger: (msg, error) => {
@@ -625,15 +625,16 @@ ServerGracefulShutdownModule = __decorate([
                     };
                 },
                 deps: {
+                    app: UTILITY_WEB_FASTIFY_APP_TOKEN,
                     server: SERVER_TOKEN,
                     logger: LOGGER_TOKEN,
                     commandLineRunner: COMMAND_LINE_RUNNER_TOKEN,
                     readinessProbe: { token: READINESS_PROBE_TOKEN, optional: true },
                     livenessProbe: { token: LIVENESS_PROBE_TOKEN, optional: true },
                 },
-            },
+            }),
             {
-                provide: SPECIAL_SERVER_PATHS,
+                provide: UTILITY_SERVER_PATHS,
                 useValue: [readyzPath, healthzPath],
                 multi: true,
             },
@@ -878,6 +879,96 @@ DependenciesVersionModule = __decorate([
     })
 ], DependenciesVersionModule);
 
+const IS_CUSTOM_SERVER_TOKEN = createToken('server utility isCustomServer');
+let UtilityServerModule = class UtilityServerModule {
+};
+UtilityServerModule = __decorate([
+    Module({
+        providers: [
+            provide({
+                provide: ENV_USED_TOKEN,
+                multi: true,
+                useValue: [{ key: 'UTILITY_SERVER_PORT', optional: true }],
+            }),
+            provide({
+                provide: UTILITY_SERVER_PORT_TOKEN,
+                useFactory: ({ envManager }) => {
+                    return +(envManager.get('UTILITY_SERVER_PORT') || envManager.get('PORT'));
+                },
+                deps: {
+                    envManager: ENV_MANAGER_TOKEN,
+                },
+            }),
+            provide({
+                provide: IS_CUSTOM_SERVER_TOKEN,
+                useFactory: ({ port, envManager }) => {
+                    return +envManager.get('PORT') !== port;
+                },
+                deps: {
+                    envManager: ENV_MANAGER_TOKEN,
+                    port: UTILITY_SERVER_PORT_TOKEN,
+                },
+            }),
+            provide({
+                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({
+                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({
+                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 ServerModule = class ServerModule {
 };
 ServerModule = __decorate([
@@ -890,6 +981,7 @@ ServerModule = __decorate([
             ServerGracefulShutdownModule,
             ServerProxyModule,
             DependenciesVersionModule,
+            UtilityServerModule,
             process.env.NODE_ENV !== 'production' && DebugHttpRequestsModule,
         ].filter(Boolean),
         providers: [

package/lib/server.js

@@ -604,13 +604,13 @@ let ServerGracefulShutdownModule = class ServerGracefulShutdownModule {
 ServerGracefulShutdownModule = tslib.__decorate([
     core.Module({
         providers: [
-            {
+            core.provide({
                 provide: tokensServerPrivate.WEB_FASTIFY_APP_BEFORE_INIT_TOKEN,
                 multi: true,
-                useFactory: ({ server, logger, commandLineRunner, livenessProbe, readinessProbe, }) => {
+                useFactory: ({ app, server, logger, commandLineRunner, livenessProbe, readinessProbe, }) => {
                     const log = logger('server');
-                    return function serverListen(instance) {
-                        terminus.createTerminus(server, instance, {
+                    return function serverListen() {
+                        terminus.createTerminus(server, app, {
                             signal: 'SIGTERM',
                             timeout: GRACEFUL_SHUTDOWN_TIMEOUT,
                             logger: (msg, error) => {
@@ -650,15 +650,16 @@ ServerGracefulShutdownModule = tslib.__decorate([
                     };
                 },
                 deps: {
+                    app: tokensServerPrivate.UTILITY_WEB_FASTIFY_APP_TOKEN,
                     server: tokensServer.SERVER_TOKEN,
                     logger: tokensCommon.LOGGER_TOKEN,
                     commandLineRunner: core.COMMAND_LINE_RUNNER_TOKEN,
                     readinessProbe: { token: tokensServer.READINESS_PROBE_TOKEN, optional: true },
                     livenessProbe: { token: tokensServer.LIVENESS_PROBE_TOKEN, optional: true },
                 },
-            },
+            }),
             {
-                provide: tokensServer.SPECIAL_SERVER_PATHS,
+                provide: tokensServer.UTILITY_SERVER_PATHS,
                 useValue: [readyzPath, healthzPath],
                 multi: true,
             },
@@ -903,6 +904,96 @@ DependenciesVersionModule = tslib.__decorate([
     })
 ], DependenciesVersionModule);
 
+const IS_CUSTOM_SERVER_TOKEN = core.createToken('server utility isCustomServer');
+let UtilityServerModule = class UtilityServerModule {
+};
+UtilityServerModule = tslib.__decorate([
+    core.Module({
+        providers: [
+            core.provide({
+                provide: tokensCommon.ENV_USED_TOKEN,
+                multi: true,
+                useValue: [{ key: 'UTILITY_SERVER_PORT', optional: true }],
+            }),
+            core.provide({
+                provide: tokensServer.UTILITY_SERVER_PORT_TOKEN,
+                useFactory: ({ envManager }) => {
+                    return +(envManager.get('UTILITY_SERVER_PORT') || envManager.get('PORT'));
+                },
+                deps: {
+                    envManager: tokensCommon.ENV_MANAGER_TOKEN,
+                },
+            }),
+            core.provide({
+                provide: IS_CUSTOM_SERVER_TOKEN,
+                useFactory: ({ port, envManager }) => {
+                    return +envManager.get('PORT') !== port;
+                },
+                deps: {
+                    envManager: tokensCommon.ENV_MANAGER_TOKEN,
+                    port: tokensServer.UTILITY_SERVER_PORT_TOKEN,
+                },
+            }),
+            core.provide({
+                provide: tokensServerPrivate.UTILITY_SERVER_TOKEN,
+                scope: core.Scope.SINGLETON,
+                useFactory: ({ isCustomServer, serverFactory, server }) => {
+                    return isCustomServer ? serverFactory() : server;
+                },
+                deps: {
+                    isCustomServer: IS_CUSTOM_SERVER_TOKEN,
+                    server: tokensServer.SERVER_TOKEN,
+                    serverFactory: tokensServerPrivate.SERVER_FACTORY_TOKEN,
+                },
+            }),
+            core.provide({
+                provide: tokensServerPrivate.UTILITY_WEB_FASTIFY_APP_TOKEN,
+                scope: core.Scope.SINGLETON,
+                useFactory: ({ isCustomServer, app, appFactory, server }) => {
+                    return isCustomServer ? appFactory({ server }) : app;
+                },
+                deps: {
+                    isCustomServer: IS_CUSTOM_SERVER_TOKEN,
+                    app: tokensServerPrivate.WEB_FASTIFY_APP_TOKEN,
+                    appFactory: tokensServerPrivate.WEB_FASTIFY_APP_FACTORY_TOKEN,
+                    server: tokensServerPrivate.UTILITY_SERVER_TOKEN,
+                },
+            }),
+            core.provide({
+                provide: core.commandLineListTokens.listen,
+                multi: true,
+                scope: core.Scope.SINGLETON,
+                useFactory: ({ logger, isCustomServer, port, app, server }) => {
+                    return async function utilityServerListen() {
+                        if (!isCustomServer) {
+                            return;
+                        }
+                        const log = logger('server:utility');
+                        await app.ready();
+                        return new Promise((resolve, reject) => {
+                            server.once('error', (error) => {
+                                log.error({ event: 'server-listen-port', error });
+                                reject(error);
+                            });
+                            server.listen(port, () => {
+                                log.warn({ event: 'server-listen-port', message: `Server listen ${port} port` });
+                                resolve();
+                            });
+                        });
+                    };
+                },
+                deps: {
+                    logger: tokensCommon.LOGGER_TOKEN,
+                    isCustomServer: IS_CUSTOM_SERVER_TOKEN,
+                    port: tokensServer.UTILITY_SERVER_PORT_TOKEN,
+                    app: tokensServerPrivate.UTILITY_WEB_FASTIFY_APP_TOKEN,
+                    server: tokensServerPrivate.UTILITY_SERVER_TOKEN,
+                },
+            }),
+        ],
+    })
+], UtilityServerModule);
+
 exports.ServerModule = class ServerModule {
 };
 exports.ServerModule = tslib.__decorate([
@@ -915,6 +1006,7 @@ exports.ServerModule = tslib.__decorate([
             ServerGracefulShutdownModule,
             ServerProxyModule,
             DependenciesVersionModule,
+            UtilityServerModule,
             process.env.NODE_ENV !== 'production' && DebugHttpRequestsModule,
         ].filter(Boolean),
         providers: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-server",
-  "version": "1.95.1",
+  "version": "1.97.0",
   "description": "",
   "browser": "lib/browser.js",
   "main": "lib/server.js",
@@ -23,11 +23,11 @@
     "@tinkoff/monkeypatch": "1.3.3",
     "@tinkoff/terminus": "0.0.2",
     "@tinkoff/url": "0.7.37",
-    "@tramvai/module-cache-warmup": "1.95.1",
-    "@tramvai/module-metrics": "1.95.1",
-    "@tramvai/papi": "1.95.1",
-    "@tramvai/tokens-server": "1.95.1",
-    "@tramvai/tokens-server-private": "1.95.1",
+    "@tramvai/module-cache-warmup": "1.97.0",
+    "@tramvai/module-metrics": "1.97.0",
+    "@tramvai/papi": "1.97.0",
+    "@tramvai/tokens-server": "1.97.0",
+    "@tramvai/tokens-server-private": "1.97.0",
     "compression": "^1.7.4",
     "express": "^4.17.1",
     "fastify": "^3.27.4",
@@ -40,11 +40,11 @@
   "peerDependencies": {
     "@tinkoff/dippy": "0.7.39",
     "@tinkoff/utils": "^2.1.2",
-    "@tramvai/cli": "1.95.1",
-    "@tramvai/core": "1.95.1",
-    "@tramvai/module-common": "1.95.1",
-    "@tramvai/module-environment": "1.95.1",
-    "@tramvai/tokens-common": "1.95.1",
+    "@tramvai/cli": "1.97.0",
+    "@tramvai/core": "1.97.0",
+    "@tramvai/module-common": "1.97.0",
+    "@tramvai/module-environment": "1.97.0",
+    "@tramvai/tokens-common": "1.97.0",
     "tslib": "^2.0.3"
   },
   "devDependencies": {