@kumologica/sdk 3.0.0-alpha4

package/src/api/tools/base/DesignerTool.js

@@ -0,0 +1,108 @@
+
+class DesignerTool {
+    constructor(designServer) {
+        this.designServer = designServer;
+        this.adminApp = designServer.getAdminServer(); // TODO: remove
+        this.flowServer = designServer.getFlowServer();
+
+        this.runtimeEventEmitter = this.flowServer.events;
+    }
+
+    getRuntimePlugin(pluginName) {
+        return this.flowServer.runtime.pluginRegistry.getPlugin(pluginName);
+    }
+
+    isRuntimePluginInstalled(pluginName) {
+        return this.getRuntimePlugin(pluginName) ? true : false;
+    }
+
+    // ================================
+    // WebSocket communication with SDK
+    // ================================
+
+    /**
+     * This method will be used by all the tools within the `install` method in order to register a websocket tool
+     * that will respond to each `eventType` request.
+     * @param {string} eventType 
+     * @param {function(string): {type: string, payload?: object}} action 
+    */
+    addEventHandler(eventType, action) {
+        this.designServer.registerEvent(eventType, action);
+    }
+
+    /**
+     * Sends an event over WebSocket back to the client.
+     * If you use this method instead of sendResponse, ensure to follow the naming convention used for responses: `{eventType}:response`
+     * @param {WebSocket} ws - The WebSocket connection.
+     * @param {string} eventType - The type of event to send.
+     * @param {object} payload - The payload data to send with the event.
+     */
+    sendEvent(ws, eventType, payload) {
+        let response = {
+            type: eventType,
+            payload
+        };
+        ws.send(JSON.stringify(response));
+    }
+
+    /**
+     * Sends a response event over WebSocket back to the client
+     * @param {WebSocket} ws - The WebSocket connection.
+     * @param {string} eventType - The type of event to send as a response.
+     * @param {object} payload - The payload data to send with the response.
+     */
+    sendResponse(ws, eventType, payload) {
+        this.sendEvent(ws, `${eventType}:response`, payload);
+    }
+
+    /**
+     * Sends an error event over WebSocket back to the client
+     * @param {WebSocket} ws - The WebSocket connection.
+     * @param {string} eventType - The type of event to send as an error.
+     * @param {Error} err - The error object to send with the error event.
+     */
+    sendError(ws, eventType, err) {
+        this.sendEvent(ws, `${eventType}:error`, { reason: err });
+    }
+
+    // ================================
+    // Communication with Runtime
+    // ================================
+
+    /**
+     * Use these two methods to subscribe to events emitted by a runtime plugin
+     * Remember that whenever you subscribe you will have to unsubscribe it when you are done
+     * otherwise, events will come duplicated.
+     * 
+     * @param {*} listener 
+     */
+    subscribeRuntimeListener(listener) {
+        this.runtimeEventEmitter.on('runtime-event', listener);
+    }
+    clearRuntimeListener(listener) {
+        this.runtimeEventEmitter.off('runtime-event', listener);
+    }
+
+    /**
+     * Use this method to invoke a command to a runtime plugin.
+     * - Plugin must extends the class `Plugin`
+     * - Communication will be done direct call to the object
+     * 
+     * @param {string} pluginName 
+     * @param {string} command 
+     * @param {*} params  - optional 
+     */
+    sendCommandToPlugin(pluginName, command, params) {
+        let plugin = this.getRuntimePlugin(pluginName);
+        if (plugin) {
+            plugin.handleCommand(command, params);
+        } else {
+            throw new Error(`Plugin not found: ${pluginName}`);
+        }
+    }
+
+}
+
+module.exports = {
+    DesignerTool
+}

package/src/api/tools/core/flow.js

@@ -0,0 +1,58 @@
+const { DesignerTool } = require("../base/DesignerTool");
+
+class CoreFlowTool extends DesignerTool {
+    constructor(designServer) {
+        super(designServer);
+    }
+    install() {
+        /**
+         * { type: 'test:run',
+         *   payload: { testcaseid: '123432.34343'} }
+         */
+        this.addEventHandler('flow:getFlow', this.getFlowAction('flow:getFlow'));
+        this.addEventHandler('flow:deployFlow', this.deployFlowAction('flow:deployFlow'));
+        this.addEventHandler('flow:reloadFlow', this.reloadFlowAction('flow:reloadFlow'));
+
+    }
+    getFlowAction(eventType) {
+        return async (ws, payload) => {
+            try {
+                let response = this.flowServer.runtime._.nodes.getFlows()
+                this.sendResponse(ws, eventType, response);
+            } catch (err) {
+                this.sendError(ws, eventType, err.message);
+            }
+
+        }
+    }
+    deployFlowAction(eventType) {
+        return async (ws, payload) => {
+            try {
+                let response = this.flowServer.runtime._.nodes.setFlows(payload, 'full');
+                this.sendResponse(ws, eventType, {});
+
+            } catch (err) {
+                this.sendError(ws, eventType, err.message);
+            }
+
+        }
+    }
+    reloadFlowAction(eventType) {
+        return async (ws, payload) => {
+            try {
+                let response = this.flowServer.runtime._.nodes.loadFlows(true);
+                this.sendResponse(ws, eventType, {});
+
+            } catch (err) {
+                this.sendError(ws, eventType, err.message);
+            }
+
+        }
+    }
+
+}
+
+
+module.exports = {
+    CoreFlowTool
+}

