@kapeta/local-cluster-service 0.6.0 → 0.7.0

package/dist/cjs/src/utils/LogData.d.ts

@@ -0,0 +1,19 @@
+import { LogEntry, LogLevel, LogSource } from '../types';
+export declare class LogData {
+    static readonly MAX_LINES = 1000;
+    private readonly entries;
+    constructor();
+    /**
+     *
+     * @param {string} msg
+     * @param {string} [level]
+     * @param {string} [source]
+     */
+    addLog(msg: string, level?: LogLevel, source?: LogSource): void;
+    /**
+     *
+     * @return {LogEntry[]}
+     */
+    getLogs(): LogEntry[];
+    toString(): string;
+}

package/dist/cjs/src/utils/LogData.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogData = void 0;
+const MAX_LINES = 1000;
+class LogData {
+    static MAX_LINES = MAX_LINES;
+    entries = [];
+    constructor() { }
+    /**
+     *
+     * @param {string} msg
+     * @param {string} [level]
+     * @param {string} [source]
+     */
+    addLog(msg, level = 'INFO', source = 'stdout') {
+        while (this.entries.length > MAX_LINES) {
+            this.entries.shift();
+        }
+        if (!msg.endsWith('\n')) {
+            msg += '\n';
+        }
+        this.entries.push({
+            time: Date.now(),
+            message: msg,
+            level,
+            source,
+        });
+    }
+    /**
+     *
+     * @return {LogEntry[]}
+     */
+    getLogs() {
+        return this.entries;
+    }
+    toString() {
+        return this.getLogs()
+            .map((entry) => entry.message)
+            .join('\n');
+    }
+}
+exports.LogData = LogData;
+module.exports = LogData;

package/dist/cjs/src/utils/pathTemplateParser.d.ts

@@ -0,0 +1,26 @@
+import { StringMap } from '../types';
+/**
+ * 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
+ *
+ */
+export declare class PathTemplate {
+    private _path;
+    private _parts;
+    constructor(pathTemplate: string);
+    get path(): string;
+    matches(path: string): boolean;
+    parse(path: string): StringMap | null;
+    create(variables: StringMap): string;
+    toString(): string;
+}
+/**
+ * Parses a path into a RESTPath
+ */
+export declare function pathTemplateParser(path: string): PathTemplate;

package/dist/cjs/src/utils/pathTemplateParser.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathTemplateParser = exports.PathTemplate = void 0;
+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 {
+    _path;
+    _parts = [];
+    constructor(pathTemplate) {
+        if (!pathTemplate.startsWith('/')) {
+            pathTemplate = '/' + pathTemplate;
+        }
+        this._path = pathTemplate;
+        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),
+                });
+            }
+            let regex;
+            let value = match[1];
+            [value, regex] = value.split(/:/, 2);
+            if (regex) {
+                regex = new RegExp('^' + regex);
+            }
+            else {
+                regex = /^[^\/]+/;
+            }
+            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() {
+        return this._path;
+    }
+    matches(path) {
+        return this.parse(path) !== null;
+    }
+    parse(path) {
+        if (!path.startsWith('/')) {
+            path = '/' + path;
+        }
+        const values = {};
+        for (let i = 0; i < this._parts.length; i++) {
+            const part = this._parts[i];
+            switch (part.type) {
+                case TYPE_PATH:
+                    if (!path.startsWith(part.value)) {
+                        return null;
+                    }
+                    path = path.substring(part.value.length);
+                    break;
+                case TYPE_VARIABLE:
+                    if (!part.regex?.test(path)) {
+                        return null;
+                    }
+                    const newPath = path.replace(part.regex, '');
+                    const value = path.substr(0, path.length - newPath.length);
+                    values[part.value] = value;
+                    path = newPath;
+                    break;
+            }
+        }
+        if (path && path !== '/') {
+            //We did not match all of it
+            return null;
+        }
+        return values;
+    }
+    create(variables) {
+        return this._parts
+            .map((part) => {
+            switch (part.type) {
+                case TYPE_PATH:
+                    return part.value;
+                case TYPE_VARIABLE:
+                    if (variables[part.value] === undefined || variables[part.value] === null) {
+                        return '';
+                    }
+                    return variables[part.value];
+            }
+        })
+            .join('');
+    }
+    toString() {
+        return 'tmpl: ' + this.path;
+    }
+}
+exports.PathTemplate = PathTemplate;
+/**
+ * Parses a path into a RESTPath
+ */
+function pathTemplateParser(path) {
+    return new PathTemplate(path);
+}
+exports.pathTemplateParser = pathTemplateParser;

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

