use std::collections::HashMap;
use std::fmt;
use std::future::Future;
use std::sync::Arc;
use futures::future::BoxFuture;
use super::{Credential, CredentialSource};
use crate::error::LlmError;
type CredentialFn = dyn Fn(String) -> BoxFuture<'static, Result<Credential, LlmError>> + Send + Sync;
type InvalidateFn = dyn Fn(&str) + Send + Sync;
#[derive(Clone)]
pub struct FnCredentials {
fetch: Arc<CredentialFn>,
on_invalidate: Option<Arc<InvalidateFn>>,
}
impl FnCredentials {
pub fn new<F, Fut>(fetch: F) -> Self
where
F: Fn(String) -> Fut + Send + Sync + 'static,
Fut: Future<Output = Result<Credential, LlmError>> + Send + 'static,
{
Self { fetch: Arc::new(move |provider| Box::pin(fetch(provider))), on_invalidate: None }
}
pub fn on_invalidate<F>(mut self, f: F) -> Self
where
F: Fn(&str) + Send + Sync + 'static,
{
self.on_invalidate = Some(Arc::new(f));
self
}
}
impl fmt::Debug for FnCredentials {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("FnCredentials")
}
}
impl CredentialSource for FnCredentials {
fn credential<'a>(&'a self, provider: &'a str) -> BoxFuture<'a, Result<Credential, LlmError>> {
(self.fetch)(provider.to_owned())
}
fn invalidate(&self, provider: &str) {
if let Some(f) = &self.on_invalidate {
f(provider);
}
}
}
#[derive(Clone, Debug, Default)]
pub struct EnvCredentials {
vars: HashMap<String, String>,
}
impl EnvCredentials {
pub fn new() -> Self {
Self::default()
}
pub fn var(mut self, provider: impl Into<String>, var: impl Into<String>) -> Self {
self.vars.insert(provider.into(), var.into());
self
}
}
impl CredentialSource for EnvCredentials {
fn credential<'a>(&'a self, provider: &'a str) -> BoxFuture<'a, Result<Credential, LlmError>> {
let result = match self.vars.get(provider).or_else(|| self.vars.get("*")) {
None => Err(LlmError::Config(format!("no environment variable configured for provider `{provider}`"))),
Some(var) => match std::env::var(var) {
Ok(value) if !value.is_empty() => Ok(Credential::new(value)),
_ => Err(LlmError::Auth(format!("environment variable `{var}` is not set"))),
},
};
Box::pin(futures::future::ready(result))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn fn_credentials_pass_provider_name() {
let source = FnCredentials::new(|p: String| async move { Ok(Credential::new(format!("k-{p}"))) });
let c = source.credential("openai").await.unwrap();
assert_eq!(c.secret, "k-openai");
}
#[tokio::test]
async fn env_credentials_report_missing_variable_by_name() {
let source = EnvCredentials::new().var("openai", "GRAPHRT_TEST_DEFINITELY_UNSET_VAR");
let err = source.credential("openai").await.unwrap_err();
assert!(err.to_string().contains("GRAPHRT_TEST_DEFINITELY_UNSET_VAR"));
let err = source.credential("other").await.unwrap_err();
assert!(matches!(err, LlmError::Config(_)));
}
}