generator-jhipster 8.3.0 → 8.5.0

package/dist/generators/server/templates/src/test/java/_package_/service/mapper/UserMapperTest.java.ejs

@@ -19,14 +19,24 @@
 package <%= packageName %>.service.mapper;
 
 import <%= user.entityAbsoluteClass %>;
+import <%= packageName %>.security.AuthoritiesConstants;
 import <%= packageName %>.service.dto.<%= user.adminUserDto %>;
 import <%= packageName %>.service.dto.<%= user.dtoClass %>;
+<%_ if (databaseTypeSql || databaseTypeMongodb || databaseTypeNeo4j) { _%>
+import <%= packageName %>.domain.Authority;
+<%_ } else { _%>
+import java.util.stream.Stream;
+import java.util.stream.Collectors;
+<%_ } _%>
 <%_ if (!authenticationTypeOauth2) { _%>
 import org.apache.commons.lang3.RandomStringUtils;
 <%_ } _%>
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
+<%_ if (generateSpringAuditor) { _%>
+import java.time.Instant;
+<%_ } _%>
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
@@ -67,12 +77,74 @@ class UserMapperTest {
         user.setLastName("doe");
 <%_ if (!databaseTypeCassandra) { _%>
         user.setImageUrl("image_url");
+<%_ } _%>
+<%_ if (generateSpringAuditor) { _%>
+        user.setCreatedBy(DEFAULT_LOGIN);
+        user.setCreatedDate(Instant.now());
+        user.setLastModifiedBy(DEFAULT_LOGIN);
+        user.setLastModifiedDate(Instant.now());
 <%_ } _%>
         user.setLangKey("en");
 
+<%_ if (databaseTypeSql || databaseTypeMongodb || databaseTypeNeo4j) { _%>
+        Set<Authority> authorities = new HashSet<>();
+        Authority authority = new Authority();
+        authority.setName(AuthoritiesConstants.USER);
+        authorities.add(authority);
+        user.setAuthorities(authorities);
+<%_ } else { _%>
+        user.setAuthorities(Stream.of(AuthoritiesConstants.USER).collect(Collectors.toSet()));
+<%_ } _%>
+
         userDto = new <%= user.adminUserDto %>(user);
     }
 
