feat(sql): support for SQLite pragma and encryption pragmas

plugins/sql/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "rust-analyzer.cargo.features": ["mysql", "postgres", "sqlite"]
+}

plugins/sql/Cargo.toml

@@ -36,8 +36,9 @@ time = "0.3"
 tokio = { version = "1", features = ["sync"] }
 indexmap = { version = "2", features = ["serde"] }
 
+libsqlite3-sys = { version = "0.30.1", features = ["bundled-sqlcipher"] }
+
 [features]
 sqlite = ["sqlx/sqlite", "sqlx/runtime-tokio"]
 mysql = ["sqlx/mysql", "sqlx/runtime-tokio-rustls"]
 postgres = ["sqlx/postgres", "sqlx/runtime-tokio-rustls"]
-# TODO: bundled-cipher etc

plugins/sql/guest-js/index.ts

@@ -42,12 +42,31 @@ export default class Database {
    *
    * @example
    * ```ts
+   * // Basic connection to a SQLite database
    * const db = await Database.load("sqlite:test.db");
+   *
+   * // Connecting with an encryption key for added security
+   * const db = await Database.load("sqlite:encrypted.db", {
+   *   sqlite: { pragmas: { "key": "encryption_key" } }
+   * });
+   *
+   * // Connecting with specific pragmas for configuration
+   * const db = await Database.load("sqlite:test.db", {
+   *   sqlite: { pragmas: { "journal_mode": "WAL", "foreign_keys": "ON" } }
+   * });
    * ```
    */
-  static async load(path: string): Promise<Database> {
+  static async load(
+    path: string,
+    options?: {
+      sqlite?: {
+        pragmas?: Record<string, string>
+      }
+    }
+  ): Promise<Database> {
     const _path = await invoke<string>('plugin:sql|load', {
-      db: path
+      db: path,
+      options
     })
 
     return new Database(_path)

plugins/sql/src/commands.rs

@@ -2,22 +2,21 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-License-Identifier: MIT
 
+use crate::{wrapper::ConnectionOptions, DbInstances, DbPool, Error, LastInsertId, Migrations};
 use indexmap::IndexMap;
 use serde_json::Value as JsonValue;
 use sqlx::migrate::Migrator;
 use tauri::{command, AppHandle, Runtime, State};
 
-use crate::{DbInstances, DbPool, Error, LastInsertId, Migrations};
-
 #[command]
 pub(crate) async fn load<R: Runtime>(
     app: AppHandle<R>,
     db_instances: State<'_, DbInstances>,
     migrations: State<'_, Migrations>,
     db: String,
+    options: Option<ConnectionOptions>,
 ) -> Result<String, crate::Error> {
-    let pool = DbPool::connect(&db, &app).await?;
-
+    let pool = DbPool::connect(&db, &app, options).await?;
     if let Some(migrations) = migrations.0.lock().await.remove(&db) {
         let migrator = Migrator::new(migrations).await?;
         pool.migrate(&migrator).await?;

plugins/sql/src/lib.rs

@@ -16,6 +16,9 @@ mod wrapper;
 
 pub use error::Error;
 pub use wrapper::DbPool;
+#[cfg(feature = "sqlite")]
+pub use wrapper::SqliteOptions;
+pub use wrapper::ConnectionOptions;
 
 use futures_core::future::BoxFuture;
 use serde::{Deserialize, Serialize};
@@ -150,7 +153,7 @@ impl Builder {
                     let mut lock = instances.0.write().await;
 
                     for db in config.preload {
-                        let pool = DbPool::connect(&db, app).await?;
+                        let pool = DbPool::connect(&db, app, None).await?;
 
                         if let Some(migrations) =
                             self.migrations.as_mut().and_then(|mm| mm.remove(&db))

plugins/sql/src/wrapper.rs

@@ -2,11 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-License-Identifier: MIT
 
+#[cfg(feature = "sqlite")]
+use std::collections::HashMap;
 #[cfg(feature = "sqlite")]
 use std::fs::create_dir_all;
 
 use indexmap::IndexMap;
 use serde_json::Value as JsonValue;
+#[cfg(feature = "sqlite")]
+use sqlx::sqlite::SqliteConnectOptions;
 #[cfg(any(feature = "sqlite", feature = "mysql", feature = "postgres"))]
 use sqlx::{migrate::MigrateDatabase, Column, Executor, Pool, Row};
 #[cfg(any(feature = "sqlite", feature = "mysql", feature = "postgres"))]
@@ -33,6 +37,40 @@ pub enum DbPool {
     None,
 }
 
+#[cfg(feature = "sqlite")]
+#[derive(serde::Serialize, serde::Deserialize, Debug)]
+pub struct SqliteOptions {
+    pub pragmas: HashMap<String, String>,
+}
+
+#[cfg(feature = "sqlite")]
+impl Default for SqliteOptions {
+    fn default() -> Self {
+        Self {
+            pragmas: HashMap::new(),
+        }
+    }
+}
+
+#[derive(serde::Serialize, serde::Deserialize, Debug)]
+pub struct ConnectionOptions {
+    #[cfg(feature = "sqlite")]
+    pub sqlite: Option<SqliteOptions>,
+    // #[cfg(feature = "mysql")]
+    // mysql: Option<MySqlOptions>,
+    // #[cfg(feature = "postgres")]
+    // postgres: Option<PostgresOptions>,
+}
+
+impl Default for ConnectionOptions {
+    fn default() -> Self {
+        Self {
+            #[cfg(feature = "sqlite")]
+            sqlite: None,
+        }
+    }
+}
+
 // public methods
 /* impl DbPool {
     /// Get the inner Sqlite Pool. Returns None for MySql and Postgres pools.
@@ -68,6 +106,7 @@ impl DbPool {
     pub(crate) async fn connect<R: Runtime>(
         conn_url: &str,
         _app: &AppHandle<R>,
+        options: Option<ConnectionOptions>,
     ) -> Result<Self, crate::Error> {
         match conn_url
             .split_once(':')
@@ -82,13 +121,23 @@ impl DbPool {
                     .expect("No App config path was found!");
 
                 create_dir_all(&app_path).expect("Couldn't create app config dir");
-
                 let conn_url = &path_mapper(app_path, conn_url);
+                let filename = conn_url.split_once(':').unwrap().1;
 
-                if !Sqlite::database_exists(conn_url).await.unwrap_or(false) {
-                    Sqlite::create_database(conn_url).await?;
+                let mut sqlite_options = SqliteConnectOptions::new()
+                    .filename(filename)
+                    .create_if_missing(true);
+                // Apply pragmas if provided
+                if let Some(conn_opts) = options {
+                    if let Some(sqlite_opts) = conn_opts.sqlite {
+                        for (pragma_name, pragma_value) in sqlite_opts.pragmas {
+                            sqlite_options = sqlite_options.pragma(pragma_name, pragma_value);
+                        }
+                    }
                 }
-                Ok(Self::Sqlite(Pool::connect(conn_url).await?))
+
+                // Connect with options (which includes create_if_missing)
+                Ok(Self::Sqlite(Pool::connect_with(sqlite_options).await?))
             }
             #[cfg(feature = "mysql")]
             "mysql" => {