generator-jhipster 8.0.0-beta.1 → 8.0.0-beta.3

package/dist/generators/base-entity-changes/generator.mjs

@@ -0,0 +1,141 @@
+/**
+ * Copyright 2013-2023 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 { existsSync, readFileSync } from 'fs';
+import GeneratorBaseApplication from '../base-application/index.mjs';
+import { PRIORITY_NAMES } from '../base-application/priorities.mjs';
+import { loadEntitiesAnnotations, loadEntitiesOtherSide } from '../base-application/support/index.mjs';
+import { relationshipEquals, relationshipNeedsForeignKeyRecreationOnly } from '../liquibase/support/index.mjs';
+import { addEntitiesOtherRelationships } from '../server/support/index.mjs';
+const { DEFAULT, WRITING_ENTITIES, POST_WRITING_ENTITIES } = PRIORITY_NAMES;
+const baseChangelog = () => ({
+    newEntity: false,
+    changedEntity: false,
+    incremental: false,
+    previousEntity: undefined,
+    addedFields: [],
+    removedFields: [],
+    addedRelationships: [],
+    removedRelationships: [],
+    relationshipsToRecreateForeignKeysOnly: [],
+    changelogData: {},
+});
+/**
+ * This is the base class for a generator for every generator.
+ */
+export default class GeneratorBaseEntityChanges extends GeneratorBaseApplication {
+    recreateInitialChangelog;
+    entityChanges;
+    getTaskFirstArgForPriority(priorityName) {
+        const firstArg = super.getTaskFirstArgForPriority(priorityName);
+        if ([DEFAULT, WRITING_ENTITIES, POST_WRITING_ENTITIES].includes(priorityName)) {
+            this.entityChanges = this.generateIncrementalChanges();
+        }
+        if ([DEFAULT].includes(priorityName)) {
+            return { ...firstArg, entityChanges: this.entityChanges };
+        }
+        if ([WRITING_ENTITIES, POST_WRITING_ENTITIES].includes(priorityName)) {
+            // const { entities = [] } = this.options;
+            // const filteredEntities = data.entities.filter(entity => entities.includes(entity.name));
+            return { ...firstArg, entityChanges: this.entityChanges };
+        }
+        return firstArg;
+    }
+    /**
+     * Generate changelog from differences between the liquibase entity and current entity.
+     */
+    generateIncrementalChanges() {
+        const recreateInitialChangelog = this.recreateInitialChangelog;
+        const { generateBuiltInUserEntity, incrementalChangelog } = this.sharedData.getApplication();
+        const entityNames = this.getExistingEntityNames();
+        const entitiesByName = Object.fromEntries(entityNames.map(entityName => [entityName, this.sharedData.getEntity(entityName)]));
+        const entitiesWithExistingChangelog = entityNames.filter(entityName => !this.isChangelogNew({ entityName, changelogDate: entitiesByName[entityName].changelogDate }));
+        const previousEntitiesByName = Object.fromEntries(entityNames
+            .filter(entityName => existsSync(this.getEntityConfigPath(entityName)))
+            .map(entityName => [
+            entityName,
+            { name: entityName, ...JSON.parse(readFileSync(this.getEntityConfigPath(entityName)).toString()) },
+        ]));
+        if (generateBuiltInUserEntity) {
+            const user = this.sharedData.getEntity('User');
+            previousEntitiesByName.User = user;
+        }
+        const entities = Object.values(previousEntitiesByName);
+        loadEntitiesAnnotations(entities);
+        loadEntitiesOtherSide(entities);
+        addEntitiesOtherRelationships(entities);
+        // Compare entity changes and create changelogs
+        return entityNames.map(entityName => {
+            const newConfig = entitiesByName[entityName];
+            const newFields = (newConfig.fields || []).filter((field) => !field.transient);
+            const newRelationships = newConfig.relationships || [];
+            const oldConfig = previousEntitiesByName[entityName];
+            if (!oldConfig || recreateInitialChangelog || !incrementalChangelog || !entitiesWithExistingChangelog.includes(entityName)) {
+                return {
+                    ...baseChangelog(),
+                    incremental: newConfig.incrementalChangelog,
+                    changelogDate: newConfig.changelogDate,
+                    newEntity: true,
+                    entity: newConfig,
+                    entityName,
+                };
+            }
+            this._debug(`Calculating diffs for ${entityName}`);
+            const oldFields = (oldConfig.fields || []).filter((field) => !field.transient);
+            const oldFieldNames = oldFields.filter(field => !field.id).map(field => field.fieldName);
+            const newFieldNames = newFields.filter(field => !field.id).map(field => field.fieldName);
+            // Calculate new fields
+            const addedFieldNames = newFieldNames.filter(fieldName => !oldFieldNames.includes(fieldName));
+            const addedFields = addedFieldNames.map(fieldName => newFields.find(field => fieldName === field.fieldName));
+            // Calculate removed fields
+            const removedFieldNames = oldFieldNames.filter(fieldName => !newFieldNames.includes(fieldName));
+            const removedFields = removedFieldNames.map(fieldName => oldFields.find(field => fieldName === field.fieldName));
+            const oldRelationships = oldConfig.relationships || [];
+            // Calculate changed/newly added relationships
+            const addedRelationships = newRelationships.filter(newRelationship => 
+            // id changes are not supported
+            !newRelationship.id &&
+                // check if the same relationship wasn't already part of the old config
+                !oldRelationships.some(oldRelationship => relationshipEquals(oldRelationship, newRelationship)));
+            // Calculate to be removed relationships
+            const removedRelationships = oldRelationships.filter(oldRelationship => 
+            // id changes are not supported
+            !oldRelationship.id &&
+                // check if there are relationships not anymore in the new config
+                !newRelationships.some(newRelationship => relationshipEquals(newRelationship, oldRelationship)));
+            // calcualte relationships that only need a foreign key recreation from the ones that are added
+            // we need both the added and the removed ones here
+            const relationshipsToRecreateForeignKeysOnly = addedRelationships
+                .filter(addedRelationship => removedRelationships.some(removedRelationship => relationshipNeedsForeignKeyRecreationOnly(removedRelationship, addedRelationship)))
+                .concat(removedRelationships.filter(removedRelationship => addedRelationships.some(addedRelationship => relationshipNeedsForeignKeyRecreationOnly(addedRelationship, removedRelationship))));
+            return {
+                ...baseChangelog(),
+                previousEntity: oldConfig,
+                entity: newConfig,
+                incremental: true,
+                changedEntity: true,
+                entityName,
+                addedFields,
+                removedFields,
+                addedRelationships,
+                removedRelationships,
+                relationshipsToRecreateForeignKeysOnly,
+            };
+        });
+    }
+}

