botpress/lib/modules.js

The world's first CMS for bots. Easily create, manage and extend chatbots.

'use strict';

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _bluebird = require('bluebird');

var _bluebird2 = _interopRequireDefault(_bluebird);

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _axios = require('axios');

var _axios2 = _interopRequireDefault(_axios);

var _helpers = require('./helpers');

var _helpers2 = _interopRequireDefault(_helpers);

var _util = require('./util');

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new _bluebird2.default(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return _bluebird2.default.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

module.exports = (logger, projectLocation, dataLocation, configManager) => {
  const loadModules = (() => {
    var _ref = _asyncToGenerator(function* (moduleDefinitions, botpress) {
      let loadedCount = 0;
      const loadedModules = {};

      yield _bluebird2.default.mapSeries(moduleDefinitions, (() => {
        var _ref2 = _asyncToGenerator(function* (mod) {
          let loader = null;
          try {
            loader = require(mod.entry);
          } catch (err) {
            return logger.error(`Error loading module "${mod.name}": ` + err.message);
          }

          if (typeof loader !== 'object') {
            return logger.warn(`Ignoring module ${mod.name}. Invalid entry point signature.`);
          }

          mod.handlers = loader;

          try {
            const configuration = configManager.getModuleConfiguration({
              name: mod.name,
              options: loader.config,
              path: mod.root
            });

            if (yield configuration.isConfigMissing()) {
              yield configuration.bootstrap();
            }

            mod.configuration = configuration;
          } catch (err) {
            logger.error(`Invalid module configuration in module ${mod.name}:`, err);
          }

          try {
            loader.init && (yield loader.init(botpress, mod.configuration, _helpers2.default));
          } catch (err) {
            logger.warn('Error during module initialization: ', err);
          }

          loadedModules[mod.name] = mod;
          logger.info(`Loaded ${mod.name}, version ${mod.version}`);
          loadedCount++;
        });

        return function (_x3) {
          return _ref2.apply(this, arguments);
        };
      })());

      if (loadedCount > 0) {
        logger.info(`Loaded ${loadedCount} modules`);
      }

      return loadedModules;
    });

    return function loadModules(_x, _x2) {
      return _ref.apply(this, arguments);
    };
  })();

  const scanModules = () => {
    const packagePath = _path2.default.join(projectLocation, 'package.json');

    if (!_fs2.default.existsSync(packagePath)) {
      return logger.warn('No package.json found at project root, ' + "which means botpress can't load any module for the bot.");
    }

    const botPackage = require(packagePath);

    let deps = botPackage.dependencies || {};
    if (_util.isDeveloping) {
      deps = _lodash2.default.merge(deps, botPackage.devDependencies || {});
    }

    return _lodash2.default.reduce(deps, (result, value, key) => {
      if (!_util2.default.isBotpressPackage(key)) {
        return result;
      }
      const entry = (0, _util.resolveFromDir)(projectLocation, key);
      if (!entry) {
        return result;
      }
      const root = (0, _util.resolveModuleRootPath)(entry);
      if (!root) {
        return result;
      }

      const modulePackage = require(_path2.default.join(root, 'package.json'));
      if (!modulePackage.botpress) {
        return result;
      }

      return result.push({
        name: key,
        root: root,
        homepage: modulePackage.homepage,
        settings: modulePackage.botpress,
        version: modulePackage.version,
        entry: entry
      }) && result;
    }, []);
  };

  const listInstalledModules = () => {
    const packagePath = (0, _util.resolveProjectFile)('package.json', projectLocation, true);
    const { dependencies } = require(packagePath);
    const prodDeps = _lodash2.default.keys(dependencies);

    return _lodash2.default.filter(prodDeps, _util2.default.isBotpressPackage);
  };

  const getRandomCommunityHero = _bluebird2.default.method(() => _axios2.default.get('https://api.github.com/repos/botpress/botpress/contributors').then(({ data: contributors }) => {
    const { login: username, html_url: github, avatar_url: avatar, contributions } = _lodash2.default.sample(contributors);
    return { username, github, avatar, contributions, module: 'botpress' };
  }).catch(() => _bluebird2.default.resolve({
    username: 'danyfs',
    github: 'https://github.com/danyfs',
    avatar: 'https://avatars1.githubusercontent.com/u/5629987?v=3',
    contributions: 'many',
    module: 'botpress'
  })));

  return {
    getRandomCommunityHero,
    listInstalled: listInstalledModules,
    _scan: scanModules,
    _load: loadModules
  };
};
//# sourceMappingURL=modules.js.map