@@ -0,0 +1 @@
+export declare function readYML(path: string): any;

package/dist/cjs/src/utils/utils.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readYML = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const yaml_1 = __importDefault(require("yaml"));
+function readYML(path) {
+    const rawYaml = node_fs_1.default.readFileSync(path);
+    try {
+        return yaml_1.default.parse(rawYaml.toString());
+    }
+    catch (err) {
+        throw new Error('Failed to parse plan YAML: ' + err);
+    }
+}
+exports.readYML = readYML;

package/dist/cjs/start.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/start.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+index_1.default
+    .start()
+    .then(({ host, port }) => console.log('Listening on port %s:%s', host, port))
+    .catch((e) => {
+    console.error('Failed to start local cluster due to an error:\n\t - %s', e.toString());
+});

package/dist/esm/index.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import HTTP from 'http';
+export type LocalClusterService = HTTP.Server & {
+    host?: string;
+    port?: number;
+};
+export type StartResult = {
+    host: string;
+    port: number;
+    dockerStatus: boolean;
+};
+declare const _default: {
+    isRunning: () => boolean;
+    getCurrentPort: () => number | undefined;
+    /**
+     * Starts the local cluster service.
+     * resolves when listening is done with port number. Rejects if listening failed.
+     */
+    start: () => Promise<StartResult>;
+    /**
+     * Stops any currently running cluster services.
+     * @return {Promise<boolean>} Returns true if the service was stopped - false if no service was running.
+     */
+    stop: () => Promise<unknown>;
+    getServices: () => any;
+};
+export default _default;

package/dist/esm/index.js

@@ -0,0 +1,121 @@
+import { clusterService } from './src/clusterService';
+import { storageService } from './src/storageService';
+import { serviceManager } from './src/serviceManager';
+import { socketManager } from './src/socketManager';
+import { containerManager } from './src/containerManager';
+import express from 'express';
+import HTTP from 'http';
+import { Server } from 'socket.io';
+import TrafficRoutes from './src/traffic/routes';
+import ProxyRoutes from './src/proxy/routes';
+import ConfigRoutes from './src/config/routes';
+import InstancesRoutes from './src/instances/routes';
+import IdentitiesRoutes from './src/identities/routes';
+import FilesystemRoutes from './src/filesystem/routes';
+import AssetsRoutes from './src/assets/routes';
+import ProviderRoutes from './src/providers/routes';
+let currentServer = null;
+function createServer() {
+    const app = express();
+    app.use('/traffic', TrafficRoutes);
+    app.use('/proxy', ProxyRoutes);
+    app.use('/config', ConfigRoutes);
+    app.use('/instances', InstancesRoutes);
+    app.use('/identities', IdentitiesRoutes);
+    app.use('/files', FilesystemRoutes);
+    app.use('/assets', AssetsRoutes);
+    app.use('/providers', ProviderRoutes);
+    app.use('/', (err, req, res) => {
+        console.error('Request failed: %s %s', req.method, req.originalUrl, err);
+        res.status(500).send({
+            ok: false,
+            error: err.error ?? err.message,
+        });
+    });
+    const server = HTTP.createServer(app);
+    //socket
+    const io = new Server(server, {
+        cors: {
+            //TODO: This should'nt be hardcoded but also shouldn't be "*"
+            origin: 'http://localhost:8080',
+        },
+    });
+    socketManager.setIo(io);
+    return server;
+}
+export default {
+    isRunning: function () {
+        return !!currentServer;
+    },
+    getCurrentPort: function () {
+        if (!currentServer) {
+            return -1;
+        }
+        return currentServer.port;
+    },
+    /**
+     * Starts the local cluster service.
+     * resolves when listening is done with port number. Rejects if listening failed.
+     */
+    start: async function () {
+        if (currentServer) {
+            throw new Error('Server already started');
+        }
+        try {
+            await containerManager.initialize();
+        }
+        catch (e) {
+            console.error('Could not ping docker runtime: ' + e.toString() + '. Make sure docker is running and working.');
+        }
+        const clusterPort = storageService.get('cluster', 'port');
+        if (clusterPort) {
+            clusterService.setClusterServicePort(clusterPort);
+        }
+        const clusterHost = storageService.get('cluster', 'host');
+        if (clusterHost) {
+            clusterService.setClusterServiceHost(clusterHost);
+        }
+        await clusterService.init();
+        currentServer = createServer();
+        const port = clusterService.getClusterServicePort();
+        const host = clusterService.getClusterServiceHost();
+        if (clusterPort !== port) {
+            storageService.put('cluster', 'port', port);
+        }
+        if (clusterHost !== host) {
+            storageService.put('cluster', 'host', host);
+        }
+        return new Promise((resolve, reject) => {
+            if (!currentServer) {
+                reject(new Error(`Current server wasn't set`));
+                return;
+            }
+            currentServer.once('error', (err) => {
+                if (currentServer) {
+                    currentServer.close();
+                    currentServer = null;
+                }
+                reject(err);
+            });
+            currentServer.listen(port, host, () => resolve({ host, port, dockerStatus: containerManager.isAlive() }));
+            currentServer.host = host;
+            currentServer.port = port;
+        });
+    },
+    /**
+     * Stops any currently running cluster services.
+     * @return {Promise<boolean>} Returns true if the service was stopped - false if no service was running.
+     */
+    stop: function () {
+        if (currentServer) {
+            return new Promise(function (resolve) {
+                if (currentServer) {
+                    currentServer.close(() => resolve(true));
+                    currentServer = null;
+                }
+            });
+        }
+        return Promise.resolve(false);
+    },
+    getServices: () => serviceManager.getServices(),
+};

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

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

