@kumologica/sdk 3.0.0

package/src/app/ui/editor-api/lib/admin/flow.js

@@ -0,0 +1,55 @@
+ 
+
+var runtimeAPI;
+var apiUtils = require("../util");
+
+module.exports = {
+    init: function(_runtimeAPI) {
+        runtimeAPI = _runtimeAPI;
+    },
+    get: function(req,res) {
+        var opts = {
+            user: req.user,
+            id: req.params.id
+        }
+        runtimeAPI.flows.getFlow(opts).then(function(result) {
+            return res.json(result);
+        }).catch(function(err) {
+            apiUtils.rejectHandler(req,res,err);
+        })
+    },
+    post: function(req,res) {
+        var opts = {
+            user: req.user,
+            flow: req.body
+        }
+        runtimeAPI.flows.addFlow(opts).then(function(id) {
+            return res.json({id:id});
+        }).catch(function(err) {
+            apiUtils.rejectHandler(req,res,err);
+        })
+    },
+    put: function(req,res) {
+        var opts = {
+            user: req.user,
+            id: req.params.id,
+            flow: req.body
+        }
+        runtimeAPI.flows.updateFlow(opts).then(function(id) {
+            return res.json({id:id});
+        }).catch(function(err) {
+            apiUtils.rejectHandler(req,res,err);
+        })
+    },
+    delete: function(req,res) {
+        var opts = {
+            user: req.user,
+            id: req.params.id
+        }
+        runtimeAPI.flows.deleteFlow(opts).then(function() {
+            res.status(204).end();
+        }).catch(function(err) {
+            apiUtils.rejectHandler(req,res,err);
+        })
+    }
+}

package/src/app/ui/editor-api/lib/admin/flows.js

@@ -0,0 +1,53 @@
+ 
+
+var runtimeAPI;
+const apiUtils = require('../util');
+
+module.exports = {
+  init: function(_runtimeAPI) {
+    runtimeAPI = _runtimeAPI;
+  },
+  get: function(req, res) {
+    var version = req.get('kumologica-core-API-Version') || 'v1';
+    if (!/^v[12]$/.test(version)) {
+      return res.status(400).json({
+        code: 'invalid_api_version',
+        message: 'Invalid API Version requested'
+      });
+    }
+    var opts = {
+      user: req.user
+    };
+    runtimeAPI.flows
+      .getFlows(opts)
+      .then(function(result) {
+        if (version === 'v1') {
+          res.json(result.flows);
+        } else if (version === 'v2') {
+          res.json(result);
+        }
+      })
+      .catch(function(err) {
+        apiUtils.rejectHandler(req, res, err);
+      });
+  },
+  post: async (req, res) => {
+    var opts = {
+      user: req.user,
+      deploymentType: req.get('kumologica-core-Deployment-Type') || 'full'
+    };
+
+    if (opts.deploymentType !== 'reload') {
+      opts.flows = req.body;
+    }
+
+    try {
+      let result = await runtimeAPI.flows.setFlows(opts);
+      // Disable below line until we decide if IDE is responsible to bind triggers to lambda
+      // RED.events.emit('editor:post-deployment');
+      res.json(result);
+    } catch (err) {
+      apiUtils.rejectHandler(req, res, err);
+    }
+  }
+};

package/src/app/ui/editor-api/lib/admin/index.js

