generator-jhipster 7.1.0 → 7.4.0

package/README.md

@@ -2,7 +2,7 @@
 
 [![NPM version][npm-image]][npm-url] [![Downloads][npmcharts-image]][npmcharts-url] [![Gitter][gitter-badge-image]][gitter-badge-url] [![Known Vulnerabilities][snyk-image]][snyk-url]
 
-[![Generator Build Status][github-actions-generator-image]][github-actions-url] [![Angular Build Status][github-actions-angular-image]][github-actions-url] [![React Build Status][github-actions-react-image]][github-actions-url] [![Vue Build Status][github-actions-vue-image]][github-actions-url] [![Webflux Build Status][github-actions-webflux-image]][github-actions-url] [![Azure DevOps Build Status][azure-devops-image]][azure-devops-url-main]
+[![Generator Build Status][github-actions-generator-image]][github-actions-url] [![Angular Build Status][github-actions-angular-image]][github-actions-url] [![React Build Status][github-actions-react-image]][github-actions-url] [![Vue Build Status][github-actions-vue-image]][github-actions-url] [![Webflux Build Status][github-actions-webflux-image]][github-actions-url] [![Azure DevOps Build Status][azure-devops-image]][azure-devops-url-main] [![Revved up by Gradle Enterprise](https://img.shields.io/badge/Revved%20up%20by-Gradle%20Enterprise-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.jhipster.tech/scans)
 
 Greetings, Java Hipster!
 

package/cli/commands.js

@@ -18,6 +18,9 @@
  */
 
 const defaultCommands = {
+  add: {
+    desc: 'Add a feature to current project',
+  },
   app: {
     desc: '[Default] Create a new JHipster application based on the selected options',
   },
@@ -56,12 +59,21 @@ const defaultCommands = {
   gae: {
     desc: 'Deploy the current application to Google App Engine',
   },
+  gradle: {
+    desc: 'Create Gradle project (alpha)',
+  },
   heroku: {
     desc: 'Deploy the current application to Heroku',
   },
   info: {
     desc: 'Display information about your current project and system',
   },
+  init: {
+    desc: 'Init project (alpha)',
+  },
+  java: {
+    desc: 'Run java generator (alpha)',
+  },
   jdl: {
     alias: 'import-jdl',
     argument: ['[jdlFiles...]'],
@@ -150,16 +162,25 @@ const defaultCommands = {
   languages: {
     desc: 'Select languages from a list of available languages. The i18n files will be copied to the /webapp/i18n folder',
   },
+  maven: {
+    desc: 'Create Maven project (alpha)',
+  },
   openshift: {
     desc: 'Deploy the current application to OpenShift',
   },
   page: {
     desc: 'Create a new page. (Supports vue clients)',
   },
+  'project-name': {
+    desc: 'Configure project name (alpha)',
+  },
   run: {
     desc: 'Run a module or custom generator',
     argument: ['[generator]'],
   },
+  'spring-boot': {
+    desc: 'Create a Spring Boot application (alpha)',
+  },
   'spring-service': {
     alias: 'service',
     desc: 'Create a new Spring service bean',

package/cli/environment-builder.js

@@ -24,6 +24,7 @@ const Environment = require('yeoman-environment');
 const { CLI_NAME, logger } = require('./utils');
 const { loadYoRc, packageNameToNamespace } = require('../generators/utils');
 const { parseBlueprintInfo, loadBlueprintsFromConfiguration, mergeBlueprints } = require('../utils/blueprint');
+const SharedData = require('../lib/support/shared-data.cjs');
 
 module.exports = class EnvironmentBuilder {
   /**
@@ -34,8 +35,15 @@ module.exports = class EnvironmentBuilder {
    */
   static create(args, options = {}, adapter) {
     // Remove after migration to environment 3.
-    const sharedOptions = { fromCli: true, localConfigOnly: true, ...options.sharedOptions, configOptions: { sharedEntities: {} } };
+    const sharedOptions = {
+      fromCli: true,
+      localConfigOnly: true,
+      ...options.sharedOptions,
+      configOptions: { sharedEntities: {} },
+      jhipsterSharedData: new SharedData(),
+    };
     const env = Environment.createEnv(args, { newErrorHandler: true, ...options, sharedOptions }, adapter);
+    env.setMaxListeners(0);
     return new EnvironmentBuilder(env);
   }
 
@@ -90,7 +98,7 @@ module.exports = class EnvironmentBuilder {
    */
   _lookupJHipster() {
     // Register jhipster generators.
-    this.env.lookup({ packagePaths: [path.join(__dirname, '..')] }).forEach(generator => {
+    this.env.lookup({ packagePaths: [path.join(__dirname, '..')], lookups: ['generators'] }).forEach(generator => {
       // Verify jhipster generators namespace.
       assert(
         generator.namespace.startsWith(`${CLI_NAME}:`),

package/cli/import-jdl.js

@@ -259,7 +259,7 @@ const generateDeploymentFiles = ({ processor, deployment }) => {
   const cwd = path.join(processor.pwd, deploymentType);
   logger.debug(`Child process will be triggered for ${jhipsterCli} with cwd: ${cwd}`);
 
-  return runGenerator(deploymentType, { cwd, fork: true }, { force: true, ...processor.options, skipPrompts: true });
+  return runGenerator(deploymentType, { cwd, fork: false }, { force: true, ...processor.options, skipPrompts: true });
 };
 
 /**
@@ -432,8 +432,8 @@ class JDLProcessor {
         applicationWithEntities.config.applications = Object.fromEntries(
           relatedApplications.map(([baseName, config]) => {
             config.gatewayServerPort = gatewayServerPort;
-            const { serverPort, applicationIndex } = config;
-            return [baseName, { serverPort, applicationIndex }];
+            const { serverPort, applicationIndex, devServerPort } = config;
+            return [baseName, { serverPort, applicationIndex, devServerPort }];
           })
         );
       }
@@ -469,13 +469,10 @@ class JDLProcessor {
           throw error;
         }
       };
-      if (this.interactive) {
-        // Queue callGenerator in chain
-        return this.importState.exportedDeployments.reduce((promise, deployment) => {
-          return promise.then(() => callGenerator(deployment));
-        }, Promise.resolve());
-      }
-      return Promise.all(this.importState.exportedDeployments.map(callGenerator));
+      // Queue callGenerator in chain
+      return this.importState.exportedDeployments.reduce((promise, deployment) => {
+        return promise.then(() => callGenerator(deployment));
+      }, Promise.resolve());
     };
 
     return callDeploymentGenerator();

package/cli/jdl.js

@@ -54,6 +54,7 @@ module.exports = ([jdlFiles = []], options = {}, env, forkProcess) => {
   }
   const promises = jdlFiles.map(toJdlFile).map(filename => {
     if (!fs.existsSync(filename)) {
+      logger.info(`File not found: ${filename}. Attempting download from jdl-samples repository`);
       return download([[filename]], options);
     }
     return Promise.resolve(filename);

package/cli/jhipster-command.js

@@ -74,9 +74,9 @@ class JHipsterCommand extends Command {
    * @private
    * Override _parseCommand to execute a callback before parsing.
    */
-  _parseCommand(operands, unknown) {
+  async _parseCommand(operands, unknown) {
     if (this._lazyBuildCommandCallBack) {
-      this._lazyBuildCommandCallBack(operands, unknown);
+      await this._lazyBuildCommandCallBack(operands, unknown);
     }
     return super._parseCommand(operands, unknown);
   }
@@ -110,7 +110,7 @@ class JHipsterCommand extends Command {
    */
   addCommandArguments(args) {
     if (Array.isArray(args)) {
-      this.arguments(`${args.join(' ')}`);
+      args.forEach(arg => this.argument(arg));
     }
     return this;
   }
@@ -137,13 +137,11 @@ class JHipsterCommand extends Command {
    */
   addGeneratorArguments(generatorArgs = []) {
     if (!generatorArgs) return this;
-    const args = generatorArgs
-      .map(argument => {
-        const argName = argument.type === Array ? `${argument.name}...` : argument.name;
-        return argument.required ? `<${argName}>` : `[${argName}]`;
-      })
-      .join(' ');
-    this.arguments(args);
+    generatorArgs.forEach(argument => {
+      let argName = argument.type === Array ? `${argument.name}...` : argument.name;
+      argName = argument.required ? `<${argName}>` : `[${argName}]`;
+      this.argument(argName, argument.description);
+    });
     return this;
   }
 
@@ -180,25 +178,13 @@ class JHipsterCommand extends Command {
     } else if (optionDefinition.type === Array) {
       cmdString = optionDefinition.required !== false ? `${cmdString} <value...>` : `${cmdString} [value...]`;
     }
-    return this.addOption(
-      new Option(cmdString, optionDefinition.description + additionalDescription)
-        .default(optionDefinition.default)
-        .hideHelp(optionDefinition.hide)
-    );
-  }
-
-  /**
-   * Override to reject errors instead of throwing and add command to error.
-   * @return promise this
-   */
-  parseAsync(argv, parseOptions) {
-    try {
-      this.parse(argv, parseOptions);
-    } catch (commanderError) {
-      commanderError.command = this;
-      return Promise.reject(commanderError);
+    const option = new Option(cmdString, optionDefinition.description + additionalDescription)
+      .default(optionDefinition.default)
+      .hideHelp(optionDefinition.hide);
+    if (optionDefinition.choices && optionDefinition.choices.length > 0) {
+      option.choices(optionDefinition.choices);
     }
-    return Promise.all(this._actionResults).then(() => this);
+    return this.addOption(option);
   }
 }
 

package/cli/program.js

@@ -52,6 +52,7 @@ const createProgram = () => {
       .option('--dry-run', 'Print conflicts', false)
       .option('--whitespace', 'Whitespace changes will not trigger conflicts', false)
       .option('--bail', 'Fail on first conflict', false)
+      .option('--install-path', 'Show jhipster install path', 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())
@@ -92,7 +93,7 @@ const buildCommands = ({ program, commands = {}, envBuilder, env, loadCommand })
       .excessArgumentsCallback(function (receivedArgs) {
         rejectExtraArgs(program, this.name(), receivedArgs);
       })
-      .lazyBuildCommand(function (operands) {
+      .lazyBuildCommand(async function (operands) {
         logger.debug(`cmd: lazyBuildCommand ${cmdName} ${operands}`);
         const command = this;
         if (cmdName === 'run') {
@@ -102,25 +103,27 @@ const buildCommands = ({ program, commands = {}, envBuilder, env, loadCommand })
             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);
-          });
+          await Promise.all(
+            command.generatorNamespaces.map(async namespace => {
+              if (!(await env.getPackagePath(namespace))) {
+                logger.fatal(chalk.red(`\nGenerator ${namespace} not found.\n`));
+              }
+              const generator = await 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 } });
+            const generator = await 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 } });
+              const generator = await env.create(`${JHIPSTER_NS}:${cmdName}`, { options: { help: true } });
               command.addGeneratorArguments(generator._arguments).addGeneratorOptions(generator._options);
 
               const usagePath = path.resolve(generator.sourceRoot(), '../USAGE');
@@ -129,34 +132,34 @@ const buildCommands = ({ program, commands = {}, envBuilder, env, loadCommand })
               }
             }
             if (cmdName === 'jdl' || program.opts().fromJdl) {
-              const appGenerator = env.create(`${JHIPSTER_NS}:app`, { options: { help: true } });
+              const appGenerator = await env.create(`${JHIPSTER_NS}:app`, { options: { help: true } });
               command.addGeneratorOptions(appGenerator._options, chalk.gray(' (application)'));
 
-              const workspacesGenerator = env.create(`${JHIPSTER_NS}:workspaces`, { options: { help: true } });
+              const workspacesGenerator = await env.create(`${JHIPSTER_NS}:workspaces`, { options: { help: true } });
               command.addGeneratorOptions(workspacesGenerator._options, chalk.gray(' (workspaces)'));
             }
 
             // 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}`);
-              }
-            });
+            await Promise.all(
+              envBuilder.getBlueprintsNamespaces().map(async blueprintNamespace => {
+                const generatorNamespace = `${blueprintNamespace}:${generatorName}`;
+                if (!(await env.get(generatorNamespace))) {
+                  return;
+                }
+                const blueprintName = blueprintNamespace.replace(/^jhipster-/, '');
+                const blueprintGenerator = await env.create(generatorNamespace, { options: { help: true } });
+                try {
+                  command.addGeneratorOptions(blueprintGenerator._options, chalk.yellow(` (blueprint option: ${blueprintName})`));
+                } catch (error) {
+                  logger.info(`Error parsing options for generator ${generatorNamespace}, error: ${error}`);
+                }
+              })
+            );
           }
         }
         command.addHelpText('after', moreInfo);
       })
-      .action((...everything) => {
+      .action(async (...everything) => {
         logger.debug('cmd: action');
         // [args, opts, command]
         const command = everything.pop();
@@ -166,12 +169,17 @@ const buildCommands = ({ program, commands = {}, envBuilder, env, loadCommand })
           ...program.opts(),
           ...cmdOptions,
         };
+        if (options.installPath) {
+          // eslint-disable-next-line no-console
+          console.log(`Using jhipster at ${path.dirname(__dirname)}`);
+          return undefined;
+        }
 
         if (opts.cliOnly) {
           logger.debug('Executing CLI only script');
           return loadCommand(cmdName)(args, options, env, envBuilder);
         }
-        env.composeWith('jhipster:bootstrap', options);
+        await env.composeWith('jhipster:bootstrap', options);
 
         if (cmdName === 'run') {
           return Promise.all(command.generatorNamespaces.map(generator => env.run(generator, options))).then(

package/generators/add/index.cjs

@@ -0,0 +1,78 @@
+/**
+ * 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 {
+  Priorities: { INITIALIZING_PRIORITY, COMPOSING_PRIORITY },
+} = require('generator-jhipster/support');
+const BaseBlueprintGenerator = require('../generator-base-blueprint');
+const { GENERATOR_ADD } = require('../generator-list');
+
+/**
+ * @experimental
+ */
+module.exports = class extends BaseBlueprintGenerator {
+  constructor(args, options, features) {
+    super(args, options, { unique: 'namespace', ...features });
+
+    this.argument('generators', {
+      type: Array,
+      required: false,
+      description: 'Generators to regenerate',
+    });
+
+    // eslint-disable-next-line no-useless-return
+    if (this.options.help) return;
+  }
+
+  async _beforeQueue() {
+    if (!this.fromBlueprint) {
+      await this.composeWithBlueprints(GENERATOR_ADD);
+    }
+  }
+
+  _initializing() {
+    return {
+      validateFromCli() {
+        this.checkInvocationFromCLI();
+      },
+      loadRuntimeOptions() {
+        this.loadRuntimeOptions();
+      },
+    };
+  }
+
+  get [INITIALIZING_PRIORITY]() {
+    if (this.delegateToBlueprint) return {};
+    return this._initializing();
+  }
+
+  _composing() {
+    return {
+      async composing() {
+        for (const generator of this.arguments) {
+          await this.composeWithJHipster(generator, [], { add: true });
+        }
+      },
+    };
+  }
+
+  get [COMPOSING_PRIORITY]() {
+    if (this.fromBlueprint) return {};
+    return this._composing();
+  }
+};

package/generators/app/esm.mjs

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ */
+import generator from './index.js';
+
+export default generator;

package/generators/app/generator.spec.mjs

@@ -0,0 +1,47 @@
+/**
+ * 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.
+ */
+import expect from 'expect';
+import lodash from 'lodash';
+import { basename, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+import testSupport from '../../test/support/index.cjs';
+import Generator from './index.js';
+
+const { snakeCase } = lodash;
+const { testBlueprintSupport } = testSupport;
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const generator = basename(__dirname);
+
+describe(`JHipster ${generator} generator`, () => {
+  it('generator-list constant matches folder name', async () => {
+    await expect((await import('../generator-list.js')).default[`GENERATOR_${snakeCase(generator).toUpperCase()}`]).toBe(generator);
+  });
+  it('should be exported at package.json', async () => {
+    await expect((await import(`generator-jhipster/esm/generators/${generator}`)).default).toBe(Generator);
+  });
+  it('should support features parameter', () => {
+    const instance = new Generator([], { help: true }, { bar: true });
+    expect(instance.features.bar).toBe(true);
+  });
+  describe('blueprint support', () => testBlueprintSupport(generator));
+});