@gigster/gig-cli/src/CLI.js

// Libraries
const yargs = require('yargs');

// Gigster
const {_} = require('@gigster/gig-utils');
const {Command, PluginManager} = require('@gigster/gig-models');
const {
  AnalyticsService,
  ConfigService,
  LogService,
  NetworkService,
  UpdateService,
} = require('@gigster/gig-services');

/**
 * The base wrapper for the CLI that handles reading the plugin config, loading
 * plugins dynamically, and executing the cli commands.
 */
class CLI {

  constructor({name, version}) {
    this.name = name;
    this.version = version;
    this.pluginManager = new PluginManager();
    ConfigService.version = version;
  }

  /**
   * Parses the plugins to extract all commands. From the commands, we can
   * then extract out the specific flags and positional args using yargs.
   */
  parseArgs() {
    const {commands} = this.pluginManager;
    const createCommand = (args, command) => {
      return args.command({
        command: command.name,
        aliases: command.aliases,
        description: command.description,
        builder: command.builder,
        handler: this.createHandler({command}),
      });
    };

    return _.tap(commands.reduce(createCommand, yargs), (args) => {
      // NOTE(mark): In order to set the proper name, we need to override the parsed
      // name from yargs.
      args.$0 = this.name; // eslint-disable-line no-param-reassign
      args.options(Command.globalFlags);
    });
  }

  /**
   * Creates a handler for the command that runs when this command is executed
   * by the user of the cli.
   */
  createHandler({command}) {
    return (argv) => {
      try {
        const [name, ...args] = argv._;
        const context = {name, args, flags: argv};

        argv.resolve(command.execute(context));
      } catch (error) {
        argv.reject(error);
      }
    };
  }

  async runHandlers({input, args}) {
    const showHelp = _.includes(input, '--help');
    const showVersion = _.includes(input, '--version');
    const positionalArgs = _.filter(input, arg => !arg.startsWith('-'));

    // If the --help or --version flags are passed in, we let yargs handle them.
    if (!showHelp && !showVersion && positionalArgs.length === 0) {
      return args.showHelp();
    }

    return new Promise((resolve, reject) => {
      // We build a context object to pass to argv to use with the `handler`.
      const context = {resolve, reject};

      args
        .exitProcess(false)
        .fail((message, error) => reject(error))
        .parse(input, context, (error, argv, output) => {
          if (error) {
            return reject(error);
          }

          if (output) {
            console.log(output); // eslint-disable-line no-console
          }

          return resolve();
        });
    });
  }

  /**
   * Sets the CLI network mode: offline / online.
   */
  async initializeNetworkMode() {
    ConfigService.online = await NetworkService.isInternetAvailable();

    if (!ConfigService.online) {
      LogService.info('Your computer seems to be offline.');
      LogService.notice('To use the CLI offline, you will need to ensure all the used packages are cached.');
      LogService.info('Proceeding with offline mode.');
    }
  }

  /**
   * Parses args and flags to determine which command to call from which plugin.
   */
  async execute({input}) {
    const event = `CLI`;
    return AnalyticsService.time(event, {}, async () => {
      // Set the log level based on --verbose.
      const verbose = _.includes(input, '--verbose');
      LogService.setVerbose(verbose);

      // Set the CLI network mode: offline / online.
      await this.initializeNetworkMode();

      // Check for update and update both CLI and plugins if necessary.
      if (ConfigService.isOnline) {
        await this.checkAndUpdate();
      }

      // Construct the Command objects through the plugin -> handler interface.
      this.pluginManager.parseCommands();

      // Parse the input and args to determine the dynamic set of commands.
      const args = this.parseArgs();

      // Extract the flags and positional args. Currently, this is what's
      // actually calling the plugins.
      await this.runHandlers({input, args});
    });
  }

  async checkAndUpdate() {
    const {autoupdate, isDevelopmentOrCI} = ConfigService;

    if (!autoupdate || isDevelopmentOrCI) {
      // We want to fetch the plugins in case they aren't downloaded already.
      this.pluginManager.fetchPlugins();
      return;
    }

    // Update and restart the CLI if an update is available.
    // Exits current process and spawns updated version of the CLI.
    await UpdateService.updateAndRestartCli();

    // Update the plugins
    await this.pluginManager.updateAndFetchPlugins();
  }

}

module.exports = CLI;