Struct MongoStore 

pub struct MongoStore { /* private fields */ }

A reusable MongoDB client and selected database.

Implementations

impl MongoStore

pub async fn connect(config: MongoStoreConfig) -> Result<Self, MongoStoreError>

Examples found in repository

examples/external_stores.rs (line 15)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let redis_url = env::var("REDIS_URL").unwrap_or_else(|_| "redis://127.0.0.1/".to_owned());
    let mongo_url =
        env::var("MONGODB_URI").unwrap_or_else(|_| "mongodb://127.0.0.1:27017".to_owned());
    let sqlite_url = env::var("DATABASE_URL").unwrap_or_else(|_| "sqlite::memory:".to_owned());

    let redis = RedisStore::new(RedisStoreConfig::new(redis_url))?;
    let sql = SqliteStore::connect_sqlite(SqlStoreConfig::new(sqlite_url)).await?;
    let mongo = MongoStore::connect(MongoStoreConfig::new(mongo_url, "rust_zero_example")).await?;

    redis.ping().await?;
    sql.health_check().await?;
    mongo.health_check().await?;
    println!("Redis, SQLite, and MongoDB are ready");
    Ok(())
}

pub fn from_client( client: Client, database: impl AsRef<str>, ) -> Result<Self, MongoStoreError>

pub fn with_metrics(self, metrics: MongoStoreMetrics) -> Self

Installs metrics for operations run through the typed helper methods.

pub fn client(&self) -> &Client

pub fn database(&self) -> &Database

pub fn collection<T>(&self, name: impl AsRef<str>) -> Collection<T>

where T: Send + Sync,

pub fn cached_collection<K, T>( &self, name: impl AsRef<str>, config: MongoCacheConfig, ) -> CachedMongoCollection<K, T>

where K: Clone + Eq + Hash, T: Clone + Send + Sync,

pub fn cached_indexed_collection<K, I, T>( &self, name: impl AsRef<str>, config: MongoCacheConfig, ) -> CachedMongoCollection<K, T, I>

where K: Clone + Eq + Hash, I: Clone + Eq + Hash, T: Clone + Send + Sync,

Creates a cached collection with distinct primary- and secondary-key types.

pub async fn health_check(&self) -> Result<(), MongoStoreError>

Examples found in repository

examples/external_stores.rs (line 19)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let redis_url = env::var("REDIS_URL").unwrap_or_else(|_| "redis://127.0.0.1/".to_owned());
    let mongo_url =
        env::var("MONGODB_URI").unwrap_or_else(|_| "mongodb://127.0.0.1:27017".to_owned());
    let sqlite_url = env::var("DATABASE_URL").unwrap_or_else(|_| "sqlite::memory:".to_owned());

    let redis = RedisStore::new(RedisStoreConfig::new(redis_url))?;
    let sql = SqliteStore::connect_sqlite(SqlStoreConfig::new(sqlite_url)).await?;
    let mongo = MongoStore::connect(MongoStoreConfig::new(mongo_url, "rust_zero_example")).await?;

    redis.ping().await?;
    sql.health_check().await?;
    mongo.health_check().await?;
    println!("Redis, SQLite, and MongoDB are ready");
    Ok(())
}

pub async fn query<T, R, F, Fut>( &self, operation: &'static str, collection: impl AsRef<str>, query: F, ) -> Result<R, MongoStoreError>

where T: Send + Sync, F: FnOnce(Collection<T>) -> Fut, Fut: Future<Output = Result<R, DriverError>>,

Runs a typed collection query with consistent metrics, tracing, and error conversion.

pub async fn query_one<T, F, Fut>( &self, operation: &'static str, collection: impl AsRef<str>, entity: impl Into<String>, query: F, ) -> Result<T, MongoStoreError>

where T: Send + Sync, F: FnOnce(Collection<T>) -> Fut, Fut: Future<Output = Result<Option<T>, DriverError>>,

Runs an optional query and converts an absent document into a stable not-found error.

pub async fn execute<T, R, F, Fut>( &self, operation: &'static str, collection: impl AsRef<str>, execute: F, ) -> Result<R, MongoStoreError>

where T: Send + Sync, F: FnOnce(Collection<T>) -> Fut, Fut: Future<Output = Result<R, DriverError>>,

Runs a typed collection mutation with consistent metrics and tracing.

pub async fn bulk_insert<T>( &self, operation: &'static str, collection: impl AsRef<str>, items: impl IntoIterator<Item = T>, batch_size: usize, ) -> Result<Vec<InsertManyResult>, MongoStoreError>

where T: Serialize + Send + Sync,

Inserts documents with MongoDB’s native insert_many in bounded batches.

pub async fn begin(&self) -> Result<ClientSession, MongoStoreError>

Starts a client session and transaction. Pass the returned session to each operation.

Trait Implementations

impl Clone for MongoStore

fn clone(&self) -> MongoStore

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MongoStore

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

Formats the value using the given formatter.