package/dist/generators/{liquibase-changelogs → base-entity-changes}/index.mjs

@@ -17,4 +17,3 @@
  * limitations under the License.
  */
 export { default } from './generator.mjs';
-export { addEntityFiles, updateEntityFiles, updateConstraintsFiles, updateMigrateFiles, fakeFiles } from './files.mjs';

package/dist/generators/base-workspaces/command.mjs

@@ -0,0 +1,4 @@
+const command = {
+    options: {},
+};
+export default command;

package/dist/generators/base-workspaces/generator.mjs

@@ -0,0 +1,141 @@
+/**
+ * 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 { readdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import chalk from 'chalk';
+import BaseGenerator from '../base/index.mjs';
+import { PRIORITY_NAMES, CUSTOM_PRIORITIES } from './priorities.mjs';
+import { YO_RC_FILE } from '../generator-constants.mjs';
+import { GENERATOR_BOOTSTRAP_APPLICATION } from '../generator-list.mjs';
+import command from './command.mjs';
+import { normalizePathEnd } from '../base/support/path.mjs';
+const { PROMPTING_WORKSPACES, CONFIGURING_WORKSPACES, LOADING_WORKSPACES, PREPARING_WORKSPACES, DEFAULT, WRITING, POST_WRITING, PRE_CONFLICTS, INSTALL, END, } = PRIORITY_NAMES;
+/**
+ * This is the base class for a generator that generates entities.
+ */
+export default class BaseWorkspacesGenerator extends BaseGenerator {
+    static PROMPTING_WORKSPACES = BaseGenerator.asPriority(PROMPTING_WORKSPACES);
+    static CONFIGURING_WORKSPACES = BaseGenerator.asPriority(CONFIGURING_WORKSPACES);
+    static LOADING_WORKSPACES = BaseGenerator.asPriority(LOADING_WORKSPACES);
+    static PREPARING_WORKSPACES = BaseGenerator.asPriority(PREPARING_WORKSPACES);
+    appsFolders;
+    directoryPath;
+    constructor(args, options, features) {
+        super(args, options, features);
+        if (!this.options.help) {
+            this.registerPriorities(CUSTOM_PRIORITIES);
+            this.parseJHipsterOptions(command.options);
+        }
+    }
+    loadWorkspacesConfig({ context = this } = {}) {
+        context.appsFolders = this.jhipsterConfig.appsFolders;
+        context.directoryPath = this.jhipsterConfig.directoryPath ?? './';
+    }
+    configureWorkspacesConfig() {
+        this.jhipsterConfig.directoryPath = normalizePathEnd(this.jhipsterConfig.directoryPath ?? './');
+    }
+    async askForWorkspacesConfig() {
+        let appsFolders;
+        await this.prompt([
+            {
+                type: 'input',
+                name: 'directoryPath',
+                message: 'Enter the root directory where your applications are located',
+                default: '../',
+                validate: async (input) => {
+                    const path = this.destinationPath(input);
+                    if (existsSync(path)) {
+                        const applications = await this.findApplicationFolders(path);
+                        return applications.length === 0 ? `No application found in ${path}` : true;
+                    }
+                    return `${path} is not a directory or doesn't exist`;
+                },
+            },
+            {
+                type: 'checkbox',
+                name: 'appsFolders',
+                when: async (answers) => {
+                    const directoryPath = answers.directoryPath;
+                    appsFolders = (await this.findApplicationFolders(directoryPath)).filter(app => app !== 'jhipster-registry' && app !== 'registry');
+                    this.log.log(chalk.green(`${appsFolders.length} applications found at ${this.destinationPath(directoryPath)}\n`));
+                    return true;
+                },
+                message: 'Which applications do you want to include in your configuration?',
+                choices: () => appsFolders,
+                default: () => appsFolders,
+                validate: input => (input.length === 0 ? 'Please choose at least one application' : true),
+            },
+        ], this.config);
+    }
+    async findApplicationFolders(directoryPath = this.directoryPath ?? '.') {
+        return (await readdir(this.destinationPath(directoryPath), { withFileTypes: true }))
+            .filter(dirent => dirent.isDirectory())
+            .map(dirent => dirent.name)
+            .filter(folder => existsSync(this.destinationPath(directoryPath, folder, 'package.json')) &&
+            existsSync(this.destinationPath(directoryPath, folder, YO_RC_FILE)));
+    }
+    async resolveApplicationFolders({ directoryPath = this.directoryPath, appsFolders = this.appsFolders ?? [], } = {}) {
+        return Object.fromEntries(appsFolders.map(appFolder => [appFolder, this.destinationPath(directoryPath ?? '.', appFolder)]));
+    }
+    async bootstrapApplications() {
+        const resolvedApplicationFolders = await this.resolveApplicationFolders();
+        for (const [_appFolder, resolvedFolder] of Object.entries(resolvedApplicationFolders)) {
+            await this.composeWithJHipster(GENERATOR_BOOTSTRAP_APPLICATION, {
+                generatorOptions: { destinationRoot: resolvedFolder, reproducible: true },
+            });
+        }
+        this.getSharedApplication(this.destinationPath()).workspacesApplications = Object.entries(resolvedApplicationFolders).map(([appFolder, resolvedFolder], index) => {
+            const application = this.getSharedApplication(resolvedFolder)?.sharedApplication;
+            application.appFolder = appFolder;
+            application.composePort = 8080 + index;
+            return application;
+        });
+    }
+    getArgsForPriority(priorityName) {
+        const args = super.getArgsForPriority(priorityName);
+        if (![
+            PROMPTING_WORKSPACES,
+            CONFIGURING_WORKSPACES,
+            LOADING_WORKSPACES,
+            PREPARING_WORKSPACES,
+            DEFAULT,
+            WRITING,
+            POST_WRITING,
+            PRE_CONFLICTS,
+            INSTALL,
+            END,
+        ].includes(priorityName)) {
+            return args;
+        }
+        const [first, ...others] = args ?? [];
+        const sharedData = this.getSharedApplication(this.destinationPath());
+        const deployment = sharedData.sharedDeployment;
+        const workspaces = sharedData.sharedWorkspaces;
+        const applications = sharedData.workspacesApplications;
+        return [
+            {
+                ...first,
+                workspaces,
+                deployment,
+                applications,
+            },
+            ...others,
+        ];
+    }
+}