@@ -0,0 +1,31 @@
+import { Definition } from '@kapeta/local-cluster-config';
+import { BlockDefinition } from '@kapeta/schemas';
+export interface EnrichedAsset {
+    ref: string;
+    editable: boolean;
+    exists: boolean;
+    version: string;
+    kind: string;
+    data: Definition;
+    path: string;
+    ymlPath: string;
+}
+declare class AssetManager {
+    private cache;
+    constructor();
+    /**
+     *
+     * @param {string[]} [assetKinds]
+     * @returns {{path: *, ref: string, data: *, editable: boolean, kind: *, exists: boolean}[]}
+     */
+    getAssets(assetKinds?: string[]): EnrichedAsset[];
+    getPlans(): EnrichedAsset[];
+    getPlan(ref: string, noCache?: boolean): Promise<Definition>;
+    getAsset(ref: string, noCache?: boolean): Promise<EnrichedAsset | undefined>;
+    createAsset(path: string, yaml: BlockDefinition): Promise<EnrichedAsset[]>;
+    updateAsset(ref: string, yaml: BlockDefinition): Promise<void>;
+    importFile(filePath: string): Promise<EnrichedAsset[]>;
+    unregisterAsset(ref: string): Promise<void>;
+}
+export declare const assetManager: AssetManager;
+export {};

package/{src → dist/esm/src}/assetManager.js

