Merge pull request silvermine#9 from 1Cor125/complete_plugin_api

feat: complete the plugin commands

Author: jjhafer

Cargo.lock

@@ -17,7 +17,7 @@ pooling, write serialization, and proper resource management.
    * **Optimized Connection Pooling**: Separate read and write pools for concurrent reads,
      even while writing
    * **Write Serialization**: Exclusive write access through connection manager
-   * **Migration Support**: Uses SQLx's database migration system (runs during preload)
+   * **Migration Support**: Uses SQLx's database migration system
    * **Custom Configuration**: Configure read pool size and idle timeouts
    * **Type Safety**: Full TypeScript bindings
    * **Resource Management**: Proper cleanup on application exit
@@ -332,7 +332,7 @@ console.log(`Transfer ID: ${results[2].lastInsertId}`);
 
 **How it works:**
 
-   * Automatically executes `BEGIN` before running statements
+   * Automatically executes `BEGIN IMMEDIATE` before running statements
    * Executes all statements in order
    * Commits with `COMMIT` if all statements succeed
    * Rolls back with `ROLLBACK` if any statement fails
@@ -360,85 +360,8 @@ await db.remove()
 
 ## Migrations
 
-Migrations run automatically during database preload at application startup.
-
-### Setting Up Migrations
-
-`src-tauri/src/lib.rs`
-
-```rust
-use tauri_plugin_sqlite::{Builder, Migration, MigrationKind};
-
-fn main() {
-    let migrations = vec![
-        // Version 1: Create initial schema
-        Migration {
-            version: 1,
-            description: "create_users_table",
-            sql: vec!["CREATE TABLE users (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                name TEXT NOT NULL,
-                email TEXT NOT NULL UNIQUE,
-                created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now'))
-            )"],
-            kind: MigrationKind::Up,
-        },
-        // Version 2: Add new column
-        Migration {
-            version: 2,
-            description: "add_users_role",
-            sql: vec!["ALTER TABLE users ADD COLUMN role TEXT DEFAULT 'user'"],
-            kind: MigrationKind::Up,
-        },
-        // Version 3: Create index and add trigger (multiple statements)
-        Migration {
-            version: 3,
-            description: "create_email_index_and_trigger",
-            sql: vec![
-                "CREATE INDEX idx_users_email ON users(email)",
-                "CREATE TRIGGER update_timestamp AFTER UPDATE ON users
-                    BEGIN
-                        UPDATE users SET created_at = strftime('%s', 'now') WHERE id = NEW.id;
-                    END",
-            ],
-            kind: MigrationKind::Up,
-        },
-    ];
-
-    tauri::Builder::default()
-        .plugin(
-            Builder::new()
-                .add_migrations("mydb.db", migrations)
-                .build(),
-        )
-        .run(tauri::generate_context!())
-        .expect("error while running tauri application");
-}
-```
-
-### Preloading Databases
-
-Add databases to `tauri.conf.json` to connect and run migrations at startup:
-
-```json
-{
-   "plugins": {
-      "sqlite": {
-         "preload": ["mydb.db", "cache.db"]
-      }
-   }
-}
-```
-
-When preloaded:
-
-1. The plugin connects to each database
-2. Runs any pending migrations defined in `add_migrations()`
-3. Keeps the connection open and ready for use
-
-> **Important:** Migrations only run during preload. If you load a database
-> dynamically with `Database.load()`, migrations will not run unless it was
-> preloaded.
+> **Note:** Database migration support is a planned feature and will be added in a
+> future release. It will be based on SQLx's migration framework.
 
 ## Query Parameter Binding
 