package/dist/generators/{liquibase-changelogs/support → base-workspaces}/index.mjs

@@ -16,5 +16,5 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-// eslint-disable-next-line import/prefer-default-export
-export { default as liquibaseComment } from './formatting.mjs';
+export { default } from './generator.mjs';
+export { default as command } from './command.mjs';

package/dist/generators/base-workspaces/internal/deployments.mjs

@@ -0,0 +1,36 @@
+/**
+ * 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 _ from 'lodash';
+import { applicationOptions, deploymentOptions } from '../../../jdl/index.js';
+import { loadDerivedPlatformConfig, loadPlatformConfig, loadDerivedServerAndPlatformProperties } from '../../server/support/index.mjs';
+const { OptionNames } = applicationOptions;
+const { Options: DeploymentOptions } = deploymentOptions;
+const { JWT_SECRET_KEY } = OptionNames;
+export function loadDeploymentConfig({ config = _.defaults({}, this.jhipsterConfig, DeploymentOptions.defaults(this.jhipsterConfig.deploymentType)), deployment = this, } = {}) {
+    deployment.appsFolders = config.appsFolders;
+    deployment.directoryPath = config.directoryPath;
+    deployment.clusteredDbApps = config.clusteredDbApps;
+    deployment.dockerRepositoryName = config.dockerRepositoryName;
+    deployment.dockerPushCommand = config.dockerPushCommand;
+    deployment.adminPassword = config.adminPassword;
+    deployment.jwtSecretKey = config[JWT_SECRET_KEY];
+    loadPlatformConfig({ config, application: deployment });
+    loadDerivedPlatformConfig({ application: deployment });
+    loadDerivedServerAndPlatformProperties({ application: deployment });
+}

package/dist/generators/{base-docker → base-workspaces/internal}/docker-base.mjs

@@ -18,11 +18,15 @@
  */
 import { existsSync } from 'fs';
 import chalk from 'chalk';
