@kapeta/local-cluster-service 0.16.8 → 0.18.0

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

@@ -1,18 +1,23 @@
-import Router from 'express-promise-router';
-import { stringBody } from '../middleware/stringBody';
-import { filesystemManager } from '../filesystemManager';
-import { corsHandler } from '../middleware/cors';
-let router = Router();
-router.use('/', corsHandler);
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const stringBody_1 = require("../middleware/stringBody");
+const filesystemManager_1 = require("../filesystemManager");
+const cors_1 = require("../middleware/cors");
+let router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
 router.get('/root', (req, res) => {
-    res.send(filesystemManager.getRootFolder());
+    res.send(filesystemManager_1.filesystemManager.getRootFolder());
 });
 router.get('/project/root', (req, res) => {
-    res.send(filesystemManager.getProjectRootFolder());
+    res.send(filesystemManager_1.filesystemManager.getProjectRootFolder());
 });
-router.use('/project/root', stringBody);
+router.use('/project/root', stringBody_1.stringBody);
 router.post('/project/root', (req, res) => {
-    filesystemManager.setProjectRootFolder(req.stringBody ?? '');
+    filesystemManager_1.filesystemManager.setProjectRootFolder(req.stringBody ?? '');
     res.sendStatus(204);
 });
 router.use('/', (req, res, next) => {
@@ -25,7 +30,7 @@ router.use('/', (req, res, next) => {
 router.get('/list', async (req, res) => {
     let pathArg = req.query.path;
     try {
-        res.send(await filesystemManager.readDirectory(pathArg));
+        res.send(await filesystemManager_1.filesystemManager.readDirectory(pathArg));
     }
     catch (err) {
         res.status(400).send({ error: '' + err });
@@ -34,7 +39,7 @@ router.get('/list', async (req, res) => {
 router.get('/readfile', async (req, res) => {
     let pathArg = req.query.path;
     try {
-        res.send(await filesystemManager.readFile(pathArg));
+        res.send(await filesystemManager_1.filesystemManager.readFile(pathArg));
     }
     catch (err) {
         res.status(400).send({ error: '' + err });
@@ -43,22 +48,22 @@ router.get('/readfile', async (req, res) => {
 router.put('/mkdir', async (req, res) => {
     let pathArg = req.query.path;
     try {
-        await filesystemManager.createFolder(pathArg);
+        await filesystemManager_1.filesystemManager.createFolder(pathArg);
         res.sendStatus(204);
     }
     catch (err) {
         res.status(400).send({ error: '' + err });
     }
 });
-router.use('/writefile', stringBody);
+router.use('/writefile', stringBody_1.stringBody);
 router.post('/writefile', async (req, res) => {
     let pathArg = req.query.path;
     try {
-        await filesystemManager.writeFile(pathArg, req.stringBody ?? '');
+        await filesystemManager_1.filesystemManager.writeFile(pathArg, req.stringBody ?? '');
         res.sendStatus(204);
     }
     catch (err) {
         res.status(400).send({ error: '' + err });
     }
 });
-export default router;
+exports.default = router;

package/dist/esm/src/filesystemManager.js

@@ -1,12 +1,18 @@
-import Path from 'path';
-import FS from 'fs';
-import FSExtra from 'fs-extra';
-import { storageService } from './storageService';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filesystemManager = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const storageService_1 = require("./storageService");
 const SECTION_ID = 'filesystem';
 const PROJECT_ROOT = 'project_root';
 function isFile(path) {
     try {
-        return FS.statSync(path).isFile();
+        return fs_1.default.statSync(path).isFile();
     }
     catch (error) {
         return false;
@@ -14,15 +20,15 @@ function isFile(path) {
 }
 class FilesystemManager {
     async writeFile(path, data) {
-        const dirName = Path.dirname(path);
-        if (!FS.existsSync(dirName)) {
-            FSExtra.mkdirpSync(dirName, {});
+        const dirName = path_1.default.dirname(path);
+        if (!fs_1.default.existsSync(dirName)) {
+            fs_extra_1.default.mkdirpSync(dirName, {});
         }
-        FS.writeFileSync(path, data);
+        fs_1.default.writeFileSync(path, data);
     }
     async createFolder(path) {
         return new Promise((resolve, reject) => {
-            FS.mkdir(path, (err) => {
+            fs_1.default.mkdir(path, (err) => {
                 if (err) {
                     err.message += '. You can only create one single folder at a time.';
                     reject(err.message);
@@ -35,15 +41,15 @@ class FilesystemManager {
     async readDirectory(path) {
         return new Promise((resolve, reject) => {
             let response = [];
-            FS.readdir(path, (err, files) => {
+            fs_1.default.readdir(path, (err, files) => {
                 if (err) {
                     reject(new Error(err));
                     return;
                 }
                 files.forEach((file) => {
                     response.push({
-                        path: Path.join(path, file),
-                        folder: FS.lstatSync(Path.join(path, file)).isDirectory(),
+                        path: path_1.default.join(path, file),
+                        folder: fs_1.default.lstatSync(path_1.default.join(path, file)).isDirectory(),
                     });
                 });
                 resolve(response);
@@ -56,7 +62,7 @@ class FilesystemManager {
                 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) => {
+                fs_1.default.readFile(path, (err, data) => {
                     if (err) {
                         reject(new Error(err.message));
                         return;
@@ -70,10 +76,10 @@ class FilesystemManager {
         return require('os').homedir();
     }
     getProjectRootFolder() {
-        return storageService.get(SECTION_ID, PROJECT_ROOT);
+        return storageService_1.storageService.get(SECTION_ID, PROJECT_ROOT);
     }
     setProjectRootFolder(folder) {
-        storageService.put(SECTION_ID, PROJECT_ROOT, folder);
+        storageService_1.storageService.put(SECTION_ID, PROJECT_ROOT, folder);
     }
 }
-export const filesystemManager = new FilesystemManager();
+exports.filesystemManager = new FilesystemManager();

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

@@ -1,11 +1,16 @@
-import Router from 'express-promise-router';
-import { KapetaAPI } from '@kapeta/nodejs-api-client';
-import { corsHandler } from '../middleware/cors';
-const router = Router();
-router.use('/', corsHandler);
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const cors_1 = require("../middleware/cors");
+const router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
 router.get('/current', async (req, res) => {
     try {
-        const api = new KapetaAPI();
+        const api = new nodejs_api_client_1.KapetaAPI();
         if (api.hasToken()) {
             res.send(await api.getCurrentIdentity());
         }
@@ -19,7 +24,7 @@ router.get('/current', async (req, res) => {
 });
 router.get('/:identityId/memberships', async (req, res) => {
     try {
-        const api = new KapetaAPI();
+        const api = new nodejs_api_client_1.KapetaAPI();
         if (api.hasToken()) {
             res.send(await api.getMemberships(req.params.identityId));
         }
@@ -31,4 +36,4 @@ router.get('/:identityId/memberships', async (req, res) => {
         res.status(e.status ?? 500).send(e);
     }
 });
-export default router;
+exports.default = router;

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

@@ -7,7 +7,7 @@ export declare class InstanceManager {
     constructor();
     private checkInstancesLater;
     getInstances(): InstanceInfo[];
-    getInstancesForPlan(systemId: string): InstanceInfo[];
+    getInstancesForPlan(systemId: string): Promise<InstanceInfo[]>;
     getInstance(systemId: string, instanceId: string): InstanceInfo | undefined;
     private exclusive;
     getLogs(systemId: string, instanceId: string): Promise<LogEntry[]>;