@kumologica/sdk 3.2.0-beta9 → 4.0.0-alpha2

package/package.json

@@ -3,7 +3,7 @@
   "productName": "Kumologica Designer",
   "copyright": "Copyright 2020 Kumologica Pty Ltd, All Rights Reserved.",
   "author": "Kumologica Pty Ltd <contact@kumologica.com>",
-  "version": "3.2.0-beta9",
+  "version": "4.0.0-alpha2",
   "description": "Kumologica Designer, harnessing Serverless for your cloud integration needs",
   "main": "src/app/main.js",
   "files": [
@@ -18,157 +18,55 @@
     "url": "https://github.com/KumologicaHQ/kumologica-designer-releases.git",
     "option": "private"
   },
-  "build": {
-    "directories": {
-      "buildResources": "src/assets"
-    },
-    "afterSign": "build/scripts/notarize.js",
-    "appId": "com.kumologica.designer",
-    "artifactName": "${productName}.${ext}",
-    "dmg": {
-      "sign": false
-    },
-    "mac": {
-      "target": [
-        "dmg",
-        "zip"
-      ],
-      "icon": "./src/assets/kumologica-app.icns",
-      "category": "public.app-category.developer-tools",
-      "hardenedRuntime": true,
-      "gatekeeperAssess": false,
-      "entitlements": "build/entitlements.mac.plist",
-      "entitlementsInherit": "build/entitlements.mac.plist"
-    },
-    "linux": {
-      "icon": "./src/assets/kumologica-app.png",
-      "target": [
-        "AppImage",
-        "deb"
-      ]
-    },
-    "win": {
-      "icon": "./src/assets/kumologica-app.png"
-    }
-  },
   "scripts": {
-    "dev": "electron .",
-    "open": "grunt && electron .",
     "open:test": "node src/cli/index open ../@kumologica-runtime/example",
     "open:mock": "node src/cli/index open ../cloud-red-examples/echo-aws",
     "test": "mocha 'src/**/*.spec.js'",
-    "grunt": "grunt",
-    "del-postinstall": "electron-builder install-app-deps",
     "license-check": "npx license-checker --summary && npx license-compatibility-checker ",
     "license-report": "npx license-report --output=table"
   },
   "license": "Proprietary",
   "dependencies": {
-    "@electron/remote": "^2.0.8",
-    "@kumologica/builder": "3.2.0-beta9",
-    "@kumologica/devkit": "3.2.0-beta9",
-    "@kumologica/runtime": "3.2.0-beta9",
-    "adm-zip": "0.4.13",
+    "@kumologica/builder": "4.0.0-alpha2",
+    "@kumologica/devkit": "4.0.0-alpha2",
+    "@kumologica/runtime": "4.0.0-alpha2",
     "ajv": "8.10.0",
     "archive-type": "^4.0.0",
-    "aws-sdk": "2.513.0",
-    "basic-auth": "2.0.1",
-    "bcryptjs": "2.4.3",
+    "archiver": "^5.3.1",
+    "better-opn": "^3.0.2",
     "bluebird": "^3.7.2",
-    "body-parser": "1.19.0",
     "chalk": "2.4.2",
-    "child_process": "1.0.2",
-    "child-process-ext": "^2.1.1",
-    "clone": "2.1.2",
+    "child-process-ext": "2.1.1",
     "content-disposition": "0.5.4",
-    "cookie-parser": "1.4.4",
-    "cors": "^2.8.5",
-    "dagre": "^0.8.5",
-    "debounce": "^1.2.0",
     "decompress": "^4.2.1",
-    "electron": "19.0.0",
-    "electron-tabs": "^1.0.1",
-    "electron-updater": "4.3.9",
     "enquirer": "2.3.6",
-    "express": "4.17.3",
-    "express-session": "1.16.2",
+    "express": "^4.17.3",
     "ext-name": "^5.0.0",
-    "extract-json-from-string": "1.0.1",
     "file-type": "^18.2.1",
     "filenamify": "^5.1.1",
     "fs-extra": "10.1.0",
     "get-stream": "^6.0.1",
-    "glob": "7.1.6",
     "got": "11.8.5",
-    "hash-sum": "2.0.0",
-    "iconv-lite": "0.5.0",
-    "ini": "^2.0.0",
     "js-yaml": "3.13.1",
     "json-cycle": "^1.3.0",
-    "jsonata": "1.7.0",
-    "jsonpath": "1.0.2",
     "make-dir": "^3.1.0",
-    "memorystore": "1.6.1",
-    "mime": "2.4.4",
-    "mustache": "3.0.1",
-    "oauth2orize": "1.11.0",
-    "os": "0.1.1",
     "p-event": "^5.0.1",
-    "passport": "0.4.0",
-    "passport-http-bearer": "1.0.1",
-    "passport-oauth2-client-password": "0.1.2",
-    "querystring": "^0.2.1",
-    "request": "2.88.0",
-    "rimraf": "3.0.0",
-    "shell-path": "2.1.0",
-    "simple-git": "^3.14.1",
-    "simplemde": "1.11.2",
-    "smoketail": "0.2.2",
-    "static-eval": "2.0.2",
-    "tcp-port-used": "1.0.2",
-    "url": "^0.11.0",
-    "util": "0.12.1",
-    "whatwg-url": "^11.0.0",
-    "when": "3.7.8",
-    "wide-align": "^1.1.5",
+    "simple-git": "^3.19.1",
     "wildcard-match": "^5.1.2",
-    "ws": "7.5.9",
-    "xterm": "4.1.0",
-    "xterm-addon-fit": "0.2.1",
+    "ws": "^8.13.0",
     "yargs": "17.3.1"
   },
   "devDependencies": {
-    "@types/node": "^12.6.8",
     "chai": "^4.2.0",
-    "grunt": "^1.0.4",
-    "grunt-cli": "~1.3.2",
-    "grunt-concurrent": "3.0.0",
-    "grunt-contrib-clean": "~1.1.0",
-    "grunt-contrib-compress": "~1.4.0",
-    "grunt-contrib-concat": "~1.0.1",
-    "grunt-contrib-copy": "~1.0.0",
-    "grunt-contrib-watch": "~1.1.0",
-    "grunt-jsdoc": "^2.2.1",
-    "grunt-jsdoc-to-markdown": "6.0.0",
-    "grunt-mkdir": "~1.0.0",
-    "grunt-mocha-istanbul": "5.0.2",
-    "grunt-npm-command": "~0.1.2",
-    "grunt-sass": "3.1.0",
-    "grunt-simple-mocha": "~0.4.1",
-    "grunt-terser": "2.0.0",
-    "istanbul": "^0.4.5",
     "license-checker": "^25.0.1",
     "license-compatibility-checker": "^0.3.4",
     "license-report": "^3.0.0",
-    "mocha": "10.2.0",
-    "node-sass": "8.0.0",
-    "tslint": "^5.18.0",
-    "typescript": "^3.5.3"
+    "mocha": "10.2.0"
   },
   "engines": {
     "node": ">=8"
   },
   "kumologica": {
-    "dev": true
+    "dev": false
   }
 }