@@ -0,0 +1,155 @@
+var express = require('express');
+
+var nodes = require('./nodes');
+var flows = require('./flows');
+var flow = require('./flow');
+var context = require('./context');
+var auth = require('../auth');
+
+var apiUtil = require('../util');
+
+module.exports = {
+  init: function(runtimeAPI) {
+    flows.init(runtimeAPI);
+    flow.init(runtimeAPI);
+    nodes.init(runtimeAPI);
+    context.init(runtimeAPI);
+
+    var needsPermission = auth.needsPermission;
+
+    var adminApp = express();
+
+    // Flows
+    adminApp.get(
+      '/flows',
+      needsPermission('flows.read'),
+      flows.get,
+      apiUtil.errorHandler
+    );
+    adminApp.post(
+      '/flows',
+      needsPermission('flows.write'),
+      flows.post,
+      apiUtil.errorHandler
+    );
+
+    // Flow
+    adminApp.get(
+      '/flow/:id',
+      needsPermission('flows.read'),
+      flow.get,
+      apiUtil.errorHandler
+    );
+    adminApp.post(
+      '/flow',
+      needsPermission('flows.write'),
+      flow.post,
+      apiUtil.errorHandler
+    );
+    adminApp.delete(
+      '/flow/:id',
+      needsPermission('flows.write'),
+      flow.delete,
+      apiUtil.errorHandler
+    );
+    adminApp.put(
+      '/flow/:id',
+      needsPermission('flows.write'),
+      flow.put,
+      apiUtil.errorHandler
+    );
+
+    // Nodes
+    adminApp.post(
+      '/nodes-reload',
+      needsPermission('nodes.write'),
+      nodes.reloadModules,
+      apiUtil.errorHandler
+    );
+    adminApp.get(
+      '/nodes',
+      needsPermission('nodes.read'),
+      nodes.getAll,
+      apiUtil.errorHandler
+    );
+    adminApp.post(
+      '/nodes',
+      needsPermission('nodes.write'),
+      nodes.post,
+      apiUtil.errorHandler
+    );
+    adminApp.get(
+      /^\/nodes\/((@[^\/]+\/)?[^\/]+)$/,
+      needsPermission('nodes.read'),
+      nodes.getModule,
+      apiUtil.errorHandler
+    );
+    adminApp.put(
+      /^\/nodes\/((@[^\/]+\/)?[^\/]+)$/,
+      needsPermission('nodes.write'),
+      nodes.putModule,
+      apiUtil.errorHandler
+    );
+    adminApp.delete(
+      /^\/nodes\/((@[^\/]+\/)?[^\/]+)$/,
+      needsPermission('nodes.write'),
+      nodes.delete,
+      apiUtil.errorHandler
+    );
+    adminApp.get(
+      /^\/nodes\/((@[^\/]+\/)?[^\/]+)\/([^\/]+)$/,
+      needsPermission('nodes.read'),
+      nodes.getSet,
+      apiUtil.errorHandler
+    );
+    adminApp.put(
+      /^\/nodes\/((@[^\/]+\/)?[^\/]+)\/([^\/]+)$/,
+      needsPermission('nodes.write'),
+      nodes.putSet,
+      apiUtil.errorHandler
+    );
+
+    // Context
+    adminApp.get(
+      '/context/:scope(global)',
+      needsPermission('context.read'),
+      context.get,
+      apiUtil.errorHandler
+    );
+    adminApp.get(
+      '/context/:scope(global)/*',
+      needsPermission('context.read'),
+      context.get,
+      apiUtil.errorHandler
+    );
+    adminApp.get(
+      '/context/:scope(node|flow)/:id',
+      needsPermission('context.read'),
+      context.get,
+      apiUtil.errorHandler
+    );
+    adminApp.get(
+      '/context/:scope(node|flow)/:id/*',
+      needsPermission('context.read'),
+      context.get,
+      apiUtil.errorHandler
+    );
+
+    // adminApp.delete("/context/:scope(global)",needsPermission("context.write"),context.delete,apiUtil.errorHandler);
+    adminApp.delete(
+      '/context/:scope(global)/*',
+      needsPermission('context.write'),
+      context.delete,
+      apiUtil.errorHandler
+    );
+    // adminApp.delete("/context/:scope(node|flow)/:id",needsPermission("context.write"),context.delete,apiUtil.errorHandler);
+    adminApp.delete(
+      '/context/:scope(node|flow)/:id/*',
+      needsPermission('context.write'),
+      context.delete,
+      apiUtil.errorHandler
+    );
+
+    return adminApp;
+  }
+};

package/src/app/ui/editor-api/lib/admin/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/app/ui/editor-api/lib/auth/clients.js

