program.js

/**
 * Copyright 2013-2021 the original author or authors from the JHipster project.
 *
 * This file is part of the JHipster project, see https://www.jhipster.tech/
 * for more information.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

const chalk = require('chalk');
const { Option } = require('commander');
const didYouMean = require('didyoumean');
const fs = require('fs');
const path = require('path');

const EnvironmentBuilder = require('./environment-builder');
const SUB_GENERATORS = require('./commands');
const JHipsterCommand = require('./jhipster-command');
const { CLI_NAME, logger, getCommand, done } = require('./utils');
const { version } = require('../package.json');
const { packageNameToNamespace } = require('../generators/utils');

const JHIPSTER_NS = CLI_NAME;

const moreInfo = `\n  For more info visit ${chalk.blue('https://www.jhipster.tech')}\n`;

const createProgram = () => {
  return (
    new JHipsterCommand()
      .storeOptionsAsProperties(false)
      .version(version)
      .addHelpText('after', moreInfo)
      // JHipster common options
      .option(
        '--blueprints <value>',
        'A comma separated list of one or more generator blueprints to use for the sub generators, e.g. --blueprints kotlin,vuejs'
      )
      .option('--no-insight', 'Disable insight')
      // Conflicter options
      .option('--force', 'Override every file', false)
      .option('--dry-run', 'Print conflicts', false)
      .option('--whitespace', 'Whitespace changes will not trigger conflicts', false)
      .option('--bail', 'Fail on first conflict', false)
      .option('--skip-regenerate', "Don't regenerate identical files", false)
      .option('--skip-yo-resolve', 'Ignore .yo-resolve files', false)
      .addOption(new Option('--from-jdl', 'Allow every option jdl forwards').default(false).hideHelp())
      .addOption(new Option('--prefer-global', 'Run jhipster installed globally').hideHelp())
      .addOption(new Option('--prefer-local', 'Run jhipster installed locally').hideHelp())
  );
};

const rejectExtraArgs = (program, cmd, extraArgs) => {
  // if extraArgs exists: Unknown commands or unknown argument.
  const first = extraArgs[0];
  if (cmd !== 'app') {
    logger.fatal(
      `${chalk.yellow(cmd)} command doesn't take ${chalk.yellow(first)} argument. See '${chalk.white(`${CLI_NAME} ${cmd} --help`)}'.`
    );
  }
  const availableCommands = program.commands.map(c => c._name);

  const suggestion = didYouMean(first, availableCommands);
  if (suggestion) {
    logger.info(`Did you mean ${chalk.yellow(suggestion)}?`);
  }

  const message = `${chalk.yellow(first)} is not a known command. See '${chalk.white(`${CLI_NAME} --help`)}'.`;
  logger.fatal(message);
};

const buildCommands = ({ program, commands = {}, envBuilder, env, loadCommand }) => {
  /* create commands */
  Object.entries(commands).forEach(([cmdName, opts]) => {
    program
      .command(cmdName, '', { isDefault: cmdName === 'app' })
      .description(opts.desc + (opts.blueprint ? chalk.yellow(` (blueprint: ${opts.blueprint})`) : ''))
      .addCommandArguments(opts.argument)
      .addCommandOptions(opts.options)
      .addHelpText('after', opts.help)
      .addAlias(opts.alias)
      .excessArgumentsCallback(function (receivedArgs) {
        rejectExtraArgs(program, this.name(), receivedArgs);
      })
      .lazyBuildCommand(function (operands) {
        logger.debug(`cmd: lazyBuildCommand ${cmdName} ${operands}`);
        const command = this;
        if (cmdName === 'run') {
          command.usage(`${operands} [options]`);
          operands = Array.isArray(operands) ? operands : [operands];
          command.generatorNamespaces = operands.map(
            namespace => `${namespace.startsWith(JHIPSTER_NS) ? '' : `${JHIPSTER_NS}-`}${namespace}`
          );
          envBuilder.lookupGenerators(command.generatorNamespaces.map(namespace => `generator-${namespace.split(':')[0]}`));
          command.generatorNamespaces.forEach(namespace => {
            if (!env.getPackagePath(namespace)) {
              logger.fatal(chalk.red(`\nGenerator ${namespace} not found.\n`));
            }
            const generator = env.create(namespace, { options: { help: true } });
            this.addGeneratorArguments(generator._arguments).addGeneratorOptions(generator._options);
          });
          return;
        }
        if (!opts.cliOnly || cmdName === 'jdl') {
          if (opts.blueprint) {
            // Blueprint only command.
            const generator = env.create(`${packageNameToNamespace(opts.blueprint)}:${cmdName}`, { options: { help: true } });
            command.addGeneratorArguments(generator._arguments).addGeneratorOptions(generator._options);
          } else {
            const generatorName = cmdName === 'jdl' ? 'app' : cmdName;
            // Register jhipster upstream options.
            if (cmdName !== 'jdl') {
              const generator = env.create(`${JHIPSTER_NS}:${cmdName}`, { options: { help: true } });
              command.addGeneratorArguments(generator._arguments).addGeneratorOptions(generator._options);

              const usagePath = path.resolve(generator.sourceRoot(), '../USAGE');
              if (fs.existsSync(usagePath)) {
                command.addHelpText('after', `\n${fs.readFileSync(usagePath, 'utf8')}`);
              }
            }
            if (cmdName === 'jdl' || program.opts().fromJdl) {
              const generator = env.create(`${JHIPSTER_NS}:app`, { options: { help: true } });
              command.addGeneratorOptions(generator._options, chalk.gray(' (application)'));
            }

            // Register blueprint specific options.
            envBuilder.getBlueprintsNamespaces().forEach(blueprintNamespace => {
              const generatorNamespace = `${blueprintNamespace}:${generatorName}`;
              if (!env.get(generatorNamespace)) {
                return;
              }
              const blueprintName = blueprintNamespace.replace(/^jhipster-/, '');
              try {
                command.addGeneratorOptions(
                  env.create(generatorNamespace, { options: { help: true } })._options,
                  chalk.yellow(` (blueprint option: ${blueprintName})`)
                );
              } catch (error) {
                logger.info(`Error parsing options for generator ${generatorNamespace}, error: ${error}`);
              }
            });
          }
        }
        command.addHelpText('after', moreInfo);
      })
      .action((...everything) => {
        logger.debug('cmd: action');
        // [args, opts, command]
        const command = everything.pop();
        const cmdOptions = everything.pop();
        const args = everything;
        const options = {
          ...program.opts(),
          ...cmdOptions,
        };

        if (opts.cliOnly) {
          logger.debug('Executing CLI only script');
          return loadCommand(cmdName)(args, options, env, envBuilder);
        }
        env.composeWith('jhipster:bootstrap', options);

        if (cmdName === 'run') {
          return Promise.all(command.generatorNamespaces.map(generator => env.run(generator, options))).then(
            results => done(results.find(result => result)),
            errors => done(errors.find(error => error))
          );
        }
        const namespace = opts.blueprint ? `${packageNameToNamespace(opts.blueprint)}:${cmdName}` : `${JHIPSTER_NS}:${cmdName}`;
        const generatorCommand = getCommand(namespace, args, opts);
        return env.run(generatorCommand, options).then(done, done);
      });
  });
};

const buildJHipster = ({
  program = createProgram(),
  envBuilder = EnvironmentBuilder.createDefaultBuilder(),
  commands = { ...SUB_GENERATORS, ...envBuilder.getBlueprintCommands() },
  env = envBuilder.getEnvironment(),
  /* eslint-disable-next-line global-require, import/no-dynamic-require */
  loadCommand = key => require(`./${key}`),
} = {}) => {
  /* setup debugging */
  logger.init(program);

  buildCommands({ program, commands, envBuilder, env, loadCommand });

  return program;
};

const runJHipster = (args = {}) => {
  const { argv = process.argv } = args;
  return buildJHipster(args).parseAsync(argv);
};

module.exports = {
  createProgram,
  buildCommands,
  buildJHipster,
  runJHipster,
};