generator-jhipster 8.0.0-beta.2 → 8.0.0-rc.1

package/dist/generators/bootstrap/support/java-unused-imports-transform.mjs

@@ -0,0 +1,25 @@
+import { extname } from 'path';
+import { passthrough } from '@yeoman/transform';
+import { isFileStateDeleted } from 'mem-fs-editor/state';
+import { removeUnusedImports } from 'java-lint';
+// eslint-disable-next-line import/prefer-default-export
+export const createRemoveUnusedImportsTransform = function (options = {}) {
+    const { ignoreErrors } = options;
+    return passthrough((file) => {
+        if (extname(file.path) === '.java' && !isFileStateDeleted(file)) {
+            if (file.contents) {
+                try {
+                    file.contents = Buffer.from(removeUnusedImports(file.contents.toString('utf8')));
+                }
+                catch (error) {
+                    const errorMessage = `Error parsing file ${file.relative}: ${error} at ${file.contents?.toString()}`;
+                    if (ignoreErrors) {
+                        this?.log?.warn?.(errorMessage);
+                        return;
+                    }
+                    throw new Error(errorMessage);
+                }
+            }
+        }
+    });
+};

package/dist/generators/bootstrap/support/multi-step-transform/template-file-fs.mjs

@@ -17,8 +17,8 @@
  * limitations under the License.
  */
 import assert from 'assert';
-import { minimatch } from 'minimatch';
 import path from 'path';