+    @Test
+    void testUserToUserDTO() {
+        <%= user.adminUserDto %> convertedUserDto = userMapper.userToAdminUserDTO(user);
+
+        assertThat(convertedUserDto.getId()).isEqualTo(user.getId());
+        assertThat(convertedUserDto.getLogin()).isEqualTo(user.getLogin());
+        assertThat(convertedUserDto.getFirstName()).isEqualTo(user.getFirstName());
+        assertThat(convertedUserDto.getLastName()).isEqualTo(user.getLastName());
+        assertThat(convertedUserDto.getEmail()).isEqualTo(user.getEmail());
+        assertThat(convertedUserDto.isActivated()).isEqualTo(user.isActivated());
+<%_ if (!databaseTypeCassandra) { _%>
+        assertThat(convertedUserDto.getImageUrl()).isEqualTo(user.getImageUrl());
+<%_ } _%>
+<%_ if (generateSpringAuditor) { _%>
+        assertThat(convertedUserDto.getCreatedBy()).isEqualTo(user.getCreatedBy());
+        assertThat(convertedUserDto.getCreatedDate()).isEqualTo(user.getCreatedDate());
+        assertThat(convertedUserDto.getLastModifiedBy()).isEqualTo(user.getLastModifiedBy());
+        assertThat(convertedUserDto.getLastModifiedDate()).isEqualTo(user.getLastModifiedDate());
+<%_ } _%>
+        assertThat(convertedUserDto.getLangKey()).isEqualTo(user.getLangKey());
+        assertThat(convertedUserDto.getAuthorities()).containsExactly(AuthoritiesConstants.USER);
+    }
+
+    @Test
+    void testUserDTOtoUser() {
+        <%= user.persistClass %> convertedUser = userMapper.userDTOToUser(userDto);
+
+        assertThat(convertedUser.getId()).isEqualTo(userDto.getId());
+        assertThat(convertedUser.getLogin()).isEqualTo(userDto.getLogin());
+        assertThat(convertedUser.getFirstName()).isEqualTo(userDto.getFirstName());
+        assertThat(convertedUser.getLastName()).isEqualTo(userDto.getLastName());
+        assertThat(convertedUser.getEmail()).isEqualTo(userDto.getEmail());
+        assertThat(convertedUser.isActivated()).isEqualTo(userDto.isActivated());
+<%_ if (!databaseTypeCassandra) { _%>
+        assertThat(convertedUser.getImageUrl()).isEqualTo(userDto.getImageUrl());
+<%_ } _%>
+        assertThat(convertedUser.getLangKey()).isEqualTo(userDto.getLangKey());
+<%_ if (generateSpringAuditor) { _%>
+        assertThat(convertedUser.getCreatedBy()).isEqualTo(userDto.getCreatedBy());
+        assertThat(convertedUser.getCreatedDate()).isEqualTo(userDto.getCreatedDate());
+        assertThat(convertedUser.getLastModifiedBy()).isEqualTo(userDto.getLastModifiedBy());
+        assertThat(convertedUser.getLastModifiedDate()).isEqualTo(userDto.getLastModifiedDate());
+<%_ } _%>
+        assertThat(convertedUser.getAuthorities())<% if (!databaseTypeCassandra && !databaseTypeCouchbase) { %>.extracting("name")<%_ } _%>.containsExactly(AuthoritiesConstants.USER);
+    }
+
     @Test
     void usersToUserDTOsShouldMapOnlyNonNullUsers() {
         List<<%= user.persistClass %>> users = new ArrayList<>();
@@ -141,20 +213,15 @@ class UserMapperTest {
 
     @Test
     void userDTOToUserMapWithAuthoritiesStringShouldReturnUserWithAuthorities() {
-        Set<String> authoritiesAsString = new HashSet<>();
-        authoritiesAsString.add("ADMIN");
-        userDto.setAuthorities(authoritiesAsString);
-
-        <%= user.persistClass %> user = userMapper.userDTOToUser(userDto);
+        <%= user.persistClass %> convertedUser = userMapper.userDTOToUser(userDto);
 
-        assertThat(user).isNotNull();
-        assertThat(user.getAuthorities()).isNotNull();
-        assertThat(user.getAuthorities()).isNotEmpty();
-<%_ if (databaseTypeSql || databaseTypeMongodb) { _%>
-        assertThat(user.getAuthorities().iterator().next().getName()).isEqualTo("ADMIN");
-<%_ } _%>
-<%_ if (databaseTypeCassandra || databaseTypeCouchbase) { _%>
-        assertThat(user.getAuthorities().iterator().next()).isEqualTo("ADMIN");
+        assertThat(convertedUser).isNotNull();
+        assertThat(convertedUser.getAuthorities()).isNotNull();
+        assertThat(convertedUser.getAuthorities()).isNotEmpty();
+<%_ if (databaseTypeSql || databaseTypeMongodb || databaseTypeNeo4j) { _%>
+        assertThat(convertedUser.getAuthorities().iterator().next().getName()).isEqualTo(AuthoritiesConstants.USER);
+<%_ } else { _%>
+        assertThat(convertedUser.getAuthorities().iterator().next()).isEqualTo(AuthoritiesConstants.USER);
 <%_ } _%>
     }
 
@@ -162,11 +229,11 @@ class UserMapperTest {
     void userDTOToUserMapWithNullAuthoritiesStringShouldReturnUserWithEmptyAuthorities() {
         userDto.setAuthorities(null);
 
-        <%= user.persistClass %> user = userMapper.userDTOToUser(userDto);
+        <%= user.persistClass %> persistUser = userMapper.userDTOToUser(userDto);
 
-        assertThat(user).isNotNull();
-        assertThat(user.getAuthorities()).isNotNull();
-        assertThat(user.getAuthorities()).isEmpty();
+        assertThat(persistUser).isNotNull();
+        assertThat(persistUser.getAuthorities()).isNotNull();
+        assertThat(persistUser.getAuthorities()).isEmpty();
     }
 
     @Test

package/dist/generators/server/templates/src/test/java/_package_/web/rest/AccountResourceIT.java.ejs

@@ -44,9 +44,8 @@ import <%= packageName %>.web.rest.vm.ManagedUserVM;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.apache.commons.lang3.RandomStringUtils;
-<%_ if (reactive && authenticationUsesCsrf || databaseTypeMongodb || databaseTypeNeo4j) { _%>
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
-<%_ } _%>
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -144,10 +143,12 @@ class AccountResourceIT {
     private MockMvc restAccountMockMvc;
 <%_ } _%>
 
-<%_ if (databaseTypeMongodb || databaseTypeNeo4j) { _%>
+<%_ if (!databaseTypeCassandra && !requiresDeleteAllUsers) { _%>
+    private Long numberOfUsers;
+
     @BeforeEach
-    public void setup() {
-        userRepository.deleteAll()<% if (reactive) { %>.block()<% } %>;
+    public void countUsers() {
+        numberOfUsers = userRepository.count()<%- reactorBlock %>;
     }
 
 <%_ } _%>
@@ -158,6 +159,16 @@ class AccountResourceIT {
     }
 
 <%_ } _%>
+    @AfterEach
+    public void cleanupAndCheck() {
+<%_ if (requiresDeleteAllUsers) { _%>
+        userRepository.deleteAll()<%- reactorBlock %>;
+<%_ } else if (!databaseTypeCassandra) { _%>
+        assertThat(userRepository.count()<%- reactorBlock %>).isEqualTo(numberOfUsers);
+        numberOfUsers = null;
+<%_ } _%>
+    }
+
     @Test
     @WithUnauthenticatedMockUser
 <%_ if (reactive) { _%>
@@ -246,6 +257,8 @@ class AccountResourceIT {
             .andExpect(jsonPath("$.authorities").value(AuthoritiesConstants.ADMIN));
 
 <%_ } _%>
+
+        userService.deleteUser(TEST_USER_LOGIN)<%- reactorBlock %>;
     }
 
     @Test
@@ -301,6 +314,8 @@ class AccountResourceIT {
 <%_ } _%>
 
         assertThat(userRepository.findOneByLogin("test-register-valid")<% if (reactive) { %>.blockOptional()<% } %>).isPresent();
+
+        userService.deleteUser("test-register-valid")<%- reactorBlock %>;
     }
 
     @Test
@@ -484,6 +499,8 @@ class AccountResourceIT {
                 .with(csrf())<% } %>)
             .andExpect(status().is4xxClientError());
 <%_ } _%>
+
+        userService.deleteUser("alice")<%- reactorBlock %>;
     }
 
     @Test
@@ -610,6 +627,8 @@ class AccountResourceIT {
                 .with(csrf())<% } %>)
             .andExpect(status().is4xxClientError());
 <%_ } _%>
