generator-jhipster 8.4.0 → 8.6.0

package/dist/generators/spring-boot/command.js

@@ -1,5 +1,27 @@
+/**
+ * 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 chalk from 'chalk';
 import { GENERATOR_JAVA, GENERATOR_LIQUIBASE, GENERATOR_SPRING_DATA_RELATIONAL } from '../generator-list.js';
-import { APPLICATION_TYPE_MICROSERVICE } from '../../jdl/index.js';
+import { createBase64Secret, createSecret } from '../base/support/secret.js';
+import { authenticationTypes, applicationTypes } from '../../jdl/index.js';
+const { OAUTH2, SESSION, JWT } = authenticationTypes;
+const { GATEWAY, MICROSERVICE } = applicationTypes;
 const command = {
     options: {
         fakeKeytool: {
@@ -11,18 +33,92 @@ const command = {
         },
     },
     configs: {
+        reactive: {
+            cli: {
+                description: 'Generate a reactive backend',
+                type: Boolean,
+            },
+            prompt: gen => ({
+                when: () => ['monolith', 'microservice'].includes(gen.jhipsterConfigWithDefaults.applicationType),
+                type: 'confirm',
+                message: 'Do you want to make it reactive with Spring WebFlux?',
+            }),
+        },
+        serverPort: {
+            prompt: gen => ({
+                when: () => ['gateway', 'microservice'].includes(gen.jhipsterConfigWithDefaults.applicationType),
+                type: 'input',
+                validate: input => (/^([0-9]*)$/.test(input) ? true : 'This is not a valid port number.'),
+                message: 'As you are running in a microservice architecture, on which port would like your server to run? It should be unique to avoid port conflicts.',
+                default: () => gen.jhipsterConfigWithDefaults.serverPort,
+            }),
+            configure: gen => {
+                if (gen.jhipsterConfig.serverPort === undefined && gen.jhipsterConfig.applicationIndex !== undefined) {
+                    gen.jhipsterConfig.serverPort = 8080 + gen.jhipsterConfig.applicationIndex;
+                }
+            },
+        },
+        serviceDiscoveryType: {
+            cli: {
+                description: 'Service discovery type',
+                type: String,
+            },
+            prompt: gen => ({
+                when: () => ['gateway', 'microservice'].includes(gen.jhipsterConfigWithDefaults.applicationType),
+                type: 'list',
+                message: 'Which service discovery server do you want to use?',
+                default: 'consul',
+            }),
+            choices: [
+                { value: 'consul', name: 'Consul (recommended)' },
+                { value: 'eureka', name: 'JHipster Registry (legacy, uses Eureka, provides Spring Cloud Config support)' },
+                { value: 'no', name: 'No service discovery' },
+            ],
+        },
+        authenticationType: {
+            cli: {
+                name: 'auth',
+                description: 'Provide authentication type for the application when skipping server side generation',
+                type: String,
+            },
+            prompt: (gen, config) => ({
+                type: 'list',
+                message: `Which ${chalk.yellow('*type*')} of authentication would you like to use?`,
+                choices: () => gen.jhipsterConfigWithDefaults.applicationType !== 'monolith'
+                    ? config.choices.filter(({ value }) => value !== 'session')
+                    : config.choices,
+                default: () => gen.jhipsterConfigWithDefaults.authenticationType,
+            }),
+            choices: [
+                { value: 'jwt', name: 'JWT authentication (stateless, with a token)' },
+                { value: 'oauth2', name: 'OAuth 2.0 / OIDC Authentication (stateful, works with Keycloak and Okta)' },
+                { value: 'session', name: 'HTTP Session Authentication (stateful, default Spring Security mechanism)' },
+            ],
+            configure: gen => {
+                const { jwtSecretKey, rememberMeKey, authenticationType, applicationType } = gen.jhipsterConfigWithDefaults;
+                if (authenticationType === SESSION && !rememberMeKey) {
+                    gen.jhipsterConfig.rememberMeKey = createSecret();
+                }
+                else if (authenticationType === OAUTH2 && gen.jhipsterConfig.skipUserManagement === undefined) {
+                    gen.jhipsterConfig.skipUserManagement = true;
+                }
+                else if (jwtSecretKey === undefined &&
+                    (authenticationType === JWT || applicationType === MICROSERVICE || applicationType === GATEWAY)) {
+                    gen.jhipsterConfig.jwtSecretKey = createBase64Secret(64, gen.options.reproducibleTests);
+                }
+            },
+        },
         feignClient: {
             description: 'Generate a feign client',
             cli: {
                 type: Boolean,
             },
-            prompt: {
+            prompt: gen => ({
                 type: 'confirm',
                 message: 'Do you want to generate a feign client?',
-                when: currentAnswer => currentAnswer.applicationType === APPLICATION_TYPE_MICROSERVICE &&
-                    currentAnswer.reactive !== undefined &&
-                    !currentAnswer.reactive,
-            },
+                when: ({ reactive }) => [MICROSERVICE].includes(gen.jhipsterConfigWithDefaults.applicationType) &&
+                    (reactive ?? gen.jhipsterConfigWithDefaults.reactive) === false,
+            }),
             default: false,
         },
         syncUserWithIdp: {
@@ -35,6 +131,16 @@ const command = {
                 message: 'Do you want to allow relationships with User entity?',
                 when: ({ authenticationType }) => (authenticationType ?? gen.jhipsterConfigWithDefaults.authenticationType) === 'oauth2',
             }),
+            configure: gen => {
+                if (gen.jhipsterConfig.syncUserWithIdp === undefined && gen.jhipsterConfigWithDefaults.authenticationType === 'oauth2') {
+                    if (gen.isJhipsterVersionLessThan('8.1.1')) {
+                        gen.jhipsterConfig.syncUserWithIdp = true;
+                    }
+                }
+                else if (gen.jhipsterConfig.syncUserWithIdp && gen.jhipsterConfig.authenticationType !== OAUTH2) {
+                    throw new Error('syncUserWithIdp is only supported with authenticationType oauth2');
+                }
+            },
         },
         defaultPackaging: {
             description: 'Default packaging for the application',
@@ -45,6 +151,11 @@ const command = {
             choices: ['jar', 'war'],
             default: 'jar',
             scope: 'storage',
+            configure: gen => {
+                if (process.env.JHI_WAR === '1') {
+                    gen.jhipsterConfig.defaultPackaging = 'war';
+                }
+            },
         },
     },
     import: [GENERATOR_JAVA, GENERATOR_LIQUIBASE, GENERATOR_SPRING_DATA_RELATIONAL],

package/dist/generators/spring-boot/files.js

@@ -401,11 +401,6 @@ export const baseServerFiles = {
             ],
         },
         {
-            condition: generator => generator.generateUserManagement ||
-                generator.authenticationTypeOauth2 ||
-                generator.databaseTypeSql ||
-                generator.databaseTypeMongodb ||
-                generator.databaseTypeCouchbase,
             path: `${SERVER_MAIN_SRC_DIR}_package_/`,
             renameTo: moveToJavaPackageSrcDir,
             templates: ['config/Constants.java'],

package/dist/generators/spring-boot/generator.js

@@ -25,7 +25,7 @@ import { serverFiles } from './files.js';
 import cleanupTask from './cleanup.js';
 import { ADD_SPRING_MILESTONE_REPOSITORY } from '../generator-constants.js';
 import { addSpringFactory, getJavaValueGeneratorForType, getPrimaryKeyValue, getSpecificationBuildForType, insertContentIntoApplicationProperties, javaBeanCase, } from '../server/support/index.js';
-import { addJavaAnnotation, generateKeyStore } from '../java/support/index.js';
+import { generateKeyStore } from '../java/support/index.js';
 import { createNeedleCallback, mutateData } from '../base/support/index.js';
 import { APPLICATION_TYPE_MICROSERVICE, applicationTypes, cacheTypes, databaseTypes, fieldTypes, messageBrokerTypes, searchEngineTypes, testFrameworkTypes, websocketTypes, } from '../../jdl/index.js';
 import { writeFiles as writeEntityFiles } from './entity-files.js';
@@ -78,6 +78,9 @@ export default class SpringBootGenerator extends BaseApplicationGenerator {
     }
     get configuring() {
         return this.asConfiguringTaskGroup({
+            async configureCommand() {
+                await this.configureCurrentJHipsterCommandConfig();
+            },
             checks() {
                 const config = this.jhipsterConfigWithDefaults;
                 if (config.enableHibernateCache && [NO_CACHE, MEMCACHED].includes(config.cacheProvider)) {
@@ -110,7 +113,7 @@ export default class SpringBootGenerator extends BaseApplicationGenerator {
     get composing() {
         return this.asComposingTaskGroup({
             async composing() {
-                const { applicationType, databaseType, messageBroker, searchEngine, websocket, cacheProvider, skipClient, clientFramework, enableTranslation, testFrameworks, feignClient, } = this.jhipsterConfigWithDefaults;
+                const { applicationType, databaseType, messageBroker, searchEngine, websocket, cacheProvider, skipClient, clientFramework, testFrameworks, feignClient, } = this.jhipsterConfigWithDefaults;
                 await this.composeWithJHipster(GENERATOR_DOCKER);
                 await this.composeWithJHipster('jhipster:java:jib');
                 await this.composeWithJHipster('jhipster:java:code-quality');
@@ -120,9 +123,6 @@ export default class SpringBootGenerator extends BaseApplicationGenerator {
                 if (applicationType === GATEWAY) {
                     await this.composeWithJHipster('jhipster:spring-cloud:gateway');
                 }
-                if (enableTranslation) {
-                    await this.composeWithJHipster(GENERATOR_LANGUAGES);
-                }
                 if (testFrameworks?.includes(CUCUMBER)) {
                     await this.composeWithJHipster(GENERATOR_CUCUMBER);
                 }
@@ -165,11 +165,30 @@ export default class SpringBootGenerator extends BaseApplicationGenerator {
     get [BaseApplicationGenerator.COMPOSING]() {
         return this.delegateTasksToBlueprint(() => this.composing);
     }
-    get preparing() {
-        return this.asPreparingTaskGroup({
+    get composingComponent() {
+        return this.asComposingComponentTaskGroup({
+            async composeLanguages() {
+                if (this.jhipsterConfigWithDefaults.enableTranslation) {
+                    await this.composeWithJHipster(GENERATOR_LANGUAGES);
+                }
+            },
+        });
+    }
+    get [BaseApplicationGenerator.COMPOSING_COMPONENT]() {
+        return this.delegateTasksToBlueprint(() => this.composingComponent);
+    }
+    get loading() {
+        return this.asLoadingTaskGroup({
             async loadCommand({ application }) {
                 await this.loadCurrentJHipsterCommandConfig(application);
             },
+        });
+    }
+    get [BaseApplicationGenerator.LOADING]() {
+        return this.delegateTasksToBlueprint(() => this.loading);
+    }
+    get preparing() {
+        return this.asPreparingTaskGroup({
             checksWebsocket({ application }) {
                 const { websocket } = application;
                 if (websocket && websocket !== NO_WEBSOCKET) {
@@ -201,6 +220,20 @@ export default class SpringBootGenerator extends BaseApplicationGenerator {
                     (application.backendType ?? 'Java') === 'Java' &&
                         (ADD_SPRING_MILESTONE_REPOSITORY || SPRING_BOOT_VERSION.includes('M') || SPRING_BOOT_VERSION.includes('RC'));
             },
+            prepare({ application, applicationDefaults }) {
+                const { reactive } = application;
+                applicationDefaults({
+                    __override__: false,
+                    requiresDeleteAllUsers: data => (data.anyEntityHasRelationshipWithUser && data.authenticationTypeOauth2) ||
+                        data.authenticationTypeOauth2 ||
+                        data.databaseTypeNeo4j ||
+                        (reactive && data.databaseTypeSql) ||
+                        (!reactive && data.databaseTypeMongodb) ||
+                        (!reactive && data.databaseTypeCassandra),
+                    reactorBlock: reactive ? '.block()' : '',
+                    reactorBlockOptional: reactive ? '.blockOptional()' : '',
+                });
+            },
             registerSpringFactory({ source, application }) {
                 source.addTestSpringFactory = ({ key, value }) => {
                     const springFactoriesFile = `${application.srcTestResources}META-INF/spring.factories`;
@@ -208,7 +241,9 @@ export default class SpringBootGenerator extends BaseApplicationGenerator {
                 };
             },
             addSpringIntegrationTest({ application, source }) {
-                source.addIntegrationTestAnnotation = ({ package: packageName, annotation }) => this.editFile(this.destinationPath(`${application.javaPackageTestDir}IntegrationTest.java`), content => addJavaAnnotation(content, { package: packageName, annotation }));
+                source.addIntegrationTestAnnotation = annotation => source.editJavaFile(this.destinationPath(`${application.javaPackageTestDir}IntegrationTest.java`), {
+                    annotations: [annotation],
+                });
             },
             addLogNeedles({ source }) {
                 source.addLogbackLogEntry = ({ file, name, level }) => this.editFile(this.destinationPath(file), createNeedleCallback({
@@ -297,7 +332,7 @@ public void set${javaBeanCase(propertyName)}(${propertyType} ${propertyName}) {
                 }
             },
             checkDtoRelationships({ entity, entityName, relationship }) {
-                if (entity.dto !== relationship.otherEntity.dto) {
+                if (entity.dto !== relationship.otherEntity.dto && !relationship.otherEntity.builtIn) {
                     this.log.warn(`Relationship between entities with different DTO configurations can cause unexpected results. Check ${relationship.relationshipName} in the ${entityName} entity.`);
                 }
             },

package/dist/generators/spring-boot/prompts.js

@@ -18,17 +18,15 @@
  */
 import chalk from 'chalk';
 import { includes, intersection } from 'lodash-es';
