lumber-forestadmin/install.js

Forest Admin for Lumber.

const os = require('os');
const fs = require('fs');
const chalk = require('chalk');
const KeyGenerator = require('./services/key-generator');
const api = require('./services/api');
const Authenticator = require('./services/authenticator');
const { parseJwt } = require('./utils/authenticator-helper');

const FORMAT_PASSWORD = /^(?=\S*?[A-Z])(?=\S*?[a-z])((?=\S*?[0-9]))\S{8,}$/;

module.exports = async (logger, inquirer, argv) => {
  const auth = new Authenticator(logger, inquirer);
  let sessionToken;

  // TODO: Remove FOREST_EMAIL, FOREST_TOKEN and FOREST_PASSWORD
  //       environment variables usage in the future major version.
  async function loginWithEmailOrTokenArgv() {
    try {
      let config = {};
      const email = argv.email || argv.e || process.env.FOREST_EMAIL;
      const token = argv.token || argv.t || process.env.FOREST_TOKEN;
      const password = argv.password || argv.P || process.env.FOREST_PASSWORD;

      const isGoogleAccount = await api.isGoogleAccount(email);
      if (token) {
        sessionToken = token;
      } else if (isGoogleAccount) {
        sessionToken = await auth.loginWithGoogle(email);
      } else {
        if (password) {
          config.password = password;
        } else {
          config = await inquirer.prompt([{
            type: 'password',
            name: 'password',
            message: 'What\'s your Forest Admin password:',
            validate: (input) => {
              if (input) { return true; }
              return 'Please enter your password.';
            },
          }]);
        }

        sessionToken = await auth.login(email, config.password);
      }
    } catch (error) {
      if (error.message === 'Unauthorized') {
        logger.error('Incorrect email or password.');
      } else {
        logger.error(`An unexpected error occured. Please create a Github issue with following error: ${chalk.red(error)}`);
      }

      process.exit(1);
    }
  }

  async function createAccount() {
    logger.info('Create an account:');
    const authConfig = await inquirer.prompt([{
      type: 'input',
      name: 'firstName',
      message: 'What\'s your first name?',
      validate: (input) => {
        if (input) { return true; }
        return 'Please enter your first name.';
      },
    }, {
      type: 'input',
      name: 'lastName',
      message: 'What\'s your last name?',
      validate: (input) => {
        if (input) { return true; }
        return 'Please enter your last name.';
      },
    }, {
      type: 'input',
      name: 'email',
      message: 'What\'s your email address?',
      validate: (input) => {
        if (input) { return true; }
        return 'Please enter your email address.';
      },
    }, {
      type: 'password',
      name: 'password',
      message: 'Choose a password:',
      validate: (password) => {
        if (password) {
          if (FORMAT_PASSWORD.test(password)) { return true; }
          return `🔓  Your password security is too weak 🔓\n
          \tPlease make sure it contains at least:\n
          \t> 8 characters\n
          \t> Upper and lower case letters\n
          \t> Numbers`;
        }

        return 'Please, choose a password.';
      },
    }]);

    try {
      await api.createUser(authConfig);
    } catch (error) {
      if (error.message === 'Conflict') {
        logger.error(`Your account already exists. Please, use the command ${chalk.cyan('lumber run lumber-forestadmin:login')}.`);
      } else {
        logger.error(`An unexpected error occured. Please create a Github issue with following error: ${chalk.red(error)}`);
      }

      process.exit(1);
    }

    sessionToken = await auth.login(authConfig.email, authConfig.password);

    logger.success('\nAccount successfully created.\n');
  }

  const email = argv.email || argv.e || process.env.FOREST_EMAIL;
  try {
    sessionToken = fs.readFileSync(`${os.homedir()}/.lumberrc`, { encoding: 'utf8' });
    if (email) {
      const sessionInfo = parseJwt(sessionToken);
      if (sessionInfo && sessionInfo.data.data.attributes.email !== email) {
        throw new Error();
      }
    }
  } catch (err) {
    if (email) {
      await loginWithEmailOrTokenArgv();
    } else {
      await createAccount();
    }
  }

  let projectConfig = {};

  const projectName = argv.projectName || argv.p;
  if (projectName) {
    projectConfig.name = projectName;
  } else {
    projectConfig = await inquirer.prompt([{
      type: 'input',
      name: 'name',
      message: 'Choose a name for your admin panel:',
    }]);
  }

  try {
    const newProject = await api.createProject(sessionToken, projectConfig);

    logger.success(`Hooray, ${chalk.green('installation success')}!`);

    return {
      envSecret: newProject.defaultEnvironment.secretKey,
      authSecret: await new KeyGenerator().generate(),
    };
  } catch (error) {
    if (error.message === 'Unauthorized') {
      logger.error(`Your session has expired. Please, relogin with the command ${chalk.cyan('lumber run lumber-forestadmin:login')}.`);
    } else if (error.message === 'Conflict') {
      logger.error('A project with this name already exists. Please choose another name.');
    } else {
      logger.error(`An unexpected error occured. Please create a Github issue with following error: ${chalk.red(error)}`);
    }

    return process.exit(1);
  }
};