Improve database, add log and cli

src/database.rs

@@ -1,5 +1,6 @@
 use std::{fs, path::PathBuf};
 
+use log::debug;
 use sqlx::{migrate::MigrateDatabase, Connection, Sqlite, SqliteConnection, SqlitePool};
 
 #[derive(sqlx::FromRow, Debug)]
@@ -44,76 +45,54 @@ impl Sheet {
 }
 
 pub struct Database {
-    connection: Option<SqlitePool>,
+    connection: SqlitePool,
 }
 
 impl Database {
-    pub fn new() -> Self {
-        Database { connection: None }
+    pub async fn setup(database_path: &str) -> sqlx::Result<Self> {
+        let connection = Database::create_connection(database_path).await?;
+        sqlx::migrate!("./db-migrations").run(&connection).await?;
+        Ok(Database { connection })
     }
 
-    pub async fn init_connection(&mut self, database_path: &str) -> sqlx::Result<()> {
+    async fn create_connection(database_path: &str) -> sqlx::Result<SqlitePool> {
         if !Sqlite::database_exists(database_path)
             .await
             .unwrap_or(false)
         {
             match Sqlite::create_database(database_path).await {
-                Ok(_) => println!("Database created"),
-                Err(e) => println!("Error creating database: {}", e),
+                Ok(_) => debug!("Database created"),
+                Err(e) => {
+                    debug!("Error creating database: {}", e);
+                    return Err(e);
+                }
             }
-        } else {
-            println!("Database already exists");
         }
 
         let connection = SqlitePool::connect(database_path).await?;
-        self.connection = Some(connection);
-        Ok(())
+        debug!("Connected to database");
+        Ok(connection)
     }
 
-    pub async fn setup_db(&mut self) -> sqlx::Result<()> {
-        // TODO: put this in migrations
-        if let Some(connection) = &self.connection {
-            sqlx::query!("
-                CREATE TABLE IF NOT EXISTS sheets (name TEXT, path TEXT, file_size INTEGER, file_hash TEXT);
-                CREATE TABLE IF NOT EXISTS composers (name TEXT, id INTEGER);
-            ").execute(connection).await?;
-        }
-        Ok(())
+    pub async fn insert_sheet(&self, sheet: Sheet) -> sqlx::Result<()> {
+        sqlx::query!(
+            "
+                INSERT INTO sheets (name, path, file_size, file_hash)
+                VALUES ($1, $2, $3, $4)
+            ",
+            sheet.name,
+            sheet.path,
+            sheet.file_size,
+            sheet.file_hash,
+        )
+        .execute(&self.connection)
+        .await
+        .map(|_| ())
     }
 
-    pub async fn insert_sheet(&mut self, sheet: Sheet) -> sqlx::Result<()> {
-        if let Some(connection) = &self.connection {
-            // let path = sheet.path.to_str().unwrap().to_string();
-            // let size = sheet.file_size as i64;
-
-            let result = sqlx::query!(
-                "
-                   INSERT INTO sheets (name, path, file_size, file_hash)
-                   VALUES ($1, $2, $3, $4)
-               ",
-                sheet.name,
-                sheet.path,
-                sheet.file_size,
-                sheet.file_hash,
-            )
-            .execute(connection)
-            .await;
-            result.unwrap();
-            println!("Inserted!!!");
-        }
-        Ok(())
-    }
-
-    pub async fn fetch_all_sheets(&mut self) -> sqlx::Result<Vec<Sheet>> {
-        if let Some(connection) = &self.connection {
-            // return sqlx::query_as!(Sheet, "SELECT * FROM sheets")
-            //     .fetch_all(connection)
-            //     .await;
-            return sqlx::query_as::<_, Sheet>("SELECT * FROM sheets")
-                .fetch_all(connection)
-                .await;
-            // return sqlx::query_as("SELECT * FROM sheets").fetch_all(connection).await;
-        }
-        Ok(Vec::new())
+    pub async fn fetch_all_sheets(&self) -> sqlx::Result<Vec<Sheet>> {
+        sqlx::query_as::<_, Sheet>("SELECT * FROM sheets")
+            .fetch_all(&self.connection)
+            .await
     }
 }

src/main.rs

@@ -4,12 +4,13 @@ mod sheet_listing;
 
 use std::{env, path::PathBuf, process};
 
+use clap::Parser;
 use database::Database;
+use env_logger::Env;
 use gtk::prelude::*;
 use mcdu::McduModel;
 use relm4::prelude::*;
 use sheet_listing::{SheetListingInput, SheetListingModel};
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
 use crate::database::Sheet;
 
@@ -94,13 +95,19 @@ impl SimpleComponent for AppModel {
     }
 }
 
+#[derive(Parser)]
+#[command(author, version, about)]
+struct Cli {
+    directory: Option<PathBuf>,
+}
+
 #[tokio::main]
 async fn main() {
-    dotenvy::dotenv().unwrap();
+    // dotenvy::dotenv().unwrap();
+    env_logger::Builder::from_env(Env::default().default_filter_or("debug")).init();
+    let cli = Cli::parse();
 
-    let mut database = Database::new();
-    database.init_connection("./testdb.db").await.unwrap();
-    database.setup_db().await.unwrap();
+    let database = Database::setup("./testdb.db").await.unwrap();
 
     database.insert_sheet(Sheet::new_debug()).await.unwrap();
     let sheets = database.fetch_all_sheets().await.unwrap();