@kapeta/local-cluster-service 0.16.8 → 0.18.0

package/dist/esm/src/providerManager.js

@@ -1,30 +1,38 @@
-import Path from 'path';
-import FSExtra from 'fs-extra';
-import { definitionsManager } from './definitionsManager';
-import { cacheManager } from './cacheManager';
-import request from 'request';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providerManager = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const definitionsManager_1 = require("./definitionsManager");
+const cacheManager_1 = require("./cacheManager");
+const request_1 = __importDefault(require("request"));
 const PROVIDER_FILE_BASE = 'https://providers.kapeta.com/files';
 class ProviderManager {
-    getWebProviders() {
-        return definitionsManager.getProviderDefinitions().filter((providerDefinition) => providerDefinition.hasWeb);
+    async getWebProviders() {
+        const providers = await definitionsManager_1.definitionsManager.getProviderDefinitions();
+        return providers.filter((providerDefinition) => providerDefinition.hasWeb);
     }
     async getProviderWebJS(handle, name, version, sourceMap = false) {
         const fullName = `${handle}/${name}`;
         const id = `${handle}/${name}/${version}/web.js${sourceMap ? '.map' : ''}`;
         const cacheKey = `provider:web:${id}`;
-        const file = cacheManager.get(cacheKey);
-        if (file && (await FSExtra.pathExists(file))) {
-            return FSExtra.readFile(file, 'utf8');
+        const file = cacheManager_1.cacheManager.get(cacheKey);
+        if (file && (await fs_extra_1.default.pathExists(file))) {
+            return fs_extra_1.default.readFile(file, 'utf8');
         }
-        const installedProvider = this.getWebProviders().find((providerDefinition) => {
+        const providers = await this.getWebProviders();
+        const installedProvider = providers.find((providerDefinition) => {
             return providerDefinition.definition.metadata.name === fullName && providerDefinition.version === version;
         });
         if (installedProvider) {
             //Check locally installed providers
-            const path = Path.join(installedProvider.path, 'web', handle, `${name}.js${sourceMap ? '.map' : ''}`);
-            if (await FSExtra.pathExists(path)) {
-                cacheManager.set(cacheKey, path, 24 * 60 * 60 * 1000);
-                return FSExtra.readFile(path);
+            const path = path_1.default.join(installedProvider.path, 'web', handle, `${name}.js${sourceMap ? '.map' : ''}`);
+            if (await fs_extra_1.default.pathExists(path)) {
+                cacheManager_1.cacheManager.set(cacheKey, path, 24 * 60 * 60 * 1000);
+                return fs_extra_1.default.readFile(path);
             }
         }
         if (version === 'local') {
@@ -33,7 +41,7 @@ class ProviderManager {
         const url = `${PROVIDER_FILE_BASE}/${id}`;
         return new Promise((resolve, reject) => {
             console.log('Loading provider from %s', url);
-            request.get(url, (error, response, body) => {
+            request_1.default.get(url, (error, response, body) => {
                 if (error) {
                     reject(error);
                     return;
@@ -51,16 +59,22 @@ class ProviderManager {
         });
     }
 }
-const providerDefinitions = definitionsManager.getProviderDefinitions();
-if (providerDefinitions.length > 0) {
-    console.log('## Loaded the following providers ##');
-    providerDefinitions.forEach((providerDefinition) => {
-        console.log(' - %s[%s:%s]', providerDefinition.definition.kind, providerDefinition.definition.metadata.name, providerDefinition.version);
-        console.log('   from %s', providerDefinition.path);
-    });
-    console.log('##');
-}
-else {
-    console.log('## No providers found ##');
-}
-export const providerManager = new ProviderManager();
+definitionsManager_1.definitionsManager
+    .getProviderDefinitions()
+    .then((providerDefinitions) => {
+    if (providerDefinitions.length > 0) {
+        console.log('## Loaded the following providers ##');
+        providerDefinitions.forEach((providerDefinition) => {
+            console.log(' - %s[%s:%s]', providerDefinition.definition.kind, providerDefinition.definition.metadata.name, providerDefinition.version);
+            console.log('   from %s', providerDefinition.path);
+        });
+        console.log('##');
+    }
+    else {
+        console.log('## No providers found ##');
+    }
+})
+    .catch((e) => {
+    console.error('Failed to load providers', e);
+});
+exports.providerManager = new ProviderManager();

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.d.ts

@@ -12,8 +12,8 @@ declare class RepositoryManager {
      */
     setSourceOfChangeFor(file: string, source: SourceOfChange): Promise<void>;
     clearSourceOfChangeFor(file: string): Promise<void>;
-    ensureDefaultProviders(): void;
-    private _install;
+    ensureDefaultProviders(): Promise<void>;
+    private scheduleInstallation;
     ensureAsset(handle: string, name: string, version: string, wait?: boolean): Promise<undefined | Task[]>;
 }
 export declare const repositoryManager: RepositoryManager;

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() {
@@ -47,32 +53,32 @@ class RepositoryManager {
     clearSourceOfChangeFor(file) {
         return this.watcher.clearSourceOfChangeFor(file);
     }
-    ensureDefaultProviders() {
-        socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_START, { providers: DEFAULT_PROVIDERS });
-        const tasks = this._install(DEFAULT_PROVIDERS);
+    async ensureDefaultProviders() {
+        socketManager_1.socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_START, { providers: DEFAULT_PROVIDERS });
+        const tasks = await this.scheduleInstallation(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) {
+    async scheduleInstallation(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 (await 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 (await 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,8 +107,7 @@ class RepositoryManager {
             //TODO: Get dependencies for local asset
             return;
         }
-        const definitions = definitionsManager.getDefinitions();
-        const installedAsset = definitions.find((d) => d.definition.metadata.name === fullName && d.version === version);
+        const installedAsset = await definitionsManager_1.definitionsManager.getDefinition(`${fullName}:${version}`);
         let assetVersion;
         try {
             assetVersion = await this._registryService.getVersion(fullName, version);
@@ -119,13 +124,13 @@ class RepositoryManager {
         }
         let tasks = undefined;
         if (!installedAsset) {
-            tasks = this._install([ref]);
+            tasks = await this.scheduleInstallation([ref]);
         }
         else {
             //Ensure dependencies are installed
             const refs = assetVersion.dependencies.map((dep) => dep.name);
             if (refs.length > 0) {
-                tasks = this._install(refs);
+                tasks = await this.scheduleInstallation(refs);
             }
         }
         if (tasks && wait) {
@@ -134,4 +139,4 @@ class RepositoryManager {
         return tasks;
     }
 }
-export const repositoryManager = new RepositoryManager();
+exports.repositoryManager = new RepositoryManager();