feat: sqlite store initial implementation

Author: lzldev

Cargo.toml

@@ -14,4 +14,5 @@ categories = ["command-line-utilities"]
 
 [dependencies]
 json = "0.12.4"
+rusqlite = { version = "0.39.0", features = ["bundled"] }
 seahorse = "2.1.0"

src/actions.rs

@@ -2,26 +2,26 @@ use std::path::Path;
 
 use seahorse::{ActionError, ActionResult, Context};
 
-use crate::config::get_config_path;
+use crate::config::{get_config_path, get_db_path};
 use crate::error::invalid;
-use crate::storage::json::JSONStore;
-use crate::storage::{Store, StoreValue};
+use crate::storage::sqlite::SQLiteStore;
+use crate::storage::{self, Store, StoreValue};
 
 pub fn init_action(_c: &Context) -> ActionResult {
-	let config_path = get_config_path();
+	let config_path = get_db_path();
 	let path = Path::new(&config_path);
 
 	if path.exists() {
 		println!("config file already exists");
 	}
 
-	JSONStore::with_force_create(true);
+	SQLiteStore::from_path(path);
 
 	Ok(())
 }
 
 pub fn list_action(c: &Context) -> ActionResult {
-	let store = JSONStore::with_force_create(c.bool_flag("force-create"));
+	let store = storage::load_storage();
 
 	for (key, value) in store.all().iter() {
 		println!("{}\t{}", key, value);
@@ -31,7 +31,7 @@ pub fn list_action(c: &Context) -> ActionResult {
 }
 
 pub fn clear_action(_c: &Context) -> ActionResult {
-	let mut store = JSONStore::new();
+	let mut store = storage::load_storage();
 
 	store.clear();
 
@@ -51,7 +51,7 @@ pub fn get_action(c: &Context) -> ActionResult {
 		return Err(invalid("key"));
 	};
 
-	let store = JSONStore::new();
+	let store = storage::load_storage();
 
 	let value = store.get(key);
 
@@ -86,12 +86,12 @@ pub fn set_action(c: &Context) -> ActionResult {
 		return Err(invalid("value"));
 	};
 
-	let mut store = JSONStore::new();
+	let mut store = storage::load_storage();
 
 	let value = StoreValue::Value(value_str.to_owned());
 	store.set(key, value.clone());
 
-	println!("{}\t{}", key, value);
+	println!("'{}' -> '{}'", key, value);
 
 	Ok(())
 }
@@ -101,7 +101,7 @@ pub fn remove_action(c: &Context) -> ActionResult {
 		return Err(invalid("key"));
 	};
 
-	let mut store = JSONStore::new();
+	let mut store = storage::load_storage();
 
 	match store.remove(key) {
 		Some(value) => println!("{}\t{}", key, value),

src/config.rs

@@ -1,8 +1,13 @@
 use std::{env::home_dir, path::PathBuf};
 
+pub fn get_config_folder_path() -> PathBuf {
+	return home_dir().expect("couldn't find home directory");
+}
+
 pub fn get_config_path() -> PathBuf {
-	let home_folder = home_dir().expect("couldn't find home directory");
-	let path = home_folder.join(".cfs.json");
+	return get_config_folder_path().join(".cfs.json");
+}
 
-	return path;
+pub fn get_db_path() -> PathBuf {
+	return get_config_folder_path().join(".cfs.db");
 }

src/storage/mod.rs

@@ -1,9 +1,11 @@
 pub mod json;
-mod sqlite;
+pub mod sqlite;
 mod value;
 
 pub use value::StoreValue;
 
+use crate::config::get_db_path;
+
 pub trait Store {
 	fn all(&self) -> Vec<(String, StoreValue)>;
 
@@ -13,3 +15,8 @@ pub trait Store {
 
 	fn clear(&mut self);
 }
+
+//TODO: Change STORE Based on config.
+pub fn load_storage() -> impl Store {
+	return sqlite::SQLiteStore::from_path(get_db_path());
+}

src/storage/sqlite/mod.rs

@@ -0,0 +1,94 @@
+use std::path::Path;
+
+use rusqlite::OptionalExtension as _;
+
+use crate::storage::{Store, StoreValue};
+
+#[derive(Debug)]
+pub struct SQLiteStore {
+	connection: rusqlite::Connection,
+}
+
+impl SQLiteStore {
+	pub fn from_path<P: AsRef<Path>>(path: P) -> Self {
+		let conn = rusqlite::Connection::open(path).expect("To Open SQLite DB");
+
+		conn
+			.execute_batch(include_str!("schema.sql"))
+			.expect("To Create DB");
+
+		return Self { connection: conn };
+	}
+}
+
+impl Store for SQLiteStore {
+	fn all(&self) -> Vec<(String, super::StoreValue)> {
+		let mut stmt = self.connection.prepare("SELECT key,value from KV").unwrap();
+
+		let values = stmt
+			.query_map([], |row| {
+				let key: String = row.get(0)?;
+				let value = StoreValue::Value(row.get::<_, String>(1)?);
+
+				return Ok((key, value));
+			})
+			.unwrap()
+			.collect::<Result<Vec<_>, _>>()
+			.unwrap();
+
+		return values;
+	}
+
+	fn get(&self, key: &str) -> Option<super::StoreValue> {
+		let stmt = self
+			.connection
+			.query_row(
+				"SELECT key,value from KV where key = ?1 LIMIT 1",
+				[key],
+				|row| Ok(StoreValue::Value(row.get(1).unwrap())),
+			)
+			.optional()
+			.unwrap();
+
+		return stmt;
+	}
+
+	fn set(&mut self, key: &str, value: super::StoreValue) -> super::StoreValue {
+		let StoreValue::Value(value) = value else {
+			panic!("Invalid value passed into SQLiteStore GET [{}]", value)
+		};
+
+		self
+			.connection
+			.execute(
+				"INSERT INTO KV VALUES(NULL,?1,?2) ON CONFLICT(key) DO UPDATE SET value = ?2 WHERE key = ?1",
+				[key, &value],
+			)
+			.unwrap();
+
+		return StoreValue::Value(value);
+	}
+
+	fn remove(&mut self, key: &str) -> Option<super::StoreValue> {
+		let value = self.get(key);
+
+		let Some(value) = value else {
+			return None;
+		};
+
+		let stmt = self
+			.connection
+			.execute("DELETE FROM KV where key = ?1", [key])
+			.unwrap();
+
+		if stmt == 0 {
+			panic!("Deleted 0 Rows when trying to delete Value from Store")
+		}
+
+		Some(value)
+	}
+
+	fn clear(&mut self) {
+		self.connection.execute("DELETE FROM KV", []).unwrap();
+	}
+}

src/storage/sqlite/schema.sql

@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS KV (
+    id INTEGER PRIMARY KEY,
+    key TEXT NOT NULL,
+    value TEXT NOT NULL
+    );
+
+CREATE UNIQUE INDEX IF NOT EXISTS kv_keys ON KV (key);