package/src/api/tools/core/index.js

@@ -0,0 +1,18 @@
+const { DesignerTool } = require("../base/DesignerTool");
+
+const { CoreFlowTool } = require('./flow');
+const { CoreNodeTool } = require('./node');
+
+class CoreTools extends DesignerTool {
+    constructor(designServer) {
+        super(designServer);
+    }
+    install() {
+        new CoreFlowTool(this.designServer).install();
+        new CoreNodeTool(this.designServer).install();
+    }
+}
+
+module.exports = {
+    CoreTools
+}

package/src/api/tools/core/node.js

@@ -0,0 +1,77 @@
+const { DesignerTool } = require("../base/DesignerTool");
+
+class CoreNodeTool extends DesignerTool {
+    constructor(designServer) {
+        super(designServer);
+    }
+    install() {
+        /**
+         * { type: 'test:run',
+         *   payload: { testcaseid: '123432.34343'} }
+         */
+        this.addEventHandler('node:getAllNodes', this.getAllNodes('node:getAllNodes'));
+        this.addEventHandler('node:getAllInstalledTypes', this.getAllInstalledTypes('node:getAllInstalledTypes'));
+
+    }
+    /**
+     *
+     * @param {*} eventType
+     * @returns
+     * {
+    "type": "node:getAllNodes:response",
+    "payload": [
+        {
+            "id": "kumologica-core/sftp",
+            "name": "sftp",
+            "types": [
+                "SFTP"
+            ],
+            "enabled": true,
+            "local": false,
+            "module": "kumologica-core",
+            "version": "3.2.0-beta6"
+        },
+        {
+            "id": "kumologica-core/Rekognition",
+            "name": "Rekognition",
+            "types": [
+                "Rekognition"
+            ],
+            "enabled": true,
+            "local": false,
+            "module": "kumologica-core",
+            "version": "3.2.0-beta6"
+        }, ...  ]
+     */
+    getAllNodes(eventType) {
+        return async (ws, payload) => {
+            try {
+                let response = this.flowServer.runtime._.nodes.getNodeList();
+                // console.log(this.flowServer.runtime._.nodes.getNodeConfigs());
+                // console.log(this.flowServer.runtime._.nodes.getNodeConfig('kumologica-core/sftp'));
+                this.sendResponse(ws, eventType, response);
+            } catch (err) {
+                this.sendError(ws, eventType, err.message);
+            }
+
+        }
+    }
+
+    getAllInstalledTypes(eventType) {
+        return async (ws, payload) => {
+            try {
+                let response = this.flowServer.runtime._.nodes.getNodeConfigs();
+                this.sendResponse(ws, eventType, response);
+            } catch (err) {
+                this.sendError(ws, eventType, err.message);
+            }
+        }
+    }
+
+}
+
+
+module.exports = {
+    CoreNodeTool
+}
+1

package/src/api/tools/debugger/index.js

