@kumologica/sdk 3.0.0-alpha4

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

@@ -0,0 +1,171 @@
+var express = require('express');
+
+var nodes = require('./nodes');
+var flows = require('./flows');
+var flow = require('./flow');
+var context = require('./context');
+var util = require('./util');
+
+let errorHandler = (err, req, res, next) => {
+  console.error(err.stack);
+  res.status(500).send('Something broke!');
+}
+
+function needsPermission(permission) {
+  return function (req, res, next) {
+    // if (userHasPermission(req.user, permission)) {
+    next();
+    // } else {
+    //   res.status(401).send('Unauthorized');
+    // }
+  };
+}
+
+module.exports = {
+  init: function (runtime) {
+    // Load all internal runtime APIs
+    let runtimeAPI = require('../index');
+    runtimeAPI.init(runtime);
+
+    flows.init(runtimeAPI);
+    flow.init(runtimeAPI);
+    nodes.init(runtimeAPI);
+    context.init(runtimeAPI);
+    util.init(runtimeAPI);
+
+    var adminApp = express();
+
+    // Flows
+    adminApp.get(
+      '/flows',
+      needsPermission('flows.read'),
+      flows.get,
+      errorHandler
+    );
+    adminApp.post(
+      '/flows',
+      needsPermission('flows.write'),
+      flows.post,
+      errorHandler
+    );
+
+    // Flow
+    adminApp.get(
+      '/flow/:id',
+      needsPermission('flows.read'),
+      flow.get,
+      errorHandler
+    );
+    adminApp.post(
+      '/flow',
+      needsPermission('flows.write'),
+      flow.post,
+      errorHandler
+    );
+    adminApp.delete(
+      '/flow/:id',
+      needsPermission('flows.write'),
+      flow.delete,
+      errorHandler
+    );
+    adminApp.put(
+      '/flow/:id',
+      needsPermission('flows.write'),
+      flow.put,
+      errorHandler
+    );
+
+    // Nodes
+    adminApp.post(
+      '/nodes-reload',
+      needsPermission('nodes.write'),
+      nodes.reloadModules,
+      errorHandler
+    );
+    adminApp.get(
+      '/nodes',
+      needsPermission('nodes.read'),
+      nodes.getAll,
+      errorHandler
+    );
+    adminApp.post(
+      '/nodes',
+      needsPermission('nodes.write'),
+      nodes.post,
+      errorHandler
+    );
+    adminApp.get(
+      /^\/nodes\/((@[^\/]+\/)?[^\/]+)$/,
+      needsPermission('nodes.read'),
+      nodes.getModule,
+      errorHandler
+    );
+    adminApp.put(
+      /^\/nodes\/((@[^\/]+\/)?[^\/]+)$/,
+      needsPermission('nodes.write'),
+      nodes.putModule,
+      errorHandler
+    );
+    adminApp.delete(
+      /^\/nodes\/((@[^\/]+\/)?[^\/]+)$/,
+      needsPermission('nodes.write'),
+      nodes.delete,
+      errorHandler
+    );
+    adminApp.get(
+      /^\/nodes\/((@[^\/]+\/)?[^\/]+)\/([^\/]+)$/,
+      needsPermission('nodes.read'),
+      nodes.getSet,
+      errorHandler
+    );
+    adminApp.put(
+      /^\/nodes\/((@[^\/]+\/)?[^\/]+)\/([^\/]+)$/,
+      needsPermission('nodes.write'),
+      nodes.putSet,
+      errorHandler
+    );
+
+    // Context
+    adminApp.get(
+      '/context/:scope(global)',
+      needsPermission('context.read'),
+      context.get,
+      errorHandler
+    );
+    adminApp.get(
+      '/context/:scope(global)/*',
+      needsPermission('context.read'),
+      context.get,
+      errorHandler
+    );
+    adminApp.get(
+      '/context/:scope(node|flow)/:id',
+      needsPermission('context.read'),
+      context.get,
+      errorHandler
+    );
+    adminApp.get(
+      '/context/:scope(node|flow)/:id/*',
+      needsPermission('context.read'),
+      context.get,
+      errorHandler
+    );
+
+    // adminApp.delete("/context/:scope(global)",needsPermission("context.write"),context.delete,errorHandler);
+    adminApp.delete(
+      '/context/:scope(global)/*',
+      needsPermission('context.write'),
+      context.delete,
+      errorHandler
+    );
+    // adminApp.delete("/context/:scope(node|flow)/:id",needsPermission("context.write"),context.delete,errorHandler);
+    adminApp.delete(
+      '/context/:scope(node|flow)/:id/*',
+      needsPermission('context.write'),
+      context.delete,
+      errorHandler
+    );
+
+    return adminApp;
+  }
+};