@@ -1,19 +1,18 @@
-const Path = require('node:path');
-const FS = require('node:fs');
-const FSExtra = require('fs-extra');
-const YAML = require('yaml');
-const ClusterConfiguration = require('@kapeta/local-cluster-config').default;
-const { Actions } = require('@kapeta/nodejs-registry-utils');
-const codeGeneratorManager = require('./codeGeneratorManager');
-const progressListener = require('./progressListener');
-const { parseKapetaUri } = require('@kapeta/nodejs-utils');
-const repositoryManager = require('./repositoryManager');
-const NodeCache = require('node-cache');
-
+import Path from 'node:path';
+import FS from 'node:fs';
+import FSExtra from 'fs-extra';
+import YAML from 'yaml';
+import NodeCache from 'node-cache';
+import ClusterConfiguration from '@kapeta/local-cluster-config';
+import { codeGeneratorManager } from './codeGeneratorManager';
+import { progressListener } from './progressListener';
+import { parseKapetaUri } from '@kapeta/nodejs-utils';
+import { repositoryManager } from './repositoryManager';
+import { Actions } from '@kapeta/nodejs-registry-utils';
 function enrichAsset(asset) {
     return {
         ref: `kapeta://${asset.definition.metadata.name}:${asset.version}`,
-        editable: asset.version === 'local', //Only local versions are editable
+        editable: asset.version === 'local',
         exists: true,
         version: asset.version,
         kind: asset.definition.kind,
@@ -22,29 +21,25 @@ function enrichAsset(asset) {
         ymlPath: asset.ymlPath,
     };
 }
-
 function compareRefs(a, b) {
     const [aProtocol, aId] = parseRef(a);
     const [bProtocol, bId] = parseRef(b);
-
     return aProtocol === bProtocol && aId === bId;
 }
 function parseRef(ref) {
     let out = ref.split(/:\/\//, 2);
-
     if (out.length === 1) {
         return ['kapeta', ref.toLowerCase()];
     }
     return [out[0].toLowerCase(), out[1].toLowerCase()];
 }
-
 class AssetManager {
+    cache;
     constructor() {
         this.cache = new NodeCache({
             stdTTL: 60 * 60, // 1 hour
         });
     }
-
     /**
      *
      * @param {string[]} [assetKinds]
@@ -61,117 +56,85 @@ class AssetManager {
             });
             assetKinds.push('core/plan');
         }
-
         const assets = ClusterConfiguration.getDefinitions(assetKinds);
-
         return assets.map(enrichAsset);
     }
-
     getPlans() {
         return this.getAssets(['core/plan']);
     }
-
     async getPlan(ref, noCache = false) {
         const asset = await this.getAsset(ref, noCache);
-
-        if ('core/plan' !== asset.kind) {
+        if ('core/plan' !== asset?.kind) {
             throw new Error('Asset was not a plan: ' + ref);
         }
-
         return asset.data;
     }
-
     async getAsset(ref, noCache = false) {
         const cacheKey = `getAsset:${ref}`;
-        if (noCache !== true && this.cache.has(cacheKey)) {
+        if (!noCache && this.cache.has(cacheKey)) {
             return this.cache.get(cacheKey);
         }
         const uri = parseKapetaUri(ref);
         await repositoryManager.ensureAsset(uri.handle, uri.name, uri.version);
-
         let asset = ClusterConfiguration.getDefinitions()
             .map(enrichAsset)
             .find((a) => parseKapetaUri(a.ref).equals(uri));
-
         if (!asset) {
             throw new Error('Asset not found: ' + ref);
         }
         this.cache.set(cacheKey, asset);
         return asset;
     }
-
     async createAsset(path, yaml) {
         if (FS.existsSync(path)) {
             throw new Error('File already exists: ' + path);
         }
-
         const dirName = Path.dirname(path);
         if (!FS.existsSync(dirName)) {
             FSExtra.mkdirpSync(dirName);
         }
-
         FS.writeFileSync(path, YAML.stringify(yaml));
-
         const asset = await this.importFile(path);
-
         if (codeGeneratorManager.canGenerateCode(yaml)) {
             await codeGeneratorManager.generate(path, yaml);
         }
         this.cache.flushAll();
         return asset;
     }
-
     async updateAsset(ref, yaml) {
         const asset = await this.getAsset(ref, true);
         if (!asset) {
             throw new Error('Attempted to update unknown asset: ' + ref);
         }
-
         if (!asset.editable) {
             throw new Error('Attempted to update read-only asset: ' + ref);
         }
-
         if (!asset.ymlPath) {
             throw new Error('Attempted to update corrupted asset: ' + ref);
         }
-
         FS.writeFileSync(asset.ymlPath, YAML.stringify(yaml));
         this.cache.flushAll();
         if (codeGeneratorManager.canGenerateCode(yaml)) {
             await codeGeneratorManager.generate(asset.ymlPath, yaml);
-        } else {
-            console.log(
-                'Could not generate code for %s',
-                yaml.kind ? yaml.kind : 'unknown yaml'
-            );
+        }
+        else {
+            console.log('Could not generate code for %s', yaml.kind ? yaml.kind : 'unknown yaml');
         }
     }
-
     async importFile(filePath) {
         if (filePath.startsWith('file://')) {
             filePath = filePath.substring('file://'.length);
         }
-
         if (!FS.existsSync(filePath)) {
             throw new Error('File not found: ' + filePath);
         }
-
-        const assetInfos = YAML.parseAllDocuments(
-            FS.readFileSync(filePath).toString()
-        ).map((doc) => doc.toJSON());
-
+        const assetInfos = YAML.parseAllDocuments(FS.readFileSync(filePath).toString()).map((doc) => doc.toJSON());
         await Actions.link(progressListener, Path.dirname(filePath));
-
         const version = 'local';
-        const refs = assetInfos.map(
-            (assetInfo) => `kapeta://${assetInfo.metadata.name}:${version}`
-        );
+        const refs = assetInfos.map((assetInfo) => `kapeta://${assetInfo.metadata.name}:${version}`);
         this.cache.flushAll();
-        return this.getAssets().filter((a) =>
-            refs.some((ref) => compareRefs(ref, a.ref))
-        );
+        return this.getAssets().filter((a) => refs.some((ref) => compareRefs(ref, a.ref)));
     }
-
     async unregisterAsset(ref) {
         const asset = await this.getAsset(ref, true);
         if (!asset) {
@@ -181,5 +144,4 @@ class AssetManager {
         await Actions.uninstall(progressListener, [asset.ref]);
     }
 }
-
-module.exports = new AssetManager();
+export const assetManager = new AssetManager();

package/dist/esm/src/assets/routes.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;