use crate::Collection;
use crate::query::SortOrder;
use crate::query::list::{ListData, ListQuery};
use crate::query::paginated::{PaginatedData, PaginatedQuery};
use crate::utils::parse_object_id;
use async_trait::async_trait;
use mongodb::bson::{Document, doc, oid::ObjectId};
use mongodb::options::{FindOneAndUpdateOptions, FindOptions, ReturnDocument, UpdateOptions};
#[async_trait]
pub trait CollectionRepository: Collection + Clone + Send + Sync + Unpin
where
Self: serde::Serialize + for<'de> serde::Deserialize<'de>,
{
async fn create(
db: &mongodb::Database,
document: &Self,
) -> Result<Self, mongodb::error::Error> {
let collection = Self::collection(db);
collection.insert_one(document).await?;
Ok(document.clone())
}
async fn create_many(
db: &mongodb::Database,
documents: Vec<Self>,
) -> Result<Vec<Self>, mongodb::error::Error> {
let collection = Self::collection(db);
collection.insert_many(&documents).await?;
Ok(documents)
}
async fn find_by_id(
db: &mongodb::Database,
id: &str,
) -> Result<Option<Self>, mongodb::error::Error> {
let collection = Self::collection(db);
let oid = parse_object_id(id)?;
collection.find_one(doc! { "_id": oid }).await
}
async fn find_one(
db: &mongodb::Database,
filter: Document,
) -> Result<Option<Self>, mongodb::error::Error> {
let collection = Self::collection(db);
collection.find_one(filter).await
}
async fn find_many(
db: &mongodb::Database,
filter: Document,
options: Option<FindOptions>,
) -> Result<Vec<Self>, mongodb::error::Error> {
let collection = Self::collection(db);
let mut cursor = match options {
None => collection.find(filter).await?,
Some(options) => collection.find(filter).with_options(options).await?,
};
let mut results = Vec::new();
use futures::TryStreamExt;
while let Some(doc) = cursor.try_next().await? {
results.push(doc);
}
Ok(results)
}
async fn find_all(db: &mongodb::Database) -> Result<Vec<Self>, mongodb::error::Error> {
Self::find_many(db, doc! {}, None).await
}
async fn find_paginated(
db: &mongodb::Database,
filter: Document,
query: &PaginatedQuery,
) -> Result<PaginatedData<Self>, mongodb::error::Error> {
let collection = Self::collection(db);
let total_count = collection.count_documents(filter.clone()).await?;
let sort_doc = if let Some(ref sort_by) = query.sort_by {
let sort_value = match query.sort_order {
SortOrder::Asc => 1,
SortOrder::Desc => -1,
};
doc! { sort_by: sort_value }
} else {
doc! { "_id": -1 } };
let find_options = FindOptions::builder()
.skip(query.skip())
.limit(query.limit())
.sort(sort_doc)
.build();
let items = Self::find_many(db, filter, Some(find_options)).await?;
let total_pages = (total_count as f64 / query.page_size as f64).ceil() as u64;
Ok(PaginatedData {
items,
total_count,
page: query.page,
page_size: query.page_size,
total_pages,
})
}
async fn find_list(
db: &mongodb::Database,
filter: Document,
query: &ListQuery,
) -> Result<ListData<Self>, mongodb::error::Error> {
let collection = Self::collection(db);
let total_count = collection.count_documents(filter.clone()).await?;
let sort_doc = if let Some(ref sort_by) = query.sort_by {
let sort_value = match query.sort_order {
SortOrder::Asc => 1,
SortOrder::Desc => -1,
};
doc! { sort_by: sort_value }
} else {
doc! { "_id": -1 } };
let find_options = FindOptions::builder().sort(sort_doc).build();
let items = Self::find_many(db, filter, Some(find_options)).await?;
Ok(ListData { items, total_count })
}
async fn count(db: &mongodb::Database, filter: Document) -> Result<u64, mongodb::error::Error> {
let collection = Self::collection(db);
collection.count_documents(filter).await
}
async fn exists(
db: &mongodb::Database,
filter: Document,
) -> Result<bool, mongodb::error::Error> {
Ok(Self::find_one(db, filter).await?.is_some())
}
async fn update_by_id(
db: &mongodb::Database,
id: &str,
update: Document,
) -> Result<bool, mongodb::error::Error> {
let collection = Self::collection(db);
let oid = parse_object_id(id)?;
let result = collection.update_one(doc! { "_id": oid }, update).await?;
Ok(result.modified_count > 0)
}
async fn update_one(
db: &mongodb::Database,
filter: Document,
update: Document,
) -> Result<bool, mongodb::error::Error> {
let collection = Self::collection(db);
let result = collection.update_one(filter, update).await?;
Ok(result.modified_count > 0)
}
async fn update_many(
db: &mongodb::Database,
filter: Document,
update: Document,
) -> Result<u64, mongodb::error::Error> {
let collection = Self::collection(db);
let result = collection.update_many(filter, update).await?;
Ok(result.modified_count)
}
async fn update_by_ids(
db: &mongodb::Database,
ids: &[String],
update: Document,
) -> Result<u64, mongodb::error::Error> {
use crate::utils::parse_object_ids;
let oids = parse_object_ids(ids)?;
let filter = doc! { "_id": { "$in": oids } };
Self::update_many(db, filter, update).await
}
async fn find_one_and_update(
db: &mongodb::Database,
filter: Document,
update: Document,
) -> Result<Option<Self>, mongodb::error::Error> {
let collection = Self::collection(db);
collection.find_one_and_update(filter, update).await
}
async fn upsert_by_id(
db: &mongodb::Database,
id: &str,
upsert: Document,
) -> Result<Option<ObjectId>, mongodb::error::Error> {
let collection = Self::collection(db);
let oid = parse_object_id(id)?;
let options = UpdateOptions::builder().upsert(true).build();
let result = collection
.update_one(doc! { "_id": oid }, upsert)
.with_options(options)
.await?;
Ok(result.upserted_id.and_then(|bson| bson.as_object_id()))
}
async fn upsert_one(
db: &mongodb::Database,
filter: Document,
upsert: Document,
) -> Result<Option<ObjectId>, mongodb::error::Error> {
let collection = Self::collection(db);
let options = UpdateOptions::builder().upsert(true).build();
let result = collection
.update_one(filter, upsert)
.with_options(options)
.await?;
Ok(result.upserted_id.and_then(|bson| bson.as_object_id()))
}
async fn find_one_and_upsert(
db: &mongodb::Database,
filter: Document,
upsert: Document,
) -> Result<Option<Self>, mongodb::error::Error> {
let collection = Self::collection(db);
let options = FindOneAndUpdateOptions::builder()
.upsert(true)
.return_document(ReturnDocument::After)
.build();
collection
.find_one_and_update(filter, upsert)
.with_options(options)
.await
}
async fn delete_by_id(db: &mongodb::Database, id: &str) -> Result<bool, mongodb::error::Error> {
let collection = Self::collection(db);
let oid = parse_object_id(id)?;
let result = collection.delete_one(doc! { "_id": oid }).await?;
Ok(result.deleted_count > 0)
}
async fn delete_one(
db: &mongodb::Database,
filter: Document,
) -> Result<bool, mongodb::error::Error> {
let collection = Self::collection(db);
let result = collection.delete_one(filter).await?;
Ok(result.deleted_count > 0)
}
async fn delete_many(
db: &mongodb::Database,
filter: Document,
) -> Result<u64, mongodb::error::Error> {
let collection = Self::collection(db);
let result = collection.delete_many(filter).await?;
Ok(result.deleted_count)
}
async fn delete_by_ids(
db: &mongodb::Database,
ids: &[String],
) -> Result<u64, mongodb::error::Error> {
use crate::utils::parse_object_ids;
let oids = parse_object_ids(ids)?;
let filter = doc! { "_id": { "$in": oids } };
Self::delete_many(db, filter).await
}
async fn find_one_and_delete(
db: &mongodb::Database,
filter: Document,
) -> Result<Option<Self>, mongodb::error::Error> {
let collection = Self::collection(db);
collection.find_one_and_delete(filter).await
}
fn aggregate() -> crate::aggregate::AggregateBuilder<Self> {
crate::aggregate::AggregateBuilder::new()
}
}