feat(database): Ensure that any database issues are resolved by standalone functions

Functions are as follows:
- save_db()
- borrow_db_checked()
- borrow_db_mut_checked()

src-tauri/src/database/commands.rs

@@ -6,24 +6,24 @@ use std::{
 
 use serde_json::Value;
 
-use crate::{database::settings::Settings, download_manager::{download_manager::DownloadManagerSignal, internal_error::InternalError}, DB};
+use crate::{database::{db::borrow_db_mut_checked, settings::Settings}, download_manager::{download_manager::DownloadManagerSignal, internal_error::InternalError}, DB};
 
-use super::{db::DATA_ROOT_DIR, debug::SystemData};
+use super::{db::{borrow_db_checked, save_db, DATA_ROOT_DIR}, debug::SystemData};
 
 // Will, in future, return disk/remaining size
 // Just returns the directories that have been set up
 #[tauri::command]
 pub fn fetch_download_dir_stats() -> Vec<PathBuf> {
-    let lock = DB.borrow_data().unwrap();
+    let lock = borrow_db_checked();
     lock.applications.install_dirs.clone()
 }
 
 #[tauri::command]
 pub fn delete_download_dir(index: usize) {
-    let mut lock = DB.borrow_data_mut().unwrap();
+    let mut lock = borrow_db_mut_checked();
     lock.applications.install_dirs.remove(index);
     drop(lock);
-    DB.save().unwrap();
+    save_db();
 }
 
 #[tauri::command]
@@ -43,7 +43,7 @@ pub fn add_download_dir(new_dir: PathBuf) -> Result<(), InternalError<()>> {
     }
 
     // Add it to the dictionary
-    let mut lock = DB.borrow_data_mut().unwrap();
+    let mut lock = borrow_db_mut_checked();
     if lock.applications.install_dirs.contains(&new_dir) {
         return Err(Error::new(
             ErrorKind::AlreadyExists,
@@ -52,14 +52,14 @@ pub fn add_download_dir(new_dir: PathBuf) -> Result<(), InternalError<()>> {
     }
     lock.applications.install_dirs.push(new_dir);
     drop(lock);
-    DB.save().unwrap();
+    save_db();
 
     Ok(())
 }
 
 #[tauri::command]
 pub fn update_settings(new_settings: Value) {
-    let mut db_lock = DB.borrow_data_mut().unwrap();
+    let mut db_lock = borrow_db_mut_checked();
     let mut current_settings = serde_json::to_value(db_lock.settings.clone()).unwrap();
     for (key, value) in new_settings.as_object().unwrap() {
         current_settings[key] = value.clone();
@@ -70,11 +70,11 @@ pub fn update_settings(new_settings: Value) {
 }
 #[tauri::command]
 pub fn fetch_settings() -> Settings {
-    DB.borrow_data().unwrap().settings.clone()
+    borrow_db_checked().settings.clone()
 }
 #[tauri::command]
 pub fn fetch_system_data() -> SystemData {
-    let db_handle = DB.borrow_data().unwrap();
+    let db_handle = borrow_db_checked();
     SystemData::new(
         db_handle.auth.as_ref().unwrap().client_id.clone(),
         db_handle.base_url.clone(),

src-tauri/src/database/db.rs

@@ -2,12 +2,12 @@ use std::{
     collections::HashMap,
     fs::{self, create_dir_all},
     path::{Path, PathBuf},
-    sync::{LazyLock, Mutex, RwLockWriteGuard},
+    sync::{LazyLock, Mutex, RwLockReadGuard, RwLockWriteGuard},
 };
 
 use chrono::Utc;
 use directories::BaseDirs;
-use log::{debug, info};
+use log::{debug, error, info};
 use rustbreak::{DeSerError, DeSerializer, PathDatabase, RustbreakError};
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use serde_with::serde_as;
@@ -169,10 +169,10 @@ pub fn set_game_status<F: FnOnce(&mut RwLockWriteGuard<'_, Database>, &Downloada
     meta: DownloadableMetadata,
     setter: F,
 ) {
-    let mut db_handle = DB.borrow_data_mut().unwrap();
+    let mut db_handle = borrow_db_mut_checked();
     setter(&mut db_handle, &meta);
     drop(db_handle);
-    DB.save().unwrap();
+    save_db();
 
     let status = GameStatusManager::fetch_state(&meta.id);
 
@@ -200,3 +200,34 @@ fn handle_invalid_database(
 
     PathDatabase::create_at_path(db_path, db).expect("Database could not be created")
 }
+
+
+pub fn borrow_db_checked<'a>() -> RwLockReadGuard<'a, Database> {
+    match DB.borrow_data() {
+        Ok(data) => data,
+        Err(e) => {
+            error!("database borrow failed with error {}", e);
+            panic!("database borrow failed with error {}", e);
+        },
+    }
+}
+
+pub fn borrow_db_mut_checked<'a>() -> RwLockWriteGuard<'a, Database> {
+    match DB.borrow_data_mut() {
+        Ok(data) => data,
+        Err(e) => {
+            error!("database borrow mut failed with error {}", e);
+            panic!("database borrow mut failed with error {}", e);
+        }
+    }
+}
+
+pub fn save_db() {
+    match DB.save() {
+        Ok(_) => {},
+        Err(e) => {
+            error!("database failed to save with error {}", e);
+            panic!("database failed to save with error {}", e)
+        },
+    }
+}