signer-daemon 0.3.1

use chrono::Duration;
use signer_core::{SignerJWT, SignerJWTClaims, SignerJWTHeader, SignerUser};
use signer_hub_kit::apis::configuration::{ApiKey, Configuration};

#[derive(Clone)]
pub struct OpenapiConfiguration {
  base_path: String,
  auth: Option<OpenapiConfigurationAuth>,
}

#[derive(Debug, Clone)]
struct OpenapiConfigurationAuth {
  user: SignerUser,
  expire_duration: Duration,
}

impl OpenapiConfiguration {
  pub fn new(user: SignerUser, base_path: String) -> Self {
    Self {
      base_path,
      auth: Some(OpenapiConfigurationAuth {
        user,
        expire_duration: Duration::minutes(5),
      }),
    }
  }

  pub fn new_no_auth(base_path: String) -> Self {
    Self {
      base_path,
      auth: None,
    }
  }

  pub fn with_base_path(&self, base_path: String) -> Self {
    let mut new_config = self.clone();
    new_config.base_path = base_path;
    new_config
  }

  pub fn expire(mut self, expire_duration: Duration) -> Self {
    if let Some(auth) = &mut self.auth {
      auth.expire_duration = expire_duration;
    }
    self
  }

  pub fn build(&self) -> Configuration {
    let api_key = if let Some(auth) = &self.auth {
      let jwt = SignerJWT::new(
        SignerJWTHeader::default(&auth.user),
        SignerJWTClaims::default(
          &auth.user,
          self.base_path.clone(),
          uuid::Uuid::new_v4().to_string(),
        )
        .with_expired_duration(auth.expire_duration),
      )
      .encode(&auth.user)
      .expect("encode jwt string failed");

      Some(ApiKey {
        prefix: Some("Bearer".into()),
        key: jwt,
      })
    } else {
      None
    };

    Configuration {
      base_path: self.base_path.clone(),
      user_agent: Some("SignerDaemon Client v0.3.1".into()),
      api_key,
      ..Default::default()
    }
  }
}