@kapeta/local-cluster-service 0.16.1 → 0.16.3

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.16.3](https://github.com/kapetacom/local-cluster-service/compare/v0.16.2...v0.16.3) (2023-08-14)
+
+
+### Bug Fixes
+
+* Add route for getting status for a single instance ([00159e2](https://github.com/kapetacom/local-cluster-service/commit/00159e255015b519d741c6528a6c9ed3a586dc25))
+
+## [0.16.2](https://github.com/kapetacom/local-cluster-service/compare/v0.16.1...v0.16.2) (2023-08-12)
+
+
+### Bug Fixes
+
+* Be smarter about caching ([086ffe4](https://github.com/kapetacom/local-cluster-service/commit/086ffe416a044a8d9dc5e33aa879960d3e3c2b1a))
+
 ## [0.16.1](https://github.com/kapetacom/local-cluster-service/compare/v0.16.0...v0.16.1) (2023-08-11)
 
 

package/dist/cjs/src/RepositoryWatcher.js

@@ -58,16 +58,26 @@ class RepositoryWatcher {
     }
     async setSourceOfChangeFor(file, source) {
         this.sourceOfChange.set(file, source);
-        const realPath = await fs_extra_1.default.realpath(file);
-        if (realPath !== file) {
-            this.sourceOfChange.set(realPath, source);
+        try {
+            const realPath = await fs_extra_1.default.realpath(file);
+            if (realPath !== file) {
+                this.sourceOfChange.set(realPath, source);
+            }
+        }
+        catch (e) {
+            // Ignore
         }
     }
     async clearSourceOfChangeFor(file) {
         this.sourceOfChange.delete(file);
-        const realPath = await fs_extra_1.default.realpath(file);
-        if (realPath !== file) {
-            this.sourceOfChange.delete(realPath);
+        try {
+            const realPath = await fs_extra_1.default.realpath(file);
+            if (realPath !== file) {
+                this.sourceOfChange.delete(realPath);
+            }
+        }
+        catch (e) {
+            // Ignore
         }
     }
     async unwatch() {

package/dist/cjs/src/assetManager.js

@@ -17,6 +17,7 @@ const utils_1 = require("./utils/utils");
 const taskManager_1 = require("./taskManager");
 const cacheManager_1 = require("./cacheManager");
 const CACHE_TTL = 60 * 60 * 1000; // 1 hour
+const toKey = (ref) => `assetManager:asset:${ref}`;
 function enrichAsset(asset) {
     return {
         ref: `kapeta://${asset.definition.metadata.name}:${asset.version}`,
@@ -73,7 +74,7 @@ class AssetManager {
     }
     async getAsset(ref, noCache = false, autoFetch = true) {
         ref = (0, utils_1.normalizeKapetaUri)(ref);
-        const cacheKey = `getAsset:${ref}`;
+        const cacheKey = toKey(ref);
         if (!noCache && cacheManager_1.cacheManager.has(cacheKey)) {
             return cacheManager_1.cacheManager.get(cacheKey);
         }
@@ -104,12 +105,19 @@ class AssetManager {
         await repositoryManager_1.repositoryManager.setSourceOfChangeFor(path, sourceOfChange);
         await fs_extra_1.default.writeFile(path, yaml_1.default.stringify(yaml));
         const asset = await this.importFile(path);
-        cacheManager_1.cacheManager.flush();
+        asset.forEach((a) => {
+            const ref = (0, utils_1.normalizeKapetaUri)(a.ref);
+            const key = toKey(ref);
+            cacheManager_1.cacheManager.set(key, a, CACHE_TTL);
+        });
+        definitionsManager_1.definitionsManager.clearCache();
+        console.log(`Created asset at: ${path}`);
         const ref = `kapeta://${yaml.metadata.name}:local`;
         this.maybeGenerateCode(ref, path, yaml);
         return asset;
     }
     async updateAsset(ref, yaml, sourceOfChange = 'filesystem') {
+        ref = (0, utils_1.normalizeKapetaUri)(ref);
         const asset = await this.getAsset(ref, true, false);
         if (!asset) {
             throw new Error('Attempted to update unknown asset: ' + ref);
@@ -122,8 +130,9 @@ class AssetManager {
         }
         await repositoryManager_1.repositoryManager.setSourceOfChangeFor(asset.ymlPath, sourceOfChange);
         await fs_extra_1.default.writeFile(asset.ymlPath, yaml_1.default.stringify(yaml));
-        console.log('Wrote to ' + asset.ymlPath);
-        cacheManager_1.cacheManager.flush();
+        console.log(`Updated asset at: ${asset.ymlPath}`);
+        cacheManager_1.cacheManager.remove(toKey(ref));
+        definitionsManager_1.definitionsManager.clearCache();
         this.maybeGenerateCode(asset.ref, asset.ymlPath, yaml);
     }
     async importFile(filePath) {
@@ -137,8 +146,12 @@ class AssetManager {
         const assetInfos = yaml_1.default.parseAllDocuments(content.toString()).map((doc) => doc.toJSON());
         await nodejs_registry_utils_1.Actions.link(new progressListener_1.ProgressListener(), node_path_1.default.dirname(filePath));
         const version = 'local';
-        const refs = assetInfos.map((assetInfo) => `kapeta://${assetInfo.metadata.name}:${version}`);
-        cacheManager_1.cacheManager.flush();
+        const refs = assetInfos.map((assetInfo) => (0, utils_1.normalizeKapetaUri)(`kapeta://${assetInfo.metadata.name}:${version}`));
+        refs.forEach((ref) => {
+            const key = toKey(ref);
+            cacheManager_1.cacheManager.remove(key);
+        });
+        definitionsManager_1.definitionsManager.clearCache();
         return this.getAssets().filter((a) => refs.some((ref) => compareRefs(ref, a.ref)));
     }
     async unregisterAsset(ref) {
@@ -146,7 +159,9 @@ class AssetManager {
         if (!asset) {
             throw new Error('Asset does not exists: ' + ref);
         }
-        cacheManager_1.cacheManager.flush();
+        const key = toKey(ref);
+        cacheManager_1.cacheManager.remove(key);
+        definitionsManager_1.definitionsManager.clearCache();
         await nodejs_registry_utils_1.Actions.uninstall(new progressListener_1.ProgressListener(), [asset.ref]);
     }
     async installAsset(ref) {
@@ -156,6 +171,9 @@ class AssetManager {
         }
         const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
         console.log('Installing %s', ref);
+        const key = toKey(ref);
+        cacheManager_1.cacheManager.remove(key);
+        definitionsManager_1.definitionsManager.clearCache();
         return await repositoryManager_1.repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, false);
     }
     maybeGenerateCode(ref, ymlPath, block) {

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

@@ -2,7 +2,7 @@ export interface CacheEntry<T = any> {
     expires: number;
     data: T;
 }
-declare class CacheManager {
+export declare class CacheManager {
     private cache;
     flush(): void;
     doCached<T>(key: string, getter: () => T, ttl?: number): T;
@@ -10,7 +10,7 @@ declare class CacheManager {
     set<T>(key: string, data: T, ttl?: number): void;
     has(key: string): boolean;
     remove(key: string): number;
+    removePrefix(key: string): void;
 }
 export declare const cacheManager: CacheManager;
 export declare const doCached: <T>(key: string, getter: () => T, ttl?: number) => T;
-export {};

package/dist/cjs/src/cacheManager.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.doCached = exports.cacheManager = void 0;
+exports.doCached = exports.cacheManager = exports.CacheManager = void 0;
 const node_cache_1 = __importDefault(require("node-cache"));
 const DEFAULT_CACHE_TTL = 60 * 1000; // 1 min
 class CacheManager {
@@ -32,7 +32,16 @@ class CacheManager {
     remove(key) {
         return this.cache.del(key);
     }
+    removePrefix(key) {
+        const keys = this.cache.keys();
+        for (const k of keys) {
+            if (k.startsWith(key)) {
+                this.remove(k);
+            }
+        }
+    }
 }
+exports.CacheManager = CacheManager;
 exports.cacheManager = new CacheManager();
 const doCached = (key, getter, ttl = DEFAULT_CACHE_TTL) => exports.cacheManager.doCached(key, getter, ttl);
 exports.doCached = doCached;

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

@@ -6,6 +6,7 @@ declare class DefinitionsManager {
     exists(ref: string): boolean;
     getProviderDefinitions(): DefinitionInfo[];
     getDefinition(ref: string): DefinitionInfo | undefined;
+    clearCache(): void;
 }
 export declare const definitionsManager: DefinitionsManager;
 export {};

package/dist/cjs/src/definitionsManager.js

@@ -18,7 +18,7 @@ class DefinitionsManager {
         return 'none';
     }
     getFullKey(kindFilter) {
-        return `DefinitionsManager:${this.getHash(kindFilter)}`;
+        return `definitionsManager:${this.getHash(kindFilter)}`;
     }
     getDefinitions(kindFilter) {
         const key = this.getFullKey(kindFilter);
@@ -39,5 +39,8 @@ class DefinitionsManager {
             return (0, nodejs_utils_1.parseKapetaUri)(`${d.definition.metadata.name}:${d.version}`).id === uri.id;
         });
     }
+    clearCache() {
+        cacheManager_1.cacheManager.removePrefix('definitionsManager:');
+    }
 }
 exports.definitionsManager = new DefinitionsManager();

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

@@ -26,6 +26,12 @@ router.get('/', (req, res) => {
 router.get('/:systemId/instances', (req, res) => {
     res.send(instanceManager_1.instanceManager.getInstancesForPlan(req.params.systemId));
 });
+/**
+ * Get single instance in a plan
+ */
+router.get('/:systemId/instances/:instanceId', (req, res) => {
+    res.send(instanceManager_1.instanceManager.getInstance(req.params.systemId, req.params.instanceId));
+});
 /**
  * Start all instances in a plan
  */

package/dist/esm/src/RepositoryWatcher.js

@@ -52,16 +52,26 @@ export class RepositoryWatcher {
     }
     async setSourceOfChangeFor(file, source) {
         this.sourceOfChange.set(file, source);
-        const realPath = await FS.realpath(file);
-        if (realPath !== file) {
-            this.sourceOfChange.set(realPath, source);
+        try {
+            const realPath = await FS.realpath(file);
+            if (realPath !== file) {
+                this.sourceOfChange.set(realPath, source);
+            }
+        }
+        catch (e) {
+            // Ignore
         }
     }
     async clearSourceOfChangeFor(file) {
         this.sourceOfChange.delete(file);
-        const realPath = await FS.realpath(file);
-        if (realPath !== file) {
-            this.sourceOfChange.delete(realPath);
+        try {
+            const realPath = await FS.realpath(file);
+            if (realPath !== file) {
+                this.sourceOfChange.delete(realPath);
+            }
+        }
+        catch (e) {
+            // Ignore
         }
     }
     async unwatch() {

package/dist/esm/src/assetManager.js

@@ -11,6 +11,7 @@ import { normalizeKapetaUri } from './utils/utils';
 import { taskManager } from './taskManager';
 import { cacheManager } from './cacheManager';
 const CACHE_TTL = 60 * 60 * 1000; // 1 hour
+const toKey = (ref) => `assetManager:asset:${ref}`;
 function enrichAsset(asset) {
     return {
         ref: `kapeta://${asset.definition.metadata.name}:${asset.version}`,
@@ -67,7 +68,7 @@ class AssetManager {
     }
     async getAsset(ref, noCache = false, autoFetch = true) {
         ref = normalizeKapetaUri(ref);
-        const cacheKey = `getAsset:${ref}`;
+        const cacheKey = toKey(ref);
         if (!noCache && cacheManager.has(cacheKey)) {
             return cacheManager.get(cacheKey);
         }
@@ -98,12 +99,19 @@ class AssetManager {
         await repositoryManager.setSourceOfChangeFor(path, sourceOfChange);
         await FS.writeFile(path, YAML.stringify(yaml));
         const asset = await this.importFile(path);
-        cacheManager.flush();
+        asset.forEach((a) => {
+            const ref = normalizeKapetaUri(a.ref);
+            const key = toKey(ref);
+            cacheManager.set(key, a, CACHE_TTL);
+        });
+        definitionsManager.clearCache();
+        console.log(`Created asset at: ${path}`);
         const ref = `kapeta://${yaml.metadata.name}:local`;
         this.maybeGenerateCode(ref, path, yaml);
         return asset;
     }
     async updateAsset(ref, yaml, sourceOfChange = 'filesystem') {
+        ref = normalizeKapetaUri(ref);
         const asset = await this.getAsset(ref, true, false);
         if (!asset) {
             throw new Error('Attempted to update unknown asset: ' + ref);
@@ -116,8 +124,9 @@ class AssetManager {
         }
         await repositoryManager.setSourceOfChangeFor(asset.ymlPath, sourceOfChange);
         await FS.writeFile(asset.ymlPath, YAML.stringify(yaml));
-        console.log('Wrote to ' + asset.ymlPath);
-        cacheManager.flush();
+        console.log(`Updated asset at: ${asset.ymlPath}`);
+        cacheManager.remove(toKey(ref));
+        definitionsManager.clearCache();
         this.maybeGenerateCode(asset.ref, asset.ymlPath, yaml);
     }
     async importFile(filePath) {
@@ -131,8 +140,12 @@ class AssetManager {
         const assetInfos = YAML.parseAllDocuments(content.toString()).map((doc) => doc.toJSON());
         await Actions.link(new ProgressListener(), Path.dirname(filePath));
         const version = 'local';
-        const refs = assetInfos.map((assetInfo) => `kapeta://${assetInfo.metadata.name}:${version}`);
-        cacheManager.flush();
+        const refs = assetInfos.map((assetInfo) => normalizeKapetaUri(`kapeta://${assetInfo.metadata.name}:${version}`));
+        refs.forEach((ref) => {
+            const key = toKey(ref);
+            cacheManager.remove(key);
+        });
+        definitionsManager.clearCache();
         return this.getAssets().filter((a) => refs.some((ref) => compareRefs(ref, a.ref)));
     }
     async unregisterAsset(ref) {
@@ -140,7 +153,9 @@ class AssetManager {
         if (!asset) {
             throw new Error('Asset does not exists: ' + ref);
         }
-        cacheManager.flush();
+        const key = toKey(ref);
+        cacheManager.remove(key);
+        definitionsManager.clearCache();
         await Actions.uninstall(new ProgressListener(), [asset.ref]);
     }
     async installAsset(ref) {
@@ -150,6 +165,9 @@ class AssetManager {
         }
         const uri = parseKapetaUri(ref);
         console.log('Installing %s', ref);
+        const key = toKey(ref);
+        cacheManager.remove(key);
+        definitionsManager.clearCache();
         return await repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, false);
     }
     maybeGenerateCode(ref, ymlPath, block) {

package/dist/esm/src/cacheManager.d.ts

@@ -2,7 +2,7 @@ export interface CacheEntry<T = any> {
     expires: number;
     data: T;
 }
-declare class CacheManager {
+export declare class CacheManager {
     private cache;
     flush(): void;
     doCached<T>(key: string, getter: () => T, ttl?: number): T;
@@ -10,7 +10,7 @@ declare class CacheManager {
     set<T>(key: string, data: T, ttl?: number): void;
     has(key: string): boolean;
     remove(key: string): number;
+    removePrefix(key: string): void;
 }
 export declare const cacheManager: CacheManager;
 export declare const doCached: <T>(key: string, getter: () => T, ttl?: number) => T;
-export {};

package/dist/esm/src/cacheManager.js

@@ -1,6 +1,6 @@
 import NodeCache from 'node-cache';
 const DEFAULT_CACHE_TTL = 60 * 1000; // 1 min
-class CacheManager {
+export class CacheManager {
     cache = new NodeCache();
     flush() {
         this.cache.flushAll();
@@ -26,6 +26,14 @@ class CacheManager {
     remove(key) {
         return this.cache.del(key);
     }
+    removePrefix(key) {
+        const keys = this.cache.keys();
+        for (const k of keys) {
+            if (k.startsWith(key)) {
+                this.remove(k);
+            }
+        }
+    }
 }
 export const cacheManager = new CacheManager();
 export const doCached = (key, getter, ttl = DEFAULT_CACHE_TTL) => cacheManager.doCached(key, getter, ttl);

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

@@ -6,6 +6,7 @@ declare class DefinitionsManager {
     exists(ref: string): boolean;
     getProviderDefinitions(): DefinitionInfo[];
     getDefinition(ref: string): DefinitionInfo | undefined;
+    clearCache(): void;
 }
 export declare const definitionsManager: DefinitionsManager;
 export {};

package/dist/esm/src/definitionsManager.js

@@ -1,6 +1,6 @@
 import ClusterConfiguration from '@kapeta/local-cluster-config';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
-import { doCached } from './cacheManager';
+import { cacheManager, doCached } from './cacheManager';
 class DefinitionsManager {
     getHash(kindFilter) {
         if (kindFilter) {
@@ -12,7 +12,7 @@ class DefinitionsManager {
         return 'none';
     }
     getFullKey(kindFilter) {
-        return `DefinitionsManager:${this.getHash(kindFilter)}`;
+        return `definitionsManager:${this.getHash(kindFilter)}`;
     }
     getDefinitions(kindFilter) {
         const key = this.getFullKey(kindFilter);
@@ -33,5 +33,8 @@ class DefinitionsManager {
             return parseKapetaUri(`${d.definition.metadata.name}:${d.version}`).id === uri.id;
         });
     }
+    clearCache() {
+        cacheManager.removePrefix('definitionsManager:');
+    }
 }
 export const definitionsManager = new DefinitionsManager();

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

@@ -21,6 +21,12 @@ router.get('/', (req, res) => {
 router.get('/:systemId/instances', (req, res) => {
     res.send(instanceManager.getInstancesForPlan(req.params.systemId));
 });
+/**
+ * Get single instance in a plan
+ */
+router.get('/:systemId/instances/:instanceId', (req, res) => {
+    res.send(instanceManager.getInstance(req.params.systemId, req.params.instanceId));
+});
 /**
  * Start all instances in a plan
  */

package/package.json

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

package/src/RepositoryWatcher.ts

@@ -6,8 +6,6 @@ import YAML from 'yaml';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import _ from 'lodash';
 import { socketManager } from './socketManager';
-import { definitionsManager } from './definitionsManager';
-import { assetManager } from './assetManager';
 import { SourceOfChange, WatchEventName } from './types';
 import { cacheManager } from './cacheManager';
 
@@ -64,17 +62,25 @@ export class RepositoryWatcher {
 
     async setSourceOfChangeFor(file: string, source: SourceOfChange) {
         this.sourceOfChange.set(file, source);
-        const realPath = await FS.realpath(file);
-        if (realPath !== file) {
-            this.sourceOfChange.set(realPath, source);
+        try {
+            const realPath = await FS.realpath(file);
+            if (realPath !== file) {
+                this.sourceOfChange.set(realPath, source);
+            }
+        } catch (e) {
+            // Ignore
         }
     }
 
     async clearSourceOfChangeFor(file: string) {
         this.sourceOfChange.delete(file);
-        const realPath = await FS.realpath(file);
-        if (realPath !== file) {
-            this.sourceOfChange.delete(realPath);
+        try {
+            const realPath = await FS.realpath(file);
+            if (realPath !== file) {
+                this.sourceOfChange.delete(realPath);
+            }
+        } catch (e) {
+            // Ignore
         }
     }
 

package/src/assetManager.ts

@@ -16,6 +16,8 @@ import { cacheManager } from './cacheManager';
 
 const CACHE_TTL = 60 * 60 * 1000; // 1 hour
 
+const toKey = (ref: string) => `assetManager:asset:${ref}`;
+
 export interface EnrichedAsset {
     ref: string;
     editable: boolean;
@@ -99,7 +101,7 @@ class AssetManager {
         autoFetch: boolean = true
     ): Promise<EnrichedAsset | undefined> {
         ref = normalizeKapetaUri(ref);
-        const cacheKey = `getAsset:${ref}`;
+        const cacheKey = toKey(ref);
         if (!noCache && cacheManager.has(cacheKey)) {
             return cacheManager.get(cacheKey);
         }
@@ -138,8 +140,14 @@ class AssetManager {
         await repositoryManager.setSourceOfChangeFor(path, sourceOfChange);
         await FS.writeFile(path, YAML.stringify(yaml));
         const asset = await this.importFile(path);
+        asset.forEach((a) => {
+            const ref = normalizeKapetaUri(a.ref);
+            const key = toKey(ref);
+            cacheManager.set(key, a, CACHE_TTL);
+        });
 
-        cacheManager.flush();
+        definitionsManager.clearCache();
+        console.log(`Created asset at: ${path}`);
 
         const ref = `kapeta://${yaml.metadata.name}:local`;
 
@@ -149,6 +157,7 @@ class AssetManager {
     }
 
     async updateAsset(ref: string, yaml: BlockDefinition, sourceOfChange: SourceOfChange = 'filesystem') {
+        ref = normalizeKapetaUri(ref);
         const asset = await this.getAsset(ref, true, false);
         if (!asset) {
             throw new Error('Attempted to update unknown asset: ' + ref);
@@ -164,9 +173,10 @@ class AssetManager {
 
         await repositoryManager.setSourceOfChangeFor(asset.ymlPath, sourceOfChange);
         await FS.writeFile(asset.ymlPath, YAML.stringify(yaml));
-        console.log('Wrote to ' + asset.ymlPath);
+        console.log(`Updated asset at: ${asset.ymlPath}`);
 
-        cacheManager.flush();
+        cacheManager.remove(toKey(ref));
+        definitionsManager.clearCache();
 
         this.maybeGenerateCode(asset.ref, asset.ymlPath, yaml);
     }
@@ -186,9 +196,15 @@ class AssetManager {
         await Actions.link(new ProgressListener(), Path.dirname(filePath));
 
         const version = 'local';
-        const refs = assetInfos.map((assetInfo) => `kapeta://${assetInfo.metadata.name}:${version}`);
+        const refs = assetInfos.map((assetInfo) =>
+            normalizeKapetaUri(`kapeta://${assetInfo.metadata.name}:${version}`)
+        );
+        refs.forEach((ref) => {
+            const key = toKey(ref);
+            cacheManager.remove(key);
+        });
 
-        cacheManager.flush();
+        definitionsManager.clearCache();
 
         return this.getAssets().filter((a) => refs.some((ref) => compareRefs(ref, a.ref)));
     }
@@ -199,7 +215,9 @@ class AssetManager {
             throw new Error('Asset does not exists: ' + ref);
         }
 
-        cacheManager.flush();
+        const key = toKey(ref);
+        cacheManager.remove(key);
+        definitionsManager.clearCache();
 
         await Actions.uninstall(new ProgressListener(), [asset.ref]);
     }
@@ -211,6 +229,9 @@ class AssetManager {
         }
         const uri = parseKapetaUri(ref);
         console.log('Installing %s', ref);
+        const key = toKey(ref);
+        cacheManager.remove(key);
+        definitionsManager.clearCache();
 
         return await repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, false);
     }

package/src/cacheManager.ts

@@ -5,7 +5,7 @@ export interface CacheEntry<T = any> {
     expires: number;
     data: T;
 }
-class CacheManager {
+export class CacheManager {
     private cache: NodeCache = new NodeCache();
 
     public flush() {
@@ -37,6 +37,15 @@ class CacheManager {
     public remove(key: string) {
         return this.cache.del(key);
     }
+
+    public removePrefix(key: string) {
+        const keys = this.cache.keys();
+        for (const k of keys) {
+            if (k.startsWith(key)) {
+                this.remove(k);
+            }
+        }
+    }
 }
 
 export const cacheManager = new CacheManager();

package/src/definitionsManager.ts

@@ -1,6 +1,6 @@
 import ClusterConfiguration, { DefinitionInfo } from '@kapeta/local-cluster-config';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
-import { doCached } from './cacheManager';
+import { cacheManager, doCached } from './cacheManager';
 
 class DefinitionsManager {
     private getHash(kindFilter?: string | string[]) {
@@ -14,7 +14,7 @@ class DefinitionsManager {
     }
 
     private getFullKey(kindFilter?: string | string[]) {
-        return `DefinitionsManager:${this.getHash(kindFilter)}`;
+        return `definitionsManager:${this.getHash(kindFilter)}`;
     }
 
     public getDefinitions(kindFilter?: string | string[]): DefinitionInfo[] {
@@ -40,6 +40,10 @@ class DefinitionsManager {
             return parseKapetaUri(`${d.definition.metadata.name}:${d.version}`).id === uri.id;
         });
     }
+
+    public clearCache() {
+        cacheManager.removePrefix('definitionsManager:');
+    }
 }
 
 export const definitionsManager = new DefinitionsManager();

package/src/instances/routes.ts

@@ -25,6 +25,13 @@ router.get('/:systemId/instances', (req: Request, res: Response) => {
     res.send(instanceManager.getInstancesForPlan(req.params.systemId));
 });
 
+/**
+ * Get single instance in a plan
+ */
+router.get('/:systemId/instances/:instanceId', (req: Request, res: Response) => {
+    res.send(instanceManager.getInstance(req.params.systemId, req.params.instanceId));
+});
+
 /**
  * Start all instances in a plan
  */