+
+        userService.deleteUser("test-register-duplicate-email-3")<%- reactorBlock %>;
     }
 
     @Test
@@ -649,6 +668,8 @@ class AccountResourceIT {
         assertThat(userDup).isPresent();
         assertThat(userDup.orElseThrow().getAuthorities()).hasSize(1)
             .containsExactly(<% if (databaseTypeSql || databaseTypeMongodb || databaseTypeNeo4j) { %>authorityRepository.findById(AuthoritiesConstants.USER).<% if (reactive) { %>block<% } else { %>orElseThrow<% } %>()<% } %><% if (databaseTypeCassandra || databaseTypeCouchbase) { %>AuthoritiesConstants.USER<% } %>);
+
+        userService.deleteUser("badguy")<%- reactorBlock %>;
     }
 
     @Test
@@ -683,6 +704,8 @@ class AccountResourceIT {
 
         user = userRepository.findOneByLogin(user.getLogin())<%_ if (reactive) { _%>.block()<% } else { %>.orElse(null)<% } %>;
         assertThat(user.isActivated()).isTrue();
+
+        userService.deleteUser("activate-account")<%- reactorBlock %>;
     }
 
     @Test
@@ -757,6 +780,8 @@ class AccountResourceIT {
 <%_ } _%>
         assertThat(updatedUser.isActivated()).isTrue();
         assertThat(updatedUser.getAuthorities()).isEmpty();