@@ -0,0 +1,193 @@
+const { DesignerTool } = require('../base/DesignerTool');
+const { TestCaseRunner, InMemoryReporter } = require('../test/lib/TestCaseRunner');
+
+const DEBUGGER_PLUGIN = 'DebuggerPlugin';
+
+/**
+ * 
+ * Commands:
+ * { type: 'debugger:start', payload: { testcaseid: '2343.3434', breakpoints: {'123.1231', '1231.123'}}
+ * { type: 'debugger:continue' }
+ * { type: 'debugger:next' }
+ * { type: 'debugger:terminate' }
+ * 
+ * Events:
+ * { type: 'debugger:on:trace', payload: { step: 1, type: 'input|output|error', message: {...}, vars: {} }}
+ * { type: 'debugger:on:change-state', payload: { step: 2, from: 'running', to: 'paused'}}
+ * { type: 'debugger:on:event', { status: "startFlow" });
+ * 
+ * Responses:
+ * { type: 'debugger:start:response', "payload": { "testCaseExecutionTimeInMs": 1.7501250505447388, "testCaseID": "e8fb91dc.46c24",  "testCaseDescription": "TestCase HelloWorld", "assertions": [... ] } }
+ */
+class DebuggerTool extends DesignerTool {
+    constructor(designerServer) {
+        super(designerServer);
+    }
+
+    install() {
+        this.addEventHandler('debugger:start', this.start('debugger:start'));
+        this.addEventHandler('debugger:next', this.next('debugger:next'));
+        this.addEventHandler('debugger:continue', this.continue('debugger:continue'));
+        this.addEventHandler('debugger:terminate', this.terminate('debugger:terminate'));
+    }
+
+
+    start(eventType) {
+        return async (ws, payload) => {
+            const { testcaseid, breakpoints } = payload;
+            // runtime -> tool -> sdk
+            let debuggerListener = this.debuggerEventListener(ws);
+
+            try {
+                if (!this.isRuntimePluginInstalled(DEBUGGER_PLUGIN)) {
+                    throw new Error("DebuggerPlugin not installed");
+                }
+                let pluginCommands = this.getRuntimePlugin(DEBUGGER_PLUGIN).listCommands();
+
+                // Subscribe to debugger plugin events
+                this.subscribeRuntimeListener(debuggerListener);
+
+                // Send command to get ready the debugger plugin  
+                this.sendCommandToPlugin(DEBUGGER_PLUGIN, pluginCommands.ENABLE, breakpoints);
+
+                // Execute the flow as a test
+                const reporter = new InMemoryReporter();
+                const runner = new TestCaseRunner(this.flowServer, testcaseid, [reporter]);
+                await runner.runAsync();
+                let response = {
+                    testCaseExecutionTimeInMs: reporter.executionTimeInMs,
+                    testCaseID: reporter.testCaseID,
+                    testCaseDescription: reporter.testCaseDescription,
+                    assertions: reporter.assertionResults
+                }
+                this.sendResponse(ws, eventType, response);
+
+            } catch (err) {
+                console.log(err);
+                this.sendError(ws, eventType, err.message);
+            } finally {
+                this.clearRuntimeListener(debuggerListener);
+            }
+
+        }
+    }
+
+    next(eventType) {
+        return async (ws, payload) => {
+            try {
+                if (!this.isRuntimePluginInstalled(DEBUGGER_PLUGIN)) {
+                    throw new Error("DebuggerPlugin not installed");
+                }
+                let pluginCommands = this.getRuntimePlugin(DEBUGGER_PLUGIN).listCommands();
+                // Send command to get ready the debugger plugin  
+                this.sendCommandToPlugin(DEBUGGER_PLUGIN, pluginCommands.NEXT);
+            } catch (err) {
+                console.log(err);
+                this.sendError(ws, eventType, err.message);
+            }
+        };
+    }
+
+    continue(eventType) {
+        return async (ws, payload) => {
+            try {
+                if (!this.isRuntimePluginInstalled(DEBUGGER_PLUGIN)) {
+                    throw new Error("DebuggerPlugin not installed");
+                }
+                let pluginCommands = this.getRuntimePlugin(DEBUGGER_PLUGIN).listCommands();
+                // Send command to get ready the debugger plugin  
+                this.sendCommandToPlugin(DEBUGGER_PLUGIN, pluginCommands.CONTINUE);
+            } catch (err) {
+                console.log(err);
+                this.sendError(ws, eventType, err.message);
+            }
+        };
+    }
+
+    terminate(eventType) {
+        return async (ws, payload) => {
+            try {
+                if (!this.isRuntimePluginInstalled(DEBUGGER_PLUGIN)) {
+                    throw new Error("DebuggerPlugin not installed");
+                }
+                let pluginCommands = this.getRuntimePlugin(DEBUGGER_PLUGIN).listCommands();
+                // Send command to get ready the debugger plugin  
+                this.sendCommandToPlugin(DEBUGGER_PLUGIN, pluginCommands.TERMINATE);
+            } catch (err) {
+                console.log(err);
+                this.sendError(ws, eventType, err.message);
+            }
+        };
+    }
+
+    debuggerEventListener(ws) {
+        return (event) => {
+            let payload = event.payload;
+
+            switch (event.id) {
+                case 'runtime-event://debuggerPlugin/startFlow':
+                    this.sendEvent(ws, 'debugger:on:event', { status: "startFlow" });
+                    break;
+                case 'runtime-event://debuggerPlugin/endFlow':
+                    this.sendEvent(ws, 'debugger:on:event', { status: "endFlow" });
+                    break;
+                case 'runtime-event://debuggerPlugin/errorFlow':
+                    this.sendEvent(ws, 'debugger:on:event', { status: "errorFlow" });
+                    break;
+
+                case 'runtime-event://debuggerPlugin/startNode':
+                case 'runtime-event://debuggerPlugin/endNode':
+                case 'runtime-event://debuggerPlugin/errorNode':
+                    this.sendEvent(ws, 'debugger:on:trace', payload);
+                    break;
+
+                case 'runtime-event://debuggerPlugin/changeState':
+                    this.sendEvent(ws, 'debugger:on:change-state', payload);
+                    break;
+                default:
+                // do nothing
+            }
+        }
+
+    };
+
+    // NOT NEEDED YET
+    // genNextUniqueId(node, testcaseid) {
+    //     let uniqueExecutionNodeId;
+    //     let id = node.id;
+    //     // check if node.id has not yet injected with unique runtime id
+    //     if (!id.includes('::')){
+    //       uniqueExecutionNodeId = `${testcaseid}::${node.id}::0`;
+    //     } else{
+    //       // Replace the testcase id for current one, if still carries the old one
+    //       let idTokenized = id.split('::');
+    //       let prevTestCaseId = idTokenized[0];
+    //       let prevNodeId = idTokenized[1];
+    //       let prevExecutionId = idTokenized[2];
+
+    //       if (prevTestCaseId !== testcaseid) {
+    //         id = `${testcaseid}::${prevNodeId}::${prevExecutionId}`
+    //       }
+
+    //       // if it has iterate over the executionId (last part of the unique runtime id)
+
+    //       let posExecId = id.lastIndexOf('::');
+    //       let prefixId = id.substr(0, posExecId);
+    //       let executionId = parseInt(id.substr(posExecId + 2));
+
+    //       uniqueExecutionNodeId = `${prefixId}::${executionId}`;
+    //       while (uniqueExecutionNodeId in this._cache) {
+    //         executionId = executionId + 1;
+    //         uniqueExecutionNodeId = `${prefixId}::${executionId}`;
+    //       }
+    //     }
+
+
+    //     return uniqueExecutionNodeId;
+    //   }
+}
+
+
+module.exports = {
+    DebuggerTool
+}

