@tramvai/module-server 2.70.1 → 2.72.3

package/lib/modules/papi/server/fileApi.js

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var eachObj = require('@tinkoff/utils/object/each');
+var tokensCommon = require('@tramvai/tokens-common');
+var tokensServer = require('@tramvai/tokens-server');
+var papi = require('@tramvai/papi');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var eachObj__default = /*#__PURE__*/_interopDefaultLegacy(eachObj);
+
+let papis;
+try {
+    // eslint-disable-next-line import/no-extraneous-dependencies
+    papis = require('@tramvai/cli/lib/external/api').default; // eslint-disable-line import/no-unresolved
+}
+catch (e) { }
+const getFileApi = ({ logger }) => {
+    const log = logger('papi:fileApi');
+    const result = [];
+    eachObj__default["default"](({ default: entry }, path) => {
+        if (!papi.isPapiMethod(entry)) {
+            log.error({
+                path,
+                entry,
+                message: `Cannot resolve a papi handler.
+Check that you are using file based papi right way by docs https://tramvai.dev/docs/how-to/how-create-papi#automatic-handler-creation
+In case you have not added any file papi handler, consider renaming directory ./src/api (by default) to the other name to resolve conflicts with papi, or
+change settings serverApiDir in tramvai.json`,
+            });
+            throw new Error('Not a papi');
+        }
+        const papiParameters = papi.getPapiParameters(entry);
+        result.push(papi.createPapiMethod({
+            ...papiParameters,
+            path: `/${path}`,
+        }));
+    }, papis);
+    return result;
+};
+const fileApiProvider = {
+    provide: tokensServer.SERVER_MODULE_PAPI_PUBLIC_ROUTE,
+    multi: true,
+    useFactory: getFileApi,
+    deps: {
+        logger: tokensCommon.LOGGER_TOKEN,
+    },
+};
+
+exports.fileApiProvider = fileApiProvider;

package/lib/modules/papi/shared.browser.js

@@ -0,0 +1,25 @@
+import { SERVER_MODULE_PAPI_PUBLIC_URL, SERVER_MODULE_PAPI_PRIVATE_URL } from '@tramvai/tokens-server';
+import { APP_INFO_TOKEN } from '@tramvai/core';
+
+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,
+        },
+    },
+];
+
+export { sharedProviders };

package/lib/modules/papi/shared.es.js

@@ -0,0 +1,25 @@
+import { SERVER_MODULE_PAPI_PUBLIC_URL, SERVER_MODULE_PAPI_PRIVATE_URL } from '@tramvai/tokens-server';
+import { APP_INFO_TOKEN } from '@tramvai/core';
+
+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,
+        },
+    },
+];
+
+export { sharedProviders };

package/lib/modules/papi/shared.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tokensServer = require('@tramvai/tokens-server');
+var core = require('@tramvai/core');
+
+const sharedProviders = [
+    {
+        provide: tokensServer.SERVER_MODULE_PAPI_PUBLIC_URL,
+        useFactory: ({ appInfo }) => {
+            return `/${appInfo.appName}/papi`;
+        },
+        deps: {
+            appInfo: core.APP_INFO_TOKEN,
+        },
+    },
+    {
+        provide: tokensServer.SERVER_MODULE_PAPI_PRIVATE_URL,
+        useFactory: ({ appInfo }) => {
+            return `/${appInfo.appName}/private/papi`;
+        },
+        deps: {
+            appInfo: core.APP_INFO_TOKEN,
+        },
+    },
+];
+
+exports.sharedProviders = sharedProviders;

package/lib/modules/proxy.es.js

@@ -0,0 +1,65 @@
+import { __decorate } from 'tslib';
+import eachObj from '@tinkoff/utils/object/each';
+import isArray from '@tinkoff/utils/is/array';
+import isObject from '@tinkoff/utils/is/object';
+import { resolve } from 'path';
+import { Module } from '@tramvai/core';
+import { PROXY_CONFIG_TOKEN } from '@tramvai/tokens-server';
+import { createProxyMiddleware } from 'http-proxy-middleware';
+import { WEB_FASTIFY_APP_INIT_TOKEN } from '@tramvai/tokens-server-private';
+import { safeNodeRequire } from './utils/require.es.js';
+
+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);
+
+export { ServerProxyModule };

package/lib/modules/proxy.js

