toasty 0.4.0

An async ORM for Rust supporting SQL and NoSQL databases
Documentation 
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

use crate::Result;

use async_trait::async_trait;
use std::borrow::Cow;
use toasty_core::driver::{Capability, Driver};
use toasty_core::{
    driver::Connection,
    schema::db::{Migration, SchemaDiff},
};

use url::Url;

/// A connection to a database, wrapping the specific driver implementation.
pub struct Connect {
    driver: Box<dyn Driver>,
}

impl std::fmt::Debug for Connect {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Connect")
            .field("driver", &self.driver)
            .finish()
    }
}

impl Connect {
    /// Create a new connection by parsing a database URL and constructing the
    /// appropriate driver.
    ///
    /// The URL scheme determines which driver is used:
    ///
    /// | Scheme | Driver | Feature flag |
    /// |---|---|---|
    /// | `sqlite` | SQLite | `sqlite` |
    /// | `postgresql` / `postgres` | PostgreSQL | `postgresql` |
    /// | `mysql` | MySQL | `mysql` |
    /// | `dynamodb` | DynamoDB | `dynamodb` |
    ///
    /// # Errors
    ///
    /// Returns an error if the URL is malformed, the scheme is unrecognized,
    /// or the required feature flag is not enabled.
    pub async fn new(url: &str) -> Result<Self> {
        #![cfg_attr(
            not(any(
                feature = "dynamodb",
                feature = "mysql",
                feature = "postgresql",
                feature = "sqlite"
            )),
            allow(unused_variables, unreachable_code)
        )]

        let url = Url::parse(url).map_err(toasty_core::Error::driver_operation_failed)?;

        let driver: Box<dyn Driver> = match url.scheme() {
            #[cfg(feature = "dynamodb")]
            "dynamodb" => {
                // DynamoDB driver requires async initialization to load AWS config from environment
                // Spawn a new thread to avoid runtime context issues
                let url = url.to_string();
                let driver = toasty_driver_dynamodb::DynamoDb::from_env(url).await?;
                Box::new(driver)
            }
            #[cfg(not(feature = "dynamodb"))]
            "dynamodb" => {
                return Err(toasty_core::Error::unsupported_feature(
                    "`dynamodb` feature not enabled",
                ));
            }

            #[cfg(feature = "mysql")]
            "mysql" => Box::new(toasty_driver_mysql::MySQL::new(url.to_string())?),
            #[cfg(not(feature = "mysql"))]
            "mysql" => {
                return Err(toasty_core::Error::unsupported_feature(
                    "`mysql` feature not enabled",
                ));
            }

            #[cfg(feature = "postgresql")]
            "postgresql" | "postgres" => Box::new(toasty_driver_postgresql::PostgreSQL::new(url)?),
            #[cfg(not(feature = "postgresql"))]
            "postgresql" | "postgres" => {
                return Err(toasty_core::Error::unsupported_feature(
                    "`postgresql` feature not enabled",
                ));
            }

            #[cfg(feature = "sqlite")]
            "sqlite" => Box::new(toasty_driver_sqlite::Sqlite::new(url)?),
            #[cfg(not(feature = "sqlite"))]
            "sqlite" => {
                return Err(toasty_core::Error::unsupported_feature(
                    "`sqlite` feature not enabled",
                ));
            }

            scheme => {
                return Err(toasty_core::Error::unsupported_feature(format!(
                    "unsupported database scheme `{scheme}`"
                )));
            }
        };

        Ok(Self { driver })
    }
}

#[async_trait]
impl Driver for Connect {
    fn url(&self) -> Cow<'_, str> {
        self.driver.url()
    }

    fn capability(&self) -> &'static Capability {
        self.driver.capability()
    }

    async fn connect(&self) -> Result<Box<dyn Connection>> {
        self.driver.connect().await
    }

    fn generate_migration(&self, schema_diff: &SchemaDiff<'_>) -> Migration {
        self.driver.generate_migration(schema_diff)
    }

    async fn reset_db(&self) -> Result<()> {
        self.driver.reset_db().await
    }
}