@kumologica/sdk 3.0.0-alpha4

package/src/api/core/flows.js

@@ -0,0 +1,286 @@
+ 
+
+/**
+ * @mixin @kumologica-core/runtime_flows
+ */
+
+/**
+ * @typedef Flows
+ * @type {object}
+ * @property {string} rev - the flow revision identifier
+ * @property {Array}  flows - the flow configuration, an array of node configuration objects
+ */
+
+/**
+ * @typedef Flow
+ * @type {object}
+ * @property {string} id - the flow identifier
+ * @property {string} label - a label for the flow
+ * @property {Array}  nodes - an array of node configuration objects
+ */
+
+var runtime;
+
+var api = (module.exports = {
+  init: function(_runtime) {
+    runtime = _runtime;
+  },
+  /**
+   * Gets the current flow configuration
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @return {Promise<Flows>} - the active flow configuration
+   * @memberof @kumologica-core/runtime_flows
+   */
+  getFlows: function(opts) {
+    return new Promise(function(resolve, reject) {
+      runtime.log.audit({ event: 'flows.get' } /*,req*/);
+      return resolve(runtime.nodes.getFlows());
+    });
+  },
+  /**
+   * Sets the current flow configuration
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @return {Promise<Flows>} - the active flow configuration
+   * @memberof @kumologica-core/runtime_flows
+   */
+  setFlows: function(opts) {
+    return new Promise(function(resolve, reject) {
+      var flows = opts.flows;
+
+      var deploymentType = opts.deploymentType || 'full';
+      runtime.log.audit({ event: 'flows.set', type: deploymentType } /*,req*/);
+
+      var apiPromise;
+      if (deploymentType === 'reload') {
+        apiPromise = runtime.nodes.loadFlows(true);
+      } else {
+        if (flows.hasOwnProperty('rev')) {
+          var currentVersion = runtime.nodes.getFlows().rev;
+          if (currentVersion !== flows.rev) {
+            var err;
+            err = new Error();
+            err.code = 'version_mismatch';
+            err.status = 409;
+            //TODO: log warning
+            return reject(err);
+          }
+        }
+        apiPromise = runtime.nodes.setFlows(flows.flows, deploymentType);
+      }
+      apiPromise
+        .then(function(flowId) {
+          return resolve({ rev: flowId });
+        })
+        .catch(function(err) {
+          if (deploymentType === 'save'){
+            runtime.log.warn(`Error saving flows: ${err.message}`);
+          } else{
+            runtime.log.warn(`Error reloading flows: ${err.message}`);
+          }
+          runtime.log.warn(err.stack);
+          return reject(err);
+        });
+    });
+  },
+
+  /**
+   * Adds a flow configuration
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @param {Object} opts.flow - the flow to add
+   * @return {Promise<String>} - the id of the added flow
+   * @memberof @kumologica-core/runtime_flows
+   */
+  addFlow: function(opts) {
+    return new Promise(function(resolve, reject) {
+      var flow = opts.flow;
+      runtime.nodes
+        .addFlow(flow)
+        .then(function(id) {
+          runtime.log.audit({ event: 'flow.add', id: id });
+          return resolve(id);
+        })
+        .catch(function(err) {
+          runtime.log.audit({
+            event: 'flow.add',
+            error: err.code || 'unexpected_error',
+            message: err.toString()
+          });
+          err.status = 400;
+          return reject(err);
+        });
+    });
+  },
+
+  /**
+   * Gets an individual flow configuration
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @param {Object} opts.id - the id of the flow to retrieve
+   * @return {Promise<Flow>} - the active flow configuration
+   * @memberof @kumologica-core/runtime_flows
+   */
+  getFlow: function(opts) {
+    return new Promise(function(resolve, reject) {
+      var flow = runtime.nodes.getFlow(opts.id);
+      if (flow) {
+        runtime.log.audit({ event: 'flow.get', id: opts.id });
+        return resolve(flow);
+      } else {
+        runtime.log.audit({
+          event: 'flow.get',
+          id: opts.id,
+          error: 'not_found'
+        });
+        var err = new Error();
+        err.code = 'not_found';
+        err.status = 404;
+        return reject(err);
+      }
+    });
+  },
+  /**
+   * Updates an existing flow configuration
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @param {Object} opts.id - the id of the flow to update
+   * @param {Object} opts.flow - the flow configuration
+   * @return {Promise<String>} - the id of the updated flow
+   * @memberof @kumologica-core/runtime_flows
+   */
+  updateFlow: function(opts) {
+    return new Promise(function(resolve, reject) {
+      var flow = opts.flow;
+      var id = opts.id;
+      try {
+        runtime.nodes
+          .updateFlow(id, flow)
+          .then(function() {
+            runtime.log.audit({ event: 'flow.update', id: id });
+            return resolve(id);
+          })
+          .catch(function(err) {
+            runtime.log.audit({
+              event: 'flow.update',
+              error: err.code || 'unexpected_error',
+              message: err.toString()
+            });
+            err.status = 400;
+            return reject(err);
+          });
+      } catch (err) {
+        if (err.code === 404) {
+          runtime.log.audit({
+            event: 'flow.update',
+            id: id,
+            error: 'not_found'
+          });
+          // TODO: this swap around of .code and .status isn't ideal
+          err.status = 404;
+          err.code = 'not_found';
+          return reject(err);
+        } else {
+          runtime.log.audit({
+            event: 'flow.update',
+            error: err.code || 'unexpected_error',
+            message: err.toString()
+          });
+          err.status = 400;
+          return reject(err);
+        }
+      }
+    });
+  },
+  /**
+   * Deletes a flow
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @param {Object} opts.id - the id of the flow to delete
+   * @return {Promise} - resolves if successful
+   * @memberof @kumologica-core/runtime_flows
+   */
+  deleteFlow: function(opts) {
+    return new Promise(function(resolve, reject) {
+      var id = opts.id;
+      try {
+        runtime.nodes
+          .removeFlow(id)
+          .then(function() {
+            runtime.log.audit({ event: 'flow.remove', id: id });
+            return resolve();
+          })
+          .catch(function(err) {
+            runtime.log.audit({
+              event: 'flow.remove',
+              id: id,
+              error: err.code || 'unexpected_error',
+              message: err.toString()
+            });
+            err.status = 400;
+            return reject(err);
+          });
+      } catch (err) {
+        if (err.code === 404) {
+          runtime.log.audit({
+            event: 'flow.remove',
+            id: id,
+            error: 'not_found'
+          });
+          // TODO: this swap around of .code and .status isn't ideal
+          err.status = 404;
+          err.code = 'not_found';
+          return reject(err);
+        } else {
+          runtime.log.audit({
+            event: 'flow.remove',
+            id: id,
+            error: err.code || 'unexpected_error',
+            message: err.toString()
+          });
+          err.status = 400;
+          return reject(err);
+        }
+      }
+    });
+  },
+
+  /**
+   * Gets the safe credentials for a node
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @param {String} opts.type - the node type to return the credential information for
+   * @param {String} opts.id - the node id
+   * @return {Promise<Object>} - the safe credentials
+   * @memberof @kumologica-core/runtime_flows
+   */
+  getNodeCredentials: function(opts) {
+    return new Promise(function(resolve, reject) {
+      runtime.log.audit({
+        event: 'credentials.get',
+        type: opts.type,
+        id: opts.id
+      });
+      var credentials = runtime.nodes.getCredentials(opts.id);
+      if (!credentials) {
+        return resolve({});
+      }
+      var definition = runtime.nodes.getCredentialDefinition(opts.type) || {};
+
+      var sendCredentials = {};
+      for (var cred in definition) {
+        if (definition.hasOwnProperty(cred)) {
+          if (definition[cred].type == 'password') {
+            var key = 'has_' + cred;
+            sendCredentials[key] =
+              credentials[cred] != null && credentials[cred] !== '';
+            continue;
+          }
+          sendCredentials[cred] = credentials[cred] || '';
+        }
+      }
+      resolve(sendCredentials);
+    });
+  }
+});