package/src/api/core/rest/nodes.js

@@ -0,0 +1,164 @@
+var apiUtils = require('./util');
+
+var runtimeAPI;
+
+module.exports = {
+  init: function(_runtimeAPI) {
+    runtimeAPI = _runtimeAPI;
+  },
+  getAll: function(req, res) {
+    var opts = {
+      user: req.user
+    };
+    if (req.get('accept') == 'application/json') {
+      runtimeAPI.nodes.getNodeList(opts).then(function(list) {
+        res.json(list);
+      });
+    } else {
+      opts.lang = apiUtils.determineLangFromHeaders(req.acceptsLanguages());
+      runtimeAPI.nodes.getNodeConfigs(opts).then(function(configs) {
+        res.send(configs);
+      });
+    }
+  },
+
+  post: function(req, res) {
+    var opts = {
+      user: req.user,
+      module: req.body.module,
+      version: req.body.version
+    };
+    runtimeAPI.nodes
+      .addModule(opts)
+      .then(function(info) {
+        res.json(info);
+      })
+      .catch(function(err) {
+        apiUtils.rejectHandler(req, res, err);
+      });
+  },
+
+  delete: function(req, res) {
+    var opts = {
+      user: req.user,
+      module: req.params[0]
+    };
+    runtimeAPI.nodes
+      .removeModule(opts)
+      .then(function() {
+        res.status(204).end();
+      })
+      .catch(function(err) {
+        apiUtils.rejectHandler(req, res, err);
+      });
+  },
+
+  getSet: function(req, res) {
+    var opts = {
+      user: req.user,
+      id: req.params[0] + '/' + req.params[2]
+    };
+    if (req.get('accept') === 'application/json') {
+      runtimeAPI.nodes
+        .getNodeInfo(opts)
+        .then(function(result) {
+          res.send(result);
+        })
+        .catch(function(err) {
+          apiUtils.rejectHandler(req, res, err);
+        });
+    } else {
+      opts.lang = apiUtils.determineLangFromHeaders(req.acceptsLanguages());
+      runtimeAPI.nodes
+        .getNodeConfig(opts)
+        .then(function(result) {
+          return res.send(result);
+        })
+        .catch(function(err) {
+          apiUtils.rejectHandler(req, res, err);
+        });
+    }
+  },
+
+  getModule: function(req, res) {
+    var opts = {
+      user: req.user,
+      module: req.params[0]
+    };
+    runtimeAPI.nodes
+      .getModuleInfo(opts)
+      .then(function(result) {
+        res.send(result);
+      })
+      .catch(function(err) {
+        apiUtils.rejectHandler(req, res, err);
+      });
+  },
+
+  reloadModules: async function(req, res) {
+    // Ensure backwards compatibility with old runtimes. Eg. user declares an external runtime to power its flows other than the embeded one
+    if (typeof runtimeAPI.httpNode.refreshingUserMiddlewares === 'function'){
+      runtimeAPI.httpNode.refreshingUserMiddlewares();
+    }
+
+    let result = await runtimeAPI.nodes.reloadModules();
+    res.send(result);
+  },
+
+  putSet: function(req, res) {
+    var body = req.body;
+    if (!body.hasOwnProperty('enabled')) {
+      // log.audit({event: "nodes.module.set",error:"invalid_request"},req);
+      res
+        .status(400)
+        .json({ code: 'invalid_request', message: 'Invalid request' });
+      return;
+    }
+    var opts = {
+      user: req.user,
+      id: req.params[0] + '/' + req.params[2],
+      enabled: body.enabled
+    };
+    runtimeAPI.nodes
+      .setNodeSetState(opts)
+      .then(function(result) {
+        res.send(result);
+      })
+      .catch(function(err) {
+        apiUtils.rejectHandler(req, res, err);
+      });
+  },
+
+  putModule: function(req, res) {
+    var body = req.body;
+    if (!body.hasOwnProperty('enabled')) {
+      // log.audit({event: "nodes.module.set",error:"invalid_request"},req);
+      res
+        .status(400)
+        .json({ code: 'invalid_request', message: 'Invalid request' });
+      return;
+    }
+    var opts = {
+      user: req.user,
+      module: req.params[0],
+      enabled: body.enabled
+    };
+    runtimeAPI.nodes
+      .setModuleState(opts)
+      .then(function(result) {
+        res.send(result);
+      })
+      .catch(function(err) {
+        apiUtils.rejectHandler(req, res, err);
+      });
+  },
+
+  getIcons: function(req, res) {
+    var opts = {
+      user: req.user
+    };
+    runtimeAPI.nodes.getIconList(opts).then(function(list) {
+      res.json(list);
+    });
+  }
+};

