wither 0.9.0

An ODM for MongoDB built upon the mongo rust driver.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

#![cfg(not(feature = "sync"))]

pub mod models;

use std::env;

use chrono::{self, TimeZone};
use lazy_static::lazy_static;
use serde::{Deserialize, Serialize};
use wither::bson::doc;
use wither::bson::oid::ObjectId;
use wither::mongodb::{Client, Database};
use wither::prelude::*;

lazy_static! {
    static ref HOST: String = env::var("HOST").expect("environment variable HOST must be defined");
    static ref PORT: String = env::var("PORT").expect("environment variable PORT must be defined");
    static ref CONNECTION_STRING: String = format!("mongodb://{}:{}/", HOST.as_str(), PORT.as_str());
}

//////////////////////////////////////////////////////////////////////////////
// User //////////////////////////////////////////////////////////////////////

#[derive(Model, Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[model(collection_name = "users")]
#[model(index(
    keys = r#"doc!{"email": 1}"#,
    options = r#"doc!{"name": "unique-email", "unique": true, "background": true}"#
))]
pub struct User {
    /// The user's unique ID.
    #[serde(rename = "_id", skip_serializing_if = "Option::is_none")]
    pub id: Option<ObjectId>,

    /// The user's unique email.
    pub email: String,
}

impl Migrating for User {
    fn migrations() -> Vec<Box<dyn wither::Migration>> {
        vec![
            // This migration doesn't really do much. Just exercises the system.
            Box::new(wither::IntervalMigration {
                name: String::from("test-migration"),
                threshold: chrono::Utc.ymd(2100, 1, 1).and_hms(1, 0, 0),
                filter: doc! {"email": doc!{"$exists": true}},
                set: Some(doc! {"testfield": "test"}),
                unset: None,
            }),
        ]
    }
}

//////////////////////////////////////////////////////////////////////////////
// UserModelBadMigrations ////////////////////////////////////////////////////

#[derive(Model, Serialize, Deserialize, Debug, Clone)]
#[model(collection_name = "users_bad_migrations")]
#[model(index(
    keys = r#"doc!{"email": 1}"#,
    options = r#"doc!{"name": "unique-email", "unique": true, "background": true}"#
))]
pub struct UserModelBadMigrations {
    /// The user's unique ID.
    #[serde(rename = "_id", skip_serializing_if = "Option::is_none")]
    pub id: Option<ObjectId>,

    /// The user's unique email.
    pub email: String,
}

impl Migrating for UserModelBadMigrations {
    fn migrations() -> Vec<Box<dyn wither::Migration>> {
        vec![
            // This migration doesn't really do much. Just exercises the system.
            Box::new(wither::IntervalMigration {
                name: String::from("test-migration"),
                threshold: chrono::Utc.ymd(2100, 1, 1).and_hms(1, 0, 0),
                filter: doc! {"email": doc!{"$exists": true}},
                set: None,
                unset: None,
            }),
        ]
    }
}

/// A singular type representing the various fixtures available in this harness.
///
/// This type represents some combination of desired states which this system's dependencies must
/// be in. Generally speaking, this represents the backend database; however it is not necessarily
/// limited to only the backend database.
pub struct Fixture {
    client: Client,
}

//////////////////////////////////////////////////////////////////////////////
// Public Builder Interface //////////////////////////////////////////////////

impl Fixture {
    /// Create a new fixture.
    pub async fn new() -> Self {
        let client = Client::with_uri_str(&CONNECTION_STRING).await.expect("failed to connect to database");
        Fixture { client }
    }

    // /// Remove all documents & indexes from the collections of the data models used by this harness.
    // pub fn with_empty_collections(self) -> Self {
    //     DB.clone().collection(User::COLLECTION_NAME).drop(None).expect("failed to drop collection");
    //     DB.clone().collection(UserModelBadMigrations::COLLECTION_NAME).drop(None).expect("failed to
    // drop collection");     self
    // }

    /// Drop the database which is used by this harness.
    pub async fn with_dropped_database(self) -> Self {
        self.get_db().drop(None).await.expect("failed to drop database");
        self
    }

    /// Sync all of the data models used by this harness.
    pub async fn with_synced_models(self) -> Self {
        User::sync(&self.get_db()).await.expect("failed to sync `User` model");
        self
    }
}

//////////////////////////////////////////////////////////////////////////////
// Public Dependencies Interface /////////////////////////////////////////////

impl Fixture {
    /// Get a handle to the database used by this harness.
    pub fn get_db(&self) -> Database {
        self.client.database("witherTestDB")
    }
}