cipherstash-client 0.12.5

pub mod service_access_key_credentials;
pub mod service_token;
pub mod service_user_credentials;

use std::time::Duration;

use async_trait::async_trait;

pub use service_access_key_credentials::ServiceAccessKeyCredentials;
pub use service_token::ServiceToken;
pub use service_user_credentials::ServiceUserCredentials;

use crate::{config::ZeroKMSAuthConfig, ZeroKMSConfig};

use super::{
    user_credentials::UserCredentials, AutoRefreshable, ClearTokenError, Credentials, GetTokenError,
};

pub enum ServiceCredentials {
    AccessKey(ServiceAccessKeyCredentials),
    ConsoleAuth(ServiceUserCredentials<UserCredentials>),
}

impl ServiceCredentials {
    pub fn build<T>(config: &ZeroKMSConfig<T>) -> Self {
        match config.auth_config() {
            ZeroKMSAuthConfig::AccessKey {
                access_key,
                cts_config,
            } => {
                let creds = ServiceAccessKeyCredentials::new(
                    &config.token_path(),
                    access_key,
                    &cts_config.base_url(),
                    None,
                );
                ServiceCredentials::AccessKey(creds)
            }
            ZeroKMSAuthConfig::UserAuth {
                console_config,
                cts_config,
            } => {
                let creds = ServiceUserCredentials::new(
                    &config.token_path(),
                    console_config.credentials(),
                    &cts_config.base_url(),
                    config.workspace_id(),
                );
                ServiceCredentials::ConsoleAuth(creds)
            }
        }
    }
}

#[async_trait]
impl Credentials for ServiceCredentials {
    type Token = ServiceToken;

    async fn get_token(&self) -> Result<Self::Token, GetTokenError> {
        match self {
            ServiceCredentials::AccessKey(ak) => ak.get_token().await,
            ServiceCredentials::ConsoleAuth(c) => c.get_token().await,
        }
    }

    async fn clear_token(&self) -> Result<(), ClearTokenError> {
        match self {
            ServiceCredentials::AccessKey(ak) => ak.clear_token().await,
            ServiceCredentials::ConsoleAuth(c) => c.clear_token().await,
        }
    }
}

#[async_trait]
impl AutoRefreshable for ServiceCredentials {
    async fn refresh(&self) -> Duration {
        match self {
            ServiceCredentials::AccessKey(ak) => ak.refresh().await,
            ServiceCredentials::ConsoleAuth(c) => c.refresh().await,
        }
    }
}