-import { applicationOptions, applicationTypes, authenticationTypes, databaseTypes, cacheTypes, serviceDiscoveryTypes, testFrameworkTypes, } from '../../jdl/jhipster/index.js';
+import { applicationOptions, applicationTypes, authenticationTypes, databaseTypes, cacheTypes, testFrameworkTypes, } from '../../jdl/jhipster/index.js';
 import { MESSAGE_BROKER } from '../server/options/index.js';
 import { R2DBC_DB_OPTIONS, SQL_DB_OPTIONS } from '../server/support/database.js';
 const { OptionNames } = applicationOptions;
-const { GATEWAY, MICROSERVICE, MONOLITH } = applicationTypes;
+const { GATEWAY, MONOLITH } = applicationTypes;
 const { CAFFEINE, EHCACHE, HAZELCAST, INFINISPAN, MEMCACHED, REDIS } = cacheTypes;
-const { JWT, OAUTH2, SESSION } = authenticationTypes;
+const { OAUTH2 } = authenticationTypes;
 const { CASSANDRA, H2_DISK, H2_MEMORY, MONGODB, NEO4J, SQL, COUCHBASE } = databaseTypes;
-const { CONSUL, EUREKA } = serviceDiscoveryTypes;
-const { AUTHENTICATION_TYPE, CACHE_PROVIDER, DATABASE_TYPE, DEV_DATABASE_TYPE, PROD_DATABASE_TYPE, REACTIVE, SERVER_PORT, SERVICE_DISCOVERY_TYPE, WEBSOCKET, SEARCH_ENGINE, ENABLE_SWAGGER_CODEGEN, } = OptionNames;
-const NO_SERVICE_DISCOVERY = serviceDiscoveryTypes.NO;
+const { CACHE_PROVIDER, DATABASE_TYPE, DEV_DATABASE_TYPE, PROD_DATABASE_TYPE, SERVICE_DISCOVERY_TYPE, WEBSOCKET, SEARCH_ENGINE, ENABLE_SWAGGER_CODEGEN, } = OptionNames;
 const NO_DATABASE = databaseTypes.NO;
 const NO_CACHE_PROVIDER = cacheTypes.NO;
 const { GATLING, CUCUMBER } = testFrameworkTypes;
