Struct mongodm::repository::Repository

pub struct Repository<M: Model> { /* fields omitted */ }

Associate a mongodb::Collection and a specific Model.

This type can safely be copied and passed around because std::sync::Arc is used internally. Underlying mongodb::Collection can be retrieved at anytime with Repository::get_underlying.

Implementations

impl<M: Model> Repository<M>

pub fn new(db: Database) -> Self

Create a new repository from the given mongo client.

pub fn new_with_options(db: Database, options: CollectionOptions) -> Self

Create a new repository with associated collection options (override Model::coll_options).

pub fn collection_name(&self) -> &'static str

Returns associated M::collection_name.

pub fn get_underlying(&self) -> Collection

Returns underlying mongodb::Collection.

pub fn cast_model<OtherModel>(self) -> Repository<OtherModel> where
    OtherModel: Model<CollConf = M::CollConf>, 

Convert this repository to use another Model. Only compiles if both Model::CollConf are identicals.

Example

use mongodm::{ToRepository, Model, CollectionConfig};
use mongodm::mongo::bson::doc;
use mongodm::f;
use serde::{Serialize, Deserialize};

struct UserCollConf;

impl CollectionConfig for UserCollConf {
    fn collection_name() -> &'static str {
        "cast_model"
    }
}

// Latest schema currently in use
#[derive(Serialize, Deserialize)]
struct User {
    username: String,
    last_seen: i64,
}

impl Model for User {
    type CollConf = UserCollConf;
}

// Old schema
#[derive(Serialize, Deserialize)]
struct UserV1 {
    name: String,
    ls: i64,
}

// Versionned version of our `User`
#[derive(Serialize, Deserialize)]
#[serde(untagged)]
enum UserVersionned {
    Last(User),
    V1(UserV1),
}

impl Model for UserVersionned {
    type CollConf = UserCollConf; // same as the non-versionned version
}

// We have some repository for `User`
let repo = db.repository::<User>();

// Assume the following document is stored: { "name": "Bernard", "ls": 1500 }

// Following query should fails because the schema doesn't match
let err = repo.find_one(doc!{ f!(name in UserV1): "Bernard" }, None).await.err().unwrap();
assert_eq!(err.to_string(), "missing field `username`"); // serde deserialization error

// We can get a repository for `UserVersionned` from our `Repository<User>`
// because `User::CollConf` == `UserVersionned::CollConf`
let repo_versionned = repo.cast_model::<UserVersionned>();

// Our versionned model should match with the document
let ret = repo_versionned.find_one(doc!{ f!(name in UserV1): "Bernard" }, None).await?;
match ret {
    Some(UserVersionned::V1(UserV1 { name, ls: 1500 })) if name == "Bernard" => { /* success */ }
    _ => panic!("Expected document was missing"),
}

Following code will fail to compile because CollectionConfig doesn’t match.

use mongodm::{ToRepository, Model, CollectionConfig};
use serde::{Serialize, Deserialize};

struct ACollConf;

impl CollectionConfig for ACollConf {
    fn collection_name() -> &'static str { "a" }
}

#[derive(Serialize, Deserialize)]
struct A;

impl Model for A {
    type CollConf = ACollConf;
}

struct BCollConf;

impl CollectionConfig for BCollConf {
    fn collection_name() -> &'static str { "B" }
}

#[derive(Serialize, Deserialize)]
struct B;

impl Model for B {
    type CollConf = BCollConf;
}

// Doesn't compile because `A` and `B` doesn't share the same `CollectionConfig`.
db.repository::<A>().cast_model::<B>();

pub async fn drop(
    &self,
    options: impl Into<Option<DropCollectionOptions>>
) -> Result<()>

Drops the underlying collection, deleting all data, users, and indexes stored inside.

pub async fn aggregate(
    &self,
    pipeline: impl IntoIterator<Item = Document>,
    options: impl Into<Option<AggregateOptions>>
) -> Result<ModelCursor<M>>

Runs an aggregation operation.

Mongo manual

pub async fn estimated_document_count(
    &self,
    options: impl Into<Option<EstimatedDocumentCountOptions>>
) -> Result<i64>

