generator-jhipster 8.0.0 → 8.1.0

package/dist/generators/feign-client/templates/src/main/java/_package_/client/OAuth2InterceptedFeignConfiguration.java.ejs

@@ -0,0 +1,35 @@
+<%#
+ 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.
+-%>
+package <%= packageName %>.client;
+
+<%_ if (authenticationTypeOauth2) { _%>
+import org.springframework.context.annotation.Bean;
+
+import feign.RequestInterceptor;
+
+import <%= packageName %>.client.AuthorizationHeaderUtil;
+
+public class OAuth2InterceptedFeignConfiguration {
+
+    @Bean(name = "oauth2RequestInterceptor")
+    public RequestInterceptor getOAuth2RequestInterceptor(AuthorizationHeaderUtil authorizationHeaderUtil) {
+        return new TokenRelayRequestInterceptor(authorizationHeaderUtil);
+    }
+}
+<%_ } _%>

package/dist/generators/feign-client/templates/src/main/java/_package_/client/OAuthIdpTokenResponseDTO.java.ejs

@@ -0,0 +1,161 @@
+<%#
+ 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.
+-%>
+package <%= packageName %>.client;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import java.io.Serializable;
+import java.util.UUID;
+
+public class OAuthIdpTokenResponseDTO implements Serializable {
+
+    @JsonProperty("token_type")
+    private String tokenType;
+
+    private String scope;
+
+    @JsonProperty("expires_in")
+    private Long expiresIn;
+
+    @JsonProperty("ext_expires_in")
+    private Long extExpiresIn;
+
+    @JsonProperty("expires_on")
+    private Long expiresOn;
+
+    @JsonProperty("not-before-policy")
+    private Long notBefore;
+
+    private UUID resource;
+
+    @JsonProperty("access_token")
+    private String accessToken;
+
+    @JsonProperty("refresh_token")
+    private String refreshToken;
+
+    @JsonProperty("id_token")
+    private String idToken;
+
+    @JsonProperty("session_state")
+    private String sessionState;
+
+    @JsonProperty("refresh_expires_in")
+    private String refreshExpiresIn;
+
+    public OAuthIdpTokenResponseDTO() {
+        // Empty constructor for serialization.
+    }
+
+    public String getRefreshExpiresIn() {
+        return refreshExpiresIn;
+    }
+
+    public void setRefreshExpiresIn(String refreshExpiresIn) {
+        this.refreshExpiresIn = refreshExpiresIn;
+    }
+
+    public String getSessionState() {
+        return sessionState;
+    }
+
+    public void setSessionState(String sessionState) {
+        this.sessionState = sessionState;
+    }
+
+    public String getTokenType() {
+        return tokenType;
+    }
+
+    public void setTokenType(String tokenType) {
+        this.tokenType = tokenType;
+    }
+
+    public String getScope() {
+        return scope;
+    }
+
+    public void setScope(String scope) {
+        this.scope = scope;
+    }
+
+    public Long getExpiresIn() {
+        return expiresIn;
+    }
+
+    public void setExpiresIn(Long expiresIn) {
+        this.expiresIn = expiresIn;
+    }
+
+    public Long getExtExpiresIn() {
+        return extExpiresIn;
+    }
+
+    public void setExtExpiresIn(Long extExpiresIn) {
+        this.extExpiresIn = extExpiresIn;
+    }
+
+    public Long getExpiresOn() {
+        return expiresOn;
+    }
+
+    public void setExpiresOn(Long expiresOn) {
+        this.expiresOn = expiresOn;
+    }
+
+    public Long getNotBefore() {
+        return notBefore;
+    }
+
+    public void setNotBefore(Long notBefore) {
+        this.notBefore = notBefore;
+    }
+
+    public UUID getResource() {
+        return resource;
+    }
+
+    public void setResource(UUID resource) {
+        this.resource = resource;
+    }
+
+    public String getAccessToken() {
+        return accessToken;
+    }
+
+    public void setAccessToken(String accessToken) {
+        this.accessToken = accessToken;
+    }
+
+    public String getRefreshToken() {
+        return refreshToken;
+    }
+
+    public void setRefreshToken(String refreshToken) {
+        this.refreshToken = refreshToken;
+    }
+
+    public String getIdToken() {
+        return idToken;
+    }
+
+    public void setIdToken(String idToken) {
+        this.idToken = idToken;
+    }
+}

package/dist/generators/feign-client/templates/src/main/java/_package_/client/TokenRelayRequestInterceptor.java.ejs