@@ -526,7 +449,7 @@ const db = Database.get('mydb.db')
 // Connection happens on first query
 ```
 
-##### `Database.closeAll(): Promise<boolean>`
+##### `Database.closeAll(): Promise<void>`
 
 Close all database connections.
 
@@ -578,15 +501,17 @@ if (user) {
 
 ##### `close(): Promise<boolean>`
 
-Close this database connection.
+Close this database connection. Returns `true` if the database was loaded and closed,
+`false` if it wasn't loaded.
 
 ```typescript
 await db.close()
 ```
 
 ##### `remove(): Promise<boolean>`
 
-Close the connection and permanently delete database file(s).
+Close the connection and permanently delete database file(s). Returns `true` if
+the database was loaded and removed, `false` if it wasn't loaded.
 
 > ⚠️ **Warning:** This cannot be undone!
 

README.md

@@ -1,4 +1,13 @@
 fn main() {
-   // TODO: Add commands to the plugin
-   tauri_plugin::Builder::new(&["hello"]).build();
+   tauri_plugin::Builder::new(&[
+      "load",
+      "execute",
+      "execute_transaction",
+      "fetch_all",
+      "fetch_one",
+      "close",
+      "close_all",
+      "remove",
+   ])
+   .build();
 }

api-iife.js

@@ -11,3 +11,4 @@ sqlx = { version = "0.8.6", features = ["runtime-tokio", "sqlite"] }
 thiserror = "2.0.17"
 tokio = { version = "1.48.0", features = ["full"] }
 tracing = { version = "0.1.41", default-features = false, features = ["std", "release_max_level_off"] }
+serde = { version = "1.0.228", features = ["derive"] }

build.rs

@@ -1,22 +1,21 @@
 //! Configuration for SQLite database connection pools
 
-use std::time::Duration;
+use serde::{Deserialize, Serialize};
 
 /// Configuration for SqliteDatabase connection pools
 ///
 /// # Examples
 ///
 /// ```
 /// use sqlx_sqlite_conn_mgr::SqliteDatabaseConfig;
-/// use std::time::Duration;
 ///
 /// // Use defaults
 /// let config = SqliteDatabaseConfig::default();
 ///
 /// // Customize specific fields
 /// let config = SqliteDatabaseConfig {
 ///     max_read_connections: 3,
-///     idle_timeout: Duration::from_secs(60),
+///     idle_timeout_secs: 60,
 /// };
 ///
 /// // Override just one field