Estimates the number of documents in the collection using collection metadata.

pub async fn count_documents(
    &self,
    filter: impl Into<Option<Document>>,
    options: impl Into<Option<CountOptions>>
) -> Result<i64>

Gets the number of documents matching filter.

Note that using Repository::estimated_document_count is recommended instead of this method is most cases.

pub async fn delete_many(
    &self,
    query: Document,
    options: impl Into<Option<DeleteOptions>>
) -> Result<DeleteResult>

Deletes all documents stored in the collection matching query.

pub async fn delete_one(
    &self,
    query: Document,
    options: impl Into<Option<DeleteOptions>>
) -> Result<DeleteResult>

Deletes up to one document found matching query.

pub async fn distinct(
    &self,
    field_name: &str,
    filter: impl Into<Option<Document>>,
    options: impl Into<Option<DistinctOptions>>
) -> Result<Vec<M>>

Finds the distinct values of the field specified by field_name across the collection.

pub async fn find(
    &self,
    filter: impl Into<Option<Document>>,
    options: impl Into<Option<FindOptions>>
) -> Result<ModelCursor<M>>

Finds the documents in the collection matching filter.

pub async fn find_one(
    &self,
    filter: impl Into<Option<Document>>,
    options: impl Into<Option<FindOneOptions>>
) -> Result<Option<M>>

Finds a single document in the collection matching filter.

pub async fn find_one_and_delete(
    &self,
    filter: Document,
    options: impl Into<Option<FindOneAndDeleteOptions>>
) -> Result<Option<M>>

Atomically finds up to one document in the collection matching filter and deletes it.

pub async fn find_one_and_replace(
    &self,
    filter: Document,
    replacement: &M,
    options: impl Into<Option<FindOneAndReplaceOptions>>
) -> Result<Option<M>>

Atomically finds up to one document in the collection matching filter and replaces it with replacement.

pub async fn find_one_and_update(
    &self,
    filter: Document,
    update: impl Into<UpdateModifications>,
    options: impl Into<Option<FindOneAndUpdateOptions>>
) -> Result<Option<M>>

Atomically finds up to one model in the collection matching filter and updates it.

Both Document and Vec<Document> implement Into<UpdateModifications>, so either can be passed in place of constructing the enum case. Note: pipeline updates are only supported in MongoDB 4.2+.

pub async fn insert_many(
    &self,
    models: impl IntoIterator<Item = M>,
    options: impl Into<Option<InsertManyOptions>>
) -> Result<InsertManyResult>

Inserts the models into the collection.

pub async fn insert_one(
    &self,
    model: &M,
    options: impl Into<Option<InsertOneOptions>>
) -> Result<InsertOneResult>

Inserts model M into the collection.

pub async fn replace_one(
    &self,
    query: Document,
    replacement: &M,
    options: impl Into<Option<ReplaceOptions>>
) -> Result<UpdateResult>

Replaces up to one document matching query in the collection with replacement.

pub async fn update_many(
    &self,
    query: Document,
    update: impl Into<UpdateModifications>,
    options: impl Into<Option<UpdateOptions>>
) -> Result<UpdateResult>

Updates all documents matching query in the collection.

Both Document and Vec<Document> implement Into<UpdateModifications>, so either can be passed in place of constructing the enum case. Note: pipeline updates are only supported in MongoDB 4.2+. See the official MongoDB documentation for more information on specifying updates.

pub async fn update_one(
    &self,
    query: Document,
    update: impl Into<UpdateModifications>,
    options: impl Into<Option<UpdateOptions>>
) -> Result<UpdateResult>

Updates up to one document matching query in the collection.

Both Document and Vec<Document> implement Into<UpdateModifications>, so either can be passed in place of constructing the enum case. Note: pipeline updates are only supported in MongoDB 4.2+. See the official MongoDB documentation for more information on specifying updates.

Trait Implementations

impl<M: Model> Clone for Repository<M>

fn clone(&self) -> Self

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<M: Debug + Model> Debug for Repository<M>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.