@kapeta/local-cluster-service 0.17.0 → 0.18.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [0.18.0](https://github.com/kapetacom/local-cluster-service/compare/v0.17.0...v0.18.0) (2023-09-02)
+
+
+### Features
+
+* Auto-rename sample plan when available ([#66](https://github.com/kapetacom/local-cluster-service/issues/66)) ([d95b844](https://github.com/kapetacom/local-cluster-service/commit/d95b844baff7e5bfceb354c854526881051f2308))
+
 # [0.17.0](https://github.com/kapetacom/local-cluster-service/compare/v0.16.8...v0.17.0) (2023-09-02)
 
 

package/dist/cjs/index.js

@@ -27,6 +27,7 @@ const request_1 = __importDefault(require("request"));
 const repositoryManager_1 = require("./src/repositoryManager");
 const commandLineUtils_1 = require("./src/utils/commandLineUtils");
 const DefaultProviderInstaller_1 = require("./src/utils/DefaultProviderInstaller");
+const authManager_1 = require("./src/authManager");
 let currentServer = null;
 function createServer() {
     const app = (0, express_1.default)();
@@ -127,6 +128,7 @@ exports.default = {
             throw new Error(`Cluster service already running on: ${clusterHost}:${clusterPort}.`);
         }
         await clusterService_1.clusterService.init();
+        await authManager_1.authManager.listenForChanges();
         currentServer = createServer();
         const port = clusterService_1.clusterService.getClusterServicePort();
         const host = clusterService_1.clusterService.getClusterServiceHost();
@@ -149,7 +151,7 @@ exports.default = {
                 reject(err);
             });
             const bindHost = (0, utils_1.getBindHost)(host);
-            currentServer.listen(port, bindHost, () => {
+            currentServer.listen(port, bindHost, async () => {
                 try {
                     (0, commandLineUtils_1.ensureCLI)().catch((e) => console.error('Failed to install CLI.', e));
                 }
@@ -158,7 +160,7 @@ exports.default = {
                 }
                 try {
                     // Start installation process for all default providers
-                    repositoryManager_1.repositoryManager.ensureDefaultProviders();
+                    await repositoryManager_1.repositoryManager.ensureDefaultProviders();
                 }
                 catch (e) {
                     console.error('Failed to install default providers.', e);

package/dist/cjs/src/assetManager.d.ts

@@ -17,8 +17,8 @@ declare class AssetManager {
      * @param {string[]} [assetKinds]
      * @returns {{path: *, ref: string, data: *, editable: boolean, kind: *, exists: boolean}[]}
      */
-    getAssets(assetKinds?: string[]): EnrichedAsset[];
-    getPlans(): EnrichedAsset[];
+    getAssets(assetKinds?: string[]): Promise<EnrichedAsset[]>;
+    getPlans(): Promise<EnrichedAsset[]>;
     getPlan(ref: string, noCache?: boolean): Promise<Definition>;
     getAsset(ref: string, noCache?: boolean, autoFetch?: boolean): Promise<EnrichedAsset | undefined>;
     createAsset(path: string, yaml: BlockDefinition, sourceOfChange?: SourceOfChange): Promise<EnrichedAsset[]>;

package/dist/cjs/src/assetManager.js

@@ -48,9 +48,9 @@ class AssetManager {
      * @param {string[]} [assetKinds]
      * @returns {{path: *, ref: string, data: *, editable: boolean, kind: *, exists: boolean}[]}
      */
-    getAssets(assetKinds) {
+    async getAssets(assetKinds) {
         if (!assetKinds) {
-            const blockTypeProviders = definitionsManager_1.definitionsManager.getDefinitions([
+            const blockTypeProviders = await definitionsManager_1.definitionsManager.getDefinitions([
                 'core/block-type',
                 'core/block-type-operator',
             ]);
@@ -59,10 +59,10 @@ class AssetManager {
             });
             assetKinds.push('core/plan');
         }
-        const assets = definitionsManager_1.definitionsManager.getDefinitions(assetKinds);
+        const assets = await definitionsManager_1.definitionsManager.getDefinitions(assetKinds);
         return assets.map(enrichAsset);
     }
-    getPlans() {
+    async getPlans() {
         return this.getAssets(['core/plan']);
     }
     async getPlan(ref, noCache = false) {
@@ -82,17 +82,16 @@ class AssetManager {
         if (autoFetch) {
             await repositoryManager_1.repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, true);
         }
-        let asset = definitionsManager_1.definitionsManager
-            .getDefinitions()
-            .map(enrichAsset)
-            .find((a) => (0, nodejs_utils_1.parseKapetaUri)(a.ref).equals(uri));
-        if (autoFetch && !asset) {
+        const definitionInfo = await definitionsManager_1.definitionsManager.getDefinition(ref);
+        if (autoFetch && !definitionInfo) {
             throw new Error('Asset not found: ' + ref);
         }
-        if (asset) {
+        if (definitionInfo) {
+            const asset = enrichAsset(definitionInfo);
             cacheManager_1.cacheManager.set(cacheKey, asset, CACHE_TTL);
+            return asset;
         }
-        return asset;
+        return undefined;
     }
     async createAsset(path, yaml, sourceOfChange = 'filesystem') {
         if (await fs_extra_1.default.pathExists(path)) {
@@ -113,7 +112,7 @@ class AssetManager {
         definitionsManager_1.definitionsManager.clearCache();
         console.log(`Created asset at: ${path}`);
         const ref = `kapeta://${yaml.metadata.name}:local`;
-        this.maybeGenerateCode(ref, path, yaml);
+        await this.maybeGenerateCode(ref, path, yaml);
         return asset;
     }
     async updateAsset(ref, yaml, sourceOfChange = 'filesystem') {
@@ -133,7 +132,7 @@ class AssetManager {
         console.log(`Updated asset at: ${asset.ymlPath}`);
         cacheManager_1.cacheManager.remove(toKey(ref));
         definitionsManager_1.definitionsManager.clearCache();
-        this.maybeGenerateCode(asset.ref, asset.ymlPath, yaml);
+        await this.maybeGenerateCode(asset.ref, asset.ymlPath, yaml);
     }
     async importFile(filePath) {
         if (filePath.startsWith('file://')) {
@@ -152,7 +151,8 @@ class AssetManager {
             cacheManager_1.cacheManager.remove(key);
         });
         definitionsManager_1.definitionsManager.clearCache();
-        return this.getAssets().filter((a) => refs.some((ref) => compareRefs(ref, a.ref)));
+        const assets = await this.getAssets();
+        return assets.filter((a) => refs.some((ref) => compareRefs(ref, a.ref)));
     }
     async unregisterAsset(ref) {
         const asset = await this.getAsset(ref, true);
@@ -176,9 +176,9 @@ class AssetManager {
         definitionsManager_1.definitionsManager.clearCache();
         return await repositoryManager_1.repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, false);
     }
-    maybeGenerateCode(ref, ymlPath, block) {
+    async maybeGenerateCode(ref, ymlPath, block) {
         ref = (0, utils_1.normalizeKapetaUri)(ref);
-        if (codeGeneratorManager_1.codeGeneratorManager.canGenerateCode(block)) {
+        if (await codeGeneratorManager_1.codeGeneratorManager.canGenerateCode(block)) {
             const assetTitle = block.metadata.title ? block.metadata.title : (0, nodejs_utils_1.parseKapetaUri)(block.metadata.name).name;
             taskManager_1.taskManager.add(`codegen:${ref}`, async () => {
                 await codeGeneratorManager_1.codeGeneratorManager.generate(ymlPath, block);

package/dist/cjs/src/assets/routes.js

@@ -28,8 +28,8 @@ router.use('/', stringBody_1.stringBody);
 /**
  * Get all local assets available
  */
-router.get('/', (req, res) => {
-    res.send(assetManager_1.assetManager.getAssets([]));
+router.get('/', async (req, res) => {
+    res.send(await assetManager_1.assetManager.getAssets([]));
 });
 /**
  * Get single asset

package/dist/cjs/src/authManager.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { EventEmitter } from 'node:events';
+declare class AuthManager extends EventEmitter {
+    private watcher?;
+    private hadToken;
+    constructor();
+    listenForChanges(): void;
+    private hasToken;
+    private handleFileChange;
+}
+export declare const authManager: AuthManager;
+export {};

package/dist/cjs/src/authManager.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authManager = void 0;
+const node_events_1 = require("node:events");
+const node_path_1 = __importDefault(require("node:path"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const definitionsManager_1 = require("./definitionsManager");
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const socketManager_1 = require("./socketManager");
+class AuthManager extends node_events_1.EventEmitter {
+    watcher;
+    hadToken;
+    constructor() {
+        super();
+        this.hadToken = this.hasToken();
+    }
+    listenForChanges() {
+        const parentDir = node_path_1.default.dirname(local_cluster_config_1.default.getKapetaBasedir());
+        //We watch the parent dir to catch changes to the base dir itself
+        this.watcher = chokidar_1.default.watch(parentDir, {
+            followSymlinks: false,
+            ignorePermissionErrors: true,
+            disableGlobbing: true,
+            persistent: true,
+            ignoreInitial: true,
+            depth: 1,
+            ignored: (path) => {
+                return !path.startsWith(local_cluster_config_1.default.getKapetaBasedir());
+            },
+        });
+        this.watcher.add(local_cluster_config_1.default.getKapetaBasedir());
+        this.watcher.on('all', this.handleFileChange.bind(this));
+        this.watcher.on('error', (error) => {
+            console.log('Error watching repository', error);
+        });
+        this.watcher.on('ready', () => {
+            console.log('Watching for auth changes: %s', local_cluster_config_1.default.getKapetaBasedir());
+        });
+    }
+    hasToken() {
+        const api = new nodejs_api_client_1.KapetaAPI();
+        return api.hasToken();
+    }
+    async handleFileChange(eventName, path) {
+        const hasTokenNow = this.hasToken();
+        if (this.hadToken !== hasTokenNow) {
+            socketManager_1.socketManager.emitGlobal('auth-change', {});
+            if (hasTokenNow) {
+                // Clear the cache in case we need to rewrite the sample plan
+                definitionsManager_1.definitionsManager.clearCache();
+            }
+            this.hadToken = hasTokenNow;
+        }
+    }
+}
+exports.authManager = new AuthManager();

package/dist/cjs/src/codeGeneratorManager.d.ts

@@ -1,7 +1,7 @@
 import { BlockDefinition } from '@kapeta/schemas';
 declare class CodeGeneratorManager {
     reload(): Promise<void>;
-    canGenerateCode(yamlContent: BlockDefinition): boolean;
+    canGenerateCode(yamlContent: BlockDefinition): Promise<boolean>;
     generate(yamlFile: string, yamlContent: BlockDefinition): Promise<void>;
 }
 export declare const codeGeneratorManager: CodeGeneratorManager;

package/dist/cjs/src/codeGeneratorManager.js

@@ -12,7 +12,7 @@ const BLOCK_TYPE_KIND = 'core/block-type';
 class CodeGeneratorManager {
     async reload() {
         codegen_1.registry.reset();
-        const languageTargets = definitionsManager_1.definitionsManager.getDefinitions(TARGET_KIND);
+        const languageTargets = await definitionsManager_1.definitionsManager.getDefinitions(TARGET_KIND);
         for (const languageTarget of languageTargets) {
             const key = `${languageTarget.definition.metadata.name}:${languageTarget.version}`;
             try {
@@ -29,12 +29,12 @@ class CodeGeneratorManager {
             }
         }
     }
-    canGenerateCode(yamlContent) {
+    async canGenerateCode(yamlContent) {
         if (!yamlContent.spec.target?.kind) {
             //Not all block types have targets
             return false;
         }
-        const blockTypes = definitionsManager_1.definitionsManager.getDefinitions(BLOCK_TYPE_KIND);
+        const blockTypes = await definitionsManager_1.definitionsManager.getDefinitions(BLOCK_TYPE_KIND);
         const blockTypeKinds = blockTypes.map((blockType) => blockType.definition.metadata.name.toLowerCase() + ':' + blockType.version);
         return !!(yamlContent && yamlContent.kind && blockTypeKinds.indexOf(yamlContent.kind.toLowerCase()) > -1);
     }

package/dist/cjs/src/configManager.js

@@ -61,7 +61,7 @@ class ConfigManager {
         if (systemId) {
             systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         }
-        const planAssets = assetManager_1.assetManager.getPlans();
+        const planAssets = await assetManager_1.assetManager.getPlans();
         const blockUri = (0, nodejs_utils_1.parseKapetaUri)(blockRef);
         let matchingIdentities = [];
         planAssets.forEach((planAsset) => {
@@ -99,7 +99,7 @@ class ConfigManager {
     async verifyIdentity(blockRef, systemId, instanceId) {
         blockRef = (0, utils_1.normalizeKapetaUri)(blockRef);
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
-        const planAssets = assetManager_1.assetManager.getPlans();
+        const planAssets = await assetManager_1.assetManager.getPlans();
         const systemUri = systemId ? (0, nodejs_utils_1.parseKapetaUri)(systemId) : null;
         const blockUri = (0, nodejs_utils_1.parseKapetaUri)(blockRef);
         let found = false;

package/dist/cjs/src/definitionsManager.d.ts

@@ -1,11 +1,12 @@
 import { DefinitionInfo } from '@kapeta/local-cluster-config';
+export declare const SAMPLE_PLAN_NAME = "kapeta/sample-nodejs-plan";
 declare class DefinitionsManager {
-    private getHash;
-    private getFullKey;
-    getDefinitions(kindFilter?: string | string[]): DefinitionInfo[];
-    exists(ref: string): boolean;
-    getProviderDefinitions(): DefinitionInfo[];
-    getDefinition(ref: string): DefinitionInfo | undefined;
+    private resolveDefinitionsAndSamples;
+    private applyFilters;
+    getDefinitions(kindFilter?: string | string[]): Promise<DefinitionInfo[]>;
+    exists(ref: string): Promise<boolean>;
+    getProviderDefinitions(): Promise<DefinitionInfo[]>;
+    getDefinition(ref: string): Promise<DefinitionInfo | undefined>;
     clearCache(): void;
 }
 export declare const definitionsManager: DefinitionsManager;

package/dist/cjs/src/definitionsManager.js

@@ -3,36 +3,120 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.definitionsManager = void 0;
+exports.definitionsManager = exports.SAMPLE_PLAN_NAME = void 0;
 const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const cacheManager_1 = require("./cacheManager");
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const utils_1 = require("./utils/utils");
+const yaml_1 = __importDefault(require("yaml"));
+const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
+const progressListener_1 = require("./progressListener");
+const path_1 = __importDefault(require("path"));
+exports.SAMPLE_PLAN_NAME = 'kapeta/sample-nodejs-plan';
+function applyHandleChange(definition, targetHandle) {
+    const originalUri = (0, nodejs_utils_1.parseKapetaUri)(definition.definition.metadata.name);
+    definition.definition.metadata.name = `${targetHandle}/${originalUri.name}`;
+    return definition;
+}
+function normalizeFilters(kindFilter) {
+    let resolvedFilters = [];
+    if (kindFilter) {
+        if (Array.isArray(kindFilter)) {
+            resolvedFilters = [...kindFilter];
+        }
+        else {
+            resolvedFilters = [kindFilter];
+        }
+    }
+    return resolvedFilters.map((k) => k.toLowerCase());
+}
 class DefinitionsManager {
-    getHash(kindFilter) {
-        if (kindFilter) {
-            if (Array.isArray(kindFilter)) {
-                return kindFilter.join(',');
+    async resolveDefinitionsAndSamples() {
+        const definitions = local_cluster_config_1.default.getDefinitions();
+        const samplePlan = definitions.find((d) => d.version === 'local' && d.definition.metadata.name === exports.SAMPLE_PLAN_NAME);
+        if (!samplePlan) {
+            return definitions;
+        }
+        // We will only rewrite the sample plan once since we change the handle to be the users handle
+        const api = new nodejs_api_client_1.KapetaAPI();
+        if (!api.hasToken()) {
+            // Not logged in yet, so we can't rewrite the sample plan
+            return definitions;
+        }
+        const profile = await api.getCurrentIdentity();
+        if (!profile) {
+            // Not logged in yet, so we can't rewrite the sample plan
+            return definitions;
+        }
+        console.log('Rewriting sample plan to use handle %s', profile.handle);
+        applyHandleChange(samplePlan, profile.handle);
+        const planDef = samplePlan.definition;
+        const blockRefs = new Set();
+        planDef.spec.blocks.forEach((b) => {
+            const blockUri = (0, nodejs_utils_1.parseKapetaUri)(b.block.ref);
+            if (blockUri.version === 'local') {
+                blockRefs.add(blockUri.id);
+                b.block.ref = (0, utils_1.normalizeKapetaUri)(`${profile.handle}/${blockUri.name}:local`);
             }
-            return kindFilter;
+        });
+        // Rewrite all blocks that are referenced by the sample plan
+        const rewrittenBlocks = Array.from(blockRefs)
+            .map((ref) => definitions.find((d) => (0, utils_1.normalizeKapetaUri)(d.definition.metadata.name + ':' + d.version) === (0, utils_1.normalizeKapetaUri)(ref)))
+            .filter((d) => d !== undefined)
+            .map((d) => applyHandleChange(d, profile.handle));
+        // Persist the rewritten assets
+        const progressListener = new progressListener_1.ProgressListener();
+        const rewrittenAssets = [samplePlan, ...rewrittenBlocks];
+        const originalRefs = [`${exports.SAMPLE_PLAN_NAME}:local`, ...Array.from(blockRefs)];
+        // Store the original paths on the assets - we'll need them later
+        for (const asset of rewrittenAssets) {
+            asset.path = await fs_extra_1.default.readlink(asset.path);
+            asset.ymlPath = path_1.default.join(asset.path, path_1.default.basename(asset.ymlPath));
+        }
+        // Uninstall the original assets
+        // This removes the symlinks
+        console.log('Uninstalling original assets', originalRefs);
+        try {
+            await nodejs_registry_utils_1.Actions.uninstall(progressListener, originalRefs);
+        }
+        catch (err) {
+            console.warn('Failed to uninstall original assets', err);
         }
-        return 'none';
+        for (const asset of rewrittenAssets) {
+            console.log('Updating %s ', asset.ymlPath);
+            await fs_extra_1.default.writeFile(asset.ymlPath, yaml_1.default.stringify(asset.definition));
+            console.log('Linking %s ', asset.path);
+            await nodejs_registry_utils_1.Actions.link(progressListener, asset.path);
+        }
+        console.log('Rewrite done for sample plan');
+        // Return the rewritten definitions
+        return local_cluster_config_1.default.getDefinitions();
     }
-    getFullKey(kindFilter) {
-        return `definitionsManager:${this.getHash(kindFilter)}`;
+    applyFilters(definitions, kindFilter) {
+        if (kindFilter.length === 0) {
+            return definitions;
+        }
+        return definitions.filter((d) => {
+            return kindFilter.includes(d.definition.kind.toLowerCase());
+        });
     }
-    getDefinitions(kindFilter) {
-        const key = this.getFullKey(kindFilter);
-        return (0, cacheManager_1.doCached)(key, () => local_cluster_config_1.default.getDefinitions(kindFilter));
+    async getDefinitions(kindFilter) {
+        kindFilter = normalizeFilters(kindFilter);
+        const definitions = await (0, cacheManager_1.doCached)('definitionsManager:all', () => this.resolveDefinitionsAndSamples());
+        return this.applyFilters(definitions, kindFilter);
     }
-    exists(ref) {
-        return !!this.getDefinition(ref);
+    async exists(ref) {
+        return !!(await this.getDefinition(ref));
     }
-    getProviderDefinitions() {
-        return (0, cacheManager_1.doCached)('providers', () => local_cluster_config_1.default.getProviderDefinitions());
+    async getProviderDefinitions() {
+        return (0, cacheManager_1.doCached)('definitionsManager:providers', () => local_cluster_config_1.default.getProviderDefinitions());
     }
-    getDefinition(ref) {
+    async getDefinition(ref) {
         const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
-        return this.getDefinitions().find((d) => {
+        const definitions = await this.getDefinitions();
+        return definitions.find((d) => {
             if (!uri.version) {
                 return d.definition.metadata.name === uri.fullName;
             }

package/dist/cjs/src/instanceManager.d.ts

@@ -7,7 +7,7 @@ export declare class InstanceManager {
     constructor();
     private checkInstancesLater;
     getInstances(): InstanceInfo[];
-    getInstancesForPlan(systemId: string): InstanceInfo[];
+    getInstancesForPlan(systemId: string): Promise<InstanceInfo[]>;
     getInstance(systemId: string, instanceId: string): InstanceInfo | undefined;
     private exclusive;
     getLogs(systemId: string, instanceId: string): Promise<LogEntry[]>;

package/dist/cjs/src/instanceManager.js

@@ -47,12 +47,12 @@ class InstanceManager {
         }
         return [...this._instances];
     }
-    getInstancesForPlan(systemId) {
+    async getInstancesForPlan(systemId) {
         if (!this._instances) {
             return [];
         }
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
-        const planInfo = definitionsManager_1.definitionsManager.getDefinition(systemId);
+        const planInfo = await definitionsManager_1.definitionsManager.getDefinition(systemId);
         if (!planInfo) {
             return [];
         }
@@ -362,9 +362,9 @@ class InstanceManager {
             await this.saveInternalInstance(instance);
             const blockSpec = blockAsset.data.spec;
             if (blockSpec.consumers) {
-                const promises = blockSpec.consumers.map((consumer) => {
+                const promises = blockSpec.consumers.map(async (consumer) => {
                     const consumerUri = (0, nodejs_utils_1.parseKapetaUri)(consumer.kind);
-                    const asset = definitionsManager_1.definitionsManager.getDefinition(consumer.kind);
+                    const asset = await definitionsManager_1.definitionsManager.getDefinition(consumer.kind);
                     if (!asset) {
                         // Definition not found
                         return Promise.resolve();

package/dist/cjs/src/instances/routes.js

@@ -23,8 +23,8 @@ router.get('/', (req, res) => {
 /**
  * Get all instances
  */
-router.get('/:systemId/instances', (req, res) => {
-    res.send(instanceManager_1.instanceManager.getInstancesForPlan(req.params.systemId));
+router.get('/:systemId/instances', async (req, res) => {
+    res.send(await instanceManager_1.instanceManager.getInstancesForPlan(req.params.systemId));
 });
 /**
  * Get single instance in a plan

package/dist/cjs/src/operatorManager.d.ts

@@ -21,7 +21,7 @@ declare class OperatorManager {
      * @param {string} version
      * @return {Operator}
      */
-    getOperator(resourceType: string, version: string): Operator;
+    getOperator(resourceType: string, version: string): Promise<Operator>;
     /**
      * Get information about a specific consumed resource
      */

package/dist/cjs/src/operatorManager.js

@@ -17,6 +17,7 @@ const lodash_1 = __importDefault(require("lodash"));
 const async_lock_1 = __importDefault(require("async-lock"));
 const taskManager_1 = require("./taskManager");
 exports.KIND_OPERATOR = 'core/resource-type-operator';
+const KIND_PLAN = 'core/plan';
 class Operator {
     _data;
     constructor(data) {
@@ -49,8 +50,8 @@ class OperatorManager {
      * @param {string} version
      * @return {Operator}
      */
-    getOperator(resourceType, version) {
-        const operators = definitionsManager_1.definitionsManager.getDefinitions(exports.KIND_OPERATOR);
+    async getOperator(resourceType, version) {
+        const operators = await definitionsManager_1.definitionsManager.getDefinitions(exports.KIND_OPERATOR);
         const operator = operators.find((operator) => operator.definition &&
             operator.definition.metadata &&
             operator.definition.metadata.name &&
@@ -69,7 +70,7 @@ class OperatorManager {
      */
     async getConsumerResourceInfo(systemId, fromServiceId, resourceType, portType, name, environment) {
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
-        const plans = definitionsManager_1.definitionsManager.getDefinitions('core/plan');
+        const plans = await definitionsManager_1.definitionsManager.getDefinitions(KIND_PLAN);
         const planUri = (0, nodejs_utils_1.parseKapetaUri)(systemId);
         const currentPlan = plans.find((plan) => plan.definition.metadata.name === planUri.fullName && plan.version === planUri.version);
         if (!currentPlan) {
@@ -79,10 +80,7 @@ class OperatorManager {
         if (!currentInstance) {
             throw new Error(`Unknown instance: ${fromServiceId} in plan ${systemId}`);
         }
-        const blockUri = (0, nodejs_utils_1.parseKapetaUri)(currentInstance.block.ref);
-        const blockDefinition = definitionsManager_1.definitionsManager
-            .getDefinitions()
-            .find((definition) => definition.version === blockUri.version && definition.definition.metadata.name === blockUri.fullName);
+        const blockDefinition = await definitionsManager_1.definitionsManager.getDefinition(currentInstance.block.ref);
         if (!blockDefinition) {
             throw new Error(`Unknown block: ${currentInstance.block.ref} in plan ${systemId}`);
         }
@@ -91,7 +89,7 @@ class OperatorManager {
             throw new Error(`Unknown resource: ${name} in block ${currentInstance.block.ref} in plan ${systemId}`);
         }
         const kindUri = (0, nodejs_utils_1.parseKapetaUri)(blockResource.kind);
-        const operator = this.getOperator(resourceType, kindUri.version);
+        const operator = await this.getOperator(resourceType, kindUri.version);
         const credentials = operator.getCredentials();
         const container = await this.ensureResource(systemId, resourceType, kindUri.version);
         const portInfo = await container.getPort(portType);
@@ -122,7 +120,7 @@ class OperatorManager {
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         const key = `${systemId}#${resourceType}:${version}`;
         return await this.operatorLock.acquire(key, async () => {
-            const operator = this.getOperator(resourceType, version);
+            const operator = await this.getOperator(resourceType, version);
             const operatorData = operator.getLocalData();
             const portTypes = Object.keys(operatorData.ports);
             portTypes.sort();

package/dist/cjs/src/providerManager.d.ts

@@ -1,5 +1,6 @@
+import { DefinitionInfo } from '@kapeta/local-cluster-config';
 declare class ProviderManager {
-    getWebProviders(): import("@kapeta/local-cluster-config").DefinitionInfo[];
+    getWebProviders(): Promise<DefinitionInfo[]>;
     getProviderWebJS(handle: string, name: string, version: string, sourceMap?: boolean): Promise<unknown>;
 }
 export declare const providerManager: ProviderManager;

package/dist/cjs/src/providerManager.js

@@ -11,8 +11,9 @@ 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_1.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}`;
@@ -22,7 +23,8 @@ class ProviderManager {
         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) {
@@ -57,16 +59,22 @@ class ProviderManager {
         });
     }
 }
-const providerDefinitions = definitionsManager_1.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 ##');
-}
+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/cjs/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;