package/src/api/tools/filemanager/index.js

@@ -0,0 +1,127 @@
+const { DesignerTool } = require("../base/DesignerTool");
+
+/**
+ * FileManagerTool
+ * A cloud designer tool responsible to facilitate the sync of files between the frontend and the local filesystem.
+ * This tool will support the following operations: rename, update, add and delete files.
+ *
+ */
+class FileManagerTool extends DesignerTool {
+    constructor(designerServer) {
+        super(designerServer);
+    }
+
+    install() {
+        /**
+         * { "type": "filemanager:pull" }
+         */
+        this.addEventHandler('filemanager:pull', this.executePull('filemanager:pull'));
+        /**
+         * { "type": "filemanager:push",
+         *   "payload": { ... }}
+         */
+        this.addEventHandler('filemanager:push', this.executePush('filemanager:push'));
+    }
+
+    /**
+     * Invoked by the client to get the project structure on the server (localfilesystem).
+     * @param {string} - eventType: "filemanager:pull"
+     */
+    executePull(eventType) {
+        /**
+         * @param {ws} - client websocket
+         * @returns {Object} - response
+         * :: Example
+         * {
+        *  'flow': '/project-directory/simple-flow.json',
+         *  'files': {
+         *      '/project-directory': {
+         *          '.kumologica': {
+         *              'editor.json': <content>
+         *              '.kumologica-ignore: "build \n",
+         *          }
+        *
+         *          'simple-flow.json': <content>,
+         *          'config.json': <content>,
+         *          'package.json': <content>
+         *      }
+         *  }
+        *
+         * }
+        */
+        return async (ws, payload) => {
+            try {
+                const response = this.flowServer.runtime.storage.getProjectStructure();
+                this.sendResponse(ws, eventType, response);
+            } catch (err) {
+                console.log(err);
+                this.sendError(ws, eventType, "An error ocurred while pulling project directory from the server");
+            }
+        }
+    }
+
+    /**
+     * Invoked by the client to send the project structure updates into the server.
+     * @param {string} - eventType: "filemanager:push"
+     */
+    executePush(eventType) {
+         /**
+         * @param {ws} - client websocket
+         * @param {Object} payload - request's payload
+         * @param {}
+         * :: Example
+         * {[
+         * {
+         *      operation: "add_file",
+         *      path: "/project-directory",
+         *      filename: "secret.pem",
+         *      content: <content>
+         *  },
+         * {
+         *      operation: "delete_file",
+         *      path: "/project-directory",
+         *      filename: "secret.pem"
+         *  },
+         * {
+         *      operation: "update_file",
+         *      path: "/project-directory",
+         *      filename: "secret.pem",
+         *      content: <content>
+         *  },
+         *  {
+         *      operation: "rename_file",
+         *      path: "/project-directory",
+         *      filename: "secret.pem",
+         *      newFileName: "keys.pem"
+         *  },
+         *  {
+         *      operation: "add_folder",
+         *      path: "/project-directory/new-folder",
+         *  },
+         * {
+         *      operation: "remove_folder",
+         *      path: "/project-directory/old-folder",
+         *  },
+         * {
+         *      operation: "rename_folder",
+         *      path: "/project-directory/old-folder",
+         *      newPath: "/project-directory/new-folder",
+         *  },
+
+         * ]}
+        */
+        return async (ws, payload) => {
+            try {
+                const response = await this.flowServer.runtime.storage.fileOperation(payload);
+                this.sendResponse(ws, eventType, response);
+            } catch (err) {
+                console.log(err);
+                this.sendError(ws, eventType, err.message);
+            }
+        }
+    }
+}
+
+module.exports = {
+    FileManagerTool
+}

