Client Interface

/**
 * Primary OIDC client interface for token grant operations
 */
public interface OidcClient extends Closeable {
    /**
     * Get access and refresh tokens using the configured grant type
     * @return Uni<Tokens> containing access and refresh tokens
     */
    Uni<Tokens> getTokens();
    
    /**
     * Get access and refresh tokens with additional grant parameters
     * @param additionalGrantParameters Additional parameters to include in the token request
     * @return Uni<Tokens> containing access and refresh tokens
     */
    Uni<Tokens> getTokens(Map<String, String> additionalGrantParameters);
    
    /**
     * Refresh access tokens using a refresh token
     * @param refreshToken The refresh token to use for obtaining new tokens
     * @return Uni<Tokens> containing new access and refresh tokens
     */
    Uni<Tokens> refreshTokens(String refreshToken);
    
    /**
     * Refresh access tokens using a refresh token with additional parameters
     * @param refreshToken The refresh token to use for obtaining new tokens
     * @param additionalGrantParameters Additional parameters to include in the refresh request
     * @return Uni<Tokens> containing new access and refresh tokens
     */
    Uni<Tokens> refreshTokens(String refreshToken, Map<String, String> additionalGrantParameters);
    
    /**
     * Revoke an access token
     * @param accessToken The access token to revoke
     * @return Uni<Boolean> true if the token has been revoked or found already invalidated,
     *         false if the token cannot be currently revoked
     */
    Uni<Boolean> revokeAccessToken(String accessToken);
    
    /**
     * Revoke an access token with additional parameters
     * @param accessToken The access token to revoke
     * @param additionalParameters Additional parameters to include in the revocation request
     * @return Uni<Boolean> true if the token has been revoked or found already invalidated,
     *         false if the token cannot be currently revoked
     */
    Uni<Boolean> revokeAccessToken(String accessToken, Map<String, String> additionalParameters);
}

import io.quarkus.oidc.client.OidcClient;
import io.quarkus.oidc.client.Tokens;
import jakarta.inject.Inject;

@ApplicationScoped
public class TokenService {
    
    @Inject
    OidcClient oidcClient;
    
    public void performTokenOperations() {
        // Basic token retrieval
        Uni<Tokens> tokens = oidcClient.getTokens();
        
        // Token retrieval with custom scope
        Map<String, String> params = Map.of("scope", "read write admin");
        Uni<Tokens> scopedTokens = oidcClient.getTokens(params);
        
        // Token refresh
        tokens.subscribe().with(tokenResult -> {
            String refreshToken = tokenResult.getRefreshToken();
            if (refreshToken != null) {
                Uni<Tokens> refreshedTokens = oidcClient.refreshTokens(refreshToken);
                // Handle refreshed tokens...
            }
        });
        
        // Token revocation
        tokens.subscribe().with(tokenResult -> {
            String accessToken = tokenResult.getAccessToken();
            Uni<Boolean> revocation = oidcClient.revokeAccessToken(accessToken);
            revocation.subscribe().with(revoked -> {
                if (revoked) {
                    System.out.println("Token revoked successfully");
                } else {
                    System.out.println("Token revocation failed, may need to retry");
                }
            });
        });
    }
}

/**
 * Factory interface for managing multiple OIDC client instances
 */
public interface OidcClients extends Closeable {
    /**
     * Get the default OIDC client
     * @return The default OidcClient instance
     */
    OidcClient getClient();
    
    /**
     * Get an OIDC client by its identifier
     * @param id The identifier of the client to retrieve
     * @return The OidcClient instance with the specified id
     */
    OidcClient getClient(String id);
    
    /**
     * Create a new OIDC client with the provided configuration
     * @param clientConfig The configuration for the new client
     * @return Uni<OidcClient> representing the asynchronously created client
     */
    Uni<OidcClient> newClient(OidcClientConfig clientConfig);
}

import io.quarkus.oidc.client.OidcClients;
import io.quarkus.oidc.client.OidcClient;
import io.quarkus.oidc.client.runtime.OidcClientConfig;
import jakarta.inject.Inject;

@ApplicationScoped
public class MultiClientService {
    
    @Inject
    OidcClients oidcClients;
    
    public void useMultipleClients() {
        // Use default client
        OidcClient defaultClient = oidcClients.getClient();
        Uni<Tokens> defaultTokens = defaultClient.getTokens();
        
        // Use named client (configured in application.properties)
        OidcClient authProviderClient = oidcClients.getClient("auth-provider");
        Uni<Tokens> authTokens = authProviderClient.getTokens();
        
        // Create new client programmatically
        OidcClientConfig config = OidcClientConfig.builder()
            .authServerUrl("https://my-provider.com/auth")
            .clientId("my-client")
            .clientSecret("my-secret")
            .build();
            
        Uni<OidcClient> newClient = oidcClients.newClient(config);
        newClient.subscribe().with(client -> {
            Uni<Tokens> tokens = client.getTokens();
            // Handle tokens...
        });
    }
}

/**
 * Exception thrown by OIDC client operations
 */
public class OidcClientException extends RuntimeException {
    public OidcClientException();
    public OidcClientException(String message);
    public OidcClientException(Throwable cause);
    public OidcClientException(String message, Throwable cause);
}

import io.quarkus.oidc.client.OidcClientException;

// Handle exceptions in reactive chains
oidcClient.getTokens()
    .subscribe().with(
        tokens -> {
            // Success - handle tokens
            String accessToken = tokens.getAccessToken();
        },
        failure -> {
            if (failure instanceof OidcClientException) {
                // Handle OIDC-specific errors
                System.err.println("OIDC error: " + failure.getMessage());
            } else {
                // Handle other errors
                System.err.println("Unexpected error: " + failure.getMessage());
            }
        }
    );