@kapeta/local-cluster-service 0.17.0 → 0.18.0

package/dist/esm/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/esm/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/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

@@ -53,18 +53,18 @@ class RepositoryManager {
     clearSourceOfChangeFor(file) {
         return this.watcher.clearSourceOfChangeFor(file);
     }
-    ensureDefaultProviders() {
+    async ensureDefaultProviders() {
         socketManager_1.socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_START, { providers: DEFAULT_PROVIDERS });
-        const tasks = this._install(DEFAULT_PROVIDERS);
+        const tasks = await this.scheduleInstallation(DEFAULT_PROVIDERS);
         Promise.allSettled(tasks.map((t) => t.wait())).then(() => {
             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_1.definitionsManager.exists(ref)) {
+                if (await definitionsManager_1.definitionsManager.exists(ref)) {
                     return;
                 }
                 //console.log(`Installing asset: ${ref}`);
@@ -89,7 +89,7 @@ class RepositoryManager {
                 continue;
             }
             ref = (0, utils_1.normalizeKapetaUri)(ref);
-            if (definitionsManager_1.definitionsManager.exists(ref)) {
+            if (await definitionsManager_1.definitionsManager.exists(ref)) {
                 continue;
             }
             const task = taskManager_1.taskManager.add(`asset:install:${ref}`, createInstaller(ref), {
@@ -107,8 +107,7 @@ class RepositoryManager {
             //TODO: Get dependencies for local asset
             return;
         }
-        const definitions = definitionsManager_1.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);
@@ -125,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) {

package/dist/esm/src/utils/BlockInstanceRunner.js

@@ -27,8 +27,9 @@ const DOCKER_ENV_VARS = [
     `KAPETA_LOCAL_CLUSTER_HOST=host.docker.internal`,
     `KAPETA_ENVIRONMENT_TYPE=docker`,
 ];
-function getProvider(uri) {
-    return definitionsManager_1.definitionsManager.getProviderDefinitions().find((provider) => {
+async function getProvider(uri) {
+    const providers = await definitionsManager_1.definitionsManager.getProviderDefinitions();
+    return providers.find((provider) => {
         const ref = `${provider.definition.metadata.name}:${provider.version}`;
         return (0, nodejs_utils_1.parseKapetaUri)(ref).id === uri.id;
     });
@@ -76,15 +77,12 @@ class BlockInstanceRunner {
         if (!blockUri.version) {
             blockUri.version = 'local';
         }
-        const assetVersion = definitionsManager_1.definitionsManager.getDefinitions().find((definitions) => {
-            const ref = `${definitions.definition.metadata.name}:${definitions.version}`;
-            return (0, nodejs_utils_1.parseKapetaUri)(ref).id === blockUri.id;
-        });
+        const assetVersion = await definitionsManager_1.definitionsManager.getDefinition(blockUri.id);
         if (!assetVersion) {
             throw new Error(`Block definition not found: ${blockUri.id}`);
         }
         const kindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.kind);
-        const providerVersion = getProvider(kindUri);
+        const providerVersion = await getProvider(kindUri);
         if (!providerVersion) {
             throw new Error(`Kind not found: ${kindUri.id}`);
         }
@@ -120,7 +118,7 @@ class BlockInstanceRunner {
             throw new Error('Missing target kind in block definition');
         }
         const kindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.spec?.target?.kind);
-        const targetVersion = getProvider(kindUri);
+        const targetVersion = await getProvider(kindUri);
         if (!targetVersion) {
             throw new Error(`Target not found: ${kindUri.id}`);
         }

package/index.ts

@@ -23,6 +23,7 @@ import request from 'request';
 import { repositoryManager } from './src/repositoryManager';
 import { ensureCLI } from './src/utils/commandLineUtils';
 import { defaultProviderInstaller } from './src/utils/DefaultProviderInstaller';
+import { authManager } from './src/authManager';
 
 export type LocalClusterService = HTTP.Server & { host?: string; port?: number };
 
@@ -147,6 +148,7 @@ export default {
         }
 
         await clusterService.init();
+        await authManager.listenForChanges();
 
         currentServer = createServer();
 
@@ -177,7 +179,7 @@ export default {
 
             const bindHost = getBindHost(host);
 
-            currentServer.listen(port, bindHost, () => {
+            currentServer.listen(port, bindHost, async () => {
                 try {
                     ensureCLI().catch((e: any) => console.error('Failed to install CLI.', e));
                 } catch (e: any) {
@@ -186,7 +188,7 @@ export default {
 
                 try {
                     // Start installation process for all default providers
-                    repositoryManager.ensureDefaultProviders();
+                    await repositoryManager.ensureDefaultProviders();
                 } catch (e: any) {
                     console.error('Failed to install default providers.', e);
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.17.0",
+    "version": "0.18.0",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {

package/src/assetManager.ts

@@ -64,9 +64,9 @@ class AssetManager {
      * @param {string[]} [assetKinds]
      * @returns {{path: *, ref: string, data: *, editable: boolean, kind: *, exists: boolean}[]}
      */
-    getAssets(assetKinds?: string[]): EnrichedAsset[] {
+    async getAssets(assetKinds?: string[]): Promise<EnrichedAsset[]> {
         if (!assetKinds) {
-            const blockTypeProviders = definitionsManager.getDefinitions([
+            const blockTypeProviders = await definitionsManager.getDefinitions([
                 'core/block-type',
                 'core/block-type-operator',
             ]);
@@ -76,12 +76,12 @@ class AssetManager {
             assetKinds.push('core/plan');
         }
 
-        const assets = definitionsManager.getDefinitions(assetKinds);
+        const assets = await definitionsManager.getDefinitions(assetKinds);
 
         return assets.map(enrichAsset);
     }
 
-    getPlans(): EnrichedAsset[] {
+    async getPlans(): Promise<EnrichedAsset[]> {
         return this.getAssets(['core/plan']);
     }
 
@@ -110,18 +110,18 @@ class AssetManager {
             await repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, true);
         }
 
-        let asset = definitionsManager
-            .getDefinitions()
-            .map(enrichAsset)
-            .find((a) => parseKapetaUri(a.ref).equals(uri));
-        if (autoFetch && !asset) {
+        const definitionInfo = await definitionsManager.getDefinition(ref);
+        if (autoFetch && !definitionInfo) {
             throw new Error('Asset not found: ' + ref);
         }
-        if (asset) {
+
+        if (definitionInfo) {
+            const asset = enrichAsset(definitionInfo);
             cacheManager.set(cacheKey, asset, CACHE_TTL);
+            return asset;
         }
 
-        return asset;
+        return undefined;
     }
 
     async createAsset(
@@ -151,7 +151,7 @@ class AssetManager {
 
         const ref = `kapeta://${yaml.metadata.name}:local`;
 
-        this.maybeGenerateCode(ref, path, yaml);
+        await this.maybeGenerateCode(ref, path, yaml);
 
         return asset;
     }
@@ -178,7 +178,7 @@ class AssetManager {
         cacheManager.remove(toKey(ref));
         definitionsManager.clearCache();
 
-        this.maybeGenerateCode(asset.ref, asset.ymlPath, yaml);
+        await this.maybeGenerateCode(asset.ref, asset.ymlPath, yaml);
     }
 
     async importFile(filePath: string) {
@@ -206,7 +206,9 @@ class AssetManager {
 
         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: string) {
@@ -236,9 +238,9 @@ class AssetManager {
         return await repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, false);
     }
 
-    private maybeGenerateCode(ref: string, ymlPath: string, block: BlockDefinition) {
+    private async maybeGenerateCode(ref: string, ymlPath: string, block: BlockDefinition) {
         ref = normalizeKapetaUri(ref);
-        if (codeGeneratorManager.canGenerateCode(block)) {
+        if (await codeGeneratorManager.canGenerateCode(block)) {
             const assetTitle = block.metadata.title ? block.metadata.title : parseKapetaUri(block.metadata.name).name;
             taskManager.add(
                 `codegen:${ref}`,

package/src/assets/routes.ts

@@ -31,8 +31,8 @@ router.use('/', stringBody);
 /**
  * Get all local assets available
  */
-router.get('/', (req: Request, res: Response) => {
-    res.send(assetManager.getAssets([]));
+router.get('/', async (req: Request, res: Response) => {
+    res.send(await assetManager.getAssets([]));
 });
 
 /**

package/src/authManager.ts

@@ -0,0 +1,62 @@
+import { EventEmitter } from 'node:events';
+import Path from 'node:path';
+import chokidar, { FSWatcher } from 'chokidar';
+import ClusterConfiguration from '@kapeta/local-cluster-config';
+import { WatchEventName } from './types';
+import { definitionsManager } from './definitionsManager';
+import { KapetaAPI } from '@kapeta/nodejs-api-client';
+import { socketManager } from './socketManager';
+
+class AuthManager extends EventEmitter {
+    private watcher?: FSWatcher;
+
+    private hadToken: boolean;
+
+    constructor() {
+        super();
+        this.hadToken = this.hasToken();
+    }
+
+    public listenForChanges() {
+        const parentDir = Path.dirname(ClusterConfiguration.getKapetaBasedir());
+        //We watch the parent dir to catch changes to the base dir itself
+        this.watcher = chokidar.watch(parentDir, {
+            followSymlinks: false,
+            ignorePermissionErrors: true,
+            disableGlobbing: true,
+            persistent: true,
+            ignoreInitial: true,
+            depth: 1,
+            ignored: (path) => {
+                return !path.startsWith(ClusterConfiguration.getKapetaBasedir());
+            },
+        });
+        this.watcher.add(ClusterConfiguration.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', ClusterConfiguration.getKapetaBasedir());
+        });
+    }
+
+    private hasToken() {
+        const api = new KapetaAPI();
+        return api.hasToken();
+    }
+
+    private async handleFileChange(eventName: WatchEventName, path: string) {
+        const hasTokenNow = this.hasToken();
+        if (this.hadToken !== hasTokenNow) {
+            socketManager.emitGlobal('auth-change', {});
+            if (hasTokenNow) {
+                // Clear the cache in case we need to rewrite the sample plan
+                definitionsManager.clearCache();
+            }
+            this.hadToken = hasTokenNow;
+        }
+    }
+}
+
+export const authManager = new AuthManager();

package/src/codeGeneratorManager.ts

@@ -10,7 +10,7 @@ const BLOCK_TYPE_KIND = 'core/block-type';
 class CodeGeneratorManager {
     async reload() {
         Targets.reset();
-        const languageTargets = definitionsManager.getDefinitions(TARGET_KIND);
+        const languageTargets = await definitionsManager.getDefinitions(TARGET_KIND);
         for (const languageTarget of languageTargets) {
             const key = `${languageTarget.definition.metadata.name}:${languageTarget.version}`;
             try {
@@ -26,13 +26,13 @@ class CodeGeneratorManager {
         }
     }
 
-    canGenerateCode(yamlContent: BlockDefinition): boolean {
+    async canGenerateCode(yamlContent: BlockDefinition): Promise<boolean> {
         if (!yamlContent.spec.target?.kind) {
             //Not all block types have targets
             return false;
         }
 
-        const blockTypes = definitionsManager.getDefinitions(BLOCK_TYPE_KIND);
+        const blockTypes = await definitionsManager.getDefinitions(BLOCK_TYPE_KIND);
         const blockTypeKinds = blockTypes.map(
             (blockType) => blockType.definition.metadata.name.toLowerCase() + ':' + blockType.version
         );

package/src/configManager.ts

@@ -80,7 +80,7 @@ class ConfigManager {
         if (systemId) {
             systemId = normalizeKapetaUri(systemId);
         }
-        const planAssets = assetManager.getPlans();
+        const planAssets = await assetManager.getPlans();
 
         const blockUri = parseKapetaUri(blockRef);
 
@@ -132,7 +132,7 @@ class ConfigManager {
     async verifyIdentity(blockRef: string, systemId: string, instanceId: string) {
         blockRef = normalizeKapetaUri(blockRef);
         systemId = normalizeKapetaUri(systemId);
-        const planAssets = assetManager.getPlans();
+        const planAssets = await assetManager.getPlans();
         const systemUri = systemId ? parseKapetaUri(systemId) : null;
         const blockUri = parseKapetaUri(blockRef);
         let found = false;

package/src/definitionsManager.ts

@@ -1,39 +1,154 @@
 import ClusterConfiguration, { DefinitionInfo } from '@kapeta/local-cluster-config';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import { cacheManager, doCached } from './cacheManager';
+import { KapetaAPI } from '@kapeta/nodejs-api-client';
+import { Plan } from '@kapeta/schemas';
+import FS from 'fs-extra';
+import { normalizeKapetaUri } from './utils/utils';
+import YAML from 'yaml';
+import { Actions } from '@kapeta/nodejs-registry-utils';
+import { ProgressListener } from './progressListener';
+import Path from 'path';
+
+export const SAMPLE_PLAN_NAME = 'kapeta/sample-nodejs-plan';
+
+function applyHandleChange(definition: DefinitionInfo, targetHandle: string) {
+    const originalUri = parseKapetaUri(definition.definition.metadata.name);
+    definition.definition.metadata.name = `${targetHandle}/${originalUri.name}`;
+    return definition;
+}
+
+function normalizeFilters(kindFilter?: string | string[]) {
+    let resolvedFilters: string[] = [];
+
+    if (kindFilter) {
+        if (Array.isArray(kindFilter)) {
+            resolvedFilters = [...kindFilter];
+        } else {
+            resolvedFilters = [kindFilter];
+        }
+    }
+
+    return resolvedFilters.map((k) => k.toLowerCase());
+}
 
 class DefinitionsManager {
-    private getHash(kindFilter?: string | string[]) {
-        if (kindFilter) {
-            if (Array.isArray(kindFilter)) {
-                return kindFilter.join(',');
+    private async resolveDefinitionsAndSamples() {
+        const definitions = ClusterConfiguration.getDefinitions();
+        const samplePlan = definitions.find(
+            (d) => d.version === 'local' && d.definition.metadata.name === 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 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 as Plan;
+
+        const blockRefs = new Set<string>();
+
+        planDef.spec.blocks.forEach((b) => {
+            const blockUri = parseKapetaUri(b.block.ref);
+            if (blockUri.version === 'local') {
+                blockRefs.add(blockUri.id);
+                b.block.ref = 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) => normalizeKapetaUri(d.definition.metadata.name + ':' + d.version) === normalizeKapetaUri(ref)
+                )
+            )
+            .filter((d) => d !== undefined)
+            .map((d) => applyHandleChange(d!, profile.handle));
+
+        // Persist the rewritten assets
+        const progressListener = new ProgressListener();
+        const rewrittenAssets = [samplePlan, ...rewrittenBlocks];
+        const originalRefs = [`${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.readlink(asset.path);
+            asset.ymlPath = Path.join(asset.path, Path.basename(asset.ymlPath));
+        }
+
+        // Uninstall the original assets
+        // This removes the symlinks
+        console.log('Uninstalling original assets', originalRefs);
+        try {
+            await 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.writeFile(asset.ymlPath, YAML.stringify(asset.definition));
+
+            console.log('Linking %s ', asset.path);
+            await Actions.link(progressListener, asset.path);
+        }
+
+        console.log('Rewrite done for sample plan');
+
+        // Return the rewritten definitions
+        return ClusterConfiguration.getDefinitions();
     }
 
-    private getFullKey(kindFilter?: string | string[]) {
-        return `definitionsManager:${this.getHash(kindFilter)}`;
+    private applyFilters(definitions: DefinitionInfo[], kindFilter: string[]): DefinitionInfo[] {
+        if (kindFilter.length === 0) {
+            return definitions;
+        }
+
+        return definitions.filter((d) => {
+            return kindFilter.includes(d.definition.kind.toLowerCase());
+        });
     }
 
-    public getDefinitions(kindFilter?: string | string[]): DefinitionInfo[] {
-        const key = this.getFullKey(kindFilter);
+    public async getDefinitions(kindFilter?: string | string[]): Promise<DefinitionInfo[]> {
+        kindFilter = normalizeFilters(kindFilter);
+
+        const definitions = await doCached<Promise<DefinitionInfo[]>>('definitionsManager:all', () =>
+            this.resolveDefinitionsAndSamples()
+        );
 
-        return doCached<DefinitionInfo[]>(key, () => ClusterConfiguration.getDefinitions(kindFilter));
+        return this.applyFilters(definitions, kindFilter);
     }
 
-    public exists(ref: string) {
-        return !!this.getDefinition(ref);
+    public async exists(ref: string) {
+        return !!(await this.getDefinition(ref));
     }
 
-    public getProviderDefinitions(): DefinitionInfo[] {
-        return doCached<DefinitionInfo[]>('providers', () => ClusterConfiguration.getProviderDefinitions());
+    public async getProviderDefinitions(): Promise<DefinitionInfo[]> {
+        return doCached<DefinitionInfo[]>('definitionsManager:providers', () =>
+            ClusterConfiguration.getProviderDefinitions()
+        );
     }
 
-    public getDefinition(ref: string) {
+    public async getDefinition(ref: string) {
         const uri = 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/src/instanceManager.ts

@@ -54,14 +54,14 @@ export class InstanceManager {
         return [...this._instances];
     }
 
-    public getInstancesForPlan(systemId: string) {
+    public async getInstancesForPlan(systemId: string) {
         if (!this._instances) {
             return [];
         }
 
         systemId = normalizeKapetaUri(systemId);
 
-        const planInfo = definitionsManager.getDefinition(systemId);
+        const planInfo = await definitionsManager.getDefinition(systemId);
 
         if (!planInfo) {
             return [];
@@ -458,9 +458,9 @@ export class InstanceManager {
 
             const blockSpec = blockAsset.data.spec as BlockDefinitionSpec;
             if (blockSpec.consumers) {
-                const promises = blockSpec.consumers.map((consumer) => {
+                const promises = blockSpec.consumers.map(async (consumer) => {
                     const consumerUri = parseKapetaUri(consumer.kind);
-                    const asset = definitionsManager.getDefinition(consumer.kind);
+                    const asset = await definitionsManager.getDefinition(consumer.kind);
                     if (!asset) {
                         // Definition not found
                         return Promise.resolve();

package/src/instances/routes.ts

@@ -21,8 +21,8 @@ router.get('/', (req: Request, res: Response) => {
 /**
  * Get all instances
  */
-router.get('/:systemId/instances', (req: Request, res: Response) => {
-    res.send(instanceManager.getInstancesForPlan(req.params.systemId));
+router.get('/:systemId/instances', async (req: Request, res: Response) => {
+    res.send(await instanceManager.getInstancesForPlan(req.params.systemId));
 });
 
 /**