@@ -25,7 +24,7 @@ use std::time::Duration;
 ///     ..Default::default()
 /// };
 /// ```
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SqliteDatabaseConfig {
    /// Maximum number of concurrent read connections
    ///
@@ -35,20 +34,20 @@ pub struct SqliteDatabaseConfig {
    /// Default: 6
    pub max_read_connections: u32,
 
-   /// Idle timeout for both read and write connections
+   /// Idle timeout for both read and write connections (in seconds)
    ///
    /// Connections that remain idle for this duration will be closed automatically.
    /// This helps prevent resource exhaustion from idle threads.
    ///
-   /// Default: 30 seconds
-   pub idle_timeout: Duration,
+   /// Default: 30
+   pub idle_timeout_secs: u64,
 }
 
 impl Default for SqliteDatabaseConfig {
    fn default() -> Self {
       Self {
          max_read_connections: 6,
-         idle_timeout: Duration::from_secs(30),
+         idle_timeout_secs: 30,
       }
    }
 }

crates/sqlx-sqlite-conn-mgr/Cargo.toml

@@ -92,14 +92,13 @@ impl SqliteDatabase {
    ///
    /// ```no_run
    /// use sqlx_sqlite_conn_mgr::{SqliteDatabase, SqliteDatabaseConfig};
-   /// use std::time::Duration;
    /// use std::sync::Arc;
    ///
    /// # async fn example() -> Result<(), sqlx_sqlite_conn_mgr::Error> {
    /// // Customize configuration when defaults don't meet your requirements
    /// let custom_config = SqliteDatabaseConfig {
    ///    max_read_connections: 10,
-   ///    idle_timeout: Duration::from_secs(60),
+   ///    idle_timeout_secs: 60,
    /// };
    /// let db = SqliteDatabase::connect("test.db", Some(custom_config)).await?;
    /// # Ok(())
@@ -151,7 +150,9 @@ impl SqliteDatabase {
          let read_pool = SqlitePoolOptions::new()
             .max_connections(config.max_read_connections)
             .min_connections(0)
-            .idle_timeout(Some(config.idle_timeout))
+            .idle_timeout(Some(std::time::Duration::from_secs(
+               config.idle_timeout_secs,
+            )))
             .connect_with(read_options)
             .await?;
 
@@ -161,7 +162,9 @@ impl SqliteDatabase {
          let write_conn = SqlitePoolOptions::new()
             .max_connections(1)
             .min_connections(0)
-            .idle_timeout(Some(config.idle_timeout))
+            .idle_timeout(Some(std::time::Duration::from_secs(
+               config.idle_timeout_secs,
+            )))
             .connect_with(write_options)
             .await?;
 
@@ -529,15 +532,13 @@ mod tests {
 
    #[tokio::test]
    async fn test_custom_config() {
-      use std::time::Duration;
-
       let test_path = std::env::current_dir()
          .unwrap()
          .join("test_custom_config.db");
 
       let custom_config = SqliteDatabaseConfig {
          max_read_connections: 10,
-         idle_timeout: Duration::from_secs(60),
+         idle_timeout_secs: 60,
       };
 
       // Verify custom config is accepted and connection works

crates/sqlx-sqlite-conn-mgr/src/config.rs

@@ -265,9 +265,17 @@ export default class Database {
     *
     * Closes the database connection pool(s) for this specific database.
     *
+    * @returns `true` if the database was loaded and successfully closed,
+    *          `false` if the database was not loaded (nothing to close)
+    *
     * @example
     * ```ts
-    * const success = await db.close()
+    * const wasClosed = await db.close()
+    * if (wasClosed) {
+    *    console.log('Database closed successfully')
+    * } else {
+    *    console.log('Database was not loaded')
+    * }
     * ```
     */
    async close(): Promise<boolean> {
@@ -284,12 +292,11 @@ export default class Database {
     *
     * @example
     * ```ts
-    * const success = await Database.closeAll()
+    * await Database.closeAll()
     * ```
     */
-   static async closeAll(): Promise<boolean> {
-      const success = await invoke<boolean>('plugin:sqlite|close_all')
-      return success
+   static async closeAll(): Promise<void> {
+      await invoke<void>('plugin:sqlite|close_all')
    }
 
    /**
@@ -300,9 +307,17 @@ export default class Database {
     *
     * **Warning:** This permanently deletes the database files from disk. Use with caution!
     *
+    * @returns `true` if the database was loaded and successfully removed,
+    *          `false` if the database was not loaded (nothing to remove)
+    *
     * @example
     * ```ts
-    * const success = await db.remove()
+    * const wasRemoved = await db.remove()
+    * if (wasRemoved) {
+    *    console.log('Database deleted successfully')
+    * } else {
+    *    console.log('Database was not loaded')
+    * }
     * ```
     */
    async remove(): Promise<boolean> {

crates/sqlx-sqlite-conn-mgr/src/database.rs

@@ -0,0 +1,13 @@
+# Automatically generated - DO NOT EDIT!
+
+"$schema" = "../../schemas/schema.json"
+
+[[permission]]
+identifier = "allow-close"
+description = "Enables the close command without any pre-configured scope."
+commands.allow = ["close"]
+
+[[permission]]
+identifier = "deny-close"
+description = "Denies the close command without any pre-configured scope."
+commands.deny = ["close"]

guest-js/index.ts

@@ -0,0 +1,13 @@
+# Automatically generated - DO NOT EDIT!
+
+"$schema" = "../../schemas/schema.json"
+
+[[permission]]
+identifier = "allow-close-all"
+description = "Enables the close_all command without any pre-configured scope."
+commands.allow = ["close_all"]
+
+[[permission]]
+identifier = "deny-close-all"
+description = "Denies the close_all command without any pre-configured scope."
+commands.deny = ["close_all"]