@@ -0,0 +1,42 @@
+<%#
+ 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.
+-%>
+package <%= packageName %>.client;
+
+import feign.RequestInterceptor;
+import feign.RequestTemplate;
+
+import java.util.Optional;
+
+public class TokenRelayRequestInterceptor implements RequestInterceptor {
+
+    public static final String AUTHORIZATION = "Authorization";
+
+    private final AuthorizationHeaderUtil authorizationHeaderUtil;
+
+    public TokenRelayRequestInterceptor(AuthorizationHeaderUtil authorizationHeaderUtil) {
+        super();
+        this.authorizationHeaderUtil = authorizationHeaderUtil;
+    }
+
+    @Override
+    public void apply(RequestTemplate template) {
+        Optional<String> authorizationHeader = authorizationHeaderUtil.getAuthorizationHeader();
+        authorizationHeader.ifPresent(s -> template.header(AUTHORIZATION, s));
+    }
+}

package/dist/generators/feign-client/templates/src/main/java/_package_/client/UserFeignClientInterceptor_jwt.java.ejs

@@ -0,0 +1,36 @@
+<%#
+ 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.
+-%>
+package <%= packageName %>.client;
+
+import <%= packageName %>.security.SecurityUtils;
+import feign.RequestInterceptor;
+import feign.RequestTemplate;
+import org.springframework.stereotype.Component;
+
+@Component
+public class UserFeignClientInterceptor implements RequestInterceptor {
+    private static final String AUTHORIZATION_HEADER = "Authorization";
+    private static final String BEARER = "Bearer";
+
+    @Override
+    public void apply(RequestTemplate template) {
+        SecurityUtils.getCurrentUserJWT()
+            .ifPresent(s -> template.header(AUTHORIZATION_HEADER,String.format("%s %s", BEARER, s)));
+    }
+}

package/dist/generators/feign-client/templates/src/main/java/_package_/config/FeignConfiguration.java.ejs

@@ -0,0 +1,45 @@
+<%#
+ 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.
+-%>
+package <%= packageName %>.config;
+
+import org.springframework.cloud.openfeign.EnableFeignClients;
+import org.springframework.cloud.openfeign.FeignClientsConfiguration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+<%_ if (reactive) { _%>
+import reactivefeign.spring.config.EnableReactiveFeignClients;
+<%_ } _%>
+@Configuration
+@EnableFeignClients(basePackages = "<%= packageName %>")
+<%_ if (reactive) { _%>
+@EnableReactiveFeignClients(basePackages = "<%= packageName %>")
+<%_ } _%>
+@Import(FeignClientsConfiguration.class)
+public class FeignConfiguration {
+
+    /**
+     * Set the Feign specific log level to log client REST requests.
+     */
+    @Bean
+    feign.Logger.Level feignLoggerLevel() {
+        return feign.Logger.Level.BASIC;
+    }
+
+}

package/dist/generators/feign-client/templates/src/test/java/_package_/client/AuthorizationHeaderUtilTest.java.ejs