+
+        userService.deleteUser("save-account")<%- reactorBlock %>;
     }
 
     @Test
@@ -810,6 +835,8 @@ class AccountResourceIT {
 <%_ } _%>
 
         assertThat(userRepository.findOneByEmailIgnoreCase("invalid email")<% if (reactive) { %>.blockOptional()<% } %>).isNotPresent();
+
+        userService.deleteUser("save-invalid-email")<%- reactorBlock %>;
     }
 
     @Test
@@ -872,8 +899,11 @@ class AccountResourceIT {
             .andExpect(status().isBadRequest());
 <%_ } _%>
 
-        <%= user.persistClass %> updatedUser = userRepository.findOneByLogin("save-existing-email")<%_ if (reactive) { _%>.block()<% } else { %>.orElse(null)<% } %>;
+        <%= user.persistClass %> updatedUser = userRepository.findOneByLogin("save-existing-email")<%_ if (reactive) { _%>.block()<% } else { %>.orElseThrow()<% } %>;
         assertThat(updatedUser.getEmail()).isEqualTo("save-existing-email@example.com");
+
+        userService.deleteUser("save-existing-email")<%- reactorBlock %>;
+        userService.deleteUser("save-existing-email2")<%- reactorBlock %>;
     }
 
     @Test
@@ -924,6 +954,8 @@ class AccountResourceIT {
 
         <%= user.persistClass %> updatedUser = userRepository.findOneByLogin("save-existing-email-and-login")<%_ if (reactive) { _%>.block()<% } else { %>.orElse(null)<% } %>;
         assertThat(updatedUser.getEmail()).isEqualTo("save-existing-email-and-login@example.com");
+
+        userService.deleteUser("save-existing-email-and-login")<%- reactorBlock %>;
     }
 
     @Test
@@ -963,6 +995,8 @@ class AccountResourceIT {
         <%= user.persistClass %> updatedUser = userRepository.findOneByLogin("change-password-wrong-existing-password")<%_ if (!reactive) { _%>.orElse(null)<% } else { %>.block()<% } %>;
         assertThat(passwordEncoder.matches("new password", updatedUser.getPassword())).isFalse();
         assertThat(passwordEncoder.matches(currentPassword, updatedUser.getPassword())).isTrue();
+
+        userService.deleteUser("change-password-wrong-existing-password")<%- reactorBlock %>;
     }
 
     @Test
@@ -1001,6 +1035,8 @@ class AccountResourceIT {
 
         <%= user.persistClass %> updatedUser = userRepository.findOneByLogin("change-password")<%_ if (reactive) { _%>.block()<% } else { %>.orElse(null)<% } %>;
         assertThat(passwordEncoder.matches("new password", updatedUser.getPassword())).isTrue();
+
+        userService.deleteUser("change-password")<%- reactorBlock %>;
     }
 
     @Test
@@ -1041,6 +1077,8 @@ class AccountResourceIT {
 
         <%= user.persistClass %> updatedUser = userRepository.findOneByLogin("change-password-too-small")<%_ if (reactive) { _%>.block()<% } else { %>.orElse(null)<% } %>;
         assertThat(updatedUser.getPassword()).isEqualTo(user.getPassword());
+
+        userService.deleteUser("change-password-too-small")<%- reactorBlock %>;
     }
 
     @Test
@@ -1081,6 +1119,8 @@ class AccountResourceIT {
 
         <%= user.persistClass %> updatedUser = userRepository.findOneByLogin("change-password-too-long")<%_ if (!reactive) { _%>.orElse(null)<% } else { %>.block()<% } %>;
         assertThat(updatedUser.getPassword()).isEqualTo(user.getPassword());
+
+        userService.deleteUser("change-password-too-long")<%- reactorBlock %>;
     }
 
     @Test
