generator-jhipster 8.7.1 → 8.7.3

package/README.md

@@ -18,9 +18,9 @@ We are honored by any contributions you may have small or large. Please refer to
 
 The following Java and Node combinations are tested and verified by GitHub Actions:
 
-| Java     | Node  | Status |
-| -------- | ----- | ------ |
-| 17/21/22 | 18/20 | ✅     |
+| Java     | Node     | Status |
+| -------- | -------- | ------ |
+| 17/21/23 | 18/20/22 | ✅     |
 
 ## Sponsors
 

package/dist/cli/commands.d.mts

@@ -1,125 +1,125 @@
-export default defaultCommands;
 declare const defaultCommands: {
-    add: {
-        desc: string;
-        removed: string;
+    readonly add: {
+        readonly desc: "Add a feature to current project";
+        readonly removed: string;
     };
-    app: {
-        desc: string;
+    readonly app: {
+        readonly desc: "[Default] Create a new JHipster application based on the selected options";
     };
-    aws: {
-        desc: string;
-        removed: string;
+    readonly aws: {
+        readonly desc: "Deploy the current application to Amazon Web Services";
+        readonly removed: string;
     };
-    'azure-app-service': {
-        desc: string;
-        removed: string;
+    readonly 'azure-app-service': {
+        readonly desc: "Deploy the current application to Azure App Service";
+        readonly removed: string;
     };
-    'azure-spring-cloud': {
-        desc: string;
-        removed: string;
+    readonly 'azure-spring-cloud': {
+        readonly desc: "Deploy the current application to Azure Spring Cloud";
+        readonly removed: string;
     };
-    'ci-cd': {
-        desc: string;
+    readonly 'ci-cd': {
+        readonly desc: "Create pipeline scripts for popular Continuous Integration/Continuous Deployment tools";
     };
-    cloudfoundry: {
-        desc: string;
-        removed: string;
+    readonly cloudfoundry: {
+        readonly desc: "Generate a `deploy/cloudfoundry` folder with a specific manifest.yml to deploy to Cloud Foundry";
+        readonly removed: string;
     };
-    'docker-compose': {
-        desc: string;
+    readonly 'docker-compose': {
+        readonly desc: "Create all required Docker deployment configuration for the selected applications";
     };
-    download: {
-        desc: string;
-        cliOnly: boolean;
-        argument: string[];
+    readonly download: {
+        readonly desc: "Download jdl file from template repository";
+        readonly cliOnly: true;
+        readonly argument: ["<jdlFiles...>"];
     };
-    entity: {
-        desc: string;
+    readonly entity: {
+        readonly desc: "Create a new JHipster entity: JPA entity, Spring server-side components and Angular client-side components";
     };
-    entities: {
-        desc: string;
+    readonly entities: {
+        readonly desc: "Regenerate entities";
     };
-    'export-jdl': {
-        desc: string;
+    readonly 'export-jdl': {
+        readonly desc: "Create a JDL file from the existing entities";
     };
-    gae: {
-        desc: string;
-        removed: string;
+    readonly gae: {
+        readonly desc: "Deploy the current application to Google App Engine";
+        readonly removed: string;
     };
-    'generate-blueprint': {
-        desc: string;
+    readonly 'generate-blueprint': {
+        readonly desc: "Generate a blueprint";
     };
-    gradle: {
-        desc: string;
+    readonly gradle: {
+        readonly desc: "Create Gradle project (alpha)";
     };
-    heroku: {
-        desc: string;
+    readonly heroku: {
+        readonly desc: "Deploy the current application to Heroku";
     };
-    info: {
-        desc: string;
+    readonly info: {
+        readonly desc: "Display information about your current project and system";
     };
-    init: {
-        desc: string;
+    readonly init: {
+        readonly desc: "Init project (alpha)";
     };
-    java: {
-        desc: string;
+    readonly java: {
+        readonly desc: "Run java generator (alpha)";
     };
-    jdl: {
-        alias: string;
-        desc: string;
-        help: string;
+    readonly jdl: {
+        readonly alias: "import-jdl";
+        readonly desc: "Create entities from the JDL file/URL/content passed in argument.\n    Use the '--interactive' flag to generate multiple applications in series.";
+        readonly help: "\n    Arguments:\n    jdlFiles # The JDL file names or URL Type: String[] Required: true if --inline is not set\n\n    Example:\n    jhipster jdl myfile.jdl\n    jhipster jdl myfile1.jdl myfile2.jdl\n    jhipster jdl https://gist.githubusercontent.com/user/path/app.jdl\n    jhipster jdl jdl-name-from-jdl-samples-repo.jdl (just pass any file name from https://github.com/jhipster/jdl-samples)\n    jhipster jdl --inline \"application { config { baseName jhapp, testFrameworks [cypress] }}\"\n    jhipster jdl --inline \\\n        \"application {\n            config {\n                baseName jhapp,\n                testFrameworks [cypress]\n            }\n        }\"\n    ";
     };
-    kubernetes: {
-        alias: string;
-        desc: string;
+    readonly kubernetes: {
+        readonly alias: "k8s";
+        readonly desc: "Deploy the current application to Kubernetes";
     };
-    'kubernetes-helm': {
-        alias: string;
-        desc: string;
+    readonly 'kubernetes-helm': {
+        readonly alias: "helm";
+        readonly desc: "Deploy the current application to Kubernetes using Helm package manager";
     };
-    'kubernetes-knative': {
-        alias: string;
-        desc: string;
+    readonly 'kubernetes-knative': {
+        readonly alias: "knative";
+        readonly desc: "Deploy the current application to Kubernetes using knative constructs";
     };
-    languages: {
-        desc: string;
+    readonly languages: {
+        readonly desc: "Select languages from a list of available languages. The i18n files will be copied to the /webapp/i18n folder";
     };
-    maven: {
-        desc: string;
+    readonly maven: {
+        readonly desc: "Create Maven project (alpha)";
     };
-    openshift: {
-        desc: string;
-        removed: string;
+    readonly openshift: {
+        readonly desc: "Deploy the current application to OpenShift";
+        readonly removed: string;
     };
-    page: {
-        desc: string;
-        removed: string;
+    readonly page: {
+        readonly desc: "Create a new page. (Supports vue clients)";
+        readonly removed: string;
     };
-    'project-name': {
-        desc: string;
+    readonly 'project-name': {
+        readonly desc: "Configure project name (alpha)";
     };
-    run: {
-        desc: string;
-        argument: string[];
+    readonly run: {
+        readonly desc: "Run a module or custom generator";
+        readonly argument: ["[generator]"];
     };
-    'spring-service': {
-        alias: string;
-        desc: string;
-        removed: string;
+    readonly 'spring-service': {
+        readonly alias: "service";
+        readonly desc: "Create a new Spring service bean";
+        readonly removed: string;
     };
-    'spring-controller': {
-        desc: string;
-        removed: string;
+    readonly 'spring-controller': {
+        readonly desc: "Create a new Spring controller";
+        readonly removed: string;
     };
-    'openapi-client': {
-        desc: string;
-        removed: string;
+    readonly 'openapi-client': {
+        readonly desc: "Generates java client code from an OpenAPI/Swagger definition";
+        readonly removed: string;
     };
-    upgrade: {
-        desc: string;
+    readonly upgrade: {
+        readonly desc: "Upgrade the JHipster version, and upgrade the generated application";
     };
-    workspaces: {
-        desc: string;
+    readonly workspaces: {
+        readonly desc: "Add workspaces configuration";
     };
 };
+export default defaultCommands;

package/dist/cli/environment-builder.d.mts

@@ -16,9 +16,9 @@ export default class EnvironmentBuilder {
      * const promise = require('yeoman-test').create('jhipster:app', {}, {createEnv: EnvironmentBuilder.createEnv}).run();
      *
      * @param {...any} args - Arguments passed to Environment.createEnv().
-     * @return {EnvironmentBuilder} envBuilder
+     * @return {Promise<Environment>} envBuilder
      */
-    static createEnv(...args: any[]): EnvironmentBuilder;
+    static createEnv(...args: any[]): Promise<Environment>;
     /**
      * Creates a new EnvironmentBuilder with a new Environment and load jhipster, blueprints and sharedOptions.
      *
@@ -35,10 +35,11 @@ export default class EnvironmentBuilder {
      * - Loads sharedOptions.
      */
     constructor(env: any);
+    /** @type {Environment} */
+    env: Environment;
     devBlueprintPath: any;
     localBlueprintPath: any;
     localBlueprintExists: any;
-    env: any;
     prepare({ blueprints, lookups, devBlueprintPath }?: {
         blueprints: any;
         lookups: any;
@@ -95,9 +96,9 @@ export default class EnvironmentBuilder {
     /**
      * Get blueprints commands.
      *
-     * @return {Object[]} blueprint commands.
+     * @return {Record<string, import('./types.js').CliCommand>} blueprint commands.
      */
-    getBlueprintCommands(): any[];
+    getBlueprintCommands(): Record<string, import("./types.js").CliCommand>;
     /**
      * Get the environment.
      *
@@ -131,7 +132,7 @@ export default class EnvironmentBuilder {
      * @private
      * Get blueprints commands.
      *
-     * @return {Object[]} commands.
+     * @return {Record<string, import('./types.js').CliCommand>} commands.
      */
     private _getBlueprintCommands;
     /**

package/dist/cli/environment-builder.mjs

@@ -42,6 +42,8 @@ const createEnvironment = (options = {}) => {
     return new Environment({ newErrorHandler: true, ...options });
 };
 export default class EnvironmentBuilder {
+    /** @type {Environment} */
+    env;
     devBlueprintPath;
     localBlueprintPath;
     localBlueprintExists;
@@ -66,7 +68,7 @@ export default class EnvironmentBuilder {
      * const promise = require('yeoman-test').create('jhipster:app', {}, {createEnv: EnvironmentBuilder.createEnv}).run();
      *
      * @param {...any} args - Arguments passed to Environment.createEnv().
-     * @return {EnvironmentBuilder} envBuilder
+     * @return {Promise<Environment>} envBuilder
      */
     static async createEnv(...args) {
         const builder = await EnvironmentBuilder.createDefaultBuilder(...args);
@@ -248,7 +250,7 @@ export default class EnvironmentBuilder {
     /**
      * Get blueprints commands.
      *
-     * @return {Object[]} blueprint commands.
+     * @return {Record<string, import('./types.js').CliCommand>} blueprint commands.
      */
     async getBlueprintCommands() {
         let blueprintsPackagePath = await this._getBlueprintPackagePaths();
@@ -349,7 +351,7 @@ export default class EnvironmentBuilder {
      * @private
      * Get blueprints commands.
      *
-     * @return {Object[]} commands.
+     * @return {Record<string, import('./types.js').CliCommand>} commands.
      */
     async _getBlueprintCommands(blueprintPackagePaths) {
         if (!blueprintPackagePaths) {

package/dist/cli/jhipster-command.d.mts

@@ -61,10 +61,10 @@ export default class JHipsterCommand extends Command {
     /**
      * Register options using generator._options structure.
      * @param {object} options
-     * @param {string} blueprintOptionDescription - description of the blueprint that adds the option
+     * @param {string} [blueprintOptionDescription] - description of the blueprint that adds the option
      * @return {JHipsterCommand} this;
      */
-    addGeneratorOptions(options: object, blueprintOptionDescription: string): JHipsterCommand;
+    addGeneratorOptions(options: object, blueprintOptionDescription?: string | undefined): JHipsterCommand;
     addJHipsterArguments(jhipsterArguments: any): this;
     addJHipsterOptions(options: any, blueprintOptionDescription: any): this;
     addJHipsterConfigs(configs: {} | undefined, blueprintOptionDescription: any): this;

package/dist/cli/jhipster-command.mjs

@@ -17,7 +17,7 @@
  * limitations under the License.
  */
 import chalk from 'chalk';
-import { Command, Option } from 'commander';
+import { Argument, Command, Option } from 'commander';
 import { kebabCase } from 'lodash-es';
 import { convertConfigToOption } from '../lib/command/index.js';
 export default class JHipsterCommand extends Command {
@@ -141,7 +141,7 @@ export default class JHipsterCommand extends Command {
     /**
      * Register options using generator._options structure.
      * @param {object} options
-     * @param {string} blueprintOptionDescription - description of the blueprint that adds the option
+     * @param {string} [blueprintOptionDescription] - description of the blueprint that adds the option
      * @return {JHipsterCommand} this;
      */
     addGeneratorOptions(options, blueprintOptionDescription) {
@@ -154,7 +154,11 @@ export default class JHipsterCommand extends Command {
         Object.entries(jhipsterArguments ?? {}).forEach(([key, value]) => {
             let argName = value.type === Array ? `${key}...` : key;
             argName = value.required ? `<${argName}>` : `[${argName}]`;
-            this.argument(argName, value.description);
+            const argument = new Argument(argName, value.description);
+            if (value.choices) {
+                argument.choices(value.choices.map(choice => (typeof choice === 'string' ? choice : choice.value)));
+            }
+            this.addArgument(argument);
         });
         return this;
     }
@@ -166,7 +170,9 @@ export default class JHipsterCommand extends Command {
     }
     addJHipsterConfigs(configs = {}, blueprintOptionDescription) {
         Object.assign(blueprintOptionDescription ? this.blueprintConfigs : this.configs, configs);
-        Object.entries(configs).forEach(([name, config]) => {
+        Object.entries(configs)
+            .filter(([_name, config]) => config.cli)
+            .forEach(([name, config]) => {
             const option = convertConfigToOption(name, config);
             if (option) {
                 this._addGeneratorOption(kebabCase(option.name), option, blueprintOptionDescription);
@@ -207,6 +213,9 @@ export default class JHipsterCommand extends Command {
         if (optionDefinition.choices && optionDefinition.choices.length > 0) {
             option.choices(optionDefinition.choices);
         }
+        if (optionDefinition.implies) {
+            option.implies(optionDefinition.implies);
+        }
         return this.addOption(option);
     }
 }

package/dist/cli/program.d.mts

@@ -1,38 +1,55 @@
-export function printJHipsterLogo(): void;
-export function createProgram({ executableName, executableVersion }?: {
-    executableName?: string | undefined;
-    executableVersion: any;
-}): JHipsterCommand;
-export function buildCommands({ program, commands, envBuilder, env, loadCommand, defaultCommand, entrypointGenerator, printLogo, printBlueprintLogo, createEnvBuilder, }: {
-    program: any;
-    commands?: {} | undefined;
-    envBuilder: any;
-    env: any;
-    loadCommand: any;
-    defaultCommand?: string | undefined;
-    entrypointGenerator: any;
-    printLogo?: (() => void) | undefined;
-    printBlueprintLogo?: (() => void) | undefined;
-    createEnvBuilder: any;
-}): Promise<void>;
-export function buildJHipster({ executableName, executableVersion, program, blueprints, lookups, createEnvBuilder, envBuilder, commands, printLogo, printBlueprintLogo, devBlueprintPath, env, loadCommand, defaultCommand, entrypointGenerator, }?: {
-    executableName: any;
-    executableVersion: any;
-    program?: JHipsterCommand | undefined;
-    blueprints: any;
-    lookups: any;
-    createEnvBuilder: any;
-    envBuilder: any;
-    commands: any;
-    printLogo: any;
-    printBlueprintLogo: any;
-    devBlueprintPath: any;
-    env: any;
-    loadCommand?: ((key: any) => Promise<any>) | undefined;
-    defaultCommand: any;
-    entrypointGenerator: any;
-}): Promise<JHipsterCommand>;
-export function runJHipster(args?: {}): Promise<JHipsterCommand>;
-export { done };
+/**
+ * Copyright 2013-2024 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 type Environment from 'yeoman-environment';
+import type { BaseEnvironmentOptions } from '@yeoman/types';
+import EnvironmentBuilder from './environment-builder.mjs';
 import JHipsterCommand from './jhipster-command.mjs';
 import { done } from './utils.mjs';
+import type { CliCommand } from './types.js';
+type BuildCommands = {
+    program: JHipsterCommand;
+    commands?: Record<string, CliCommand>;
+    envBuilder?: EnvironmentBuilder;
+    env: Environment;
+    loadCommand?: (key: string) => Promise<(...args: any[]) => Promise<any>>;
+    defaultCommand?: string;
+    entrypointGenerator?: string;
+    silent?: boolean;
+    printLogo?: () => void | Promise<void>;
+    printBlueprintLogo?: () => void | Promise<void>;
+    createEnvBuilder: (options?: BaseEnvironmentOptions) => Promise<EnvironmentBuilder>;
+};
+type BuildJHipsterOptions = Partial<BuildCommands> & {
+    executableName?: string;
+    executableVersion?: string;
+    blueprints?: Record<string, string>;
+    lookups?: any[];
+    devBlueprintPath?: string;
+};
+export declare const printJHipsterLogo: () => void;
+export declare const createProgram: ({ executableName, executableVersion, }?: {
+    executableName?: string;
+    executableVersion?: string;
+}) => JHipsterCommand;
+export declare const buildCommands: ({ program, commands, envBuilder, env, loadCommand, defaultCommand, entrypointGenerator, printLogo, printBlueprintLogo, createEnvBuilder, silent, }: BuildCommands) => void;
+export declare const buildJHipster: ({ executableName, executableVersion, program, blueprints, lookups, createEnvBuilder, envBuilder, commands, devBlueprintPath, env, ...buildOptions }?: BuildJHipsterOptions) => Promise<JHipsterCommand>;
+export declare const runJHipster: (args?: {
+    argv?: string[];
+} & BuildJHipsterOptions) => Promise<JHipsterCommand>;
+export { done };

package/dist/cli/program.mjs

@@ -23,7 +23,7 @@ import didYouMean from 'didyoumean';
 import chalk from 'chalk';
 import { packageJson } from '../lib/index.js';
 import { packageNameToNamespace } from '../generators/base/support/index.js';
-import command from '../generators/base/command.js';
+import baseCommand from '../generators/base/command.js';
 import { GENERATOR_APP, GENERATOR_BOOTSTRAP, GENERATOR_JDL } from '../generators/generator-list.js';
 import { extractArgumentsFromConfigs } from '../lib/command/index.js';
 import { buildJDLApplicationConfig } from '../lib/command/jdl.js';
@@ -43,9 +43,9 @@ export const printJHipsterLogo = () => {
     // eslint-disable-next-line no-console
     console.log(logo);
 };
-const buildAllDependencies = async (generatorNames, { env, blueprintNamespaces }) => {
+const buildAllDependencies = async (generatorNames, { env, blueprintNamespaces = [] }) => {
     const allDependencies = {};
-    const registerDependency = async ({ namespace, blueprintNamespace }) => {
+    const registerDependency = async ({ namespace, blueprintNamespace, }) => {
         const meta = await env.getGeneratorMeta(namespace.includes(':') ? namespace : `${JHIPSTER_NS}:${namespace}`);
         if (meta) {
             allDependencies[namespace] = { meta, blueprintNamespace };
@@ -53,7 +53,7 @@ const buildAllDependencies = async (generatorNames, { env, blueprintNamespaces }
         else if (!blueprintNamespace) {
             logger.warn(`Generator ${namespace} not found.`);
         }
-        return meta?.importModule();
+        return (await meta?.importModule?.());
     };
     const lookupDependencyOptions = async ({ namespace, blueprintNamespace }) => {
         const lookupGeneratorAndImports = async ({ namespace, blueprintNamespace }) => {
@@ -97,7 +97,8 @@ const addCommandGeneratorOptions = async (command, generatorMeta, { root, bluepr
         }
     }
     try {
-        if (root || !generatorModule.command || generatorModule.command.loadGeneratorOptions) {
+        if (generatorModule.command?.loadGeneratorOptions !== false &&
+            (root || !generatorModule.command || generatorModule.command.loadGeneratorOptions)) {
             const generator = await generatorMeta.instantiateHelp();
             // Add basic yeoman generator options
             command.addGeneratorOptions(generator._options, blueprintOptionDescription);
@@ -126,7 +127,7 @@ const addCommandRootGeneratorOptions = async (command, generatorMeta, { usage =
         }
     }
 };
-export const createProgram = ({ executableName = CLI_NAME, executableVersion } = {}) => {
+export const createProgram = ({ executableName = CLI_NAME, executableVersion, } = {}) => {
     return (new JHipsterCommand()
         .name(executableName)
         .storeOptionsAsProperties(false)
@@ -144,8 +145,9 @@ export const createProgram = ({ executableName = CLI_NAME, executableVersion } =
         .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)
-        .addJHipsterOptions(command.options)
-        .addJHipsterConfigs(command.configs));
+        .addJHipsterOptions(baseCommand.options)
+        // @ts-expect-error configs is not defined, but can be added later
+        .addJHipsterConfigs(baseCommand.configs));
 };
 const rejectExtraArgs = ({ program, command, extraArgs }) => {
     // if extraArgs exists: Unknown commands or unknown argument.
@@ -161,7 +163,10 @@ const rejectExtraArgs = ({ program, command, extraArgs }) => {
     const message = `${chalk.yellow(first)} is not a known command. See '${chalk.white(`${CLI_NAME} --help`)}'.`;
     logger.fatal(message);
 };
-export const buildCommands = async ({ program, commands = {}, envBuilder, env, loadCommand, defaultCommand = GENERATOR_APP, entrypointGenerator, printLogo = printJHipsterLogo, printBlueprintLogo = () => { }, createEnvBuilder, }) => {
+export const buildCommands = ({ program, commands = {}, envBuilder, env, loadCommand = async (key) => {
+    const { default: command } = await import(`./${key}.mjs`);
+    return command;
+}, defaultCommand = GENERATOR_APP, entrypointGenerator, printLogo = printJHipsterLogo, printBlueprintLogo = () => { }, createEnvBuilder, silent, }) => {
     /* create commands */
     Object.entries(commands).forEach(([cmdName, opts]) => {
         const { desc, blueprint, argument, options: commandOptions, alias, help: commandHelp, cliOnly, removed, useOptions = {} } = opts;
@@ -181,12 +186,16 @@ export const buildCommands = async ({ program, commands = {}, envBuilder, env, l
                 logger.fatal(removed);
                 return;
             }
+            if (!silent) {
+                await printLogo();
+                await printBlueprintLogo();
+            }
             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}`);
-                await envBuilder.lookupGenerators(command.generatorNamespaces.map(namespace => `generator-${namespace.split(':')[0]}`));
+                await envBuilder?.lookupGenerators(command.generatorNamespaces.map(namespace => `generator-${namespace.split(':')[0]}`));
                 await Promise.all(command.generatorNamespaces.map(async (namespace) => {
                     const generatorMeta = env.getGeneratorMeta(namespace.includes(':') ? namespace : `${JHIPSTER_NS}:${namespace}`);
                     if (!generatorMeta) {
@@ -211,7 +220,7 @@ export const buildCommands = async ({ program, commands = {}, envBuilder, env, l
                 }
                 const allDependencies = await buildAllDependencies(boostrapGen, {
                     env,
-                    blueprintNamespaces: envBuilder.getBlueprintsNamespaces(),
+                    blueprintNamespaces: envBuilder?.getBlueprintsNamespaces(),
                 });
                 for (const [metaName, { meta: generatorMeta, blueprintNamespace }] of Object.entries(allDependencies)) {
                     if (blueprintNamespace) {
@@ -242,7 +251,7 @@ export const buildCommands = async ({ program, commands = {}, envBuilder, env, l
                 ...useOptions,
                 commandName: cmdName,
                 entrypointGenerator,
-                blueprints: envBuilder.getBlueprintsOption(),
+                blueprints: envBuilder?.getBlueprintsOption(),
                 positionalArguments: args,
                 jdlDefinition,
                 commandsConfigs,
@@ -252,8 +261,6 @@ export const buildCommands = async ({ program, commands = {}, envBuilder, env, l
                 console.log(path.dirname(__dirname));
                 return Promise.resolve();
             }
-            printLogo();
-            printBlueprintLogo();
             if (cliOnly) {
                 logger.debug('Executing CLI only script');
                 const cliOnlyCommand = await loadCommand(cmdName);
@@ -262,44 +269,46 @@ export const buildCommands = async ({ program, commands = {}, envBuilder, env, l
                     : Promise.reject(new Error(`Command ${cmdName} is not a function.`));
             }
             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)));
+                return Promise.all(command.generatorNamespaces.map(generator => env.run(generator, options))).then(results => silent || done(results.find(result => result)), errors => silent || done(errors.find(error => error)));
             }
             if (cmdName === 'upgrade') {
                 options.programName = program.name();
                 options.createEnvBuilder = createEnvBuilder;
             }
             const namespace = blueprint ? `${packageNameToNamespace(blueprint)}:${cmdName}` : `${JHIPSTER_NS}:${cmdName}`;
-            const generatorCommand = getCommand(namespace, args, opts);
-            return env.run(generatorCommand, options).then(done, done);
+            const generatorCommand = getCommand(namespace, args);
+            const promise = env.run(generatorCommand, options);
+            if (silent) {
+                return promise;
+            }
+            return promise.then(done, done);
         });
     });
 };
-export const buildJHipster = async ({ executableName, executableVersion, program = createProgram({ executableName, executableVersion }), blueprints, lookups, createEnvBuilder, envBuilder, commands, printLogo, printBlueprintLogo, devBlueprintPath, env, loadCommand = async (key) => {
-    const { default: command } = await import(`./${key}.mjs`);
-    return command;
-}, defaultCommand, entrypointGenerator, } = {}) => {
+export const buildJHipster = async ({ executableName, executableVersion, program = createProgram({ executableName, executableVersion }), blueprints, lookups, createEnvBuilder, envBuilder, commands, devBlueprintPath, env, ...buildOptions } = {}) => {
     createEnvBuilder =
         createEnvBuilder ?? (async (options) => EnvironmentBuilder.create(options).prepare({ blueprints, lookups, devBlueprintPath }));
-    envBuilder = envBuilder ?? (await createEnvBuilder());
-    env = env ?? envBuilder.getEnvironment();
-    commands = commands ?? { ...SUB_GENERATORS, ...(await envBuilder.getBlueprintCommands()) };
-    await buildCommands({
+    if (!env) {
+        envBuilder = envBuilder ?? (await createEnvBuilder());
+        env = env ?? envBuilder.getEnvironment();
+        commands = { ...SUB_GENERATORS, ...(await envBuilder.getBlueprintCommands()), ...commands };
+    }
+    else {
+        commands = { ...SUB_GENERATORS, ...commands };
+    }
+    buildCommands({
+        ...buildOptions,
         program,
         commands,
         envBuilder,
         env,
-        loadCommand,
-        defaultCommand,
-        entrypointGenerator,
-        printLogo,
-        printBlueprintLogo,
         createEnvBuilder,
     });
     return program;
 };
 export const runJHipster = async (args = {}) => {
-    const { argv = process.argv } = args;
-    const jhipsterProgram = await buildJHipster(args);
+    const { argv = process.argv, ...buildJHipsterOptions } = args;
+    const jhipsterProgram = await buildJHipster(buildJHipsterOptions);
     return jhipsterProgram.parseAsync(argv);
 };
 export { done };