@@ -0,0 +1,263 @@
+<%#
+ 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.
+-%>
+package <%= packageName %>.client;
+
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.http.RequestEntity;
+import org.springframework.http.ResponseEntity;
+import org.springframework.http.converter.HttpMessageConverter;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.context.SecurityContext;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClient;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClientService;
+import org.springframework.security.oauth2.client.authentication.OAuth2AuthenticationToken;
+import org.springframework.security.oauth2.client.registration.ClientRegistration;
+import org.springframework.security.oauth2.core.*;
+import org.springframework.security.oauth2.core.oidc.OidcIdToken;
+import org.springframework.security.oauth2.core.oidc.user.DefaultOidcUser;
+import org.springframework.security.oauth2.jwt.Jwt;
+import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationToken;
+import org.springframework.web.client.ResponseErrorHandler;
+import org.springframework.web.client.RestTemplate;
+
+/**
+ * Test class for the {@link AuthorizationHeaderUtil} utility class.
+ */
+@ExtendWith(MockitoExtension.class)
+class AuthorizationHeaderUtilTest {
+
+    public static final String VALID_REGISTRATION_ID = "OIDC";
+    public static final String SUB_VALUE = "123456";
+
+    @Mock
+    private OAuth2AuthorizedClientService clientService;
+
+    @Mock
+    private RestTemplateBuilder restTemplateBuilder;
+
+    @Mock
+    private SecurityContext securityContext;
+
+    @InjectMocks
+    private AuthorizationHeaderUtil authorizationHeaderUtil;
+
+    @BeforeEach
+    public void setup() {
+        SecurityContextHolder.setContext(securityContext);
+    }
+
+    @Test
+    void getAuthorizationHeader_Authentication() {
+        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken("principal", "credentials");
+        doReturn(authenticationToken).when(securityContext).getAuthentication();
+
+        Optional<String> header = authorizationHeaderUtil.getAuthorizationHeader();
+
+        Assertions.assertThat(header).isNotNull().isEmpty();
+    }
+
+    @Test
+    void getAuthorizationHeader_JwtAuthentication() {
+        JwtAuthenticationToken jwtToken = new JwtAuthenticationToken(
+            new Jwt("tokenVal", Instant.now(), Instant.now().plus(Duration.ofMinutes(3)), Map.of("alg", "HS256"), Map.of("sub", SUB_VALUE))
+        );
+        doReturn(jwtToken).when(securityContext).getAuthentication();
+
+        Optional<String> header = authorizationHeaderUtil.getAuthorizationHeader();
+
+        Assertions.assertThat(header).isNotNull().isNotEmpty().get().isEqualTo("Bearer tokenVal");
+    }
+
+    @Test
+    void getAuthorizationHeader_OAuth2Authentication_InvalidClient() {
+        OAuth2AuthenticationToken oauth2Token = getTestOAuth2AuthenticationToken("INVALID");
+
+        doReturn(oauth2Token).when(securityContext).getAuthentication();
+
+        Assertions
+            .assertThatThrownBy(() -> {
+                authorizationHeaderUtil.getAuthorizationHeader();
+            })
+            .isInstanceOf(OAuth2AuthorizationException.class)
+            .hasMessageContaining("[access_denied] The token is expired");
+    }
+
+    @Test
+    void getAuthorizationHeader_OAuth2Authentication() {
+        OAuth2AuthenticationToken oauth2Token = getTestOAuth2AuthenticationToken(VALID_REGISTRATION_ID);
+        OAuth2AuthorizedClient authorizedClient = getTestOAuth2AuthorizedClient();
+
+        doReturn(oauth2Token).when(securityContext).getAuthentication();
+        doReturn(authorizedClient).when(clientService).loadAuthorizedClient(eq(VALID_REGISTRATION_ID), eq(SUB_VALUE));
+
+        Optional<String> header = authorizationHeaderUtil.getAuthorizationHeader();
+        Assertions.assertThat(header).isNotNull().isNotEmpty().get().isEqualTo("Bearer tokenVal");
+    }
+
+    @Test
+    void getAuthorizationHeader_OAuth2Authentication_RefreshToken() {
+        doReturn(restTemplateBuilder)
+            .when(restTemplateBuilder)
+            .additionalMessageConverters(any(HttpMessageConverter.class), any(HttpMessageConverter.class));
+        doReturn(restTemplateBuilder).when(restTemplateBuilder).errorHandler(any(ResponseErrorHandler.class));
+        doReturn(restTemplateBuilder).when(restTemplateBuilder).basicAuthentication(anyString(), anyString());
+
+        OAuth2AuthenticationToken oauth2Token = getTestOAuth2AuthenticationToken(VALID_REGISTRATION_ID);
+        OAuth2AuthorizedClient authorizedClient = getTestOAuth2AuthorizedClient(true);
+
+        doReturn(oauth2Token).when(securityContext).getAuthentication();
+        doReturn(authorizedClient).when(clientService).loadAuthorizedClient(eq(VALID_REGISTRATION_ID), eq(SUB_VALUE));
+
+        RestTemplate restTemplate = mock(RestTemplate.class);
+        ResponseEntity<OAuthIdpTokenResponseDTO> refreshResponse = ResponseEntity.of(getTestOAuthIdpTokenResponseDTO(true));
+        doReturn(refreshResponse).when(restTemplate).exchange(any(RequestEntity.class), eq(OAuthIdpTokenResponseDTO.class));
+        doReturn(restTemplate).when(restTemplateBuilder).build();
+
+        Optional<String> header = authorizationHeaderUtil.getAuthorizationHeader();
+        Assertions.assertThat(header).isNotNull().isNotEmpty().get().isEqualTo("Bearer tokenVal");
+    }
+
+    @Test
+    void getAuthorizationHeader_OAuth2Authentication_RefreshToken_NoRefreshToken() {
+        doReturn(restTemplateBuilder)
+            .when(restTemplateBuilder)
+            .additionalMessageConverters(any(HttpMessageConverter.class), any(HttpMessageConverter.class));
+        doReturn(restTemplateBuilder).when(restTemplateBuilder).errorHandler(any(ResponseErrorHandler.class));
+        doReturn(restTemplateBuilder).when(restTemplateBuilder).basicAuthentication(anyString(), anyString());
+
+        OAuth2AuthenticationToken oauth2Token = getTestOAuth2AuthenticationToken(VALID_REGISTRATION_ID);
+        OAuth2AuthorizedClient authorizedClient = getTestOAuth2AuthorizedClient(true);
+
+        doReturn(oauth2Token).when(securityContext).getAuthentication();
+        doReturn(authorizedClient).when(clientService).loadAuthorizedClient(eq(VALID_REGISTRATION_ID), eq(SUB_VALUE));
+
+        RestTemplate restTemplate = mock(RestTemplate.class);
+        ResponseEntity<OAuthIdpTokenResponseDTO> refreshResponse = ResponseEntity.of(getTestOAuthIdpTokenResponseDTO(false));
+        doReturn(refreshResponse).when(restTemplate).exchange(any(RequestEntity.class), eq(OAuthIdpTokenResponseDTO.class));
+        doReturn(restTemplate).when(restTemplateBuilder).build();
+
+        Optional<String> header = authorizationHeaderUtil.getAuthorizationHeader();
+        Assertions.assertThat(header).isNotNull().isNotEmpty().get().isEqualTo("Bearer tokenVal");
+    }
+
+    @Test
+    void getAuthorizationHeader_OAuth2Authentication_RefreshTokenFails() {
+        doReturn(restTemplateBuilder)
+            .when(restTemplateBuilder)
+            .additionalMessageConverters(any(HttpMessageConverter.class), any(HttpMessageConverter.class));
+        doReturn(restTemplateBuilder).when(restTemplateBuilder).errorHandler(any(ResponseErrorHandler.class));
+        doReturn(restTemplateBuilder).when(restTemplateBuilder).basicAuthentication(anyString(), anyString());
+
+        OAuth2AuthenticationToken oauth2Token = getTestOAuth2AuthenticationToken(VALID_REGISTRATION_ID);
+        OAuth2AuthorizedClient authorizedClient = getTestOAuth2AuthorizedClient(true);
+
+        doReturn(oauth2Token).when(securityContext).getAuthentication();
+        doReturn(authorizedClient).when(clientService).loadAuthorizedClient(eq(VALID_REGISTRATION_ID), eq(SUB_VALUE));
+
+        RestTemplate restTemplate = mock(RestTemplate.class);
+        doThrow(new OAuth2AuthorizationException(new OAuth2Error("E"), "error"))
+            .when(restTemplate)
+            .exchange(any(RequestEntity.class), eq(OAuthIdpTokenResponseDTO.class));
+        doReturn(restTemplate).when(restTemplateBuilder).build();
+
+        Assertions
+            .assertThatThrownBy(() -> {
+                authorizationHeaderUtil.getAuthorizationHeader();
+            })
+            .isInstanceOf(OAuth2AuthenticationException.class)
+            .hasMessageContaining("error");
+    }
+
+    private OAuth2AuthorizedClient getTestOAuth2AuthorizedClient() {
+        return getTestOAuth2AuthorizedClient(false);
+    }
+
+    private OAuth2AuthorizedClient getTestOAuth2AuthorizedClient(boolean accessTokenExpired) {
+        Instant issuedAt = Instant.now();
+        Instant expiresAt;
+        if (accessTokenExpired) {
+            expiresAt = issuedAt.plus(Duration.ofNanos(1));
+            try {
+                Thread.sleep(1);
+            } catch (Exception e) {
+                fail("Error in Thread.sleep(1) : " + e.getMessage());
+            }
+        } else {
+            expiresAt = issuedAt.plus(Duration.ofMinutes(3));
+        }
+        OAuth2AccessToken token = new OAuth2AccessToken(OAuth2AccessToken.TokenType.BEARER, "tokenVal", issuedAt, expiresAt);
+
+        return new OAuth2AuthorizedClient(
+            ClientRegistration
+                .withRegistrationId(VALID_REGISTRATION_ID)
+                .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
+                .clientId("web-app")
+                .clientSecret("secret")
+                .redirectUri("/login/oauth2/code/oidc")
+                .authorizationUri("http://localhost:8080/auth/realms/master/protocol/openid-connect/auth")
+                .tokenUri("https://localhost:8080/auth/realms/master/protocol/openid-connect/token")
+                .build(),
+            "sub",
+            token,
+            new OAuth2RefreshToken("refreshVal", Instant.now())
+        );
+    }
+
+    private OAuth2AuthenticationToken getTestOAuth2AuthenticationToken(String registrationId) {
+        return new OAuth2AuthenticationToken(
+            new DefaultOidcUser(
+                List.of(new SimpleGrantedAuthority("USER")),
+                OidcIdToken.withTokenValue("tokenVal").claim("sub", SUB_VALUE).build()
+            ),
+            List.of(new SimpleGrantedAuthority("USER")),
+            registrationId
+        );
+    }
+
+    private Optional<OAuthIdpTokenResponseDTO> getTestOAuthIdpTokenResponseDTO(boolean hasRefreshToken) {
+        OAuthIdpTokenResponseDTO dto = new OAuthIdpTokenResponseDTO();
+        dto.setAccessToken("tokenVal");
+        dto.setIdToken("tokenVal");
+        dto.setNotBefore(0l);
+        dto.setRefreshExpiresIn("1800");
+        dto.setSessionState("ccea4a55");
+        dto.setExpiresIn(300l);
+        dto.setRefreshToken(hasRefreshToken ? "tokenVal" : null);
+        dto.setScope("openid email profile offline_access");
+        return Optional.of(dto);
+    }
+}