-import { convertSecretToBase64, createBase64Secret, removeFieldsWithNullishValues } from '../base/support/index.mjs';
-import { applicationTypes, buildToolTypes, getConfigWithDefaults } from '../../jdl/jhipster/index.mjs';
+import { convertSecretToBase64, createBase64Secret, removeFieldsWithNullishValues } from '../../base/support/index.mjs';
+import { applicationTypes, buildToolTypes, getConfigWithDefaults } from '../../../jdl/jhipster/index.mjs';
+import { GENERATOR_JHIPSTER } from '../../generator-constants.mjs';
+import { loadDeploymentConfig } from '../../base-workspaces/internal/index.mjs';
+import { loadDerivedAppConfig } from '../../app/support/index.mjs';
+import { loadDerivedPlatformConfig, loadDerivedServerConfig } from '../../server/support/index.mjs';
 const { MAVEN } = buildToolTypes;
 const { MONOLITH, MICROSERVICE, GATEWAY } = applicationTypes;
-export { checkDocker } from './docker-utils.mjs';
+export { checkDocker } from '../../docker/support/index.mjs';
 /**
  * Check Images
  */
@@ -66,18 +70,6 @@ export function configureImageNames() {
         this.appConfigs[i].targetImageName = targetImageName;
     }
 }