package/src/api/core/index.js

@@ -0,0 +1,29 @@
+var runtime;
+
+var api = module.exports = {
+    init: function(_runtime) {
+        runtime = _runtime;
+        api.comms.init(runtime);
+        api.flows.init(runtime);
+        api.nodes.init(runtime);
+        api.settings.init(runtime);
+        api.library.init(runtime);
+        api.projects.init(runtime);
+        api.context.init(runtime);
+    },
+
+    comms: require("./comms"),
+    flows: require("./flows"),
+    library: require("./library"),
+    nodes: require("./nodes"),
+    settings: require("./settings"),
+    projects: require("./projects"),
+    context: require("./context"),
+
+    isStarted: function(opts) {
+        return Promise.resolve(runtime.isStarted());
+    },
+    version: function(opts) {
+        return Promise.resolve(runtime.version());
+    }
+}

package/src/api/core/library.js

@@ -0,0 +1,106 @@
+ 
+
+/**
+ * @mixin @kumologica-core/runtime_library
+ */
+
+var runtime;
+
+var api = module.exports = {
+    init: function(_runtime) {
+        runtime = _runtime;
+    },
+
+    /**
+    * Gets an entry from the library.
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {String} opts.type - the type of entry
+    * @param {String} opts.path - the path of the entry
+    * @return {Promise<String|Object>} - resolves when complete
+    * @memberof @kumologica-core/runtime_library
+    */
+    getEntry: function(opts) {
+        return new Promise(function(resolve,reject) {
+            runtime.library.getEntry(opts.type,opts.path).then(function(result) {
+                runtime.log.audit({event: "library.get",type:opts.type,path:opts.path});
+                return resolve(result);
+            }).catch(function(err) {
+                if (err) {
+                    runtime.log.warn(`Error loading library entry '${opts.path}': ${err.toString()}`);
+                    if (err.code === 'forbidden') {
+                        err.status = 403;
+                        return reject(err);
+                    } else if (err.code === "not_found") {
+                        err.status = 404;
+                    } else {
+                        err.status = 400;
+                    }
+                    runtime.log.audit({event: "library.get",type:opts.type,path:opts.path,error:err.code});
+                    return reject(err);
+                }
+                runtime.log.audit({event: "library.get",type:opts.type,error:"not_found"});
+                var error = new Error();
+                error.code = "not_found";
+                error.status = 404;
+                return reject(error);
+            });
+        })
+    },
+
+    /**
+    * Saves an entry to the library
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {String} opts.type - the type of entry
+    * @param {String} opts.path - the path of the entry
+    * @param {Object} opts.meta - any meta data associated with the entry
+    * @param {String} opts.body - the body of the entry
+    * @return {Promise} - resolves when complete
+    * @memberof @kumologica-core/runtime_library
+    */
+    saveEntry: function(opts) {
+        return new Promise(function(resolve,reject) {
+            runtime.library.saveEntry(opts.type,opts.path,opts.meta,opts.body).then(function() {
+                runtime.log.audit({event: "library.set",type:opts.type,path:opts.path});
+                return resolve();
+            }).catch(function(err) {
+                runtime.log.warn(`Error saving library entry '${opts.path}': ${err.toString()}`);
+                if (err.code === 'forbidden') {
+                    runtime.log.audit({event: "library.set",type:opts.type,path:opts.path,error:"forbidden"});
+                    err.status = 403;
+                    return reject(err);
+                }
+                runtime.log.audit({event: "library.set",type:opts.type,path:opts.path,error:"unexpected_error",message:err.toString()});
+                var error = new Error();
+                error.status = 400;
+                return reject(error);
+            });
+        })
+    },
+    /**
+    * Returns a complete listing of all entries of a given type in the library.
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {String} opts.type - the type of entry
+    * @return {Promise<Object>} - the entry listing
+    * @memberof @kumologica-core/runtime_library
+    */
+    getEntries: function(opts) {
+        return new Promise(function(resolve,reject) {
+            if (opts.type !== 'flows') {
+                return reject(new Error("API only supports flows"));
+
+            }
+            runtime.storage.getAllFlows().then(function(flows) {
+                runtime.log.audit({event: "library.get.all",type:"flow"});
+                var examples = runtime.nodes.getNodeExampleFlows();
+                if (examples) {
+                    flows.d = flows.d||{};
+                    flows.d._examples_ = examples;
+                }
+                return resolve(flows);
+            });
+        })
+    }
+}