@@ -0,0 +1,73 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var eachObj = require('@tinkoff/utils/object/each');
+var isArray = require('@tinkoff/utils/is/array');
+var isObject = require('@tinkoff/utils/is/object');
+var path = require('path');
+var core = require('@tramvai/core');
+var tokensServer = require('@tramvai/tokens-server');
+var httpProxyMiddleware = require('http-proxy-middleware');
+var tokensServerPrivate = require('@tramvai/tokens-server-private');
+var require$1 = require('./utils/require.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var eachObj__default = /*#__PURE__*/_interopDefaultLegacy(eachObj);
+var isArray__default = /*#__PURE__*/_interopDefaultLegacy(isArray);
+var isObject__default = /*#__PURE__*/_interopDefaultLegacy(isObject);
+
+exports.ServerProxyModule = class ServerProxyModule {
+};
+exports.ServerProxyModule = tslib.__decorate([
+    core.Module({
+        providers: [
+            {
+                provide: tokensServerPrivate.WEB_FASTIFY_APP_INIT_TOKEN,
+                useFactory: ({ defaultProxies }) => {
+                    return (app) => {
+                        const proxyConfig = require$1.safeNodeRequire(path.resolve(process.cwd(), 'proxy.conf'));
+                        const proxies = defaultProxies !== null && defaultProxies !== void 0 ? defaultProxies : [];
+                        if (!proxyConfig && proxies.length === 0) {
+                            return;
+                        }
+                        if (isArray__default["default"](proxyConfig)) {
+                            proxies.push(...proxyConfig);
+                        }
+                        else if (proxyConfig === null || proxyConfig === void 0 ? void 0 : proxyConfig.target) {
+                            proxies.push(proxyConfig);
+                        }
+                        else if (isObject__default["default"](proxyConfig)) {
+                            eachObj__default["default"]((target, source) => {
+                                const options = typeof target === 'string' ? { target } : target;
+                                proxies.push({ context: source, ...options });
+                            }, proxyConfig);
+                        }
+                        proxies.forEach((proxy) => {
+                            const middleware = httpProxyMiddleware.createProxyMiddleware(proxy.context, {
+                                changeOrigin: true,
+                                onProxyRes: (proxyRes) => {
+                                    // eslint-disable-next-line no-param-reassign
+                                    proxyRes.headers['x-tramvai-proxied-response'] = '1';
+                                },
+                                ...proxy,
+                            });
+                            app.addHook('onRequest', (req, res, next) => {
+                                middleware(req.raw, res.raw, next);
+                            });
+                        });
+                    };
+                },
+                deps: {
+                    defaultProxies: {
+                        token: tokensServer.PROXY_CONFIG_TOKEN,
+                        optional: true,
+                    },
+                },
+                multi: true,
+            },
+        ],
+    })
+], exports.ServerProxyModule);

package/lib/modules/serverTiming.es.js

@@ -0,0 +1,30 @@
+import { declareModule, provide } from '@tramvai/core';
+import { COMMAND_LINE_EXECUTION_END_TOKEN } from '@tramvai/tokens-core-private';
+import { RESPONSE_MANAGER_TOKEN } from '@tramvai/tokens-common';
+
+const ServerTimingModule = declareModule({
+    name: 'ServerTiming',
+    providers: [
+        provide({
+            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(', ')}`);
+                }
+            },
+        }),
+    ],
+});
+
+export { ServerTimingModule };

package/lib/modules/serverTiming.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@tramvai/core');
+var tokensCorePrivate = require('@tramvai/tokens-core-private');
+var tokensCommon = require('@tramvai/tokens-common');
+
+const ServerTimingModule = core.declareModule({
+    name: 'ServerTiming',
+    providers: [
+        core.provide({
+            provide: tokensCorePrivate.COMMAND_LINE_EXECUTION_END_TOKEN,
+            multi: true,
+            useValue: (di, type, status, timingInfo) => {
+                var _a;
+                if (type === 'server' && status === 'customer') {
+                    const responseManager = di.get(tokensCommon.RESPONSE_MANAGER_TOKEN);
+                    const initialHeader = (_a = responseManager.getHeader('Server-Timing')) !== null && _a !== void 0 ? _a : '';
+                    const entries = [];
+                    // index for custom sort
+                    let index = 0;
+                    for (const line in timingInfo) {
+                        const info = timingInfo[line];
+                        entries.push(`line_${index++}_${line};dur=${info.end - info.start}`);
+                    }
+                    responseManager.setHeader('Server-Timing', `${initialHeader ? `${initialHeader}, ` : ''}${entries.join(', ')}`);
+                }
+            },
+        }),
+    ],
+});
+
+exports.ServerTimingModule = ServerTimingModule;

package/lib/modules/statics.es.js

@@ -0,0 +1,48 @@
+import { __decorate } from 'tslib';
+import { resolve } from 'path';
+import FastifyStatic from '@fastify/static';
+import { Module, provide } from '@tramvai/core';
+import { SERVER_MODULE_STATICS_OPTIONS } from '@tramvai/tokens-server';
+import { WEB_FASTIFY_APP_BEFORE_INIT_TOKEN } from '@tramvai/tokens-server-private';
+
+const ONE_YEAR = 365 * 24 * 60 * 60;
+let ServerStaticsModule = class ServerStaticsModule {
+};
+ServerStaticsModule = __decorate([
+    Module({
+        providers: [
+            provide({
+                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);
+
+export { ServerStaticsModule };

package/lib/modules/statics.js

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var path = require('path');
+var FastifyStatic = require('@fastify/static');
+var core = require('@tramvai/core');
+var tokensServer = require('@tramvai/tokens-server');
+var tokensServerPrivate = require('@tramvai/tokens-server-private');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var FastifyStatic__default = /*#__PURE__*/_interopDefaultLegacy(FastifyStatic);
+
+const ONE_YEAR = 365 * 24 * 60 * 60;
+exports.ServerStaticsModule = class ServerStaticsModule {
+};
+exports.ServerStaticsModule = tslib.__decorate([
+    core.Module({
+        providers: [
+            core.provide({
+                provide: tokensServerPrivate.WEB_FASTIFY_APP_BEFORE_INIT_TOKEN,
+                useFactory: ({ options }) => {
+                    const path$1 = (options === null || options === void 0 ? void 0 : options.path) || 'public';
+                    return (instance) => {
+                        instance.register(FastifyStatic__default["default"], {
+                            decorateReply: false,
+                            // for backward compatibility, leaving default prefix.
+                            // without `wildcard: false` property, this middleware has conflicts with express compatibility plugin
+                            prefix: `/`,
+                            // prevent errors by use FastifyStatic only for all defined files in the served folder,
+                            // will not serve the newly added file on the filesystem - https://github.com/fastify/fastify-static#wildcard
+                            wildcard: false,
+                            root: path.resolve(process.cwd(), path$1),
+                            setHeaders: (res) => {
+                                const oneYearForward = new Date(Date.now() + ONE_YEAR * 1000);
+                                res.setHeader('cache-control', `public, max-age=${ONE_YEAR}`);
+                                res.setHeader('expires', oneYearForward.toUTCString());
+                            },
+                        });
+                    };
+                },
+                deps: {
+                    options: {
+                        token: tokensServer.SERVER_MODULE_STATICS_OPTIONS,
+                        optional: true,
+                    },
+                },
+                multi: true,
+            }),
+        ],
+    })
+], exports.ServerStaticsModule);

package/lib/modules/utilityServer.es.js

@@ -0,0 +1,99 @@
+import { __decorate } from 'tslib';
+import { UTILITY_SERVER_PORT_TOKEN, SERVER_TOKEN } from '@tramvai/tokens-server';
+import { UTILITY_SERVER_TOKEN, SERVER_FACTORY_TOKEN, UTILITY_WEB_FASTIFY_APP_TOKEN, WEB_FASTIFY_APP_TOKEN, WEB_FASTIFY_APP_FACTORY_TOKEN } from '@tramvai/tokens-server-private';
+import { ENV_USED_TOKEN, ENV_MANAGER_TOKEN, LOGGER_TOKEN } from '@tramvai/tokens-common';
+import { createToken, Module, provide, Scope, commandLineListTokens } from '@tramvai/core';
+
+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,
+                scope: Scope.SINGLETON,
+                useFactory: ({ envManager }) => {
+                    return +(envManager.get('UTILITY_SERVER_PORT') || envManager.get('PORT'));
+                },
+                deps: {
+                    envManager: ENV_MANAGER_TOKEN,
+                },
+            }),
+            provide({
+                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({
+                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);
+
+export { UtilityServerModule };

package/lib/modules/utilityServer.js

@@ -0,0 +1,101 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+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 IS_CUSTOM_SERVER_TOKEN = core.createToken('server utility isCustomServer');
+exports.UtilityServerModule = class UtilityServerModule {
+};
+exports.UtilityServerModule = tslib.__decorate([
+    core.Module({
+        providers: [
+            core.provide({
+                provide: tokensCommon.ENV_USED_TOKEN,
+                multi: true,
+                useValue: [{ key: 'UTILITY_SERVER_PORT', optional: true }],
+            }),
+            core.provide({
+                provide: tokensServer.UTILITY_SERVER_PORT_TOKEN,
+                scope: core.Scope.SINGLETON,
+                useFactory: ({ envManager }) => {
+                    return +(envManager.get('UTILITY_SERVER_PORT') || envManager.get('PORT'));
+                },
+                deps: {
+                    envManager: tokensCommon.ENV_MANAGER_TOKEN,
+                },
+            }),
+            core.provide({
+                provide: IS_CUSTOM_SERVER_TOKEN,
+                scope: core.Scope.SINGLETON,
+                useFactory: ({ port, envManager }) => {
+                    return +envManager.get('PORT') !== port;
+                },
+                deps: {
+                    envManager: tokensCommon.ENV_MANAGER_TOKEN,
+                    port: tokensServer.UTILITY_SERVER_PORT_TOKEN,
+                },
+            }),
+            core.provide({
+                provide: tokensServerPrivate.UTILITY_SERVER_TOKEN,
+                scope: core.Scope.SINGLETON,
+                useFactory: ({ isCustomServer, serverFactory, server }) => {
+                    return isCustomServer ? serverFactory() : server;
+                },
+                deps: {
+                    isCustomServer: IS_CUSTOM_SERVER_TOKEN,
+                    server: tokensServer.SERVER_TOKEN,
+                    serverFactory: tokensServerPrivate.SERVER_FACTORY_TOKEN,
+                },
+            }),
+            core.provide({
+                provide: tokensServerPrivate.UTILITY_WEB_FASTIFY_APP_TOKEN,
+                scope: core.Scope.SINGLETON,
+                useFactory: ({ isCustomServer, app, appFactory, server }) => {
+                    return isCustomServer ? appFactory({ server }) : app;
+                },
+                deps: {
+                    isCustomServer: IS_CUSTOM_SERVER_TOKEN,
+                    app: tokensServerPrivate.WEB_FASTIFY_APP_TOKEN,
+                    appFactory: tokensServerPrivate.WEB_FASTIFY_APP_FACTORY_TOKEN,
+                    server: tokensServerPrivate.UTILITY_SERVER_TOKEN,
+                },
+            }),
+            core.provide({
+                provide: core.commandLineListTokens.listen,
+                multi: true,
+                scope: core.Scope.SINGLETON,
+                useFactory: ({ logger, isCustomServer, port, app, server }) => {
+                    return async function utilityServerListen() {
+                        if (!isCustomServer) {
+                            return;
+                        }
+                        const log = logger('server:utility');
+                        await app.ready();
+                        return new Promise((resolve, reject) => {
+                            server.once('error', (error) => {
+                                log.error({ event: 'server-listen-port', error });
+                                reject(error);
+                            });
+                            server.listen(port, () => {
+                                log.warn({ event: 'server-listen-port', message: `Server listen ${port} port` });
+                                resolve();
+                            });
+                        });
+                    };
+                },
+                deps: {
+                    logger: tokensCommon.LOGGER_TOKEN,
+                    isCustomServer: IS_CUSTOM_SERVER_TOKEN,
+                    port: tokensServer.UTILITY_SERVER_PORT_TOKEN,
+                    app: tokensServerPrivate.UTILITY_WEB_FASTIFY_APP_TOKEN,
+                    server: tokensServerPrivate.UTILITY_SERVER_TOKEN,
+                },
+            }),
+        ],
+    })
+], exports.UtilityServerModule);

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

@@ -0,0 +1,11 @@
+const nodeRequire = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require;
+const safeNodeRequire = (path) => {
+    try {
+        return nodeRequire(path);
+    }
+    catch (e) {
+        return null;
+    }
+};
+
+export { nodeRequire, safeNodeRequire };

package/lib/modules/utils/require.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const nodeRequire = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require;
+const safeNodeRequire = (path) => {
+    try {
+        return nodeRequire(path);
+    }
+    catch (e) {
+        return null;
+    }
+};
+
+exports.nodeRequire = nodeRequire;
+exports.safeNodeRequire = safeNodeRequire;