package/src/api/core/rest/util.js

@@ -0,0 +1,53 @@
+let runtimeAPI;
+let log;
+
+module.exports = {
+    init: function(_runtimeAPI) {
+      runtimeAPI = _runtimeAPI;
+      log = runtimeAPI.log;
+  },
+  errorHandler: function(err, req, res, next) {
+    //TODO: why this when rejectHandler also?!
+
+    if (err.message === 'request entity too large') {
+      log.error(err);
+    } else {
+      log.error(err.stack);
+    }
+    log.audit(
+      {
+        event: 'api.error',
+        error: err.code || 'unexpected_error',
+        message: err.toString()
+      },
+      req
+    );
+    res
+      .status(400)
+      .json({ error: 'unexpected_error', message: err.toString() });
+  },
+
+  determineLangFromHeaders: function(acceptedLanguages) {
+    var lang = 'en-US';
+    acceptedLanguages = acceptedLanguages || [];
+    if (acceptedLanguages.length >= 1) {
+      lang = acceptedLanguages[0];
+    }
+    return lang;
+  },
+  rejectHandler: function(req, res, err) {
+    //TODO: why this when errorHandler also?!
+    log.audit(
+      {
+        event: 'api.error',
+        error: err.code || 'unexpected_error',
+        message: err.message || err.toString()
+      },
+      req
+    );
+    res.status(err.status || 400).json({
+      code: err.code || 'unexpected_error',
+      message: err.message || err.toString()
+    });
+  }
+};

package/src/api/core/settings.js

