rust-mysql-crud.rs

use mysql::*;
use mysql::prelude::*;
use std::env;

/// Database
///
/// Provides functionalities for database interactions.
///
/// Author: Mokter Hossain
/// Email: mo@gglink.uk
/// Website: www.gglink.uk
/// Github: https://github.com/moktermd08
/// LinkedIn: https://www.linkedin.com/in/mr-mokter/
/// Twitter: https://twitter.com/moGGLink
pub struct Database {
    host: String,
    user: String,
    password: String,
    database: String,
    connection: Option<PooledConn>,
}

impl Database {
    /// Creates a new `Database` instance with the given credentials.
    pub fn new() -> Self {
        Database {
            host: "localhost".to_string(),
            user: "user".to_string(),
            password: "password".to_string(),
            database: "database".to_string(),
            connection: None,
        }
    }

    /// Establishes a database connection.
    ///
    /// Returns `true` on successful connection, `false` on failure.
    ///
    /// # Errors
    /// Returns `Err` if the connection to the database fails.
    pub fn connect(&mut self) -> Result<bool, Box<dyn std::error::Error>> {
        let url = format!(
            "mysql://{}:{}@{}/{}",
            self.user, self.password, self.host, self.database
        );
        
        let pool = Pool::new(url)?;
        self.connection = Some(pool.get_conn()?);
        
        Ok(true)
    }

    /// Closes the database connection.
    ///
    /// Returns `true` on success, `false` on failure.
    pub fn disconnect(&mut self) -> bool {
        self.connection.take().is_some()
    }

    /// Sanitizes user input.
    ///
    /// # Arguments
    ///
    /// * `data` - The user input data.
    ///
    /// # Returns
    ///
    /// The sanitized data.
    pub fn sanitize_input(&self, data: &str) -> String {
        // In Rust, prepared statements automatically handle SQL escaping,
        // so we just need to handle the other sanitization steps.
        let data = data.trim();
        let data = html_escape::encode_text(data); // Escapes HTML in the text.
        data.to_string()
    }

    /// Sanitizes output.
    ///
    /// # Arguments
    ///
    /// * `data` - The data to be sent to the client.
    ///
    /// # Returns
    ///
    /// The sanitized data.
    pub fn sanitize_output(data: &str) -> String {
        html_escape::encode_text(data).to_string()
    }
}

/// MySQLDatabase
///
/// A concrete implementation of the `Database` struct for MySQL databases.
pub struct MySQLDatabase {
    // Here you can add any additional fields or methods specific to MySQLDatabase.
    // For this example, we'll just reuse the Database struct.
    db: Database,
}

impl MySQLDatabase {
    pub fn new() -> Self {
        MySQLDatabase {
            db: Database::new(),
        }
    }

    // Here you can implement the additional methods specific to MySQLDatabase.
}

fn main() {
    // Example usage
    let mut db = MySQLDatabase::new();
    
    match db.db.connect() {
        Ok(_) => {
            println!("Connected successfully.");
            let input = "<h1>Title</h1>";
            let sanitized_input = db.db.sanitize_input(input);
            println!("Sanitized Input: {}", sanitized_input);

            let output = "<h1>Title</h1>";
            let sanitized_output = Database::sanitize_output(output);
            println!("Sanitized Output: {}", sanitized_output);
        }
        Err(e) => {
            println!("Failed to connect to the database: {}", e);
        }
    }

    db.db.disconnect();
}