@@ -0,0 +1,17 @@
+ 
+
+var clients = [
+    {id:"kumologica-core-editor",secret:"not_available"},
+    {id:"kumologica-core-admin",secret:"not_available"}
+];
+
+module.exports = {
+    get: function(id) {
+        for (var i=0;i<clients.length;i++) {
+            if (clients[i].id == id) {
+                return Promise.resolve(clients[i]);
+            }
+        }
+        return Promise.resolve(null);
+    }
+}

package/src/app/ui/editor-api/lib/auth/index.js

@@ -0,0 +1,267 @@
+ 
+
+/**
+ * @mixin @kumologica-core/editor-api_auth
+ */
+
+var passport = require('passport');
+var oauth2orize = require('oauth2orize');
+
+var strategies = require('./strategies');
+var Tokens = require('./tokens');
+var Users = require('./users');
+var permissions = require('./permissions');
+
+var theme = require('../editor/theme');
+
+var settings = null;
+const { util: runtimeUtil } = require('../../../../lib/runtime-loader');
+
+const log = runtimeUtil.log;
+
+passport.use(strategies.bearerStrategy.BearerStrategy);
+passport.use(strategies.clientPasswordStrategy.ClientPasswordStrategy);
+passport.use(strategies.anonymousStrategy);
+
+var server = oauth2orize.createServer();
+
+server.exchange(
+  oauth2orize.exchange.password(strategies.passwordTokenExchange)
+);
+
+function init(_settings, storage) {
+  settings = _settings;
+  if (settings.adminAuth) {
+    var mergedAdminAuth = Object.assign(
+      {},
+      settings.adminAuth,
+      settings.adminAuth.module
+    );
+    Users.init(mergedAdminAuth);
+    Tokens.init(mergedAdminAuth, storage);
+  }
+}
+/**
+ * Returns an Express middleware function that ensures the user making a request
+ * has the necessary permission.
+ *
+ * @param {String} permission - the permission required for the request, such as `flows.write`
+ * @return {Function} - an Express middleware
+ * @memberof @kumologica-core/editor-api_auth
+ */
+function needsPermission(permission) {
+  return function(req, res, next) {
+    if (settings && settings.adminAuth) {
+      return passport.authenticate(['bearer', 'anon'], { session: false })(
+        req,
+        res,
+        function() {
+          if (!req.user) {
+            return next();
+          }
+          if (permissions.hasPermission(req.authInfo.scope, permission)) {
+            return next();
+          }
+          log.audit({ event: 'permission.fail', permissions: permission }, req);
+          return res.status(401).end();
+        }
+      );
+    } else {
+      next();
+    }
+  };
+}
+
+function ensureClientSecret(req, res, next) {
+  if (!req.body.client_secret) {
+    req.body.client_secret = 'not_available';
+  }
+  next();
+}
+function authenticateClient(req, res, next) {
+  return passport.authenticate(['oauth2-client-password'], { session: false })(
+    req,
+    res,
+    next
+  );
+}
+function getToken(req, res, next) {
+  return server.token()(req, res, next);
+}
+
+function login(req, res) {
+  var response = {};
+  if (settings.adminAuth) {
+    var mergedAdminAuth = Object.assign(
+      {},
+      settings.adminAuth,
+      settings.adminAuth.module
+    );
+    if (mergedAdminAuth.type === 'credentials') {
+      response = {
+        type: 'credentials',
+        prompts: [
+          { id: 'username', type: 'text', label: 'user.username' },
+          { id: 'password', type: 'password', label: 'user.password' }
+        ]
+      };
+    } else if (mergedAdminAuth.type === 'strategy') {
+      var urlPrefix =
+        settings.httpAdminRoot === '/' ? '' : settings.httpAdminRoot;
+      response = {
+        type: 'strategy',
+        prompts: [
+          {
+            type: 'button',
+            label: mergedAdminAuth.strategy.label,
+            url: urlPrefix + 'auth/strategy'
+          }
+        ]
+      };
+      if (mergedAdminAuth.strategy.icon) {
+        response.prompts[0].icon = mergedAdminAuth.strategy.icon;
+      }
+      if (mergedAdminAuth.strategy.image) {
+        response.prompts[0].image = theme.serveFile(
+          '/login/',
+          mergedAdminAuth.strategy.image
+        );
+      }
+    }
+    if (theme.context().login && theme.context().login.image) {
+      response.image = theme.context().login.image;
+    }
+  }
+  res.json(response);
+}
+
+function revoke(req, res) {
+  var token = req.body.token;
+  // TODO: audit log
+  Tokens.revoke(token).then(function() {
+    log.audit({ event: 'auth.login.revoke' }, req);
+    if (
+      settings.editorTheme &&
+      settings.editorTheme.logout &&
+      settings.editorTheme.logout.redirect
+    ) {
+      res.json({ redirect: settings.editorTheme.logout.redirect });
+    } else {
+      res.status(200).end();
+    }
+  });
+}
+
+function completeVerify(profile, done) {
+  Users.authenticate(profile).then(function(user) {
+    if (user) {
+      Tokens.create(user.username, 'kumologica-core-editor', user.permissions).then(
+        function(tokens) {
+          log.audit({
+            event: 'auth.login',
+            username: user.username,
+            scope: user.permissions
+          });
+          user.tokens = tokens;
+          done(null, user);
+        }
+      );
+    } else {
+      log.audit({
+        event: 'auth.login.fail.oauth',
+        username: typeof profile === 'string' ? profile : profile.username
+      });
+      done(null, false);
+    }
+  });
+}
+
+function genericStrategy(adminApp, strategy) {
+  var crypto = require('crypto');
+  var session = require('express-session');
+  var MemoryStore = require('memorystore')(session);
+
+  adminApp.use(
+    session({
+      // As the session is only used across the life-span of an auth
+      // hand-shake, we can use a instance specific random string
+      secret: crypto.randomBytes(20).toString('hex'),
+      resave: false,
+      saveUninitialized: false,
+      store: new MemoryStore({
+        checkPeriod: 86400000 // prune expired entries every 24h
+      })
+    })
+  );
+  //TODO: all passport references ought to be in ./auth
+  adminApp.use(passport.initialize());
+  adminApp.use(passport.session());
+
+  var options = strategy.options;
+
+  passport.use(
+    new strategy.strategy(options, function() {
+      var originalDone = arguments[arguments.length - 1];
+      if (options.verify) {
+        var args = Array.from(arguments);
+        args[args.length - 1] = function(err, profile) {
+          if (err) {
+            return originalDone(err);
+          } else {
+            return completeVerify(profile, originalDone);
+          }
+        };
+        options.verify.apply(null, args);
+      } else {
+        var profile = arguments[arguments.length - 2];
+        return completeVerify(profile, originalDone);
+      }
+    })
+  );
+
+  adminApp.get(
+    '/auth/strategy',
+    passport.authenticate(strategy.name, {
+      session: false,
+      failureRedirect: settings.httpAdminRoot
+    }),
+    completeGenerateStrategyAuth
+  );
+
+  var callbackMethodFunc = adminApp.get;
+  if (/^post$/i.test(options.callbackMethod)) {
+    callbackMethodFunc = adminApp.post;
+  }
+  callbackMethodFunc.call(
+    adminApp,
+    '/auth/strategy/callback',
+    passport.authenticate(strategy.name, {
+      session: false,
+      failureRedirect: settings.httpAdminRoot
+    }),
+    completeGenerateStrategyAuth
+  );
+}
+function completeGenerateStrategyAuth(req, res) {
+  var tokens = req.user.tokens;
+  delete req.user.tokens;
+  // Successful authentication, redirect home.
+  res.redirect(settings.httpAdminRoot + '?access_token=' + tokens.accessToken);
+}
+
+module.exports = {
+  init: init,
+  needsPermission: needsPermission,
+  ensureClientSecret: ensureClientSecret,
+  authenticateClient: authenticateClient,
+  getToken: getToken,
+  errorHandler: function(err, req, res, next) {
+    //TODO: audit log statment
+    //console.log(err.stack);
+    //log.log({level:"audit",type:"auth",msg:err.toString()});
+    return server.errorHandler()(err, req, res, next);
+  },
+  login: login,
+  revoke: revoke,
+  genericStrategy: genericStrategy
+};