+import { minimatch } from 'minimatch';
 import TemplateFile from './template-file.mjs';
 export default class TemplateFileFs {
     constructor(options = {}) {

package/dist/generators/bootstrap/support/multi-step-transform/template-file.mjs

@@ -1,7 +1,7 @@
 import assert from 'assert';
+import path from 'path';
 import debugBuilder from 'debug';
 import ejs from 'ejs';
-import path from 'path';
 import TemplateData from './template-data.mjs';
 export default class TemplateFile {
     constructor(filename, extension) {

package/dist/generators/bootstrap/support/prettier-support.mjs

@@ -20,16 +20,19 @@ import { passthrough } from 'p-transform';
 import { isFileStateDeleted } from 'mem-fs-editor/state';
 import prettier from 'prettier';
 import prettierPluginJava from 'prettier-plugin-java';
+import prettierPluginProperties from 'prettier-plugin-properties';
 import prettierPluginPackagejson from 'prettier-plugin-packagejson';
 import { Minimatch } from 'minimatch';
 const minimatch = new Minimatch('**/{.prettierrc**,.prettierignore}');
-export const isPrettierConfigFile = file => minimatch.match(file.path);
-export const createPrettierTransform = function (options, generator, transformOptions = {}) {
-    if (typeof transformOptions === 'boolean') {
-        transformOptions = { ignoreErrors: transformOptions };
-    }
-    const { ignoreErrors = false, extensions } = transformOptions;
-    const minimatch = new Minimatch(`**/*.{${extensions}}`, { dot: true });
+export const isPrettierConfigFilePath = (filePath) => minimatch.match(filePath);
+export const isPrettierConfigFile = (file) => isPrettierConfigFilePath(file.path);
+export const createPrettierTransform = async function (options = {}) {
+    // prettier cache is global, generators may execute more than one commit.
+    // In case prettier config is committed to disk at later commits, the cache may be outdated.
+    await prettier.clearConfigCache();
+    const { ignoreErrors = false, extensions = '*', prettierPackageJson, prettierJava, prettierProperties, prettierOptions } = options;
+    const globExpression = extensions.includes(',') ? `**/*.{${extensions}}` : `**/*.${extensions}`;
+    const minimatch = new Minimatch(globExpression, { dot: true });
     return passthrough(async (file) => {
         if (!minimatch.match(file.path) || isFileStateDeleted(file)) {
             return;
@@ -41,21 +44,25 @@ export const createPrettierTransform = function (options, generator, transformOp
         let fileContent;
         try {
             const resolvedDestinationFileOptions = await prettier.resolveConfig(file.relative);
-            const prettierOptions = {
-                plugins: [],
+            const fileOptions = {
                 // Config from disk
                 ...resolvedDestinationFileOptions,
+                plugins: [],
                 // for better errors
                 filepath: file.relative,
+                ...prettierOptions,
             };
-            if (options.packageJson) {
-                prettierOptions.plugins.push(prettierPluginPackagejson);
+            if (prettierPackageJson && file.path.endsWith('package.json')) {
+                fileOptions.plugins.push(prettierPluginPackagejson);
+            }
+            if (prettierJava && file.path.endsWith('.java')) {
+                fileOptions.plugins.push(prettierPluginJava);
             }
-            if (options.java) {
-                prettierOptions.plugins.push(prettierPluginJava);
+            if (prettierProperties) {
+                fileOptions.plugins.push(prettierPluginProperties);
             }
             fileContent = file.contents.toString('utf8');
-            const data = prettier.format(fileContent, prettierOptions);
+            const data = await prettier.format(fileContent, fileOptions);
             file.contents = Buffer.from(data);
         }
         catch (error) {
@@ -72,7 +79,7 @@ At: ${fileContent
                 errorMessage = `Unknown prettier error: ${error}`;
             }
             if (ignoreErrors) {
-                generator.log.warn(errorMessage);
+                this?.log?.warn?.(errorMessage);
                 return;
             }
             throw new Error(errorMessage);

package/dist/generators/bootstrap-application/generator.mjs

@@ -20,27 +20,56 @@ import assert from 'assert';
 import BaseApplicationGenerator from '../base-application/index.mjs';
 import { validations } from '../../jdl/jhipster/index.mjs';
 import { stringifyApplicationData, derivedPrimaryKeyProperties, preparePostEntitiesCommonDerivedProperties, preparePostEntityCommonDerivedProperties, } from '../base-application/support/index.mjs';
-import { GENERATOR_BOOTSTRAP_APPLICATION_CLIENT, GENERATOR_BOOTSTRAP_APPLICATION_SERVER } from '../generator-list.mjs';
+import { GENERATOR_BOOTSTRAP_APPLICATION, GENERATOR_BOOTSTRAP_APPLICATION_CLIENT, GENERATOR_BOOTSTRAP_APPLICATION_SERVER, } from '../generator-list.mjs';
 import { preparePostEntityServerDerivedProperties } from '../server/support/index.mjs';
+import { getDefaultAppName } from '../project-name/support/index.mjs';
+import { packageJson } from '../../lib/index.mjs';
+import { loadStoredAppOptions } from '../app/support/index.mjs';
+import { JHIPSTER_DOCUMENTATION_ARCHIVE_PATH, JHIPSTER_DOCUMENTATION_URL } from '../generator-constants.mjs';
 const { Validations: { MAX, MIN, MAXLENGTH, MINLENGTH, MAXBYTES, MINBYTES, PATTERN }, SUPPORTED_VALIDATION_RULES, } = validations;
 export default class BootstrapApplicationGenerator extends BaseApplicationGenerator {
     constructor(args, options, features) {
-        super(args, options, features);
+        super(args, options, { jhipsterBootstrap: false, ...features });
         if (this.options.help)
             return;
-        this.loadStoredAppOptions();
-        this.loadRuntimeOptions();
+        loadStoredAppOptions.call(this);
     }
     async beforeQueue() {
+        if (!this.fromBlueprint) {
+            await this.composeWithBlueprints(GENERATOR_BOOTSTRAP_APPLICATION);
+        }
+        if (this.delegateToBlueprint) {
+            throw new Error('Only sbs blueprint is supported');
+        }
         await this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION_CLIENT);
         await this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION_SERVER);
     }
+    get configuring() {
+        return this.asConfiguringTaskGroup({
+            defaults() {
+                if (!this.options.reproducible) {
+                    this.config.defaults({
+                        jhipsterVersion: packageJson.version,
+                        baseName: getDefaultAppName(this),
+                        creationTimestamp: new Date().getTime(),
+                    });
+                }
+            },
+        });
+    }
+    get [BaseApplicationGenerator.CONFIGURING]() {
+        return this.configuring;
+    }
     get preparing() {
         return this.asPreparingTaskGroup({
-            preparing({ application }) {
+            preparing({ application, applicationDefaults }) {
                 if (application.authenticationType === 'oauth2' || application.databaseType === 'no') {
                     application.skipUserManagement = true;
                 }
+                applicationDefaults({
+                    useNpmWrapper: application => application.clientFrameworkAny && application.backendTypeSpringBoot,
+                    documentationArchiveUrl: ({ jhipsterVersion }) => `${JHIPSTER_DOCUMENTATION_URL}${JHIPSTER_DOCUMENTATION_ARCHIVE_PATH}v${jhipsterVersion}`,
+                });
                 let prettierExtensions = 'md,json,yml,html';
                 if (application.clientFrameworkAny) {
                     prettierExtensions = `${prettierExtensions},cjs,mjs,js,ts,tsx,css,scss`;

package/dist/generators/bootstrap-application-base/generator.mjs

@@ -18,26 +18,33 @@
  */
 import assert from 'assert';
 import os from 'os';
-import _ from 'lodash';
+import * as _ from 'lodash-es';
 import chalk from 'chalk';
+import { passthrough } from '@yeoman/transform';
 import BaseApplicationGenerator from '../base-application/index.mjs';
-import { addFakerToEntity, loadEntitiesAnnotations, loadEntitiesOtherSide, stringifyApplicationData, } from '../base-application/support/index.mjs';
-import { prepareEntity as prepareEntityForTemplates, prepareField as prepareFieldForTemplates, prepareRelationship, } from '../base-application/support/index.mjs';
+import { addFakerToEntity, loadEntitiesAnnotations, loadEntitiesOtherSide, stringifyApplicationData, prepareEntity as prepareEntityForTemplates, prepareField as prepareFieldForTemplates, prepareRelationship, } from '../base-application/support/index.mjs';
 import { createUserEntity } from './utils.mjs';
-import { DOCKER_DIR } from '../generator-constants.mjs';
-import { GENERATOR_BOOTSTRAP, GENERATOR_COMMON, GENERATOR_PROJECT_NAME } from '../generator-list.mjs';
+import { JAVA_DOCKER_DIR } from '../generator-constants.mjs';
+import { GENERATOR_BOOTSTRAP, GENERATOR_BOOTSTRAP_APPLICATION_BASE, GENERATOR_COMMON, GENERATOR_PROJECT_NAME } from '../generator-list.mjs';
 import { packageJson } from '../../lib/index.mjs';
 import { loadLanguagesConfig } from '../languages/support/index.mjs';
+import { loadAppConfig, loadDerivedAppConfig, loadStoredAppOptions } from '../app/support/index.mjs';
 const isWin32 = os.platform() === 'win32';
 const { lowerFirst } = _;
 export default class BootstrapApplicationBase extends BaseApplicationGenerator {
     constructor(args, options, features) {
-        super(args, options, features);
+        super(args, options, { jhipsterBootstrap: false, ...features });
         if (this.options.help)
             return;
-        this.loadStoredAppOptions();
+        loadStoredAppOptions.call(this);
     }
     async beforeQueue() {
+        if (!this.fromBlueprint) {
+            await this.composeWithBlueprints(GENERATOR_BOOTSTRAP_APPLICATION_BASE);
+        }
+        if (this.delegateToBlueprint) {
+            throw new Error('Only sbs blueprint is supported');
+        }
         await this.dependsOnJHipster(GENERATOR_PROJECT_NAME);
         await this.composeWithJHipster(GENERATOR_BOOTSTRAP);
     }
@@ -66,8 +73,12 @@ export default class BootstrapApplicationBase extends BaseApplicationGenerator {
     get loading() {
         return this.asLoadingTaskGroup({
             loadApplication({ application, control }) {
-                this.loadAppConfig(undefined, application);
-                loadLanguagesConfig(application, this.jhipsterConfigWithDefaults, control);
+                loadAppConfig({
+                    config: this.jhipsterConfigWithDefaults,
+                    application,
+                    useVersionPlaceholders: this.useVersionPlaceholders,
+                });
+                loadLanguagesConfig({ application, config: this.jhipsterConfigWithDefaults, control });
             },
             loadNodeDependencies({ application }) {
                 this.loadNodeDependencies(application.nodeDependencies, {
@@ -84,13 +95,14 @@ export default class BootstrapApplicationBase extends BaseApplicationGenerator {
     }
     get preparing() {
         return this.asPreparingTaskGroup({
-            prepareApplication({ application }) {
-                this.loadDerivedAppConfig(application);
-                application.nodePackageManager = 'npm';
-                application.dockerServicesDir = DOCKER_DIR;
-                // TODO v8 drop the following variables
-                const anyApplication = application;
-                anyApplication.clientPackageManager = application.nodePackageManager;
+            prepareApplication({ application, applicationDefaults }) {
+                loadDerivedAppConfig({ application });
+                applicationDefaults({
+                    nodePackageManager: 'npm',
+                    dockerServicesDir: JAVA_DOCKER_DIR,
+                    // TODO drop clientPackageManager
+                    clientPackageManager: ({ nodePackageManager }) => nodePackageManager,
+                });
             },
         });
     }
@@ -214,6 +226,41 @@ export default class BootstrapApplicationBase extends BaseApplicationGenerator {
     get [BaseApplicationGenerator.PREPARING_EACH_ENTITY_RELATIONSHIP]() {
         return this.preparingEachEntityRelationship;
     }
+    get default() {
+        return this.asDefaultTaskGroup({
+            task({ application }) {
+                const packageJsonFiles = [this.destinationPath('package.json')];
+                if (application.clientRootDir) {
+                    packageJsonFiles.push(this.destinationPath(`${application.clientRootDir}package.json`));
+                }
+                const isPackageJson = file => packageJsonFiles.includes(file.path);
+                const populateNullValues = dependencies => {
+                    if (!dependencies)
+                        return;
+                    for (const key of Object.keys(dependencies)) {
+                        if (dependencies[key] === null && application.nodeDependencies[key]) {
+                            dependencies[key] = application.nodeDependencies[key];
+                        }
+                    }
+                };
+                this.queueTransformStream(passthrough(file => {
+                    if (file.contents && isPackageJson(file)) {
+                        const content = JSON.parse(file.contents.toString());
+                        populateNullValues(content.dependencies);
+                        populateNullValues(content.devDependencies);
+                        populateNullValues(content.peerDependencies);
+                        file.contents = Buffer.from(`${JSON.stringify(content, null, 2)}\n`);
+                    }
+                }), {
+                    name: 'updating package.json dependency versions',
+                    streamOptions: { filter: isPackageJson },
+                });
+            },
+        });
+    }
+    get [BaseApplicationGenerator.DEFAULT]() {
+        return this.default;
+    }
     /**
      * Return the user home
      */

package/dist/generators/bootstrap-application-base/utils.mjs

@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import _ from 'lodash';
+import * as _ from 'lodash-es';
 import { authenticationTypes, databaseTypes, fieldTypes } from '../../jdl/jhipster/index.mjs';
 import { loadRequiredConfigIntoEntity } from '../base-application/support/index.mjs';
 import { hibernateSnakeCase } from '../server/support/string.mjs';

package/dist/generators/bootstrap-application-client/generator.mjs

@@ -16,24 +16,33 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { preparePostEntityClientDerivedProperties } from '../client/support/index.mjs';
+import { loadClientConfig, loadDerivedClientConfig, preparePostEntityClientDerivedProperties } from '../client/support/index.mjs';
 import BaseApplicationGenerator from '../base-application/index.mjs';
-import { GENERATOR_BOOTSTRAP_APPLICATION_BASE } from '../generator-list.mjs';
+import { GENERATOR_BOOTSTRAP_APPLICATION_BASE, GENERATOR_BOOTSTRAP_APPLICATION_CLIENT } from '../generator-list.mjs';
+import { loadStoredAppOptions } from '../app/support/index.mjs';
+import clientCommand from '../client/command.mjs';
+import { loadConfig, loadDerivedConfig } from '../../lib/internal/index.mjs';
 export default class BootStrapApplicationClient extends BaseApplicationGenerator {
     constructor(args, options, features) {
-        super(args, options, features);
+        super(args, options, { jhipsterBootstrap: false, ...features });
         if (this.options.help)
             return;
-        this.loadStoredAppOptions();
-        this.loadRuntimeOptions();
+        loadStoredAppOptions.call(this);
     }
     async beforeQueue() {
+        if (!this.fromBlueprint) {
+            await this.composeWithBlueprints(GENERATOR_BOOTSTRAP_APPLICATION_CLIENT);
+        }
+        if (this.delegateToBlueprint) {
+            throw new Error('Only sbs blueprint is supported');
+        }
         await this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION_BASE);
     }
     get loading() {
         return this.asLoadingTaskGroup({
             loadApplication({ application }) {
-                this.loadClientConfig(undefined, application);
+                loadConfig(clientCommand.configs, { config: this.jhipsterConfigWithDefaults, application });
+                loadClientConfig({ config: this.jhipsterConfigWithDefaults, application });
             },
         });
     }
@@ -43,7 +52,8 @@ export default class BootStrapApplicationClient extends BaseApplicationGenerator
     get preparing() {
         return this.asPreparingTaskGroup({
             prepareApplication({ application }) {
-                this.loadDerivedClientConfig(application);
+                loadDerivedConfig(clientCommand.configs, { application });
+                loadDerivedClientConfig({ application });
             },
         });
     }

package/dist/generators/bootstrap-application-server/generator.mjs

@@ -16,26 +16,41 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import _ from 'lodash';
+import * as _ from 'lodash-es';
 import BaseApplicationGenerator from '../base-application/index.mjs';
-import { GENERATOR_BOOTSTRAP_APPLICATION_BASE } from '../generator-list.mjs';
-import { dockerContainers, javaDependencies } from '../generator-constants.mjs';
+import { GENERATOR_BOOTSTRAP_APPLICATION_BASE, GENERATOR_BOOTSTRAP_APPLICATION_SERVER } from '../generator-list.mjs';
+import { JAVA_VERSION, MAIN_DIR, SERVER_MAIN_RES_DIR, SERVER_MAIN_SRC_DIR, SERVER_TEST_RES_DIR, SERVER_TEST_SRC_DIR, TEST_DIR, dockerContainers, javaDependencies, } from '../generator-constants.mjs';
 import { loadRequiredConfigIntoEntity, prepareEntityPrimaryKeyForTemplates } from '../base-application/support/index.mjs';
-import { loadRequiredConfigDerivedProperties, prepareEntity as prepareEntityServerForTemplates, getPomVersionProperties, getGradleLibsVersionsProperties, } from '../server/support/index.mjs';
+import { loadRequiredConfigDerivedProperties, prepareEntity as prepareEntityServerForTemplates, getPomVersionProperties, getGradleLibsVersionsProperties, addEntitiesOtherRelationships, hibernateSnakeCase, loadServerConfig, loadDerivedServerConfig, prepareRelationship, } from '../server/support/index.mjs';
 import { prepareField as prepareFieldForLiquibaseTemplates } from '../liquibase/support/index.mjs';
 import { dockerPlaceholderGenerator, getDockerfileContainers } from '../docker/utils.mjs';
 import { GRADLE_VERSION } from '../gradle/constants.mjs';
-import { addEntitiesOtherRelationships } from '../server/support/index.mjs';
+import { normalizePathEnd } from '../base/support/path.mjs';
+import { getFrontendAppName } from '../base/support/index.mjs';
+import { getMainClassName } from '../java/support/index.mjs';
+import { loadConfig, loadDerivedConfig } from '../../lib/internal/index.mjs';
+import serverCommand from '../server/command.mjs';
 export default class BoostrapApplicationServer extends BaseApplicationGenerator {
+    constructor(args, options, features) {
+        super(args, options, { jhipsterBootstrap: false, ...features });
+    }
     async beforeQueue() {
+        if (!this.fromBlueprint) {
+            await this.composeWithBlueprints(GENERATOR_BOOTSTRAP_APPLICATION_SERVER);
+        }
+        if (this.delegateToBlueprint) {
+            throw new Error('Only sbs blueprint is supported');
+        }
         await this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION_BASE);
     }
     get loading() {
         return this.asLoadingTaskGroup({
-            async loadApplication({ application, control }) {
-                this.loadServerConfig(undefined, application);
+            async loadApplication({ application }) {
+                loadConfig(serverCommand.configs, { config: this.jhipsterConfigWithDefaults, application });
+                loadServerConfig({ config: this.jhipsterConfigWithDefaults, application });
                 application.gradleVersion = this.useVersionPlaceholders ? 'GRADLE_VERSION' : GRADLE_VERSION;
-                application.backendType = 'Java';
+                application.javaVersion = this.useVersionPlaceholders ? 'JAVA_VERSION' : JAVA_VERSION;
+                application.backendType = this.jhipsterConfig.backendType ?? 'Java';
                 const pomFile = this.readTemplate(this.jhipsterTemplatePath('../../server/resources/pom.xml'))?.toString();
                 const gradleLibsVersions = this.readTemplate(this.jhipsterTemplatePath('../../server/resources/gradle/libs.versions.toml'))?.toString();
                 application.packageInfoJavadocs = [];
@@ -60,7 +75,25 @@ export default class BoostrapApplicationServer extends BaseApplicationGenerator
     get preparing() {
         return this.asPreparingTaskGroup({
             prepareApplication({ application }) {
-                this.loadDerivedServerConfig(application);
+                loadDerivedConfig(serverCommand.configs, { application });
+                loadDerivedServerConfig({ application });
+            },
+            prepareForTemplates({ application: app }) {
+                const application = app;
+                // Application name modified, using each technology's conventions
+                application.frontendAppName = getFrontendAppName({ baseName: application.baseName });
+                application.mainClass = getMainClassName({ baseName: application.baseName });
+                application.jhiTablePrefix = hibernateSnakeCase(application.jhiPrefix);
+                application.mainJavaDir = SERVER_MAIN_SRC_DIR;
+                application.mainJavaPackageDir = normalizePathEnd(`${SERVER_MAIN_SRC_DIR}${application.packageFolder}`);
+                application.mainJavaResourceDir = SERVER_MAIN_RES_DIR;
+                application.testJavaDir = SERVER_TEST_SRC_DIR;
+                application.testJavaPackageDir = normalizePathEnd(`${SERVER_TEST_SRC_DIR}${application.packageFolder}`);
+                application.testResourceDir = SERVER_TEST_RES_DIR;
+                application.srcMainDir = MAIN_DIR;
+                application.srcTestDir = TEST_DIR;
+                application.backendTypeSpringBoot = application.backendType === 'Java';
+                application.backendTypeJavaAny = application.backendTypeJavaAny ?? application.backendTypeSpringBoot;
             },
         });
     }
@@ -72,7 +105,7 @@ export default class BoostrapApplicationServer extends BaseApplicationGenerator
             loadingEntities({ application, entitiesToLoad }) {
                 for (const { entityName } of entitiesToLoad) {
                     const entity = this.sharedData.getEntity(entityName);
-                    loadRequiredConfigIntoEntity(entity, application);
+                    loadRequiredConfigIntoEntity.call(this, entity, application);
                     loadRequiredConfigDerivedProperties(entity);
                 }
             },
@@ -110,6 +143,16 @@ export default class BoostrapApplicationServer extends BaseApplicationGenerator
     get [BaseApplicationGenerator.PREPARING_EACH_ENTITY_FIELD]() {
         return this.preparingEachEntityField;
     }
+    get preparingEachEntityRelationship() {
+        return this.asPreparingEachEntityRelationshipTaskGroup({
+            prepareRelationship({ entity, relationship }) {
+                prepareRelationship({ entity, relationship });
+            },
+        });
+    }
+    get [BaseApplicationGenerator.PREPARING_EACH_ENTITY_RELATIONSHIP]() {
+        return this.preparingEachEntityRelationship;
+    }
     get postPreparingEachEntity() {
         return this.asPostPreparingEachEntityTaskGroup({
             processDerivedPrimaryKeyFields({ entity }) {

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

@@ -0,0 +1,11 @@
+const command = {
+    options: {
+        customWorkspacesConfig: {
+            type: Boolean,
+            description: 'Use custom configuration',
+            scope: 'generator',
+            hide: true,
+        },
+    },
+};
+export default command;

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

@@ -0,0 +1,85 @@
+/**
+ * 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 BaseWorkspacesGenerator from '../base-workspaces/index.mjs';
+import { GENERATOR_BOOTSTRAP_WORKSPACES } from '../generator-list.mjs';
+import command from './command.mjs';
+export default class DockerComposeGenerator extends BaseWorkspacesGenerator {
+    sharedWorkspaces;
+    customWorkspacesConfig;
+    async beforeQueue() {
+        this.sharedWorkspaces = this.getSharedApplication().sharedWorkspaces;
+        this.sharedWorkspaces.existingWorkspaces = this.sharedWorkspaces.existingWorkspaces ?? Boolean(this.jhipsterConfig.appsFolders);
+        this.parseJHipsterOptions(command.options);
+        if (!this.fromBlueprint) {
+            await this.composeWithBlueprints(GENERATOR_BOOTSTRAP_WORKSPACES);
+        }
+    }
+    get prompting() {
+        return this.asPromptingTaskGroup({
+            async askForOptions() {
+                if (this.customWorkspacesConfig || (this.sharedWorkspaces.existingWorkspaces && !this.options.askAnswered))
+                    return;
+                await this.askForWorkspacesConfig();
+            },
+        });
+    }
+    get [BaseWorkspacesGenerator.PROMPTING]() {
+        return this.delegateTasksToBlueprint(() => this.prompting);
+    }
+    get configuring() {
+        return this.asConfiguringTaskGroup({
+            configureWorkspaces() {
+                this.configureWorkspacesConfig();
+            },
+        });
+    }
+    get [BaseWorkspacesGenerator.CONFIGURING]() {
+        return this.delegateTasksToBlueprint(() => this.configuring);
+    }
+    get loading() {
+        return this.asLoadingTaskGroup({
+            loadWorkspacesConfig() {
+                this.loadWorkspacesConfig();
+            },
+        });
+    }
+    get [BaseWorkspacesGenerator.LOADING]() {
+        return this.delegateTasksToBlueprint(() => this.loading);
+    }
+    get preparing() {
+        return this.asPreparingTaskGroup({
+            async bootstrapApplications() {
+                await this.bootstrapApplications();
+            },
+        });
+    }
+    get [BaseWorkspacesGenerator.PREPARING]() {
+        return this.delegateTasksToBlueprint(() => this.preparing);
+    }
+    get loadingWorkspaces() {
+        return {
+            loadWorkspacesConfig({ workspaces }) {
+                this.loadWorkspacesConfig({ context: workspaces });
+            },
+        };
+    }
+    get [BaseWorkspacesGenerator.LOADING_WORKSPACES]() {
+        return this.delegateTasksToBlueprint(() => this.loadingWorkspaces);
+    }
+}

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

@@ -16,8 +16,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/*
- * Register generator-base at yeoman-environment
- */
-import BaseDockerGenerator from './generator.mjs';
-export default BaseDockerGenerator;
+export { default } from './generator.mjs';