@@ -52,70 +50,8 @@ const getOptionFromArray = (array, option) => {
 export async function askForServerSideOpts({ control }) {
     if (control.existingProject && !this.options.askAnswered)
         return;
-    const { applicationType, serverPort: defaultServerPort, reactive } = this.jhipsterConfigWithDefaults;
+    const { applicationType } = this.jhipsterConfigWithDefaults;
     const prompts = [
-        {
-            when: () => [MONOLITH, MICROSERVICE].includes(applicationType),
-            type: 'confirm',
-            name: REACTIVE,
-            message: 'Do you want to make it reactive with Spring WebFlux?',
-            default: reactive,
-        },
-        {
-            when: () => applicationType === GATEWAY || applicationType === MICROSERVICE,
-            type: 'input',
-            name: SERVER_PORT,
-            validate: input => (/^([0-9]*)$/.test(input) ? true : 'This is not a valid port number.'),
-            message: 'As you are running in a microservice architecture, on which port would like your server to run? It should be unique to avoid port conflicts.',
-            default: defaultServerPort,
-        },
-        {
-            when: () => applicationType === 'gateway' || applicationType === 'microservice',
-            type: 'list',
-            name: SERVICE_DISCOVERY_TYPE,
-            message: 'Which service discovery server do you want to use?',
-            choices: [
-                {
-                    value: CONSUL,
-                    name: 'Consul (recommended)',
-                },
-                {
-                    value: EUREKA,
-                    name: 'JHipster Registry (legacy, uses Eureka, provides Spring Cloud Config support)',
-                },
-                {
-                    value: NO_SERVICE_DISCOVERY,
-                    name: 'No service discovery',
-                },
-            ],
-            default: CONSUL,
-        },
-        {
-            when: answers => (applicationType === MONOLITH && answers.serviceDiscoveryType !== EUREKA) || [GATEWAY, MICROSERVICE].includes(applicationType),
-            type: 'list',
-            name: AUTHENTICATION_TYPE,
-            message: `Which ${chalk.yellow('*type*')} of authentication would you like to use?`,
-            choices: answers => {
-                const opts = [
-                    {
-                        value: JWT,
-                        name: 'JWT authentication (stateless, with a token)',
-                    },
-                ];
-                opts.push({
-                    value: OAUTH2,
-                    name: 'OAuth 2.0 / OIDC Authentication (stateful, works with Keycloak and Okta)',
-                });
-                if (applicationType === MONOLITH && answers.serviceDiscoveryType !== EUREKA) {
-                    opts.push({
-                        value: SESSION,
-                        name: 'HTTP Session Authentication (stateful, default Spring Security mechanism)',
-                    });
-                }
-                return opts;
-            },
-            default: this.jhipsterConfigWithDefaults.authenticationType,
-        },
         {
             type: 'list',
             name: DATABASE_TYPE,
@@ -300,7 +236,7 @@ export async function askForServerTestOpts({ control }) {
         {
             type: 'checkbox',
             name: 'serverTestFrameworks',
-            message: 'Besides Junit, which testing frameworks would you like to use?',
+            message: 'Besides JUnit, which testing frameworks would you like to use?',
             choices: [
                 { name: 'Gatling', value: GATLING },
                 { name: 'Cucumber', value: CUCUMBER },