generator-jhipster 8.0.0-rc.1 → 8.1.0

package/dist/generators/feign-client/generator.mjs

@@ -0,0 +1,65 @@
+/**
+ * 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 BaseApplicationGenerator from '../base-application/index.mjs';
+import { GENERATOR_BOOTSTRAP_APPLICATION, GENERATOR_FEIGN_CLIENT } from '../generator-list.mjs';
+import { feignFiles } from './files.mjs';
+import cleanupTask from './cleanup.mjs';
+export default class FeignClientGenerator extends BaseApplicationGenerator {
+    async beforeQueue() {
+        if (!this.fromBlueprint) {
+            await this.composeWithBlueprints(GENERATOR_FEIGN_CLIENT);
+        }
+        if (!this.delegateToBlueprint) {
+            await this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION);
+        }
+    }
+    get writing() {
+        return this.asWritingTaskGroup({
+            cleanupTask,
+            async writeTask({ application }) {
+                await this.writeFiles({
+                    sections: feignFiles,
+                    context: application,
+                });
+            },
+        });
+    }
+    get [BaseApplicationGenerator.WRITING]() {
+        return this.delegateTasksToBlueprint(() => this.writing);
+    }
+    get postWriting() {
+        return this.asPostWritingTaskGroup({
+            addDependencies({ application, source }) {
+                const openFeignArtifact = { groupId: 'org.springframework.cloud', artifactId: 'spring-cloud-starter-openfeign' };
+                if (application.buildToolMaven) {
+                    source.addMavenDependency?.(openFeignArtifact);
+                }
+                if (application.buildToolGradle) {
+                    source.addGradleDependency?.({
+                        ...openFeignArtifact,
+                        scope: 'implementation',
+                    });
+                }
+            },
+        });
+    }
+    get [BaseApplicationGenerator.POST_WRITING]() {
+        return this.asPostWritingTaskGroup(this.delegateTasksToBlueprint(() => this.postWriting));
+    }
+}

package/dist/generators/feign-client/index.mjs

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ */
+export { default } from './generator.mjs';

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