@@ -1119,6 +1159,8 @@ class AccountResourceIT {
 
         <%= user.persistClass %> updatedUser = userRepository.findOneByLogin("change-password-empty")<%_ if (reactive) { _%>.block()<% } else { %>.orElse(null)<% } %>;
         assertThat(updatedUser.getPassword()).isEqualTo(user.getPassword());
+
+        userService.deleteUser("change-password-empty")<%- reactorBlock %>;
     }
 <%_ if (authenticationTypeSession && !reactive) { _%>
 
@@ -1165,6 +1207,9 @@ class AccountResourceIT {
             .andExpect(jsonPath("$.[*].ipAddress").value(hasItem(token.getIpAddress())))
             .andExpect(jsonPath("$.[*].userAgent").value(hasItem(token.getUserAgent())))
             .andExpect(jsonPath("$.[*].tokenDate").value(hasItem(containsString(<% if (databaseTypeCassandra) { %>"2017-03-28T15:25:57.123Z"<% } else { %>token.getTokenDate().toString()<% } %>))));
+
+        persistentTokenRepository.delete(token);
+        userService.deleteUser("current-sessions")<%- reactorBlock %>;
     }
 
     @Test
@@ -1210,6 +1255,9 @@ class AccountResourceIT {
             .andExpect(status().isOk());
 
         assertThat(persistentTokenRepository.findByUser(user)).isEmpty();
+
+        persistentTokenRepository.delete(token);
+        userService.deleteUser("invalidate-session")<%- reactorBlock %>;
     }
     <%_ } _%>
 
@@ -1244,6 +1292,8 @@ class AccountResourceIT {
             .with(csrf())<%_ } _%>)
             .andExpect(status().isOk());
 <%_ } _%>
+
+        userService.deleteUser("password-reset")<%- reactorBlock %>;
     }
 
     @Test
@@ -1277,6 +1327,8 @@ class AccountResourceIT {
             .with(csrf())<%_ } _%>)
             .andExpect(status().isOk());
 <%_ } _%>
+
+        userService.deleteUser("password-reset-upper-case")<%- reactorBlock %>;
     }
 
     @Test
@@ -1336,6 +1388,8 @@ class AccountResourceIT {
 
         <%= user.persistClass %> updatedUser = userRepository.findOneByLogin(user.getLogin())<%_ if (reactive) { _%>.block()<% } else { %>.orElse(null)<% } %>;
         assertThat(passwordEncoder.matches(keyAndPassword.getNewPassword(), updatedUser.getPassword())).isTrue();
+
+        userService.deleteUser("finish-password-reset")<%- reactorBlock %>;
     }
 
     @Test
@@ -1378,6 +1432,8 @@ class AccountResourceIT {
 
         <%= user.persistClass %> updatedUser = userRepository.findOneByLogin(user.getLogin())<%_ if (!reactive) { _%>.orElse(null)<% } else { %>.block()<% } %>;
         assertThat(passwordEncoder.matches(keyAndPassword.getNewPassword(), updatedUser.getPassword())).isFalse();
+
+        userService.deleteUser("finish-password-reset-too-small")<%- reactorBlock %>;
     }
 
     @Test

package/dist/generators/server/templates/src/test/java/_package_/web/rest/AccountResourceIT_oauth2.java.ejs

@@ -34,11 +34,17 @@ import static org.mockito.Mockito.*;
 
 import <%= packageName %>.IntegrationTest;
 import <%= packageName %>.security.AuthoritiesConstants;
+<%_ if (syncUserWithIdp) { _%>
+import <%= packageName %>.repository.UserRepository;
+<%_ } _%>
 
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.MediaType;
 import org.springframework.security.test.context.support.WithMockUser;