-/**
- * Set Apps Folder Paths
- */
-export function setAppsFolderPaths() {
-    if (this.applicationType)
-        return;
-    this.appsFolderPaths = [];
-    for (let i = 0; i < this.appsFolders.length; i++) {
-        const path = this.destinationPath(this.directoryPath + this.appsFolders[i]);
-        this.appsFolderPaths.push(path);
-    }
-}
 /**
  * Load config from this.appFolders
  */
@@ -87,21 +79,19 @@ export function loadConfigs() {
     this.monolithicNb = 0;
     this.microserviceNb = 0;
     const serverPort = 8080;
+    const getJhipsterConfig = yoRcPath => this.createStorage(yoRcPath, GENERATOR_JHIPSTER);
     // Loading configs
     this.log.debug(`Apps folders: ${this.appsFolders}`);
     this.appsFolders.forEach((appFolder, index) => {
         const path = this.destinationPath(`${this.directoryPath + appFolder}`);
         this.log.debug(chalk.red.bold(`App folder ${path}`));
         if (this.fs.exists(`${path}/.yo-rc.json`)) {
-            const config = getConfigWithDefaults(removeFieldsWithNullishValues(this.getJhipsterConfig(`${path}/.yo-rc.json`).getAll()));
+            const config = getConfigWithDefaults(removeFieldsWithNullishValues(getJhipsterConfig(`${path}/.yo-rc.json`).getAll()));
             config.composePort = serverPort + index;
             this.log.debug(chalk.red.bold(`${config.baseName} has compose port ${config.composePort} and appIndex ${config.applicationIndex}`));
-            this.loadAppConfig(config, config);
-            this.loadServerConfig(config, config);
-            this.loadPlatformConfig(config, config);
-            this.loadDerivedAppConfig(config);
-            this.loadDerivedPlatformConfig(config);
-            this.loadDerivedServerConfig(config);
+            loadDerivedAppConfig({ application: config });
+            loadDerivedPlatformConfig({ application: config });
+            loadDerivedServerConfig({ application: config });
             if (config.applicationType === MONOLITH) {
                 this.monolithicNb++;
             }
@@ -128,7 +118,7 @@ export function setClusteredApps() {
     }
 }
 export function loadFromYoRc() {
-    this.loadDeploymentConfig();
+    loadDeploymentConfig.call(this);
     this.useKafka = false;
     this.usePulsar = false;
     this.useMemcached = false;

package/dist/generators/base-workspaces/internal/docker-dependencies.mjs

@@ -0,0 +1,27 @@
+/**
+ * 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 { dockerContainers as elasticDockerContainer } from '../../generator-constants.mjs';
+import { dockerPlaceholderGenerator, getDockerfileContainers } from '../../docker/utils.mjs';
+export async function loadDockerDependenciesTask({ context = this } = {}) {
+    const dockerfile = this.readTemplate(this.jhipsterTemplatePath('../../server/resources/Dockerfile'));
+    context.dockerContainers = this.prepareDependencies({
+        ...elasticDockerContainer,
+        ...getDockerfileContainers(dockerfile),
+    }, dockerPlaceholderGenerator);
+}

package/dist/generators/{base-docker → base-workspaces/internal}/docker-prompts.mjs

@@ -18,9 +18,9 @@
  */
 import chalk from 'chalk';
 import shelljs from 'shelljs';
-import { loadConfigs, setClusteredApps } from './docker-base.mjs';
-import { applicationTypes, monitoringTypes, serviceDiscoveryTypes } from '../../jdl/jhipster/index.mjs';
-import { convertSecretToBase64 } from '../base/support/index.mjs';
+import { loadConfigs } from './docker-base.mjs';
+import { applicationTypes, monitoringTypes, serviceDiscoveryTypes } from '../../../jdl/jhipster/index.mjs';
+import { convertSecretToBase64 } from '../../base/support/index.mjs';
 const { MICROSERVICE, MONOLITH, GATEWAY } = applicationTypes;
 const { PROMETHEUS } = monitoringTypes;
 const monitoring = monitoringTypes;
@@ -64,7 +64,7 @@ async function askForApplicationType() {
             default: MONOLITH,
         },
     ];
-    const props = await this.prompt(prompts);
+    const props = await this.prompt(prompts, this.config);
     this.deploymentApplicationType = props.deploymentApplicationType;
 }
 /**
@@ -89,7 +89,7 @@ async function askForGatewayType() {
             default: 'SpringCloudGateway',
         },
     ];
-    const props = await this.prompt(prompts);
+    const props = await this.prompt(prompts, this.config);
     this.gatewayType = props.gatewayType;
 }
 /**
@@ -125,7 +125,7 @@ async function askForPath() {
             },
         },
     ];
-    const props = await this.prompt(prompts);
+    const props = await this.prompt(prompts, this.config);
     this.directoryPath = props.directoryPath;
     // Patch the path if there is no trailing "/"
     if (!this.directoryPath.endsWith('/')) {
@@ -153,13 +153,13 @@ async function askForApps() {
             type: 'checkbox',
             name: 'chosenApps',
             message: messageAskForApps,
-            choices: this.appsFolders,
+            choices: this.appsFolders ?? [],
             default: this.defaultAppsFolders,
             validate: input => (input.length === 0 ? 'Please choose at least one application' : true),
         },
     ];
     const props = await this.prompt(prompts);
-    this.appsFolders = props.chosenApps;
+    this.appsFolders = this.jhipsterConfig.appsFolders = props.chosenApps;
     loadConfigs.call(this);
 }
 /**
@@ -185,9 +185,8 @@ async function askForClustersMode() {
             default: this.clusteredDbApps,
         },
     ];
-    const props = await this.prompt(prompts);
+    const props = await this.prompt(prompts, this.config);
     this.clusteredDbApps = props.clusteredDbApps;
-    setClusteredApps.call(this);
 }
 /**
  * Ask For Monitoring
@@ -213,7 +212,7 @@ async function askForMonitoring() {
             default: this.monitoring ? this.monitoring : NO_MONITORING,
         },
     ];
-    const props = await this.prompt(prompts);
+    const props = await this.prompt(prompts, this.config);
     this.monitoring = props.monitoring;
 }
 /**
@@ -223,7 +222,7 @@ async function askForServiceDiscovery() {
     if (this.regenerate)
         return;
     const serviceDiscoveryEnabledApps = [];
-    this.appConfigs.forEach((appConfig, index) => {
+    this.appConfigs.forEach(appConfig => {
         if (appConfig.serviceDiscoveryAny) {
             serviceDiscoveryEnabledApps.push({
                 baseName: appConfig.baseName,
@@ -271,7 +270,7 @@ async function askForServiceDiscovery() {
                 default: CONSUL,
             },
         ];
-        const props = this.prompt(prompts);
+        const props = await this.prompt(prompts, this.config);
         this.serviceDiscoveryType = props.serviceDiscoveryType;
     }
 }
@@ -290,7 +289,7 @@ async function askForAdminPassword() {
             validate: input => (input.length < 5 ? 'The password must have at least 5 characters' : true),
         },
     ];
-    const props = await this.prompt(prompts);
+    const props = await this.prompt(prompts, this.config);
     this.adminPassword = props.adminPassword;
     this.adminPasswordBase64 = convertSecretToBase64(this.adminPassword);
 }
@@ -308,7 +307,7 @@ async function askForDockerRepositoryName() {
             default: this.dockerRepositoryName,
         },
     ];
-    const props = await this.prompt(prompts);
+    const props = await this.prompt(prompts, this.config);
     this.dockerRepositoryName = props.dockerRepositoryName;
 }
 /**
@@ -325,7 +324,7 @@ async function askForDockerPushCommand() {
             default: this.dockerPushCommand ? this.dockerPushCommand : 'docker push',
         },
     ];
-    const props = await this.prompt(prompts);
+    const props = await this.prompt(prompts, this.config);
     this.dockerPushCommand = props.dockerPushCommand;
 }
 /**

package/dist/generators/base-workspaces/internal/index.mjs

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+export * from './deployments.mjs';
+export * from './docker-dependencies.mjs';