@kapeta/local-cluster-service 0.16.7 → 0.17.0

package/dist/esm/src/providers/routes.js

@@ -1,15 +1,20 @@
-import Router from 'express-promise-router';
-import { providerManager } from '../providerManager';
-import { corsHandler } from '../middleware/cors';
-const router = Router();
-router.use('/', corsHandler);
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const providerManager_1 = require("../providerManager");
+const cors_1 = require("../middleware/cors");
+const router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
 router.get('/', async (req, res) => {
-    const result = await providerManager.getWebProviders();
+    const result = await providerManager_1.providerManager.getWebProviders();
     res.send(result);
 });
 router.get('/asset/:handle/:name/:version/web.js', async (req, res) => {
     const { handle, name, version } = req.params;
-    let result = await providerManager.getProviderWebJS(handle, name, version);
+    let result = await providerManager_1.providerManager.getProviderWebJS(handle, name, version);
     if (!result) {
         res.status(404).send('');
     }
@@ -22,7 +27,7 @@ router.get('/asset/:handle/:name/:version/web.js', async (req, res) => {
 });
 router.get('/asset/:handle/:name/:version/web.js.map', async (req, res) => {
     const { handle, name, version } = req.params;
-    const result = await providerManager.getProviderWebJS(handle, name, version, true);
+    const result = await providerManager_1.providerManager.getProviderWebJS(handle, name, version, true);
     if (!result) {
         res.status(404).send('');
     }
@@ -34,4 +39,4 @@ router.get('/asset/:handle/:name/:version/web.js.map', async (req, res) => {
         res.send(result);
     }
 });
-export default router;
+exports.default = router;

package/dist/esm/src/proxy/routes.js

@@ -1,25 +1,30 @@
-import Router from 'express-promise-router';
-import { proxyRestRequest } from './types/rest';
-import { proxyWebRequest } from './types/web';
-import { stringBody } from '../middleware/stringBody';
-import { serviceManager } from '../serviceManager';
-import { clusterService } from '../clusterService';
-import { assetManager } from '../assetManager';
-import _ from 'lodash';
-const router = Router();
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const rest_1 = require("./types/rest");
+const web_1 = require("./types/web");
+const stringBody_1 = require("../middleware/stringBody");
+const serviceManager_1 = require("../serviceManager");
+const clusterService_1 = require("../clusterService");
+const assetManager_1 = require("../assetManager");
+const lodash_1 = __importDefault(require("lodash"));
+const router = (0, express_promise_router_1.default)();
 /**
  * @var {{[key:string]:ProxyRequestHandler}}
  */
 const TYPE_HANDLERS = {
-    rest: proxyRestRequest,
-    web: proxyWebRequest,
+    rest: rest_1.proxyRestRequest,
+    web: web_1.proxyWebRequest,
 };
 function getResource(resources, resourceName) {
     return resources.find((resource) => {
         return resource.metadata.name.toLowerCase() === resourceName.toLowerCase();
     });
 }
-router.use('/:systemId/:consumerInstanceId/:consumerResourceName', stringBody);
+router.use('/:systemId/:consumerInstanceId/:consumerResourceName', stringBody_1.stringBody);
 router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async (req, res) => {
     try {
         const typeHandler = TYPE_HANDLERS[req.params.type.toLowerCase()];
@@ -27,10 +32,10 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
             res.status(401).send({ error: 'Unknown connection type: ' + req.params.type });
             return;
         }
-        const plan = await assetManager.getPlan(req.params.systemId);
+        const plan = await assetManager_1.assetManager.getPlan(req.params.systemId);
         // We can find the connection by the consumer information alone since
         // only 1 provider can be connected to a consumer resource at a time
-        const connection = _.find(plan.spec.connections, (connection) => {
+        const connection = lodash_1.default.find(plan.spec.connections, (connection) => {
             return (connection.consumer.blockId.toLowerCase() === req.params.consumerInstanceId.toLowerCase() &&
                 connection.consumer.resourceName.toLowerCase() === req.params.consumerResourceName.toLowerCase());
         });
@@ -40,14 +45,14 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
             });
             return;
         }
-        const toBlockInstance = _.find(plan.spec.blocks, (blockInstance) => {
+        const toBlockInstance = lodash_1.default.find(plan.spec.blocks, (blockInstance) => {
             return blockInstance.id.toLowerCase() === connection.consumer.blockId.toLowerCase();
         });
         if (!toBlockInstance) {
             res.status(401).send({ error: `Block instance not found "${req.params.consumerInstanceId}` });
             return;
         }
-        const toBlockAsset = await assetManager.getAsset(toBlockInstance.block.ref);
+        const toBlockAsset = await assetManager_1.assetManager.getAsset(toBlockInstance.block.ref);
         if (!toBlockAsset) {
             res.status(401).send({ error: `Block asset not found "${toBlockInstance.block.ref}` });
             return;
@@ -59,15 +64,15 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
             });
             return;
         }
-        const basePath = clusterService.getProxyPath(req.params.systemId, req.params.consumerInstanceId, req.params.consumerResourceName, req.params.type);
-        const fromBlockInstance = _.find(plan.spec.blocks, (blockInstance) => {
+        const basePath = clusterService_1.clusterService.getProxyPath(req.params.systemId, req.params.consumerInstanceId, req.params.consumerResourceName, req.params.type);
+        const fromBlockInstance = lodash_1.default.find(plan.spec.blocks, (blockInstance) => {
             return blockInstance.id.toLowerCase() === connection.provider.blockId.toLowerCase();
         });
         if (!fromBlockInstance) {
             res.status(401).send({ error: `Block instance not found "${connection.provider.blockId}` });
             return;
         }
-        const fromBlockAsset = await assetManager.getAsset(fromBlockInstance.block.ref);
+        const fromBlockAsset = await assetManager_1.assetManager.getAsset(fromBlockInstance.block.ref);
         if (!fromBlockAsset) {
             res.status(401).send({ error: `Block asset not found "${fromBlockInstance.block.ref}` });
             return;
@@ -80,7 +85,7 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
             return;
         }
         //Get target address
-        let address = await serviceManager.getProviderAddress(req.params.systemId, connection.provider.blockId, req.params.type);
+        let address = await serviceManager_1.serviceManager.getProviderAddress(req.params.systemId, connection.provider.blockId, req.params.type);
         while (address.endsWith('/')) {
             address = address.substring(0, address.length - 1);
         }
@@ -103,4 +108,4 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
         res.status(400).send({ error: err.message });
     }
 });
-export default router;
+exports.default = router;

package/dist/esm/src/proxy/types/rest.js

@@ -1,20 +1,26 @@
-import _ from 'lodash';
-import request from 'request';
-import Path from 'path';
-import { pathTemplateParser } from '../../utils/pathTemplateParser';
-import { networkManager } from '../../networkManager';
-import { socketManager } from '../../socketManager';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyRestRequest = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const request_1 = __importDefault(require("request"));
+const path_1 = __importDefault(require("path"));
+const pathTemplateParser_1 = require("../../utils/pathTemplateParser");
+const networkManager_1 = require("../../networkManager");
+const socketManager_1 = require("../../socketManager");
 function getRestMethodId(restResource, httpMethod, httpPath) {
-    return _.findKey(restResource.spec.methods, (method) => {
+    return lodash_1.default.findKey(restResource.spec.methods, (method) => {
         let methodType = method.method ? method.method.toUpperCase() : 'GET';
         if (methodType.toUpperCase() !== httpMethod.toUpperCase()) {
             return false;
         }
         let path = method.path;
         if (restResource.spec.basePath) {
-            path = Path.join(restResource.spec.basePath, path);
+            path = path_1.default.join(restResource.spec.basePath, path);
         }
-        const pathTemplate = pathTemplateParser(path);
+        const pathTemplate = (0, pathTemplateParser_1.pathTemplateParser)(path);
         return pathTemplate.matches(httpPath);
     });
 }
@@ -29,18 +35,18 @@ function resolveMethods(req, opts) {
     if (!consumerMethodId) {
         throw new Error(`Consumer method not found for path "${req.method} ${opts.consumerPath}" in resource "${req.params.consumerInstanceId}::${req.params.consumerResourceName}`);
     }
-    const consumerMethod = _.cloneDeep(opts.consumerResource.spec.methods[consumerMethodId]);
+    const consumerMethod = lodash_1.default.cloneDeep(opts.consumerResource.spec.methods[consumerMethodId]);
     if (!consumerMethod) {
         throw new Error(`Consumer method not found for path "${req.method} ${opts.consumerPath}" in resource "${req.params.consumerInstanceId}::${req.params.consumerResourceName}`);
     }
     consumerMethod.id = consumerMethodId;
-    const providerMethodId = _.findKey(opts.connection.mapping, (mapping) => {
+    const providerMethodId = lodash_1.default.findKey(opts.connection.mapping, (mapping) => {
         return mapping.targetId === consumerMethodId;
     });
     if (!providerMethodId) {
         throw new Error(`Connection contained no mapping for consumer method "${consumerMethodId}`);
     }
-    const providerMethod = _.cloneDeep(opts.providerResource.spec.methods[providerMethodId]);
+    const providerMethod = lodash_1.default.cloneDeep(opts.providerResource.spec.methods[providerMethodId]);
     if (!providerMethod) {
         throw new Error(`Provider method not found "${providerMethodId}" in resource "${opts.connection.provider.blockId}::${opts.connection.provider.resourceName}`);
     }
@@ -50,10 +56,10 @@ function resolveMethods(req, opts) {
         providerMethod,
     };
 }
-export function proxyRestRequest(req, res, opts) {
+function proxyRestRequest(req, res, opts) {
     let { consumerMethod, providerMethod } = resolveMethods(req, opts);
-    const consumerPathTemplate = pathTemplateParser(consumerMethod.path);
-    const providerPathTemplate = pathTemplateParser(providerMethod.path);
+    const consumerPathTemplate = (0, pathTemplateParser_1.pathTemplateParser)(consumerMethod.path);
+    const providerPathTemplate = (0, pathTemplateParser_1.pathTemplateParser)(providerMethod.path);
     const pathVariables = consumerPathTemplate.parse(opts.consumerPath);
     if (!pathVariables) {
         res.status(400).send({
@@ -65,7 +71,7 @@ export function proxyRestRequest(req, res, opts) {
     if (!providerPath.startsWith('/')) {
         providerPath = '/' + providerPath;
     }
-    const requestHeaders = _.clone(req.headers);
+    const requestHeaders = lodash_1.default.clone(req.headers);
     delete requestHeaders['content-length'];
     delete requestHeaders['content-encoding'];
     delete requestHeaders['connection'];
@@ -78,16 +84,16 @@ export function proxyRestRequest(req, res, opts) {
         body: req.stringBody,
         headers: requestHeaders,
     };
-    const traffic = networkManager.addRequest(req.params.systemId, opts.connection, reqOpts, consumerMethod.id, providerMethod.id);
-    socketManager.emit(traffic.connectionId, 'traffic_start', traffic);
-    request(reqOpts, function (err, response, responseBody) {
+    const traffic = networkManager_1.networkManager.addRequest(req.params.systemId, opts.connection, reqOpts, consumerMethod.id, providerMethod.id);
+    socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_start', traffic);
+    (0, request_1.default)(reqOpts, function (err, response, responseBody) {
         if (err) {
             traffic.asError(err);
-            socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
+            socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
             res.status(500).send({ error: '' + err });
             return;
         }
-        const responseHeaders = _.clone(response.headers);
+        const responseHeaders = lodash_1.default.clone(response.headers);
         delete responseHeaders['content-length'];
         delete responseHeaders['content-encoding'];
         delete responseHeaders['connection'];
@@ -98,10 +104,11 @@ export function proxyRestRequest(req, res, opts) {
             headers: response.headers,
             body: responseBody,
         });
-        socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
+        socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
         if (responseBody) {
             res.write(responseBody);
         }
         res.end();
     });
 }
+exports.proxyRestRequest = proxyRestRequest;

package/dist/esm/src/proxy/types/web.js

@@ -1,9 +1,15 @@
-import request from 'request';
-import _ from 'lodash';
-import { networkManager } from '../../networkManager';
-import { socketManager } from '../../socketManager';
-export function proxyWebRequest(req, res, opts) {
-    const requestHeaders = _.clone(req.headers);
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyWebRequest = void 0;
+const request_1 = __importDefault(require("request"));
+const lodash_1 = __importDefault(require("lodash"));
+const networkManager_1 = require("../../networkManager");
+const socketManager_1 = require("../../socketManager");
+function proxyWebRequest(req, res, opts) {
+    const requestHeaders = lodash_1.default.clone(req.headers);
     delete requestHeaders['content-length'];
     delete requestHeaders['content-encoding'];
     delete requestHeaders['connection'];
@@ -22,12 +28,12 @@ export function proxyWebRequest(req, res, opts) {
         headers: requestHeaders,
         body: req.stringBody,
     };
-    const traffic = networkManager.addRequest(req.params.systemId, opts.connection, reqOpts);
-    socketManager.emit(traffic.connectionId, 'traffic_start', traffic);
-    const proxyReq = request(reqOpts);
+    const traffic = networkManager_1.networkManager.addRequest(req.params.systemId, opts.connection, reqOpts);
+    socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_start', traffic);
+    const proxyReq = (0, request_1.default)(reqOpts);
     proxyReq.on('error', function (err) {
         traffic.asError(err);
-        socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
+        socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
         if (!res.headersSent) {
             res.status(500).send({ error: '' + err });
         }
@@ -39,8 +45,9 @@ export function proxyWebRequest(req, res, opts) {
             headers: response.headers,
             body: null,
         });
-        socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
+        socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
     });
     //We need to pipe the proxy response to the client response to handle sockets and event streams
     proxyReq.pipe(res);
 }
+exports.proxyWebRequest = proxyWebRequest;

package/dist/esm/src/repositoryManager.js

@@ -1,12 +1,18 @@
-import os from 'node:os';
-import { socketManager } from './socketManager';
-import { Actions, Config, RegistryService } from '@kapeta/nodejs-registry-utils';
-import { definitionsManager } from './definitionsManager';
-import { taskManager } from './taskManager';
-import { normalizeKapetaUri } from './utils/utils';
-import { ProgressListener } from './progressListener';
-import { RepositoryWatcher } from './RepositoryWatcher';
-import { cacheManager } from './cacheManager';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repositoryManager = void 0;
+const node_os_1 = __importDefault(require("node:os"));
+const socketManager_1 = require("./socketManager");
+const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
+const definitionsManager_1 = require("./definitionsManager");
+const taskManager_1 = require("./taskManager");
+const utils_1 = require("./utils/utils");
+const progressListener_1 = require("./progressListener");
+const RepositoryWatcher_1 = require("./RepositoryWatcher");
+const cacheManager_1 = require("./cacheManager");
 const EVENT_DEFAULT_PROVIDERS_START = 'default-providers-start';
 const EVENT_DEFAULT_PROVIDERS_END = 'default-providers-end';
 const DEFAULT_PROVIDERS = [
@@ -27,8 +33,8 @@ class RepositoryManager {
     _registryService;
     watcher;
     constructor() {
-        this._registryService = new RegistryService(Config.data.registry.url);
-        this.watcher = new RepositoryWatcher();
+        this._registryService = new nodejs_registry_utils_1.RegistryService(nodejs_registry_utils_1.Config.data.registry.url);
+        this.watcher = new RepositoryWatcher_1.RepositoryWatcher();
         this.listenForChanges();
     }
     listenForChanges() {
@@ -48,31 +54,31 @@ class RepositoryManager {
         return this.watcher.clearSourceOfChangeFor(file);
     }
     ensureDefaultProviders() {
-        socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_START, { providers: DEFAULT_PROVIDERS });
+        socketManager_1.socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_START, { providers: DEFAULT_PROVIDERS });
         const tasks = this._install(DEFAULT_PROVIDERS);
         Promise.allSettled(tasks.map((t) => t.wait())).then(() => {
-            socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_END, {});
+            socketManager_1.socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_END, {});
         });
     }
     _install(refs) {
         //We make sure to only install one asset at a time - otherwise unexpected things might happen
         const createInstaller = (ref) => {
             return async () => {
-                if (definitionsManager.exists(ref)) {
+                if (definitionsManager_1.definitionsManager.exists(ref)) {
                     return;
                 }
                 //console.log(`Installing asset: ${ref}`);
                 //Auto-install missing asset
                 try {
                     //We change to a temp dir to avoid issues with the current working directory
-                    process.chdir(os.tmpdir());
-                    await Actions.install(new ProgressListener(), [ref], {});
+                    process.chdir(node_os_1.default.tmpdir());
+                    await nodejs_registry_utils_1.Actions.install(new progressListener_1.ProgressListener(), [ref], {});
                 }
                 catch (e) {
                     console.error(`Failed to install asset: ${ref}`, e);
                     throw e;
                 }
-                cacheManager.flush();
+                cacheManager_1.cacheManager.flush();
                 //console.log(`Asset installed: ${ref}`);
             };
         };
@@ -82,11 +88,11 @@ class RepositoryManager {
             if (!ref) {
                 continue;
             }
-            ref = normalizeKapetaUri(ref);
-            if (definitionsManager.exists(ref)) {
+            ref = (0, utils_1.normalizeKapetaUri)(ref);
+            if (definitionsManager_1.definitionsManager.exists(ref)) {
                 continue;
             }
-            const task = taskManager.add(`asset:install:${ref}`, createInstaller(ref), {
+            const task = taskManager_1.taskManager.add(`asset:install:${ref}`, createInstaller(ref), {
                 name: `Installing ${ref}`,
                 group: 'asset:install:', //Group prevents multiple tasks from running at the same time
             });
@@ -101,7 +107,7 @@ class RepositoryManager {
             //TODO: Get dependencies for local asset
             return;
         }
-        const definitions = definitionsManager.getDefinitions();
+        const definitions = definitionsManager_1.definitionsManager.getDefinitions();
         const installedAsset = definitions.find((d) => d.definition.metadata.name === fullName && d.version === version);
         let assetVersion;
         try {
@@ -134,4 +140,4 @@ class RepositoryManager {
         return tasks;
     }
 }
-export const repositoryManager = new RepositoryManager();
+exports.repositoryManager = new RepositoryManager();

package/dist/esm/src/serviceManager.js

@@ -1,19 +1,25 @@
-import _ from 'lodash';
-import { clusterService } from './clusterService';
-import { storageService } from './storageService';
-import { normalizeKapetaUri } from './utils/utils';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceManager = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const clusterService_1 = require("./clusterService");
+const storageService_1 = require("./storageService");
+const utils_1 = require("./utils/utils");
 const DEFAULT_PORT_TYPE = 'rest';
 class ServiceManager {
     _systems;
     constructor() {
-        this._systems = storageService.get('services');
+        this._systems = storageService_1.storageService.get('services');
         if (!this._systems) {
             this._systems = {};
         }
-        _.forEach(this._systems, (system) => {
-            _.forEach(system, (services) => {
-                _.forEach(services, (portInfo) => {
-                    clusterService.reservePort(portInfo.port);
+        lodash_1.default.forEach(this._systems, (system) => {
+            lodash_1.default.forEach(system, (services) => {
+                lodash_1.default.forEach(services, (portInfo) => {
+                    clusterService_1.clusterService.reservePort(portInfo.port);
                 });
             });
         });
@@ -28,7 +34,7 @@ class ServiceManager {
             host = 'host.docker.internal';
         }
         else {
-            host = clusterService.getClusterServiceHost();
+            host = clusterService_1.clusterService.getClusterServiceHost();
         }
         if (path.startsWith('/')) {
             path = path.substring(1);
@@ -36,7 +42,7 @@ class ServiceManager {
         return `http://${host}:${port}/${path}`;
     }
     _ensureSystem(systemId) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         if (!this._systems[systemId]) {
             this._systems[systemId] = {};
         }
@@ -50,13 +56,13 @@ class ServiceManager {
         return system[serviceId];
     }
     async ensureServicePort(systemId, blockInstanceId, portType = DEFAULT_PORT_TYPE) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         if (!portType) {
             portType = DEFAULT_PORT_TYPE;
         }
         const service = this._ensureService(systemId, blockInstanceId);
         if (!service[portType]) {
-            const port = await clusterService.getNextAvailablePort();
+            const port = await clusterService_1.clusterService.getNextAvailablePort();
             service[portType] = { port };
             this._save();
         }
@@ -64,7 +70,7 @@ class ServiceManager {
         return portTypeSection.port;
     }
     _save() {
-        storageService.put('services', this._systems);
+        storageService_1.storageService.put('services', this._systems);
     }
     /**
      * Gets the consumable address of a service block resource
@@ -73,9 +79,9 @@ class ServiceManager {
      *
      */
     getConsumerAddress(systemId, consumerInstanceId, consumerResourceName, portType, environmentType) {
-        systemId = normalizeKapetaUri(systemId);
-        const port = clusterService.getClusterServicePort();
-        const path = clusterService.getProxyPath(systemId, consumerInstanceId, consumerResourceName, portType);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
+        const port = clusterService_1.clusterService.getClusterServicePort();
+        const path = clusterService_1.clusterService.getProxyPath(systemId, consumerInstanceId, consumerResourceName, portType);
         return this._forLocal(port, path, environmentType);
     }
     /**
@@ -87,7 +93,7 @@ class ServiceManager {
      *
      */
     async getProviderAddress(systemId, providerInstanceId, portType) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         const port = await this.ensureServicePort(systemId, providerInstanceId, portType);
         return this._forLocal(port);
     }
@@ -95,4 +101,4 @@ class ServiceManager {
         return this._systems;
     }
 }
-export const serviceManager = new ServiceManager();
+exports.serviceManager = new ServiceManager();

package/dist/esm/src/socketManager.js

@@ -1,12 +1,18 @@
-import _ from 'lodash';
-import { normalizeKapetaUri } from './utils/utils';
-export const EVENT_STATUS_CHANGED = 'status-changed';
-export const EVENT_INSTANCE_CREATED = 'instance-created';
-export const EVENT_INSTANCE_EXITED = 'instance-exited';
-export const EVENT_INSTANCE_LOG = 'instance-log';
-export const EVENT_SYSTEM_LOG = 'system-log';
-export const EVENT_LOG = 'log';
-export class SocketManager {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.socketManager = exports.SocketManager = exports.EVENT_LOG = exports.EVENT_SYSTEM_LOG = exports.EVENT_INSTANCE_LOG = exports.EVENT_INSTANCE_EXITED = exports.EVENT_INSTANCE_CREATED = exports.EVENT_STATUS_CHANGED = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const utils_1 = require("./utils/utils");
+exports.EVENT_STATUS_CHANGED = 'status-changed';
+exports.EVENT_INSTANCE_CREATED = 'instance-created';
+exports.EVENT_INSTANCE_EXITED = 'instance-exited';
+exports.EVENT_INSTANCE_LOG = 'instance-log';
+exports.EVENT_SYSTEM_LOG = 'system-log';
+exports.EVENT_LOG = 'log';
+class SocketManager {
     _io;
     _sockets;
     constructor() {
@@ -28,33 +34,39 @@ export class SocketManager {
         return this._io;
     }
     emit(context, type, payload) {
+        if (!this._io) {
+            return;
+        }
         this.io.to(context).emit(type, { context, payload });
     }
     emitGlobal(type, payload) {
+        if (!this._io) {
+            return;
+        }
         this.io.emit(type, payload);
     }
     emitSystemEvent(systemId, type, payload) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         try {
-            socketManager.emit(`${systemId}/instances`, type, payload);
+            exports.socketManager.emit(`${systemId}/instances`, type, payload);
         }
         catch (e) {
             console.warn('Failed to emit instance event: %s', e.message);
         }
     }
     emitInstanceLog(systemId, instanceId, payload) {
-        this.emitInstanceEvent(systemId, instanceId, EVENT_INSTANCE_LOG, payload);
+        this.emitInstanceEvent(systemId, instanceId, exports.EVENT_INSTANCE_LOG, payload);
     }
     emitSystemLog(systemId, payload) {
-        this.emitSystemEvent(systemId, EVENT_SYSTEM_LOG, payload);
+        this.emitSystemEvent(systemId, exports.EVENT_SYSTEM_LOG, payload);
     }
     emitGlobalLog(payload) {
-        this.emitGlobal(EVENT_LOG, payload);
+        this.emitGlobal(exports.EVENT_LOG, payload);
     }
     emitInstanceEvent(systemId, instanceId, type, payload) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         try {
-            socketManager.emit(`${systemId}/instances/${instanceId}`, type, payload);
+            exports.socketManager.emit(`${systemId}/instances/${instanceId}`, type, payload);
         }
         catch (e) {
             console.warn('Failed to emit instance event: %s', e.message);
@@ -77,7 +89,8 @@ export class SocketManager {
         });
     }
     _handleSocketDestroyed(socket) {
-        _.pull(this._sockets, socket);
+        lodash_1.default.pull(this._sockets, socket);
     }
 }
-export const socketManager = new SocketManager();
+exports.SocketManager = SocketManager;
+exports.socketManager = new SocketManager();