@@ -0,0 +1,287 @@
+/**
+ * @mixin @kumologica-core/runtime_settings
+ */
+
+var util = require('util');
+var runtime;
+
+function extend(target, source) {
+  var keys = Object.keys(source);
+  var i = keys.length;
+  while (i--) {
+    var value = source[keys[i]];
+    var type = typeof value;
+    if (
+      type === 'string' ||
+      type === 'number' ||
+      type === 'boolean' ||
+      Array.isArray(value)
+    ) {
+      target[keys[i]] = value;
+    } else if (value === null) {
+      if (target.hasOwnProperty(keys[i])) {
+        delete target[keys[i]];
+      }
+    } else {
+      // Object
+      if (target.hasOwnProperty(keys[i])) {
+        target[keys[i]] = extend(target[keys[i]], value);
+      } else {
+        target[keys[i]] = value;
+      }
+    }
+  }
+  return target;
+}
+
+function getSSHKeyUsername(userObj) {
+  var username = '__default';
+  if (userObj && userObj.username) {
+    username = userObj.username;
+  }
+  return username;
+}
+var api = (module.exports = {
+  init: function (_runtime) {
+    runtime = _runtime;
+  },
+  // Read a particular key from the runtime settings - unsafe call (?)
+  get: function (key) {
+    return runtime.settings[key];
+  },
+  /**
+   * Gets the runtime settings object
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @return {Promise<Object>} - the runtime settings
+   * @memberof @kumologica-core/runtime_settings
+   */
+  getRuntimeSettings: function (opts) {
+    return new Promise(function (resolve, reject) {
+      try {
+        var safeSettings = {
+          httpNodeRoot: runtime.settings.httpNodeRoot || '/',
+          version: runtime.settings.version,
+          userDir: runtime.settings.userDir,
+        };
+        if (opts && opts.user) {
+          safeSettings.user = {};
+          var props = ['anonymous', 'username', 'image', 'permissions'];
+          props.forEach((prop) => {
+            if (opts.user.hasOwnProperty(prop)) {
+              safeSettings.user[prop] = opts.user[prop];
+            }
+          });
+        }
+
+        safeSettings.context = runtime.nodes.listContextStores();
+
+        if (util.isArray(runtime.settings.paletteCategories)) {
+          safeSettings.paletteCategories = runtime.settings.paletteCategories;
+        }
+
+        if (runtime.settings.flowFilePretty) {
+          safeSettings.flowFilePretty = runtime.settings.flowFilePretty;
+        }
+
+        if (!runtime.nodes.paletteEditorEnabled()) {
+          safeSettings.editorTheme = safeSettings.editorTheme || {};
+          safeSettings.editorTheme.palette =
+            safeSettings.editorTheme.palette || {};
+          safeSettings.editorTheme.palette.editable = false;
+        }
+        if (runtime.storage.projects) {
+          var activeProject = runtime.storage.projects.getActiveProject();
+          if (activeProject) {
+            safeSettings.project = activeProject;
+          } else if (runtime.storage.projects.flowFileExists()) {
+            safeSettings.files = {
+              flow: runtime.storage.projects.getFlowFilename(),
+              credentials: runtime.storage.projects.getCredentialsFilename(),
+            };
+          }
+          safeSettings.git = {
+            globalUser: runtime.storage.projects.getGlobalGitUser(),
+          };
+        }
+
+        safeSettings.flowEncryptionType = runtime.nodes.getCredentialKeyType();
+
+        runtime.settings.exportNodeSettings(safeSettings);
+
+        resolve(safeSettings);
+      } catch (err) {
+        console.log(err);
+      }
+    });
+  },
+
+  /**
+   * Gets an individual user's settings object
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @return {Promise<Object>} - the user settings
+   * @memberof @kumologica-core/runtime_settings
+   */
+  getUserSettings: function (opts) {
+    opts = opts || {};
+    var username;
+    if (!opts.user || opts.user.anonymous) {
+      username = '_';
+    } else {
+      username = opts.user.username;
+    }
+    return Promise.resolve(runtime.settings.getUserSettings(username) || {});
+  },
+
+  /**
+   * Updates an individual user's settings object.
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @param {Object} opts.settings - the updates to the user settings
+   * @return {Promise<Object>} - the user settings
+   * @memberof @kumologica-core/runtime_settings
+   */
+  updateUserSettings: function (opts) {
+    var username;
+    if (!opts.user || opts.user.anonymous) {
+      username = '_';
+    } else {
+      username = opts.user.username;
+    }
+    return new Promise(function (resolve, reject) {
+      var currentSettings = runtime.settings.getUserSettings(username) || {};
+      currentSettings = extend(currentSettings, opts.settings);
+      try {
+        runtime.settings
+          .setUserSettings(username, currentSettings)
+          .then(function () {
+            runtime.log.audit({ event: 'settings.update', username: username });
+            return resolve();
+          })
+          .catch(function (err) {
+            runtime.log.audit({
+              event: 'settings.update',
+              username: username,
+              error: err.code || 'unexpected_error',
+              message: err.toString(),
+            });
+            err.status = 400;
+            return reject(err);
+          });
+      } catch (err) {
+        runtime.log.warn(`Cannot save user settings: ${err.toString()}`);
+        runtime.log.audit({
+          event: 'settings.update',
+          username: username,
+          error: err.code || 'unexpected_error',
+          message: err.toString(),
+        });
+        err.status = 400;
+        return reject(err);
+      }
+    });
+  },
+
+  /**
+   * Gets a list of a user's ssh keys
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @return {Promise<Object>} - the user's ssh keys
+   * @memberof @kumologica-core/runtime_settings
+   */
+  getUserKeys: function (opts) {
+    return new Promise(function (resolve, reject) {
+      var username = getSSHKeyUsername(opts.user);
+      runtime.storage.projects.ssh
+        .listSSHKeys(username)
+        .then(function (list) {
+          return resolve(list);
+        })
+        .catch(function (err) {
+          err.status = 400;
+          return reject(err);
+        });
+    });
+  },
+
+  /**
+   * Gets a user's ssh public key
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @param {User} opts.id - the id of the key to return
+   * @return {Promise<String>} - the user's ssh public key
+   * @memberof @kumologica-core/runtime_settings
+   */
+  getUserKey: function (opts) {
+    return new Promise(function (resolve, reject) {
+      var username = getSSHKeyUsername(opts.user);
+      // console.log('username:', username);
+      runtime.storage.projects.ssh
+        .getSSHKey(username, opts.id)
+        .then(function (data) {
+          if (data) {
+            return resolve(data);
+          } else {
+            var err = new Error('Key not found');
+            err.code = 'not_found';
+            err.status = 404;
+            return reject(err);
+          }
+        })
+        .catch(function (err) {
+          err.status = 400;
+          return reject(err);
+        });
+    });
+  },
+
+  /**
+   * Generates a new ssh key pair
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @param {User} opts.name - the id of the key to return
+   * @param {User} opts.password - (optional) the password for the key pair
+   * @param {User} opts.comment - (option) a comment to associate with the key pair
+   * @param {User} opts.size - (optional) the size of the key. Default: 2048
+   * @return {Promise<String>} - the id of the generated key
+   * @memberof @kumologica-core/runtime_settings
+   */
+  generateUserKey: function (opts) {
+    return new Promise(function (resolve, reject) {
+      var username = getSSHKeyUsername(opts.user);
+      runtime.storage.projects.ssh
+        .generateSSHKey(username, opts)
+        .then(function (name) {
+          return resolve(name);
+        })
+        .catch(function (err) {
+          err.status = 400;
+          return reject(err);
+        });
+    });
+  },
+
+  /**
+   * Deletes a user's ssh key pair
+   * @param {Object} opts
+   * @param {User} opts.user - the user calling the api
+   * @param {User} opts.id - the id of the key to delete
+   * @return {Promise} - resolves when deleted
+   * @memberof @kumologica-core/runtime_settings
+   */
+  removeUserKey: function (opts) {
+    return new Promise(function (resolve, reject) {
+      var username = getSSHKeyUsername(opts.user);
+      runtime.storage.projects.ssh
+        .deleteSSHKey(username, opts.id)
+        .then(function () {
+          return resolve();
+        })
+        .catch(function (err) {
+          err.status = 400;
+          return reject(err);
+        });
+    });
+  },
+});