@kapeta/local-cluster-service 0.5.10 → 0.5.12

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.5.12](https://github.com/kapetacom/local-cluster-service/compare/v0.5.11...v0.5.12) (2023-06-21)
+
+
+### Bug Fixes
+
+* await asset deletion and only cache successful web requests ([663a4a7](https://github.com/kapetacom/local-cluster-service/commit/663a4a7987385f9a0550d6149a23b7a9de08b226))
+
+## [0.5.11](https://github.com/kapetacom/local-cluster-service/compare/v0.5.10...v0.5.11) (2023-06-20)
+
+
+### Bug Fixes
+
+* Improve path template parser. ([#36](https://github.com/kapetacom/local-cluster-service/issues/36)) ([b655da1](https://github.com/kapetacom/local-cluster-service/commit/b655da1e97740ff2b4fe0f2bcd7f75b04003753e))
+
 ## [0.5.10](https://github.com/kapetacom/local-cluster-service/compare/v0.5.9...v0.5.10) (2023-06-19)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kapeta/local-cluster-service",
-  "version": "0.5.10",
+  "version": "0.5.12",
   "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
   "main": "index.js",
   "repository": {

package/src/assets/routes.js

@@ -2,9 +2,8 @@ const Router = require('express-promise-router').default;
 const YAML = require('yaml');
 const assetManager = require('../assetManager');
 
-
 function parseBody(req) {
-    switch(req.headers['content-type']) {
+    switch (req.headers['content-type']) {
         case 'application/json':
         case 'application/x-json':
         case 'text/json':
@@ -36,16 +35,15 @@ router.get('/', (req, res) => {
  */
 router.get('/read', async (req, res) => {
     if (!req.query.ref) {
-        res.status(400).send({error:'Query parameter "ref" is missing'});
+        res.status(400).send({ error: 'Query parameter "ref" is missing' });
         return;
     }
 
     try {
         res.send(await assetManager.getAsset(req.query.ref, true));
-    } catch(err) {
-        res.status(400).send({error: err.message});
+    } catch (err) {
+        res.status(400).send({ error: err.message });
     }
-
 });
 
 /**
@@ -53,7 +51,7 @@ router.get('/read', async (req, res) => {
  */
 router.post('/create', async (req, res) => {
     if (!req.query.path) {
-        res.status(400).send({error:'Query parameter "path" is missing'});
+        res.status(400).send({ error: 'Query parameter "path" is missing' });
         return;
     }
 
@@ -63,11 +61,10 @@ router.post('/create', async (req, res) => {
         const assets = await assetManager.createAsset(req.query.path, content);
 
         res.status(200).send(assets);
-    } catch(err) {
+    } catch (err) {
         console.log('Failed while creating asset', req.query.path, err.message);
-        res.status(400).send({error: err.message});
+        res.status(400).send({ error: err.message });
     }
-
 });
 
 /**
@@ -75,7 +72,7 @@ router.post('/create', async (req, res) => {
  */
 router.put('/update', async (req, res) => {
     if (!req.query.ref) {
-        res.status(400).send({error:'Query parameter "ref" is missing'});
+        res.status(400).send({ error: 'Query parameter "ref" is missing' });
         return;
     }
 
@@ -85,39 +82,36 @@ router.put('/update', async (req, res) => {
         await assetManager.updateAsset(req.query.ref, content);
 
         res.sendStatus(204);
-    } catch(err) {
+    } catch (err) {
         console.log('Failed while updating asset', req.query.ref, err.message);
-        res.status(400).send({error: err.message});
+        res.status(400).send({ error: err.message });
     }
-
 });
 
-
 /**
  * Unregisters an asset (doesn't delete the asset)
  */
-router.delete('/', (req, res) => {
+router.delete('/', async (req, res) => {
     if (!req.query.ref) {
-        res.status(400).send({error:'Query parameter "ref" is missing'});
+        res.status(400).send({ error: 'Query parameter "ref" is missing' });
         return;
     }
 
     try {
-        assetManager.unregisterAsset(req.query.ref);
+        await assetManager.unregisterAsset(req.query.ref);
 
         res.status(204).send();
-    } catch(err) {
-        res.status(400).send({error: err.message});
+    } catch (err) {
+        res.status(400).send({ error: err.message });
     }
 });
 
-
 /**
  * Registers an existing file as an asset
  */
 router.put('/import', async (req, res) => {
     if (!req.query.ref) {
-        res.status(400).send({error:'Query parameter "ref" is missing'});
+        res.status(400).send({ error: 'Query parameter "ref" is missing' });
         return;
     }
 
@@ -125,9 +119,9 @@ router.put('/import', async (req, res) => {
         const assets = await assetManager.importFile(req.query.ref);
 
         res.status(200).send(assets);
-    } catch(err) {
-        res.status(400).send({error: err.message});
+    } catch (err) {
+        res.status(400).send({ error: err.message });
     }
 });
 
-module.exports = router;
+module.exports = router;

package/src/providerManager.js

@@ -1,40 +1,52 @@
 const FS = require('fs');
 const Path = require('path');
 const FSExtra = require('fs-extra');
-const repositoryManager = require('./repositoryManager')
+const repositoryManager = require('./repositoryManager');
 const ClusterConfiguration = require('@kapeta/local-cluster-config').default;
 
 class ProviderManager {
-
     constructor() {
         this._webAssetCache = {};
     }
 
     getWebProviders() {
-        return ClusterConfiguration
-            .getProviderDefinitions()
-            .filter((providerDefinition) => providerDefinition.hasWeb)
+        return ClusterConfiguration.getProviderDefinitions().filter(
+            (providerDefinition) => providerDefinition.hasWeb
+        );
     }
 
     async getAsset(handle, name, version, sourceMap = false) {
         const fullName = `${handle}/${name}`;
-        const id = `${handle}/${name}/${version}/web.js${sourceMap ? '.map' : ''}`;
-        
-        if (this._webAssetCache[id] &&
-            await FSExtra.pathExists(this._webAssetCache[id])) {
-            return FSExtra.readFile(this._webAssetCache[id]);
+        const id = `${handle}/${name}/${version}/web.js${
+            sourceMap ? '.map' : ''
+        }`;
+
+        if (
+            this._webAssetCache[id] &&
+            (await FSExtra.pathExists(this._webAssetCache[id]))
+        ) {
+            return FSExtra.readFile(this._webAssetCache[id], 'utf8');
         }
 
         await repositoryManager.ensureAsset(handle, name, version);
 
-        const installedProvider = this.getWebProviders().find((providerDefinition) => {
-            return providerDefinition.definition.metadata.name === fullName &&
-                providerDefinition.version === version;
-        })
+        const installedProvider = this.getWebProviders().find(
+            (providerDefinition) => {
+                return (
+                    providerDefinition.definition.metadata.name === fullName &&
+                    providerDefinition.version === version
+                );
+            }
+        );
 
         if (installedProvider) {
             //Check locally installed providers
-            const path = Path.join(installedProvider.path, 'web', handle, `${name}.js${sourceMap ? '.map' : ''}`);
+            const path = Path.join(
+                installedProvider.path,
+                'web',
+                handle,
+                `${name}.js${sourceMap ? '.map' : ''}`
+            );
             if (await FSExtra.pathExists(path)) {
                 this._webAssetCache[id] = path;
 
@@ -50,10 +62,15 @@ const providerDefinitions = ClusterConfiguration.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);
+    providerDefinitions.forEach((providerDefinition) => {
+        console.log(
+            ' - %s[%s:%s]',
+            providerDefinition.definition.kind,
+            providerDefinition.definition.metadata.name,
+            providerDefinition.version
+        );
         console.log('   from %s', providerDefinition.path);
-    })
+    });
 } else {
     console.log('## No providers found ##');
 }

package/src/providers/routes.js

@@ -12,37 +12,32 @@ router.get('/', async (req, res) => {
 });
 
 router.get('/asset/:handle/:name/:version/web.js', async (req, res) => {
-
-    const {handle, name, version} = req.params;
+    const { handle, name, version } = req.params;
     let result = await providerManager.getAsset(handle, name, version);
 
-    if (version !== 'local') {
-        res.setHeader('Cache-Control', 'max-age=31536000, immutable');
-    }
-
     if (!result) {
         res.status(404).send('');
     } else {
-        res.send(result.toString()
-            .replace(`${name}.js.map`, 'web.js.map')
-        );
+        if (version !== 'local') {
+            res.setHeader('Cache-Control', 'max-age=31536000, immutable');
+        }
+        res.send(result.toString().replace(`${name}.js.map`, 'web.js.map'));
     }
 });
 
 router.get('/asset/:handle/:name/:version/web.js.map', async (req, res) => {
-
-    const {handle, name, version} = req.params;
+    const { handle, name, version } = req.params;
     const result = await providerManager.getAsset(handle, name, version, true);
-    if (version !== 'local') {
-        res.setHeader('Cache-Control', 'max-age=31536000, immutable');
-    }
 
     if (!result) {
         res.status(404).send('');
     } else {
+        // Only cache successful requests
+        if (version !== 'local') {
+            res.setHeader('Cache-Control', 'max-age=31536000, immutable');
+        }
         res.send(result);
     }
 });
 
-
-module.exports = router;
+module.exports = router;

package/src/repositoryManager.js

@@ -1,23 +1,24 @@
-const ClusterConfiguration = require("@kapeta/local-cluster-config").default;
-const FS = require("node:fs");
-const FSExtra = require("fs-extra");
-const Path = require("node:path");
-const socketManager = require("./socketManager");
-const {Actions, RegistryService, Config} = require("@kapeta/nodejs-registry-utils");
-const progressListener = require("./progressListener");
-const os = require("os");
-const {parseKapetaUri} = require("@kapeta/nodejs-utils");
+const ClusterConfiguration = require('@kapeta/local-cluster-config').default;
+const FS = require('node:fs');
+const FSExtra = require('fs-extra');
+const Path = require('node:path');
+const socketManager = require('./socketManager');
+const {
+    Actions,
+    RegistryService,
+    Config,
+} = require('@kapeta/nodejs-registry-utils');
+const progressListener = require('./progressListener');
+const os = require('os');
+const { parseKapetaUri } = require('@kapeta/nodejs-utils');
 const INSTALL_ATTEMPTED = {};
 
 class RepositoryManager {
-
     constructor() {
         this.watcher = null;
         this.changeEventsEnabled = true;
         this.listenForChanges();
-        this._registryService = new RegistryService(
-            Config.data.registry.url
-        );
+        this._registryService = new RegistryService(Config.data.registry.url);
         this._cache = {};
         this._installQueue = [];
     }
@@ -32,16 +33,20 @@ class RepositoryManager {
             FSExtra.mkdirpSync(baseDir);
         }
 
-        let allDefinitions = ClusterConfiguration
-            .getDefinitions();
+        let allDefinitions = ClusterConfiguration.getDefinitions();
 
-        console.log('Watching local repository for provider changes: %s', baseDir);
+        console.log(
+            'Watching local repository for provider changes: %s',
+            baseDir
+        );
         try {
             this.watcher = FS.watch(baseDir, { recursive: true });
         } catch (e) {
             // Fallback to run without watch mode due to potential platform issues.
             // https://nodejs.org/docs/latest/api/fs.html#caveats
-            console.log('Unable to watch for changes. Changes to assets will not update automatically.');
+            console.log(
+                'Unable to watch for changes. Changes to assets will not update automatically.'
+            );
             return;
         }
         this.watcher.on('change', (eventType, filename) => {
@@ -54,11 +59,21 @@ class RepositoryManager {
                 return;
             }
 
-            const ymlPath = Path.join(baseDir, handle, name, version, 'kapeta.yml');
+            const ymlPath = Path.join(
+                baseDir,
+                handle,
+                name,
+                version,
+                'kapeta.yml'
+            );
             const newDefinitions = ClusterConfiguration.getDefinitions();
 
-            const newDefinition = newDefinitions.find(d => d.ymlPath === ymlPath);
-            let currentDefinition = allDefinitions.find(d => d.ymlPath === ymlPath);
+            const newDefinition = newDefinitions.find(
+                (d) => d.ymlPath === ymlPath
+            );
+            let currentDefinition = allDefinitions.find(
+                (d) => d.ymlPath === ymlPath
+            );
             const ymlExists = FS.existsSync(ymlPath);
             let type;
             if (ymlExists) {
@@ -85,9 +100,13 @@ class RepositoryManager {
                 }
             }
 
-            const payload = {type, definition: currentDefinition?.definition, asset: {handle, name, version} };
+            const payload = {
+                type,
+                definition: currentDefinition?.definition,
+                asset: { handle, name, version },
+            };
 
-            allDefinitions = newDefinitions
+            allDefinitions = newDefinitions;
             socketManager.emit(`assets`, 'changed', payload);
         });
     }
@@ -108,21 +127,42 @@ class RepositoryManager {
         const out = new Promise((resolve, reject) => {
             this._installQueue.push(async () => {
                 try {
-                    const normalizedRefs = refs.map(ref => parseKapetaUri(ref).id)
-                    const filteredRefs = normalizedRefs.filter(ref => !INSTALL_ATTEMPTED[ref]);
+                    const normalizedRefs = refs.map(
+                        (ref) => parseKapetaUri(ref).id
+                    );
+                    const filteredRefs = normalizedRefs.filter(
+                        (ref) => !INSTALL_ATTEMPTED[ref]
+                    );
+                    console.log(filteredRefs);
                     if (filteredRefs.length > 0) {
-                        filteredRefs.forEach(ref => INSTALL_ATTEMPTED[ref] = true);
+                        filteredRefs.forEach(
+                            (ref) => (INSTALL_ATTEMPTED[ref] = true)
+                        );
                         //Auto-install missing asset
                         try {
                             //We change to a temp dir to avoid issues with the current working directory
                             process.chdir(os.tmpdir());
                             //Disable change events while installing
                             this.setChangeEventsEnabled(false);
-                            socketManager.emit(`install`, 'install:action', {type: 'start', refs});
-                            await Actions.install(progressListener, normalizedRefs, {});
-                            socketManager.emit(`install`, 'install:action', {type: 'done', refs});
+                            socketManager.emit(`install`, 'install:action', {
+                                type: 'start',
+                                refs,
+                            });
+                            await Actions.install(
+                                progressListener,
+                                normalizedRefs,
+                                {}
+                            );
+                            socketManager.emit(`install`, 'install:action', {
+                                type: 'done',
+                                refs,
+                            });
                         } catch (e) {
-                            socketManager.emit(`install`, 'install:action', {type: 'failed', refs, error: e.message});
+                            socketManager.emit(`install`, 'install:action', {
+                                type: 'failed',
+                                refs,
+                                error: e.message,
+                            });
                         } finally {
                             this.setChangeEventsEnabled(true);
                         }
@@ -131,12 +171,12 @@ class RepositoryManager {
                 } catch (e) {
                     reject(e);
                 } finally {
-                    this._processNext().catch(e => console.error(e));
+                    this._processNext().catch((e) => console.error(e));
                 }
-            })
+            });
         });
 
-        this._processNext().catch(e => console.error(e));
+        this._processNext().catch((e) => console.error(e));
 
         return out;
     }
@@ -167,10 +207,10 @@ class RepositoryManager {
         }
 
         const definitions = ClusterConfiguration.getDefinitions();
-        const installedAsset = definitions.find(d =>
-                        d.definition.metadata.name === fullName &&
-                        d.version === version);
-
+        const installedAsset = definitions.find(
+            (d) =>
+                d.definition.metadata.name === fullName && d.version === version
+        );
 
         if (installedAsset && this._cache[ref] === true) {
             return;
@@ -182,7 +222,10 @@ class RepositoryManager {
 
         let assetVersion;
         try {
-            assetVersion = await this._registryService.getVersion(fullName, version);
+            assetVersion = await this._registryService.getVersion(
+                fullName,
+                version
+            );
             if (!assetVersion) {
                 this._cache[ref] = false;
                 return;
@@ -205,9 +248,7 @@ class RepositoryManager {
             console.log(`Auto-installing dependencies: ${refs.join(', ')}`);
             await this._install(refs);
         }
-
-
     }
 }
 
-module.exports = new RepositoryManager();
+module.exports = new RepositoryManager();

package/src/utils/pathTemplateParser.js

@@ -2,6 +2,17 @@
 const TYPE_VARIABLE = 'variable';
 const TYPE_PATH = 'path';
 
+/**
+ * A path template is a string that can be used to match a path and extract variables from it.
+ *
+ * E.g. /foo/{bar}/baz
+ *
+ * Would match /foo/123/baz and extract bar=123
+ *
+ * You can also specify a regex for the variable:
+ *  /foo/{bar:[0-9]+}/baz
+ *
+ */
 class PathTemplate {
     constructor(pathTemplate) {
         if (!pathTemplate.startsWith('/')) {
@@ -9,33 +20,41 @@ class PathTemplate {
         }
         this._path = pathTemplate;
 
-        this._parts = pathTemplate.split(/{/g).map((part) => {
-            if (part.endsWith('}')) {
-                let regex,
-                    value = part.substr(0, part.length -  1);
-
-                [value, regex] = value.split(/:/, 2);
+        const variableRegex = /{([^}]+)}/g;
+        let match, offset = 0;
+        this._parts = [];
+        while((match = variableRegex.exec(pathTemplate)) !== null) {
+            if (match.index > offset) {
+                this._parts.push({
+                    type: TYPE_PATH,
+                    value: pathTemplate.substring(offset, match.index)
+                });
+            }
 
-                if (regex) {
-                    regex = new RegExp('^' + regex);
-                } else {
-                    regex = /^[^\/]+/
-                }
+            let regex;
+            let value = match[1];
+            [value, regex] = value.split(/:/, 2);
 
-                return {
-                    type: TYPE_VARIABLE,
-                    value,
-                    regex
-                };
+            if (regex) {
+                regex = new RegExp('^' + regex);
+            } else {
+                regex = /^[^\/]+/
             }
 
-            return {
-                type: TYPE_PATH,
-                value: part
-            };
-        });
-
+            this._parts.push({
+                type: TYPE_VARIABLE,
+                value,
+                regex
+            });
+            offset = match.index + match[0].length;
+        }
 
+        if (offset < pathTemplate.length) {
+            this._parts.push({
+                type: TYPE_PATH,
+                value: pathTemplate.substring(offset)
+            });
+        }
     }
 
     get path() {
@@ -61,7 +80,7 @@ class PathTemplate {
                         return null;
                     }
 
-                    path = path.substr(part.value.length);
+                    path = path.substring(part.value.length);
                     break;
                 case TYPE_VARIABLE:
                     if (!part.regex.test(path)) {