@@ -0,0 +1,174 @@
+<%#
+ 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 java.net.URI;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.http.MediaType;
+import org.springframework.http.RequestEntity;
+import org.springframework.http.ResponseEntity;
+import org.springframework.http.converter.FormHttpMessageConverter;
+import org.springframework.security.core.Authentication;
+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.http.OAuth2ErrorResponseErrorHandler;
+import org.springframework.security.oauth2.core.*;
+import org.springframework.security.oauth2.core.endpoint.OAuth2AccessTokenResponse;
+import org.springframework.security.oauth2.core.endpoint.OAuth2ParameterNames;
+import org.springframework.security.oauth2.core.http.converter.OAuth2AccessTokenResponseHttpMessageConverter;
+import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationToken;
+import org.springframework.stereotype.Component;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+import org.springframework.web.client.RestTemplate;
+
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+@Component
+public class AuthorizationHeaderUtil {
+
+    private final OAuth2AuthorizedClientService clientService;
+    private final RestTemplateBuilder restTemplateBuilder;
+    private final Logger log = LoggerFactory.getLogger(AuthorizationHeaderUtil.class);
+
+    public AuthorizationHeaderUtil(OAuth2AuthorizedClientService clientService, RestTemplateBuilder restTemplateBuilder) {
+        this.clientService = clientService;
+        this.restTemplateBuilder = restTemplateBuilder;
+    }
+
+    public Optional<String> getAuthorizationHeader() {
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        if (authentication instanceof OAuth2AuthenticationToken) {
+            OAuth2AuthenticationToken oauthToken = (OAuth2AuthenticationToken) authentication;
+            String name = oauthToken.getName();
+            String registrationId = oauthToken.getAuthorizedClientRegistrationId();
+            OAuth2AuthorizedClient client = clientService.loadAuthorizedClient(
+                registrationId,
+                name);
+
+            if (null == client) {
+                throw new OAuth2AuthorizationException(new OAuth2Error("access_denied", "The token is expired", null));
+            }
+            OAuth2AccessToken accessToken = client.getAccessToken();
+
+            if (accessToken != null) {
+                String tokenType = accessToken.getTokenType().getValue();
+                String accessTokenValue = accessToken.getTokenValue();
+                if (isExpired(accessToken)) {
+                    log.info("AccessToken expired, refreshing automatically");
+                    accessTokenValue = refreshToken(client, oauthToken);
+                    if (null == accessTokenValue) {
+                        SecurityContextHolder.getContext().setAuthentication(null);
+                        throw new OAuth2AuthorizationException(new OAuth2Error("access_denied", "The token is expired", null));
+                    }
+                }
+                String authorizationHeaderValue = String.format("%s %s", tokenType, accessTokenValue);
+                return Optional.of(authorizationHeaderValue);
+            }
+
+        } else if (authentication instanceof JwtAuthenticationToken) {
+            JwtAuthenticationToken accessToken = (JwtAuthenticationToken) authentication;
+            String tokenValue = accessToken.getToken().getTokenValue();
+            String authorizationHeaderValue = String.format("%s %s", OAuth2AccessToken.TokenType.BEARER.getValue(), tokenValue);
+            return Optional.of(authorizationHeaderValue);
+        }
+        return Optional.empty();
+    }
+
+    private String refreshToken(OAuth2AuthorizedClient client, OAuth2AuthenticationToken oauthToken) {
+        OAuth2AccessTokenResponse atr = refreshTokenClient(client);
+        if (atr == null || atr.getAccessToken() == null) {
+            log.info("Failed to refresh token for user");
+            return null;
+        }
+
+        OAuth2RefreshToken refreshToken = atr.getRefreshToken() != null ? atr.getRefreshToken(): client.getRefreshToken();
+        OAuth2AuthorizedClient updatedClient = new OAuth2AuthorizedClient(
+            client.getClientRegistration(),
+            client.getPrincipalName(),
+            atr.getAccessToken(),
+            refreshToken
+        );
+
+        clientService.saveAuthorizedClient(updatedClient, oauthToken);
+        return atr.getAccessToken().getTokenValue();
+    }
+
+    private OAuth2AccessTokenResponse refreshTokenClient(OAuth2AuthorizedClient currentClient) {
+
+        MultiValueMap<String, String> formParameters = new LinkedMultiValueMap<>();
+        formParameters.add(OAuth2ParameterNames.GRANT_TYPE, AuthorizationGrantType.REFRESH_TOKEN.getValue());
+        formParameters.add(OAuth2ParameterNames.REFRESH_TOKEN, currentClient.getRefreshToken().getTokenValue());
+        formParameters.add(OAuth2ParameterNames.CLIENT_ID, currentClient.getClientRegistration().getClientId());
+        RequestEntity requestEntity = RequestEntity
+            .post(URI.create(currentClient.getClientRegistration().getProviderDetails().getTokenUri()))
+            .contentType(MediaType.APPLICATION_FORM_URLENCODED)
+            .body(formParameters);
+        try {
+            RestTemplate r = restTemplate(currentClient.getClientRegistration().getClientId(), currentClient.getClientRegistration().getClientSecret());
+            ResponseEntity<OAuthIdpTokenResponseDTO> responseEntity = r.exchange(requestEntity, OAuthIdpTokenResponseDTO.class);
+            return toOAuth2AccessTokenResponse(responseEntity.getBody());
+        } catch (OAuth2AuthorizationException e) {
+            log.error("Unable to refresh token", e);
+            throw new OAuth2AuthenticationException(e.getError(), e);
+        }
+    }
+
+    private OAuth2AccessTokenResponse toOAuth2AccessTokenResponse(OAuthIdpTokenResponseDTO oAuthIdpResponse) {
+        Map<String, Object> additionalParameters = new HashMap<>();
+        additionalParameters.put("id_token", oAuthIdpResponse.getIdToken());
+        additionalParameters.put("not-before-policy", oAuthIdpResponse.getNotBefore());
+        additionalParameters.put("refresh_expires_in", oAuthIdpResponse.getRefreshExpiresIn());
+        additionalParameters.put("session_state", oAuthIdpResponse.getSessionState());
+        return OAuth2AccessTokenResponse.withToken(oAuthIdpResponse.getAccessToken())
+            .expiresIn(oAuthIdpResponse.getExpiresIn())
+            .refreshToken(oAuthIdpResponse.getRefreshToken())
+            .scopes(Pattern.compile("\\s").splitAsStream(oAuthIdpResponse.getScope()).collect(Collectors.toSet()))
+            .tokenType(OAuth2AccessToken.TokenType.BEARER)
+            .additionalParameters(additionalParameters)
+            .build();
+    }
+
+    private RestTemplate restTemplate(String clientId, String clientSecret) {
+        return restTemplateBuilder
+            .additionalMessageConverters(
+                new FormHttpMessageConverter(),
+                new OAuth2AccessTokenResponseHttpMessageConverter())
+            .errorHandler(new OAuth2ErrorResponseErrorHandler())
+            .basicAuthentication(clientId, clientSecret)
+            .build();
+    }
+
+    private boolean isExpired(OAuth2AccessToken accessToken) {
+        Instant now = Instant.now();
+        Instant expiresAt = accessToken.getExpiresAt();
+        return now.isAfter(expiresAt.minus(Duration.ofMinutes(1L)));
+    }
+}

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

@@ -0,0 +1,72 @@
+<%#
+ 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 org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.core.annotation.AliasFor;
+
+import java.lang.annotation.*;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+@Documented
+@FeignClient
+public @interface AuthorizedFeignClient {
+
+    @AliasFor(annotation = FeignClient.class, attribute = "name")
+    String name() default "";
+
+    /**
+     * A custom {@code @Configuration} for the feign client.
+     *
+     * Can contain override {@code @Bean} definition for the pieces that
+     * make up the client, for instance {@link feign.codec.Decoder},
+     * {@link feign.codec.Encoder}, {@link feign.Contract}.
+     *
+     * @return the custom {@code @Configuration} for the feign client.
+     * @see org.springframework.cloud.openfeign.FeignClientsConfiguration for the defaults.
+     */
+    @AliasFor(annotation = FeignClient.class, attribute = "configuration")
+    Class<?>[] configuration() default OAuth2InterceptedFeignConfiguration.class;
+
+    /**
+     * An absolute URL or resolvable hostname (the protocol is optional).
+     * @return the URL.
+     */
+    String url() default "";
+
+    /**
+     * Whether 404s should be decoded instead of throwing FeignExceptions.
+     * @return true if 404s will be decoded; false otherwise.
+     */
+    boolean decode404() default false;
+
+    /**
+     * Fallback class for the specified Feign client interface. The fallback class must
+     * implement the interface annotated by this annotation and be a valid Spring bean.
+     * @return the fallback class for the specified Feign client interface.
+     */
+    Class<?> fallback() default void.class;
+
+    /**
+     * Path prefix to be used by all method-level mappings.
+     * @return the path prefix to be used by all method-level mappings.
+     */
+    String path() default "";
+}

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;
+    }
+
+}