use std::fmt::Debug;
use std::sync::Arc;
use http::StatusCode;
use log::debug;
use super::core::*;
use super::error::parse_error;
use super::writer::*;
use crate::raw::*;
use crate::services::supabase::reader::SupabaseReader;
use crate::*;
#[doc = include_str!("docs.md")]
#[derive(Default)]
pub struct SupabaseBuilder {
root: Option<String>,
bucket: String,
endpoint: Option<String>,
key: Option<String>,
http_client: Option<HttpClient>,
}
impl Debug for SupabaseBuilder {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SupabaseBuilder")
.field("root", &self.root)
.field("bucket", &self.bucket)
.field("endpoint", &self.endpoint)
.finish_non_exhaustive()
}
}
impl SupabaseBuilder {
pub fn root(&mut self, root: &str) -> &mut Self {
self.root = if root.is_empty() {
None
} else {
Some(root.to_string())
};
self
}
pub fn bucket(&mut self, bucket: &str) -> &mut Self {
self.bucket = bucket.to_string();
self
}
pub fn endpoint(&mut self, endpoint: &str) -> &mut Self {
self.endpoint = if endpoint.is_empty() {
None
} else {
Some(endpoint.trim_end_matches('/').to_string())
};
self
}
pub fn key(&mut self, key: &str) -> &mut Self {
self.key = Some(key.to_string());
self
}
pub fn http_client(&mut self, client: HttpClient) -> &mut Self {
self.http_client = Some(client);
self
}
}
impl Builder for SupabaseBuilder {
const SCHEME: Scheme = Scheme::Supabase;
type Accessor = SupabaseBackend;
fn from_map(map: std::collections::HashMap<String, String>) -> Self {
let mut builder = SupabaseBuilder::default();
map.get("root").map(|v| builder.root(v));
map.get("bucket").map(|v| builder.bucket(v));
map.get("endpoint").map(|v| builder.endpoint(v));
map.get("key").map(|v| builder.key(v));
builder
}
fn build(&mut self) -> Result<Self::Accessor> {
let root = normalize_root(&self.root.take().unwrap_or_default());
debug!("backend use root {}", &root);
let bucket = &self.bucket;
let endpoint = self.endpoint.take().unwrap_or_default();
let http_client = if let Some(client) = self.http_client.take() {
client
} else {
HttpClient::new().map_err(|err| {
err.with_operation("Builder::build")
.with_context("service", Scheme::Supabase)
})?
};
let key = self.key.as_ref().map(|k| k.to_owned());
let core = SupabaseCore::new(&root, bucket, &endpoint, key, http_client);
let core = Arc::new(core);
Ok(SupabaseBackend { core })
}
}
#[derive(Debug)]
pub struct SupabaseBackend {
core: Arc<SupabaseCore>,
}
impl Access for SupabaseBackend {
type Reader = SupabaseReader;
type Writer = oio::OneShotWriter<SupabaseWriter>;
type Lister = ();
type BlockingReader = ();
type BlockingWriter = ();
type BlockingLister = ();
fn info(&self) -> AccessorInfo {
let mut am = AccessorInfo::default();
am.set_scheme(Scheme::Supabase)
.set_root(&self.core.root)
.set_name(&self.core.bucket)
.set_native_capability(Capability {
stat: true,
read: true,
write: true,
delete: true,
..Default::default()
});
am
}
async fn stat(&self, path: &str, _args: OpStat) -> Result<RpStat> {
let mut resp = self.core.supabase_head_object(path).await?;
match resp.status() {
StatusCode::OK => parse_into_metadata(path, resp.headers()).map(RpStat::new),
_ => {
resp = self.core.supabase_get_object_info(path).await?;
match resp.status() {
StatusCode::NOT_FOUND if path.ends_with('/') => {
Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
}
_ => Err(parse_error(resp).await?),
}
}
}
}
async fn read(&self, path: &str, args: OpRead) -> Result<(RpRead, Self::Reader)> {
Ok((
RpRead::default(),
SupabaseReader::new(self.core.clone(), path, args),
))
}
async fn write(&self, path: &str, args: OpWrite) -> Result<(RpWrite, Self::Writer)> {
Ok((
RpWrite::default(),
oio::OneShotWriter::new(SupabaseWriter::new(self.core.clone(), path, args)),
))
}
async fn delete(&self, path: &str, _: OpDelete) -> Result<RpDelete> {
let resp = self.core.supabase_delete_object(path).await?;
if resp.status().is_success() {
Ok(RpDelete::default())
} else {
let e = parse_error(resp).await?;
if e.kind() == ErrorKind::NotFound {
Ok(RpDelete::default())
} else {
Err(e)
}
}
}
}