use std::sync::Arc;
use url::Url;
use crate::datasets::DatasetService;
use crate::errors::Result;
use crate::ingestion::IngestionService;
use crate::intelligence::{AskOptions, AskStream, IntelligenceService};
use crate::schedules::ScheduleService;
use crate::secrets::OrgSecretService;
use crate::transport::{Dispatcher, RestTransport, Transport};
use crate::types::AskResponse;
use crate::{DEFAULT_BASE_URL, USER_AGENT};
#[derive(Clone)]
pub struct Client {
inner: Arc<Inner>,
}
pub(crate) struct Inner {
pub(crate) dispatcher: Dispatcher,
}
impl Client {
pub fn new<S: Into<String>>(api_key: S) -> Self {
Self::builder()
.api_key(api_key)
.build()
.expect("default client construction is infallible")
}
pub fn builder() -> ClientBuilder {
ClientBuilder::default()
}
pub fn datasets(&self) -> DatasetService {
DatasetService::new(self.clone())
}
pub fn ingestion(&self) -> IngestionService {
IngestionService::new(self.clone())
}
pub fn sources(&self) -> IngestionService {
self.ingestion()
}
pub fn schedules(&self) -> ScheduleService {
ScheduleService::new(self.clone())
}
pub fn org_secrets(&self) -> OrgSecretService {
OrgSecretService::new(self.clone())
}
pub fn intelligence(&self) -> IntelligenceService {
IntelligenceService::new(self.clone())
}
pub async fn ask<S: Into<String>>(&self, query: S) -> Result<AskResponse> {
self.intelligence().ask(query.into()).await
}
pub async fn ask_with<S: Into<String>>(
&self,
query: S,
options: AskOptions,
) -> Result<AskResponse> {
self.intelligence().ask_with(query.into(), options).await
}
pub async fn ask_stream<S: Into<String>>(&self, query: S) -> Result<AskStream> {
self.intelligence()
.stream(query.into(), AskOptions::default())
.await
}
pub(crate) fn dispatcher(&self) -> &Dispatcher {
&self.inner.dispatcher
}
}
#[derive(Default)]
pub struct ClientBuilder {
api_key: Option<String>,
base_url: Option<String>,
user_agent: Option<String>,
http_client: Option<reqwest::Client>,
transport: Option<Arc<dyn Transport>>,
}
impl ClientBuilder {
pub fn api_key<S: Into<String>>(mut self, api_key: S) -> Self {
self.api_key = Some(api_key.into());
self
}
pub fn base_url<S: Into<String>>(mut self, base_url: S) -> Self {
self.base_url = Some(base_url.into());
self
}
pub fn user_agent<S: Into<String>>(mut self, user_agent: S) -> Self {
self.user_agent = Some(user_agent.into());
self
}
pub fn http_client(mut self, client: reqwest::Client) -> Self {
self.http_client = Some(client);
self
}
pub fn transport(mut self, transport: Arc<dyn Transport>) -> Self {
self.transport = Some(transport);
self
}
pub fn build(self) -> Result<Client> {
let api_key = self.api_key.unwrap_or_default();
let user_agent = self.user_agent.unwrap_or_else(|| USER_AGENT.to_owned());
let transport: Arc<dyn Transport> = if let Some(t) = self.transport {
t
} else {
let raw = self.base_url.unwrap_or_else(|| DEFAULT_BASE_URL.to_owned());
let trimmed = raw.trim_end_matches('/').to_owned();
let url = Url::parse(&trimmed)?;
let mut rest = RestTransport::new(url, api_key, user_agent)?;
if let Some(http) = self.http_client {
rest = rest.with_http_client(http);
}
Arc::new(rest)
};
Ok(Client {
inner: Arc::new(Inner {
dispatcher: Dispatcher::new(transport),
}),
})
}
}