package/dist/generators/generate-blueprint/command.mjs

@@ -22,7 +22,7 @@ const command = {
             scope: 'storage',
         },
         [DYNAMIC]: {
-            description: 'Genate dynamic generators (advanced)',
+            description: 'Generate dynamic generators (advanced)',
             type: Boolean,
             scope: 'storage',
         },

package/dist/generators/generate-blueprint/resources/package.json

@@ -1,5 +1,5 @@
 {
   "dependencies": {
-    "vitest": "0.34.6"
+    "vitest": "1.0.2"
   }
 }

package/dist/generators/generate-blueprint/templates/vitest.config.ts.ejs

@@ -2,7 +2,7 @@ import { defineConfig, defaultExclude } from 'vitest/config';
 
 export default defineConfig({
   test: {
-    threads: false,
+    pool: 'forks',
     hookTimeout: 20000,
     exclude: [...defaultExclude.filter(val => val !== '**/cypress/**'), '**/templates/**', '**/resources/**'],
   },

package/dist/generators/generator-constants.mjs

@@ -18,7 +18,7 @@
  */
 export const BLUEPRINT_API_VERSION = 'jhipster-8';
 // jhipster-bom version
-export const JHIPSTER_DEPENDENCIES_VERSION = '8.0.0';
+export const JHIPSTER_DEPENDENCIES_VERSION = '8.1.0';
 // Version of Java
 export const JAVA_VERSION = '17';
 export const JAVA_COMPATIBLE_VERSIONS = ['17', '18', '19', '20', '21'];
@@ -27,27 +27,31 @@ export const ADD_SPRING_MILESTONE_REPOSITORY = false;
 // Version of Node, NPM
 export const NODE_VERSION = '18.18.2';
 export const OPENAPI_GENERATOR_CLI_VERSION = '2.7.0';
+/**
+ * @type {Record<string, string>}
+ */
 export const javaDependencies = {
     /**
      * spring-boot version should match the one managed by https://mvnrepository.com/artifact/tech.jhipster/jhipster-dependencies/JHIPSTER_DEPENDENCIES_VERSION
      */
-    'spring-boot': '3.1.5',
+    'spring-boot': '3.2.0',
     /*
      * hibernate version should match the one managed by https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-dependencies/SPRING_BOOT_VERSION
      * Required due to hibernate-jpamodelgen annotation processor.
      */
-    hibernate: '6.2.13.Final',
+    hibernate: '6.3.1.Final',
     /*
      * cassandra driver version should match the one managed by https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-dependencies/SPRING_BOOT_VERSION
      * Required due to java-driver-mapper-processor annotation processor.
      */
-    cassandra: '4.15.0',
+    cassandra: '4.17.0',
 };
 Object.freeze(javaDependencies);
 // The version should be coherent with the one from spring-data-elasticsearch project
-export const ELASTICSEARCH_TAG = '8.7.1';
+export const ELASTICSEARCH_TAG = '8.10.4';
 export const ELASTICSEARCH_IMAGE = 'docker.elastic.co/elasticsearch/elasticsearch';
 /**
+ * @type {Record<string, string>}
  * Manually updated docker containers
  */
 export const dockerContainers = {

package/dist/generators/generator-list.mjs

@@ -39,6 +39,7 @@ export const GENERATOR_DOCKER_COMPOSE = 'docker-compose';
 export const GENERATOR_ENTITIES = 'entities';
 export const GENERATOR_ENTITY = 'entity';
 export const GENERATOR_EXPORT_JDL = 'export-jdl';
+export const GENERATOR_FEIGN_CLIENT = 'feign-client';
 export const GENERATOR_GATLING = 'gatling';
 export const GENERATOR_GENERATE_BLUEPRINT = 'generate-blueprint';
 export const GENERATOR_GIT = 'git';