@kapeta/local-cluster-service 0.16.0 → 0.16.1

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

@@ -1,5 +1,6 @@
 import { Definition } from '@kapeta/local-cluster-config';
 import { BlockDefinition } from '@kapeta/schemas';
+import { SourceOfChange } from './types';
 export interface EnrichedAsset {
     ref: string;
     editable: boolean;
@@ -11,9 +12,6 @@ export interface EnrichedAsset {
     ymlPath: string;
 }
 declare class AssetManager {
-    private cache;
-    constructor();
-    clearCache(): void;
     /**
      *
      * @param {string[]} [assetKinds]
@@ -23,12 +21,12 @@ declare class AssetManager {
     getPlans(): EnrichedAsset[];
     getPlan(ref: string, noCache?: boolean): Promise<Definition>;
     getAsset(ref: string, noCache?: boolean, autoFetch?: boolean): Promise<EnrichedAsset | undefined>;
-    createAsset(path: string, yaml: BlockDefinition): Promise<EnrichedAsset[]>;
-    updateAsset(ref: string, yaml: BlockDefinition): Promise<void>;
-    private maybeGenerateCode;
+    createAsset(path: string, yaml: BlockDefinition, sourceOfChange?: SourceOfChange): Promise<EnrichedAsset[]>;
+    updateAsset(ref: string, yaml: BlockDefinition, sourceOfChange?: SourceOfChange): Promise<void>;
     importFile(filePath: string): Promise<EnrichedAsset[]>;
     unregisterAsset(ref: string): Promise<void>;
     installAsset(ref: string): Promise<import("./taskManager").Task<void>[] | undefined>;
+    private maybeGenerateCode;
 }
 export declare const assetManager: AssetManager;
 export {};

package/dist/esm/src/assetManager.js

@@ -1,7 +1,6 @@
 import Path from 'node:path';
 import FS from 'fs-extra';
 import YAML from 'yaml';
-import NodeCache from 'node-cache';
 import { codeGeneratorManager } from './codeGeneratorManager';
 import { ProgressListener } from './progressListener';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
@@ -10,10 +9,8 @@ import { Actions } from '@kapeta/nodejs-registry-utils';
 import { definitionsManager } from './definitionsManager';
 import { normalizeKapetaUri } from './utils/utils';
 import { taskManager } from './taskManager';
-function clearAllCaches() {
-    definitionsManager.clearCache();
-    assetManager.clearCache();
-}
+import { cacheManager } from './cacheManager';
+const CACHE_TTL = 60 * 60 * 1000; // 1 hour
 function enrichAsset(asset) {
     return {
         ref: `kapeta://${asset.definition.metadata.name}:${asset.version}`,
@@ -39,15 +36,6 @@ function parseRef(ref) {
     return [out[0].toLowerCase(), out[1].toLowerCase()];
 }
 class AssetManager {
-    cache;
-    constructor() {
-        this.cache = new NodeCache({
-            stdTTL: 60 * 60, // 1 hour
-        });
-    }
-    clearCache() {
-        this.cache.flushAll();
-    }
     /**
      *
      * @param {string[]} [assetKinds]
@@ -80,8 +68,8 @@ class AssetManager {
     async getAsset(ref, noCache = false, autoFetch = true) {
         ref = normalizeKapetaUri(ref);
         const cacheKey = `getAsset:${ref}`;
-        if (!noCache && this.cache.has(cacheKey)) {
-            return this.cache.get(cacheKey);
+        if (!noCache && cacheManager.has(cacheKey)) {
+            return cacheManager.get(cacheKey);
         }
         const uri = parseKapetaUri(ref);
         if (autoFetch) {
@@ -95,11 +83,11 @@ class AssetManager {
             throw new Error('Asset not found: ' + ref);
         }
         if (asset) {
-            this.cache.set(cacheKey, asset);
+            cacheManager.set(cacheKey, asset, CACHE_TTL);
         }
         return asset;
     }
-    async createAsset(path, yaml) {
+    async createAsset(path, yaml, sourceOfChange = 'filesystem') {
         if (await FS.pathExists(path)) {
             throw new Error('File already exists: ' + path);
         }
@@ -107,14 +95,15 @@ class AssetManager {
         if (!(await FS.pathExists(dirName))) {
             await FS.mkdirp(dirName);
         }
+        await repositoryManager.setSourceOfChangeFor(path, sourceOfChange);
         await FS.writeFile(path, YAML.stringify(yaml));
         const asset = await this.importFile(path);
-        clearAllCaches();
+        cacheManager.flush();
         const ref = `kapeta://${yaml.metadata.name}:local`;
         this.maybeGenerateCode(ref, path, yaml);
         return asset;
     }
-    async updateAsset(ref, yaml) {
+    async updateAsset(ref, yaml, sourceOfChange = 'filesystem') {
         const asset = await this.getAsset(ref, true, false);
         if (!asset) {
             throw new Error('Attempted to update unknown asset: ' + ref);
@@ -125,36 +114,11 @@ class AssetManager {
         if (!asset.ymlPath) {
             throw new Error('Attempted to update corrupted asset: ' + ref);
         }
-        const path = asset.ymlPath;
-        try {
-            await repositoryManager.ignoreChangesFor(path);
-            await FS.writeFile(asset.ymlPath, YAML.stringify(yaml));
-            console.log('Wrote to ' + asset.ymlPath);
-            clearAllCaches();
-            this.maybeGenerateCode(asset.ref, asset.ymlPath, yaml);
-        }
-        finally {
-            //We need to wait a bit for the disk to settle before we can resume watching
-            setTimeout(async () => {
-                try {
-                    await repositoryManager.resumeChangedFor(path);
-                }
-                catch (e) { }
-            }, 500);
-        }
-    }
-    maybeGenerateCode(ref, ymlPath, block) {
-        ref = normalizeKapetaUri(ref);
-        if (codeGeneratorManager.canGenerateCode(block)) {
-            const assetTitle = block.metadata.title ? block.metadata.title : parseKapetaUri(block.metadata.name).name;
-            taskManager.add(`codegen:${ref}`, async () => {
-                await codeGeneratorManager.generate(ymlPath, block);
-            }, {
-                name: `Generating code for ${assetTitle}`,
-            });
-            return true;
-        }
-        return false;
+        await repositoryManager.setSourceOfChangeFor(asset.ymlPath, sourceOfChange);
+        await FS.writeFile(asset.ymlPath, YAML.stringify(yaml));
+        console.log('Wrote to ' + asset.ymlPath);
+        cacheManager.flush();
+        this.maybeGenerateCode(asset.ref, asset.ymlPath, yaml);
     }
     async importFile(filePath) {
         if (filePath.startsWith('file://')) {
@@ -168,7 +132,7 @@ class AssetManager {
         await Actions.link(new ProgressListener(), Path.dirname(filePath));
         const version = 'local';
         const refs = assetInfos.map((assetInfo) => `kapeta://${assetInfo.metadata.name}:${version}`);
-        clearAllCaches();
+        cacheManager.flush();
         return this.getAssets().filter((a) => refs.some((ref) => compareRefs(ref, a.ref)));
     }
     async unregisterAsset(ref) {
@@ -176,7 +140,7 @@ class AssetManager {
         if (!asset) {
             throw new Error('Asset does not exists: ' + ref);
         }
-        clearAllCaches();
+        cacheManager.flush();
         await Actions.uninstall(new ProgressListener(), [asset.ref]);
     }
     async installAsset(ref) {
@@ -188,5 +152,18 @@ class AssetManager {
         console.log('Installing %s', ref);
         return await repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, false);
     }
+    maybeGenerateCode(ref, ymlPath, block) {
+        ref = normalizeKapetaUri(ref);
+        if (codeGeneratorManager.canGenerateCode(block)) {
+            const assetTitle = block.metadata.title ? block.metadata.title : parseKapetaUri(block.metadata.name).name;
+            taskManager.add(`codegen:${ref}`, async () => {
+                await codeGeneratorManager.generate(ymlPath, block);
+            }, {
+                name: `Generating code for ${assetTitle}`,
+            });
+            return true;
+        }
+        return false;
+    }
 }
 export const assetManager = new AssetManager();

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

@@ -58,7 +58,7 @@ router.post('/create', async (req, res) => {
     }
     const content = parseBody(req);
     try {
-        const assets = await assetManager.createAsset(req.query.path, content);
+        const assets = await assetManager.createAsset(req.query.path, content, 'user');
         res.status(200).send(assets);
     }
     catch (err) {
@@ -76,7 +76,7 @@ router.put('/update', async (req, res) => {
     }
     const content = parseBody(req);
     try {
-        await assetManager.updateAsset(req.query.ref, content);
+        await assetManager.updateAsset(req.query.ref, content, 'user');
         res.sendStatus(204);
     }
     catch (err) {

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

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

package/dist/esm/src/cacheManager.js

@@ -0,0 +1,31 @@
+import NodeCache from 'node-cache';
+const DEFAULT_CACHE_TTL = 60 * 1000; // 1 min
+class CacheManager {
+    cache = new NodeCache();
+    flush() {
+        this.cache.flushAll();
+    }
+    doCached(key, getter, ttl = DEFAULT_CACHE_TTL) {
+        const data = this.cache.get(key);
+        if (data !== undefined) {
+            return data;
+        }
+        const result = getter();
+        this.cache.set(key, result, ttl);
+        return result;
+    }
+    get(key) {
+        return this.cache.get(key);
+    }
+    set(key, data, ttl = DEFAULT_CACHE_TTL) {
+        this.cache.set(key, data, ttl);
+    }
+    has(key) {
+        return this.cache.has(key);
+    }
+    remove(key) {
+        return this.cache.del(key);
+    }
+}
+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

@@ -1,9 +1,7 @@
 import { DefinitionInfo } from '@kapeta/local-cluster-config';
 declare class DefinitionsManager {
-    private cache;
-    private getKey;
-    clearCache(): void;
-    private doCached;
+    private getHash;
+    private getFullKey;
     getDefinitions(kindFilter?: string | string[]): DefinitionInfo[];
     exists(ref: string): boolean;
     getProviderDefinitions(): DefinitionInfo[];

package/dist/esm/src/definitionsManager.js

@@ -1,9 +1,8 @@
 import ClusterConfiguration from '@kapeta/local-cluster-config';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
-const CACHE_TTL = 60 * 1000; // 1 min
+import { doCached } from './cacheManager';
 class DefinitionsManager {
-    cache = {};
-    getKey(kindFilter) {
+    getHash(kindFilter) {
         if (kindFilter) {
             if (Array.isArray(kindFilter)) {
                 return kindFilter.join(',');
@@ -12,31 +11,18 @@ class DefinitionsManager {
         }
         return 'none';
     }
-    clearCache() {
-        this.cache = {};
-    }
-    doCached(key, getter) {
-        if (this.cache[key]) {
-            if (this.cache[key].expires > Date.now()) {
-                return this.cache[key].definitions;
-            }
-            delete this.cache[key];
-        }
-        this.cache[key] = {
-            expires: Date.now() + CACHE_TTL,
-            definitions: getter(),
-        };
-        return this.cache[key].definitions;
+    getFullKey(kindFilter) {
+        return `DefinitionsManager:${this.getHash(kindFilter)}`;
     }
     getDefinitions(kindFilter) {
-        const key = this.getKey(kindFilter);
-        return this.doCached(key, () => ClusterConfiguration.getDefinitions(kindFilter));
+        const key = this.getFullKey(kindFilter);
+        return doCached(key, () => ClusterConfiguration.getDefinitions(kindFilter));
     }
     exists(ref) {
         return !!this.getDefinition(ref);
     }
     getProviderDefinitions() {
-        return this.doCached('providers', () => ClusterConfiguration.getProviderDefinitions());
+        return doCached('providers', () => ClusterConfiguration.getProviderDefinitions());
     }
     getDefinition(ref) {
         const uri = parseKapetaUri(ref);

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

@@ -1,4 +1,5 @@
 import { Task } from './taskManager';
+import { SourceOfChange } from './types';
 declare class RepositoryManager {
     private _registryService;
     private _cache;
@@ -6,8 +7,12 @@ declare class RepositoryManager {
     constructor();
     listenForChanges(): void;
     stopListening(): Promise<void>;
-    ignoreChangesFor(file: string): Promise<void>;
-    resumeChangedFor(file: string): Promise<void>;
+    /**
+     * Setting the source of change helps us know
+     * how to react to changes in the UI.
+     */
+    setSourceOfChangeFor(file: string, source: SourceOfChange): Promise<void>;
+    clearSourceOfChangeFor(file: string): Promise<void>;
     ensureDefaultProviders(): void;
     private _install;
     ensureAsset(handle: string, name: string, version: string, wait?: boolean): Promise<undefined | Task[]>;

package/dist/esm/src/repositoryManager.js

@@ -6,11 +6,7 @@ import { taskManager } from './taskManager';
 import { normalizeKapetaUri } from './utils/utils';
 import { ProgressListener } from './progressListener';
 import { RepositoryWatcher } from './RepositoryWatcher';
-import { assetManager } from './assetManager';
-function clearAllCaches() {
-    definitionsManager.clearCache();
-    assetManager.clearCache();
-}
+import { cacheManager } from './cacheManager';
 const EVENT_DEFAULT_PROVIDERS_START = 'default-providers-start';
 const EVENT_DEFAULT_PROVIDERS_END = 'default-providers-end';
 const DEFAULT_PROVIDERS = [
@@ -44,11 +40,15 @@ class RepositoryManager {
     async stopListening() {
         return this.watcher.unwatch();
     }
-    ignoreChangesFor(file) {
-        return this.watcher.ignoreChangesFor(file);
+    /**
+     * Setting the source of change helps us know
+     * how to react to changes in the UI.
+     */
+    setSourceOfChangeFor(file, source) {
+        return this.watcher.setSourceOfChangeFor(file, source);
     }
-    resumeChangedFor(file) {
-        return this.watcher.resumeChangedFor(file);
+    clearSourceOfChangeFor(file) {
+        return this.watcher.clearSourceOfChangeFor(file);
     }
     ensureDefaultProviders() {
         socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_START, { providers: DEFAULT_PROVIDERS });
@@ -79,7 +79,7 @@ class RepositoryManager {
                     console.error(`Failed to install asset: ${ref}`, e);
                     throw e;
                 }
-                clearAllCaches();
+                cacheManager.flush();
                 //console.log(`Asset installed: ${ref}`);
             };
         };

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

@@ -8,6 +8,8 @@ export type StringMap = {
 export type AnyMap = {
     [key: string]: any;
 };
+export type SourceOfChange = 'user' | 'filesystem';
+export type WatchEventName = 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir';
 export type LogLevel = 'ERROR' | 'WARN' | 'INFO' | 'DEBUG' | 'TRACE' | 'FATAL';
 export type LogSource = 'stdout' | 'stderr';
 export type EnvironmentType = 'docker' | 'process';

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

@@ -21,7 +21,7 @@ export function readYML(path) {
         return YAML.parse(rawYaml.toString());
     }
     catch (err) {
-        throw new Error('Failed to parse plan YAML: ' + err);
+        throw new Error(`Failed to parse plan YAML: ${err}`);
     }
 }
 export function isWindows() {

package/package.json

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

package/src/RepositoryWatcher.ts

@@ -8,13 +8,9 @@ import _ from 'lodash';
 import { socketManager } from './socketManager';
 import { definitionsManager } from './definitionsManager';
 import { assetManager } from './assetManager';
+import { SourceOfChange, WatchEventName } from './types';
+import { cacheManager } from './cacheManager';
 
-function clearAllCaches() {
-    definitionsManager.clearCache();
-    assetManager.clearCache();
-}
-
-type WatchEventName = 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir';
 interface AssetIdentity {
     handle: string;
     name: string;
@@ -27,7 +23,7 @@ export class RepositoryWatcher {
     private readonly baseDir: string;
     private allDefinitions: DefinitionInfo[] = [];
     private symbolicLinks: { [link: string]: string } = {};
-    private ignoredFiles: Set<string> = new Set<string>();
+    private sourceOfChange: Map<string, SourceOfChange> = new Map();
     constructor() {
         this.baseDir = ClusterConfiguration.getRepositoryBasedir();
     }
@@ -66,19 +62,19 @@ export class RepositoryWatcher {
         }
     }
 
-    async ignoreChangesFor(file: string) {
-        this.ignoredFiles.add(file);
+    async setSourceOfChangeFor(file: string, source: SourceOfChange) {
+        this.sourceOfChange.set(file, source);
         const realPath = await FS.realpath(file);
         if (realPath !== file) {
-            this.ignoredFiles.add(realPath);
+            this.sourceOfChange.set(realPath, source);
         }
     }
 
-    async resumeChangedFor(file: string) {
-        this.ignoredFiles.delete(file);
+    async clearSourceOfChangeFor(file: string) {
+        this.sourceOfChange.delete(file);
         const realPath = await FS.realpath(file);
         if (realPath !== file) {
-            this.ignoredFiles.delete(realPath);
+            this.sourceOfChange.delete(realPath);
         }
     }
 
@@ -139,10 +135,6 @@ export class RepositoryWatcher {
             return;
         }
 
-        if (this.ignoredFiles.has(path)) {
-            return;
-        }
-
         //console.log('File changed', eventName, path);
 
         const assetIdentity = await this.getAssetIdentity(path);
@@ -172,10 +164,14 @@ export class RepositoryWatcher {
             }
         }
 
-        await this.checkForChange(assetIdentity);
+        const sourceOfChange = this.sourceOfChange.get(path) ?? 'filesystem';
+        await this.checkForChange(assetIdentity, sourceOfChange);
+
+        // We consume the sourceOfChange when the file is changed
+        this.sourceOfChange.delete(path);
     }
 
-    private async checkForChange(assetIdentity: AssetIdentity) {
+    private async checkForChange(assetIdentity: AssetIdentity, sourceOfChange: SourceOfChange) {
         const ymlPath = Path.join(
             this.baseDir,
             assetIdentity.handle,
@@ -219,13 +215,15 @@ export class RepositoryWatcher {
             type,
             definition: newDefinition?.definition ?? currentDefinition?.definition,
             asset: assetIdentity,
+            sourceOfChange,
         };
 
         this.allDefinitions = newDefinitions;
 
         //console.log('Asset changed', payload);
         socketManager.emitGlobal('asset-change', payload);
-        clearAllCaches();
+
+        cacheManager.flush();
     }
 
     private async exists(path: string): Promise<boolean> {