@kapeta/local-cluster-service 0.6.1 → 0.7.0

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

@@ -1,20 +1,18 @@
-const Path = require("path");
-const FS = require("fs");
-const FSExtra = require('fs-extra');
-const storageService = require('./storageService');
+import Path from 'path';
+import FS from 'fs';
+import FSExtra from 'fs-extra';
+import { storageService } from './storageService';
 const SECTION_ID = 'filesystem';
 const PROJECT_ROOT = 'project_root';
-
 function isFile(path) {
     try {
-        return FS.statSync(path).isFile()
-    } catch (error) {
+        return FS.statSync(path).isFile();
+    }
+    catch (error) {
         return false;
     }
 }
-
 class FilesystemManager {
-
     async writeFile(path, data) {
         const dirName = Path.dirname(path);
         console.log('Dir name', dirName, path);
@@ -24,20 +22,18 @@ class FilesystemManager {
         }
         FS.writeFileSync(path, data);
     }
-
     async createFolder(path) {
         return new Promise((resolve, reject) => {
             FS.mkdir(path, (err) => {
                 if (err) {
-                    err.message += ". You can only create one single folder at a time.";
+                    err.message += '. You can only create one single folder at a time.';
                     reject(err.message);
                     return;
                 }
                 resolve();
-            })
-        })
+            });
+        });
     }
-
     async readDirectory(path) {
         return new Promise((resolve, reject) => {
             let response = [];
@@ -49,41 +45,37 @@ class FilesystemManager {
                 files.forEach((file) => {
                     response.push({
                         path: Path.join(path, file),
-                        folder: FS.lstatSync(Path.join(path, file)).isDirectory()
-                    })
+                        folder: FS.lstatSync(Path.join(path, file)).isDirectory(),
+                    });
                 });
-                resolve(response)
+                resolve(response);
             });
-        })
+        });
     }
-
     async readFile(path) {
         return new Promise((resolve, reject) => {
             if (!isFile(path)) {
-                reject(new Error("The path provided is invalid.Please check that the path and file name that were provided are spelled correctly. "));
-            } else {
+                reject(new Error('The path provided is invalid.Please check that the path and file name that were provided are spelled correctly. '));
+            }
+            else {
                 FS.readFile(path, (err, data) => {
                     if (err) {
                         reject(new Error(err.message));
                         return;
                     }
-                    resolve(data)
+                    resolve(data);
                 });
             }
-        })
+        });
     }
-
     getRootFolder() {
         return require('os').homedir();
     }
-
     getProjectRootFolder() {
         return storageService.get(SECTION_ID, PROJECT_ROOT);
     }
-
     setProjectRootFolder(folder) {
         storageService.put(SECTION_ID, PROJECT_ROOT, folder);
     }
 }
-
-module.exports = new FilesystemManager();
+export const filesystemManager = new FilesystemManager();

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

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

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

@@ -0,0 +1,13 @@
+import Router from 'express-promise-router';
+import { KapetaAPI } from '@kapeta/nodejs-api-client';
+import { corsHandler } from '../middleware/cors';
+const router = Router();
+const api = new KapetaAPI();
+router.use('/', corsHandler);
+router.get('/current', async (req, res) => {
+    res.send(await api.getCurrentIdentity());
+});
+router.get('/:identityId/memberships', async (req, res) => {
+    res.send(await api.getMemberships(req.params.identityId));
+});
+export default router;

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

@@ -0,0 +1,56 @@
+import { InstanceInfo, ProcessInfo } from './types';
+declare class InstanceManager {
+    private _interval;
+    /**
+     * Contains an array of running instances that have self-registered with this
+     * cluster service. This is done by the Kapeta SDKs
+     */
+    private _instances;
+    /**
+     * Contains the process info for the instances started by this manager. In memory only
+     * so can't be relied on for knowing everything that's running.
+     *
+     */
+    private _processes;
+    constructor();
+    _save(): void;
+    _checkInstances(): Promise<void>;
+    _isRunning(instance: InstanceInfo): Promise<any>;
+    _getInstanceStatus(instance: InstanceInfo): Promise<string>;
+    getInstances(): InstanceInfo[];
+    getInstancesForPlan(systemId: string): InstanceInfo[];
+    /**
+     * Get instance information
+     *
+     * @param {string} systemId
+     * @param {string} instanceId
+     * @return {*}
+     */
+    getInstance(systemId: string, instanceId: string): InstanceInfo | undefined;
+    /**
+     *
+     * @param {string} systemId
+     * @param {string} instanceId
+     * @param {InstanceInfo} info
+     * @return {Promise<void>}
+     */
+    registerInstance(systemId: string, instanceId: string, info: Omit<InstanceInfo, 'systemId' | 'instanceId'>): Promise<void>;
+    setInstanceAsStopped(systemId: string, instanceId: string): void;
+    _emit(systemId: string, type: string, payload: any): void;
+    createProcessesForPlan(planRef: string): Promise<ProcessInfo[]>;
+    _stopInstance(instance: InstanceInfo): Promise<void>;
+    stopAllForPlan(planRef: string): Promise<void>;
+    createProcess(planRef: string, instanceId: string): Promise<ProcessInfo>;
+    /**
+     *
+     * @param {string} planRef
+     * @param {string} instanceId
+     * @return {ProcessInfo|null}
+     */
+    getProcessForInstance(planRef: string, instanceId: string): ProcessInfo | null;
+    restartIfRunning(planRef: string, instanceId: string): Promise<ProcessInfo | undefined>;
+    stopProcess(planRef: string, instanceId: string): Promise<void>;
+    stopAllProcesses(): Promise<void>;
+}
+export declare const instanceManager: InstanceManager;
+export {};