package/src/api/tools/git/index.js

@@ -0,0 +1,103 @@
+const { DesignerTool } = require("../base/DesignerTool");
+const simpleGit = require('simple-git');
+
+class GitTool extends DesignerTool {
+    constructor(designerServer) {
+        super(designerServer);
+    }
+
+    install() {
+        /**
+         * { "type": "git:status"}
+         */
+        this.addEventHandler('git:status', this.executeGitStatus('git:status'));
+        /**
+         * { "type": "git:add-and-commit",
+         *   "payload": { "commit": "commit message..." }}
+         */
+        this.addEventHandler('git:add-and-commit', this.executeAddAndCommit('git:add-and-commit'));
+        /**
+         * { "type": "git:push-origin" 
+         *   "payload": {
+         *      proxy: "http://my-annoying-proxy" // optional
+         *   }
+         * }
+         */
+        this.addEventHandler('git:push-origin', this.executePushOrigin('git:push-origin'));
+
+    }
+
+    gitCommand(options) {
+        const { proxy } = options || {};
+
+        // base options
+        let gitOptions = {
+            baseDir: this.flowServer.serverSettings.projectDir,
+            binary: 'git',
+            maxConcurrentProcesses: 6,
+            trimmed: false
+        }
+        // proxy included?
+        if (proxy) {
+            gitOptions = { ...gitOptions, config: [`http.proxy=${proxy}`] }
+        }
+        return simpleGit(gitOptions);
+    }
+
+    executeGitStatus(eventType) {
+        return async (ws, payload) => {
+            try {
+                const git = this.gitCommand();
+                let status = await git.status();  //['-', 'sb']  // newStatus = {ahead, behind, current, tracking};
+                this.sendResponse(ws, eventType, { status });
+            } catch (err) {
+                this.sendError(ws, eventType, "The current project directory is not a Git repository. Please initialize Git in this directory.");
+            }
+        }
+    }
+
+    executeAddAndCommit(eventType) {
+        return async (ws, payload) => {
+            try {
+                const { commit } = payload;
+                if (!commit) {
+                    throw new Error('Commit message cannot be empty')
+                }
+                const git = this.gitCommand();
+                const resp = await git.add('./*').commit(commit);
+                this.sendResponse(ws, eventType, { resp });
+            } catch (err) {
+                this.sendError(ws, eventType, err.message);
+            }
+        }
+    }
+
+    executePushOrigin(eventType) {
+        return async (ws, payload) => {
+            try {
+                const { proxy } = payload;
+                const git = this.gitCommand({ proxy });
+                let currentBranch = await this.readCurrentBranch();
+                const resp = await git.push('origin', currentBranch);
+                this.sendResponse(ws, eventType, { resp });
+            } catch (e) {
+                this.sendError(ws, eventType, err.message);
+            }
+        }
+    }
+
+    async readCurrentBranch() {
+        try {
+            const git = this.gitCommand();
+            const localBranches = await git.branchLocal();
+            return localBranches.current;
+        } catch (err) {
+            throw err;
+        }
+
+    }
+}
+
+module.exports = {
+    GitTool
+}