use core::{marker::PhantomData, str::FromStr};
use bson::{Bson, Document, doc};
use mongodb::Database;
use smol_bytes::Utf8Bytes;
use crate::{
Timestamp,
drive::registry::{RetireOrigin, RootKey},
};
use super::{Landing, RetiredRow, RetiredStore, RetiredStoreError, RetiredTable, UnnameableFamily};
const ID: &str = "_id";
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct MalformedField;
impl core::fmt::Display for MalformedField {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str("the field is absent or holds a type the ledger does not write")
}
}
impl core::error::Error for MalformedField {}
pub struct MongoRetired<Root> {
database: Database,
table: RetiredTable,
root: PhantomData<fn() -> Root>,
}
impl<Root> core::fmt::Debug for MongoRetired<Root> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("MongoRetired")
.field("collection", &self.table.name())
.finish_non_exhaustive()
}
}
impl<Root> Clone for MongoRetired<Root> {
fn clone(&self) -> Self {
Self {
database: self.database.clone(),
table: self.table.clone(),
root: PhantomData,
}
}
}
impl<Root> MongoRetired<Root> {
pub fn new(database: Database, family: impl Into<Utf8Bytes>) -> Result<Self, UnnameableFamily> {
Ok(Self {
database,
table: RetiredTable::new(family)?,
root: PhantomData,
})
}
#[inline]
#[must_use]
pub const fn table(&self) -> &RetiredTable {
&self.table
}
fn collection(&self) -> mongodb::Collection<Document> {
self.database.collection::<Document>(self.table.name())
}
fn refuse(&self, verb: &'static str, source: mongodb::error::Error) -> RetiredStoreError {
RetiredStoreError::new(verb, self.table.named(), source)
}
}
impl<Root> RetiredStore<Root> for MongoRetired<Root>
where
Root: RootKey + core::fmt::Display + FromStr,
<Root as FromStr>::Err: core::error::Error + Send + Sync + 'static,
{
fn ready(&self) -> Landing<'_, ()> {
Box::pin(core::future::ready(Ok(())))
}
fn record<'a>(&'a self, row: &'a RetiredRow<Root>) -> Landing<'a, ()> {
Box::pin(async move {
let filter = doc! { ID: row.key().to_string() };
let update = doc! {
"$set": { RetiredTable::ORIGIN: row.origin().as_str() },
"$setOnInsert": {
RetiredTable::RETIRED_SECOND: row.at().as_second(),
RetiredTable::RETIRED_NANOSECOND: row.at().subsec_nanosecond(),
RetiredTable::LATE_TAILS: row.late_tails(),
},
};
self
.collection()
.update_one(filter, update)
.upsert(true)
.await
.map(|_written| ())
.map_err(|source| self.refuse("record", source))
})
}
fn erase<'a>(&'a self, key: &'a Root) -> Landing<'a, ()> {
Box::pin(async move {
self
.collection()
.delete_one(doc! { ID: key.to_string() })
.await
.map(|_gone| ())
.map_err(|source| self.refuse("erase", source))
})
}
fn roll(&self) -> Landing<'_, Vec<RetiredRow<Root>>> {
Box::pin(async move {
let mut cursor = self
.collection()
.find(doc! {})
.await
.map_err(|source| self.refuse("roll", source))?;
let mut rows = Vec::new();
while cursor
.advance()
.await
.map_err(|source| self.refuse("roll", source))?
{
let document = cursor
.deserialize_current()
.map_err(|source| self.refuse("roll", source))?;
rows.push(self.read(&document)?);
}
Ok(rows)
})
}
}
impl<Root> MongoRetired<Root>
where
Root: RootKey + core::fmt::Display + FromStr,
<Root as FromStr>::Err: core::error::Error + Send + Sync + 'static,
{
fn read(&self, document: &Document) -> Result<RetiredRow<Root>, RetiredStoreError> {
let key = self.text(document, ID)?;
let key = Root::from_str(&key).map_err(|refusal| self.malformed(ID, refusal))?;
let second = self.integer(document, RetiredTable::RETIRED_SECOND)?;
let nanosecond = self.integer(document, RetiredTable::RETIRED_NANOSECOND)?;
let nanosecond = i32::try_from(nanosecond)
.map_err(|refusal| self.malformed(RetiredTable::RETIRED_NANOSECOND, refusal))?;
let at = Timestamp::from_parts(second, nanosecond)
.map_err(|refusal| self.malformed(RetiredTable::RETIRED_SECOND, refusal))?;
let origin = self.text(document, RetiredTable::ORIGIN)?;
let late_tails = document
.get_bool(RetiredTable::LATE_TAILS)
.map_err(|refusal| self.malformed(RetiredTable::LATE_TAILS, refusal))?;
Ok(RetiredRow::new(
key,
at,
RetireOrigin::from(origin),
late_tails,
))
}
fn text(&self, document: &Document, field: &'static str) -> Result<String, RetiredStoreError> {
document
.get_str(field)
.map(ToOwned::to_owned)
.map_err(|refusal| self.malformed(field, refusal))
}
fn integer(&self, document: &Document, field: &'static str) -> Result<i64, RetiredStoreError> {
match document.get(field) {
Some(Bson::Int64(value)) => Ok(*value),
Some(Bson::Int32(value)) => Ok(i64::from(*value)),
_ => Err(self.malformed(field, MalformedField)),
}
}
fn malformed(
&self,
field: &'static str,
source: impl core::error::Error + Send + Sync + 'static,
) -> RetiredStoreError {
RetiredStoreError::new(
"roll",
Utf8Bytes::from(format!("{table}.{field}", table = self.table.name())),
source,
)
}
}