package/src/api/core/comms.js

@@ -0,0 +1,141 @@
+ 
+ 
+/**
+ * This is the comms subsystem of the runtime.
+ * @mixin @kumologica-core/runtime_comms
+ */
+
+/**
+ * A WebSocket connection between the runtime and the editor.
+ * @typedef CommsConnection
+ * @type {object}
+ * @property {string} session - a unique session identifier
+ * @property {Object} user - the user associated with the connection
+ * @property {Function} send - publish a message to the connection
+ */
+
+
+var runtime;
+var retained = {};
+var connections = [];
+
+
+function handleCommsEvent(event) {
+    publish(event.topic,event.data,event.retain);
+}
+function handleStatusEvent(event) {
+    var status = {
+        text: event.status.text,
+        fill: event.status.fill,
+        shape: event.status.shape
+    };
+    publish("status/"+event.id,status,true);
+}
+function handleRuntimeEvent(event) {
+    //runtime.log.trace("runtime event: "+JSON.stringify(event));
+    publish("notification/"+event.id,event.payload||{},event.retain);
+}
+function handleEventLog(event) {
+    var type = event.payload.type;
+    var id = event.id;
+    if (event.payload.data) {
+        var data = event.payload.data;
+        if (data.endsWith('\n')) {
+            data = data.substring(0,data.length-1);
+        }
+        var lines = data.split(/\n/);
+        lines.forEach(line => {
+            runtime.log.debug((type?("["+type+"] "):"")+line)
+        })
+    }
+    publish("event-log/"+event.id,event.payload||{});
+}
+
+function publish(topic,data,retain) {
+    if (retain) {
+        retained[topic] = data;
+    } else {
+        delete retained[topic];
+    }
+    connections.forEach(connection => connection.send(topic,data))
+}
+
+
+var api = module.exports = {
+    init: function(_runtime) {
+        runtime = _runtime;
+        connections = [];
+        retained = {};
+        runtime.events.removeListener("node-status",handleStatusEvent);
+        runtime.events.on("node-status",handleStatusEvent);
+        runtime.events.removeListener("runtime-event",handleRuntimeEvent);
+        runtime.events.on("runtime-event",handleRuntimeEvent);
+        runtime.events.removeListener("comms",handleCommsEvent);
+        runtime.events.on("comms",handleCommsEvent);
+        runtime.events.removeListener("event-log",handleEventLog);
+        runtime.events.on("event-log",handleEventLog);
+    },
+
+    /**
+    * Registers a new comms connection
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {CommsConnection} opts.client - the client connection
+    * @return {Promise<Object>} - resolves when complete
+    * @memberof @kumologica-core/runtime_comms
+    */
+    addConnection: function(opts) {
+        connections.push(opts.client);
+        return Promise.resolve();
+    },
+
+    /**
+    * Unregisters a comms connection
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {CommsConnection} opts.client - the client connection
+    * @return {Promise<Object>} - resolves when complete
+    * @memberof @kumologica-core/runtime_comms
+    */
+    removeConnection: function(opts) {
+        for (var i=0;i<connections.length;i++) {
+            if (connections[i] === opts.client) {
+                connections.splice(i,1);
+                break;
+            }
+        }
+        return Promise.resolve();
+    },
+
+    /**
+    * Subscribes a comms connection to a given topic. Currently, all clients get
+    * automatically subscribed to everything and cannot unsubscribe. Sending a subscribe
+    * request will trigger retained messages to be sent.
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {CommsConnection} opts.client - the client connection
+    * @param {String} opts.topic - the topic to subscribe to
+    * @return {Promise<Object>} - resolves when complete
+    * @memberof @kumologica-core/runtime_comms
+    */
+    subscribe: function(opts) {
+        var re = new RegExp("^"+opts.topic.replace(/([\[\]\?\(\)\\\\$\^\*\.|])/g,"\\$1").replace(/\+/g,"[^/]+").replace(/\/#$/,"(\/.*)?")+"$");
+        for (var t in retained) {
+            if (re.test(t)) {
+                opts.client.send(t,retained[t]);
+            }
+        }
+        return Promise.resolve();
+    },
+
+    /**
+    * TODO: Unsubscribes a comms connection from a given topic
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {CommsConnection} opts.client - the client connection
+    * @param {String} opts.topic - the topic to unsubscribe from
+    * @return {Promise<Object>} - resolves when complete
+    * @memberof @kumologica-core/runtime_comms
+    */
+    unsubscribe: function(opts) {}
+};

package/src/api/core/context.js

@@ -0,0 +1,296 @@
+
+
+/**
+ * @mixin @kumologica-core/runtime_context
+ */
+
+var runtime;
+
+let util = require('@kumologica/runtime').util;
+
+function exportContextStore(scope, ctx, store, result, callback) {
+  ctx.keys(store, function (err, keys) {
+    if (err) {
+      return callback(err);
+    }
+    result[store] = {};
+    var c = keys.length;
+    if (c === 0) {
+      callback(null);
+    } else {
+      keys.forEach(function (key) {
+        ctx.get(key, store, function (err, v) {
+          if (err) {
+            return callback(err);
+          }
+          if (
+            scope !== 'global' ||
+            store === runtime.nodes.listContextStores().default ||
+            !runtime.settings.hasOwnProperty('functionGlobalContext') ||
+            !runtime.settings.functionGlobalContext.hasOwnProperty(key) ||
+            runtime.settings.functionGlobalContext[key] !== v
+          ) {
+            result[store][key] = util.encodeObject({ msg: v });
+          }
+          c--;
+          if (c === 0) {
+            callback(null);
+          }
+        });
+      });
+    }
+  });
+}
+
+var api = (module.exports = {
+  init: function (_runtime) {
+    runtime = _runtime;
+  },
+  /**
+    * Gets the info of an individual node set
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {String} opts.scope - the scope of the context
+    * @param {String} opts.id - the id of the context
+    * @param {String} opts.store - the context store
+    * @param {String} opts.key - the context key
+
+    * @return {Promise} - the node information
+    * @memberof @kumologica-core/runtime_context
+    */
+  getValue: function (opts) {
+    return new Promise(function (resolve, reject) {
+      var scope = opts.scope;
+      var id = opts.id;
+      var store = opts.store;
+      var key = opts.key;
+
+      var availableStores = runtime.nodes.listContextStores();
+      //{ default: 'default', stores: [ 'default', 'file' ] }
+      if (store && availableStores.stores.indexOf(store) === -1) {
+        runtime.log.audit({
+          event: 'context.get',
+          scope: scope,
+          id: id,
+          store: store,
+          key: key,
+          error: 'not_found'
+        });
+        var err = new Error();
+        err.code = 'not_found';
+        err.status = 404;
+        return reject(err);
+      }
+      var ctx;
+      if (scope === 'global') {
+        ctx = runtime.nodes.getContext('global');
+      } else if (scope === 'flow') {
+        ctx = runtime.nodes.getContext(id);
+      } else if (scope === 'node') {
+        var node = runtime.nodes.getNode(id);
+        if (node) {
+          ctx = node.context();
+        }
+      }
+      if (ctx) {
+        if (key) {
+          store = store || availableStores.default;
+          ctx.get(key, store, function (err, v) {
+            var encoded = util.encodeObject({ msg: v });
+            if (store !== availableStores.default) {
+              encoded.store = store;
+            }
+            runtime.log.audit({
+              event: 'context.get',
+              scope: scope,
+              id: id,
+              store: store,
+              key: key
+            });
+            resolve(encoded);
+          });
+          return;
+        } else {
+          var stores;
+          if (!store) {
+            stores = availableStores.stores;
+          } else {
+            stores = [store];
+          }
+
+          var result = {};
+          var c = stores.length;
+          var errorReported = false;
+          stores.forEach(function (store) {
+            exportContextStore(scope, ctx, store, result, function (err) {
+              if (err) {
+                // TODO: proper error reporting
+                if (!errorReported) {
+                  errorReported = true;
+                  runtime.log.audit({
+                    event: 'context.get',
+                    scope: scope,
+                    id: id,
+                    store: store,
+                    key: key,
+                    error: 'unexpected_error'
+                  });
+                  var err = new Error();
+                  err.code = 'unexpected_error';
+                  err.status = 400;
+                  return reject(err);
+                }
+
+                return;
+              }
+              c--;
+              if (c === 0) {
+                if (!errorReported) {
+                  runtime.log.audit({
+                    event: 'context.get',
+                    scope: scope,
+                    id: id,
+                    store: store,
+                    key: key
+                  });
+                  resolve(result);
+                }
+              }
+            });
+          });
+        }
+      } else {
+        runtime.log.audit({
+          event: 'context.get',
+          scope: scope,
+          id: id,
+          store: store,
+          key: key
+        });
+        resolve({});
+      }
+    });
+  },
+
+  /**
+    * Gets the info of an individual node set
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {String} opts.scope - the scope of the context
+    * @param {String} opts.id - the id of the context
+    * @param {String} opts.store - the context store
+    * @param {String} opts.key - the context key
+
+    * @return {Promise} - the node information
+    * @memberof @kumologica-core/runtime_context
+    */
+  delete: function (opts) {
+    return new Promise(function (resolve, reject) {
+      var scope = opts.scope;
+      var id = opts.id;
+      var store = opts.store;
+      var key = opts.key;
+
+      var availableStores = runtime.nodes.listContextStores();
+      //{ default: 'default', stores: [ 'default', 'file' ] }
+      if (store && availableStores.stores.indexOf(store) === -1) {
+        runtime.log.audit({
+          event: 'context.get',
+          scope: scope,
+          id: id,
+          store: store,
+          key: key,
+          error: 'not_found'
+        });
+        var err = new Error();
+        err.code = 'not_found';
+        err.status = 404;
+        return reject(err);
+      }
+      var ctx;
+      if (scope === 'global') {
+        ctx = runtime.nodes.getContext('global');
+      } else if (scope === 'flow') {
+        ctx = runtime.nodes.getContext(id);
+      } else if (scope === 'node') {
+        var node = runtime.nodes.getNode(id);
+        if (node) {
+          ctx = node.context();
+        }
+      }
+      if (ctx) {
+        if (key) {
+          store = store || availableStores.default;
+          ctx.set(key, undefined, store, function (err) {
+            runtime.log.audit({
+              event: 'context.delete',
+              scope: scope,
+              id: id,
+              store: store,
+              key: key
+            });
+            resolve();
+          });
+          return;
+        } else {
+          // TODO: support deleting whole context
+          runtime.log.audit({
+            event: 'context.get',
+            scope: scope,
+            id: id,
+            store: store,
+            key: key,
+            error: 'not_found'
+          });
+          var err = new Error();
+          err.code = 'not_found';
+          err.status = 404;
+          return reject(err);
+          // var stores;
+          // if (!store) {
+          //     stores = availableStores.stores;
+          // } else {
+          //     stores = [store];
+          // }
+          //
+          // var result = {};
+          // var c = stores.length;
+          // var errorReported = false;
+          // stores.forEach(function(store) {
+          //     exportContextStore(scope,ctx,store,result,function(err) {
+          //         if (err) {
+          //             // TODO: proper error reporting
+          //             if (!errorReported) {
+          //                 errorReported = true;
+          //                 runtime.log.audit({event: "context.delete",scope:scope,id:id,store:store,key:key,error:"unexpected_error"});
+          //                 var err = new Error();
+          //                 err.code = "unexpected_error";
+          //                 err.status = 400;
+          //                 return reject(err);
+          //             }
+          //
+          //             return;
+          //         }
+          //         c--;
+          //         if (c === 0) {
+          //             if (!errorReported) {
+          //                 runtime.log.audit({event: "context.get",scope:scope,id:id,store:store,key:key});
+          //                 resolve(result);
+          //             }
+          //         }
+          //     });
+          // })
+        }
+      } else {
+        runtime.log.audit({
+          event: 'context.delete',
+          scope: scope,
+          id: id,
+          store: store,
+          key: key
+        });
+        resolve();
+      }
+    });
+  }
+});