ruskit 0.1.5

A modern web framework for Rust inspired by Laravel
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

use std::sync::Arc;
use sqlx::{sqlite::{SqlitePool, SqlitePoolOptions}};
use std::fs;
use std::path::Path;
use std::sync::Mutex;
use once_cell::sync::Lazy;

pub mod model;
pub mod query_builder;
pub mod migration;
pub mod config;
pub mod seeder;
pub mod factory;

use config::DatabaseConfig;
use seeder::DatabaseSeeder;

pub static POOL: Lazy<Mutex<Option<Arc<SqlitePool>>>> = Lazy::new(|| Mutex::new(None));

#[derive(Debug)]
pub enum DatabaseError {
    ConnectionError(sqlx::Error),
    ConfigError(String),
    Other(String),
}

impl std::fmt::Display for DatabaseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            DatabaseError::ConnectionError(e) => write!(f, "Database connection error: {}", e),
            DatabaseError::ConfigError(e) => write!(f, "Database configuration error: {}", e),
            DatabaseError::Other(e) => write!(f, "Database error: {}", e),
        }
    }
}

impl std::error::Error for DatabaseError {}

impl From<sqlx::Error> for DatabaseError {
    fn from(error: sqlx::Error) -> Self {
        DatabaseError::ConnectionError(error)
    }
}

impl From<serde_json::Error> for DatabaseError {
    fn from(error: serde_json::Error) -> Self {
        DatabaseError::Other(error.to_string())
    }
}

impl From<std::io::Error> for DatabaseError {
    fn from(error: std::io::Error) -> Self {
        DatabaseError::Other(error.to_string())
    }
}

/// Initialize the database connection pool
pub async fn initialize(config: Option<DatabaseConfig>) -> Result<(), DatabaseError> {
    let config = config.unwrap_or_else(|| DatabaseConfig::default());
    let database_path = config.database_path();
    let db_path = Path::new(&database_path);

    // Create database directory if it doesn't exist
    if let Some(parent) = db_path.parent() {
        println!("Creating database directory: {}", parent.display());
        fs::create_dir_all(parent)?;
    }

    println!("Connecting to database with URL: {}", config.connection_url());
    let pool = SqlitePoolOptions::new()
        .max_connections(5)
        .connect(&config.connection_url())
        .await?;

    println!("Successfully connected to database");

    // Enable foreign key constraints
    println!("Enabling foreign key constraints");
    sqlx::query("PRAGMA foreign_keys = ON;")
        .execute(&pool)
        .await?;

    println!("Database pool initialized successfully");

    *POOL.lock().unwrap() = Some(Arc::new(pool));

    Ok(())
}

/// Get a reference to the database pool
pub fn get_pool() -> Result<Arc<SqlitePool>, DatabaseError> {
    println!("Getting database pool...");
    let pool = POOL.lock()
        .unwrap()
        .as_ref()
        .cloned()
        .ok_or(DatabaseError::ConnectionError(
            sqlx::Error::Configuration("Database not initialized".into())
        ))?;
    println!("Got database pool successfully");
    Ok(pool)
}

pub async fn seed() -> Result<(), DatabaseError> {
    println!("Starting database seeding...");
    println!("Running seeders...");
    match DatabaseSeeder::run_all().await {
        Ok(_) => {
            println!("All seeders completed successfully");
            Ok(())
        },
        Err(e) => {
            println!("Error running seeders: {}", e);
            Err(e)
        }
    }
}