+<%_ if (authenticationTypeOauth2) { _%>
+import org.junit.jupiter.api.AfterEach;
+<%_ } _%>
 <%_ if (reactive) { _%>
 import org.junit.jupiter.api.BeforeEach;
 import org.springframework.boot.test.autoconfigure.web.reactive.AutoConfigureWebTestClient;
@@ -74,6 +80,11 @@ import org.springframework.transaction.annotation.Transactional;
 <%_ } _%>
 @IntegrationTest
 class AccountResourceIT {
+<%_ if (syncUserWithIdp) { _%>
+
+    @Autowired
+    private UserRepository userRepository;
+<%_ } _%>
 
 <%_ if (reactive) { _%>
     private Map<String, Object> claims;
@@ -106,6 +117,17 @@ class AccountResourceIT {
         claims.put("email", "jane.doe@jhipster.com");
     }
 
+<%_ } _%>
+<%_ if (syncUserWithIdp) { _%>
+    @AfterEach
+    public void cleanup() {
+        // Remove syncUserWithIdp users
+    <%_ if (databaseTypeSql && reactive) { _%>
+        userRepository.deleteAllUserAuthorities()<%- reactorBlock %>;
+    <%_ } _%>
+        userRepository.deleteAll()<%- reactorBlock %>;
+    }
+
 <%_ } _%>
     @Test
 <%_ if (databaseTypeSql && !reactive) { _%>

package/dist/generators/server/templates/src/test/resources/config/application.yml.ejs

@@ -132,13 +132,32 @@ spring:
     allow-bean-definition-overriding: true
   messages:
     basename: i18n/messages
-<%_ if (generateInMemoryUserCredentials) { _%>
+<%_ if (generateInMemoryUserCredentials || authenticationTypeOauth2 || authenticationTypeJwt) { _%>
   security:
+  <%_ if (generateInMemoryUserCredentials) { _%>
     user:
       name: test
       password: test
       roles:
         - USER
+  <%_ } _%>
+  <%_ if (authenticationTypeOauth2) { _%>
+    oauth2:
+      client:
+        provider:
+          oidc:
+            issuer-uri: http://DO_NOT_CALL:9080/realms/jhipster
+      resourceserver:
+        jwt:
+          principal-claim-name: preferred_username
+  <%_ } _%>
+  <%_ if (authenticationTypeJwt) { _%>
+    oauth2:
+      resourceserver:
+        jwt:
+          authority-prefix: ''
+          authorities-claim-name: auth
+  <%_ } _%>
 <%_ } _%>
   task:
     execution:
@@ -153,15 +172,6 @@ spring:
         size: 20
   thymeleaf:
     mode: HTML
-<%_ if (authenticationTypeOauth2) { _%>
-  # Allow SecurityConfiguration to initialize w/o specifying an empty issuer-uri is OK
-  security:
-    oauth2:
-      client:
-        provider:
-          oidc:
-            issuer-uri: http://DO_NOT_CALL:9080/realms/jhipster
-<%_ } _%>
 
 server:
   port: 10344

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

@@ -197,4 +197,7 @@ export default asWritingTask(function cleanupTask(taskParam) {
             this.removeFile('gradle/sonar.gradle');
         }
     }
+    if (this.isJhipsterVersionLessThan('8.4.0')) {
+        this.removeFile(`${application.javaPackageSrcDir}config/LocaleConfiguration.java`);
+    }
 });

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,7 +131,31 @@ const command = {
                 message: 'Do you want to allow relationships with User entity?',
                 when: ({ authenticationType }) => (authenticationType ?? gen.jhipsterConfigWithDefaults.authenticationType) === 'oauth2',
             }),
-            default: false,
+            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',
+            cli: {
+                type: String,
+                hide: true,
+            },
+            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,20 +401,10 @@ 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'],
         },
-        {
-            path: `${SERVER_MAIN_SRC_DIR}_package_/`,
-            renameTo: moveToJavaPackageSrcDir,
-            templates: [data => `config/LocaleConfiguration_${data.imperativeOrReactive}.java`],
-        },
     ],
     serverJavaDomain: [
         {