keycloak-pattern/bff/src/main/java/com/example/keycloakpattern/bff/BffController.java

package com.example.keycloakpattern.bff;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.CacheControl;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.Authentication;
import org.springframework.security.oauth2.client.OAuth2AuthorizeRequest;
import org.springframework.security.oauth2.client.OAuth2AuthorizedClient;
import org.springframework.security.oauth2.client.OAuth2AuthorizedClientManager;
import org.springframework.security.oauth2.client.OAuth2AuthorizedClientService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestClient;
import org.springframework.web.server.ResponseStatusException;

import static org.springframework.http.HttpStatus.UNAUTHORIZED;

@RestController
public class BffController {

    private final OAuth2AuthorizedClientService authorizedClientService;
    private final OAuth2AuthorizedClientManager authorizedClientManager;
    private final RestClient resourceApi;
    private final AtomicReference<String> theme = new AtomicReference<>("system");

    public BffController(
        OAuth2AuthorizedClientService authorizedClientService,
        OAuth2AuthorizedClientManager authorizedClientManager,
        RestClient.Builder restClientBuilder,
        @Value("${resource-api.base-url}") String resourceApiBaseUrl
    ) {
        this.authorizedClientService = authorizedClientService;
        this.authorizedClientManager = authorizedClientManager;
        this.resourceApi = restClientBuilder.baseUrl(resourceApiBaseUrl).build();
    }

    @GetMapping("/bff/token-boundary")
    ResponseEntity<Map<String, Object>> tokenBoundary(Authentication authentication) {
        OAuth2AuthorizedClient client = authorizedClientService.loadAuthorizedClient(
            "keycloak",
            authentication.getName()
        );

        Map<String, Object> response = new LinkedHashMap<>();
        response.put("pattern", "AP3-backend-for-frontend");
        response.put("principal", authentication.getName());
        response.put("accessTokenStoredOnServer", client != null
            && client.getAccessToken() != null);
        response.put("refreshTokenStoredOnServer", client != null
            && client.getRefreshToken() != null);
        response.put("browserTokenCount", 0);
        response.put("csrfProtectionEnabled", true);

        return ResponseEntity.ok()
            .cacheControl(CacheControl.noStore())
            .header("Pragma", "no-cache")
            .body(response);
    }

    @GetMapping("/bff/api/me")
    ResponseEntity<?> currentUser(Authentication authentication) {
        OAuth2AuthorizedClient client = authorizedClient(authentication);
        return resourceApi.get()
            .uri("/api/me")
            .header(
                HttpHeaders.AUTHORIZATION,
                "Bearer " + client.getAccessToken().getTokenValue()
            )
            .retrieve()
            .toEntity(Map.class);
    }

    @PostMapping("/bff/api/preferences")
    Map<String, Object> updatePreference(
        Authentication authentication,
        @RequestParam(defaultValue = "system") String theme
    ) {
        this.theme.set(theme);
        return Map.of(
            "updated", true,
            "theme", this.theme.get(),
            "principal", authentication.getName()
        );
    }

    @GetMapping("/bff/api/preferences")
    Map<String, String> preference() {
        return Map.of("theme", theme.get());
    }

    private OAuth2AuthorizedClient authorizedClient(Authentication authentication) {
        OAuth2AuthorizeRequest request = OAuth2AuthorizeRequest
            .withClientRegistrationId("keycloak")
            .principal(authentication)
            .build();
        OAuth2AuthorizedClient client = authorizedClientManager.authorize(request);
        if (client == null || client.getAccessToken() == null) {
            throw new ResponseStatusException(
                UNAUTHORIZED,
                "No authorized Keycloak client is available"
            );
        }
        return client;
    }
}