tideway 0.1.0

A batteries-included Rust web framework built on Axum for building SaaS applications quickly
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

use super::config::DatabaseConfig;
use crate::error::{Result, TidewayError};
use sea_orm::{ConnectOptions, Database, DatabaseConnection as SeaOrmConnection};
use std::time::Duration;

/// Wrapper around SeaORM database connection
#[derive(Clone)]
pub struct DatabaseConnection {
    pub conn: SeaOrmConnection,
}

impl DatabaseConnection {
    /// Create a new database connection from config
    pub async fn connect(config: &DatabaseConfig) -> Result<Self> {
        let mut opt = ConnectOptions::new(&config.url);
        opt.max_connections(config.max_connections)
            .min_connections(config.min_connections)
            .connect_timeout(Duration::from_secs(config.connect_timeout))
            .idle_timeout(Duration::from_secs(config.idle_timeout))
            .sqlx_logging(true);

        let conn = Database::connect(opt)
            .await
            .map_err(|e| TidewayError::internal(format!("Failed to connect to database: {}", e)))?;

        tracing::info!(
            "Database connected with {} max connections",
            config.max_connections
        );

        Ok(Self { conn })
    }

    /// Ping the database to check connection health
    pub async fn ping(&self) -> Result<()> {
        self.conn
            .ping()
            .await
            .map_err(|e| TidewayError::internal(format!("Database ping failed: {}", e)))
    }

    /// Close the database connection
    pub async fn close(self) -> Result<()> {
        self.conn
            .close()
            .await
            .map_err(|e| TidewayError::internal(format!("Failed to close database: {}", e)))
    }

    /// Get the inner SeaORM connection
    pub fn as_ref(&self) -> &SeaOrmConnection {
        &self.conn
    }
}

impl std::ops::Deref for DatabaseConnection {
    type Target = SeaOrmConnection;

    fn deref(&self) -> &Self::Target {
        &self.conn
    }
}