refactor: use builder style (#50)

* refactor(upload): use plugin builder style

* refactor(sql): use builder style

* refactor(fs-watch): use builder style

* refactor(fs-extra): use builder style

* refactor(auth): use builder style

* fmt

* fmt

Co-authored-by: FabianLars <fabianlars@fabianlars.de>

plugins/authenticator/guest-js/index.ts

@@ -2,7 +2,7 @@ import { invoke } from "@tauri-apps/api/tauri";
 
 export class Authenticator {
   async init(): Promise<void> {
-    return await invoke("plugin:authenticator|init");
+    return await invoke("plugin:authenticator|init_auth");
   }
 
   async register(challenge: string, application: string): Promise<string> {

plugins/authenticator/src/lib.rs

@@ -6,13 +6,16 @@ mod auth;
 mod error;
 mod u2f;
 
-use tauri::{plugin::Plugin, Invoke, Runtime};
+use tauri::{
+    plugin::{Builder as PluginBuilder, TauriPlugin},
+    Runtime,
+};
 
 pub use error::Error;
 type Result<T> = std::result::Result<T, Error>;
 
 #[tauri::command]
-fn init() {
+fn init_auth() {
     auth::init_usb();
 }
 
@@ -60,30 +63,14 @@ fn verify_signature(
     )
 }
 
-pub struct TauriAuthenticator<R: Runtime> {
+pub fn init<R: Runtime>() -> TauriPlugin<R> {
-    invoke_handler: Box<dyn Fn(Invoke<R>) + Send + Sync>,
+    PluginBuilder::new("authenticator")
-}
+        .invoke_handler(tauri::generate_handler![
-
+            init_auth,
-impl<R: Runtime> Default for TauriAuthenticator<R> {
-    fn default() -> Self {
-        Self {
-            invoke_handler: Box::new(tauri::generate_handler![
-                init,
             register,
             verify_registration,
             sign,
             verify_signature
-            ]),
+        ])
-        }
+        .build()
-    }
-}
-
-impl<R: Runtime> Plugin<R> for TauriAuthenticator<R> {
-    fn name(&self) -> &'static str {
-        "authenticator"
-    }
-
-    fn extend_api(&mut self, invoke: Invoke<R>) {
-        (self.invoke_handler)(invoke)
-    }
 }

plugins/fs-extra/src/lib.rs

@@ -3,7 +3,11 @@
 // SPDX-License-Identifier: MIT
 
 use serde::{ser::Serializer, Serialize};
-use tauri::{command, plugin::Plugin, Invoke, Runtime};
+use tauri::{
+    command,
+    plugin::{Builder as PluginBuilder, TauriPlugin},
+    Runtime,
+};
 
 use std::{
     path::PathBuf,
@@ -121,25 +125,8 @@ async fn exists(path: PathBuf) -> bool {
     path.exists()
 }
 
-/// Tauri plugin.
+pub fn init<R: Runtime>() -> TauriPlugin<R> {
-pub struct FsExtra<R: Runtime> {
+    PluginBuilder::new("fs-extra")
-    invoke_handler: Box<dyn Fn(Invoke<R>) + Send + Sync>,
+        .invoke_handler(tauri::generate_handler![exists, metadata])
-}
+        .build()
-
-impl<R: Runtime> Default for FsExtra<R> {
-    fn default() -> Self {
-        Self {
-            invoke_handler: Box::new(tauri::generate_handler![exists, metadata]),
-        }
-    }
-}
-
-impl<R: Runtime> Plugin<R> for FsExtra<R> {
-    fn name(&self) -> &'static str {
-        "fs-extra"
-    }
-
-    fn extend_api(&mut self, message: Invoke<R>) {
-        (self.invoke_handler)(message)
-    }
 }

plugins/fs-watch/src/lib.rs

@@ -3,8 +3,11 @@ use notify::{
     Watcher as _,
 };
 use serde::{ser::Serializer, Deserialize, Serialize};
-use serde_json::Value as JsonValue;
+use tauri::{
-use tauri::{command, plugin::Plugin, AppHandle, Invoke, Manager, Runtime, State, Window};
+    command,
+    plugin::{Builder as PluginBuilder, TauriPlugin},
+    Manager, Runtime, State, Window,
+};
 
 use std::{
     collections::HashMap,
@@ -160,30 +163,12 @@ async fn unwatch(watchers: State<'_, WatcherCollection>, id: Id) -> Result<()> {
     Ok(())
 }
 
-/// Tauri plugin.
+pub fn init<R: Runtime>() -> TauriPlugin<R> {
-pub struct Watcher<R: Runtime> {
+    PluginBuilder::new("fs-watch")
-    invoke_handler: Box<dyn Fn(Invoke<R>) + Send + Sync>,
+        .invoke_handler(tauri::generate_handler![watch, unwatch])
-}
+        .setup(|app| {
-
-impl<R: Runtime> Default for Watcher<R> {
-    fn default() -> Self {
-        Self {
-            invoke_handler: Box::new(tauri::generate_handler![watch, unwatch]),
-        }
-    }
-}
-
-impl<R: Runtime> Plugin<R> for Watcher<R> {
-    fn name(&self) -> &'static str {
-        "fs-watch"
-    }
-
-    fn initialize(&mut self, app: &AppHandle<R>, _config: JsonValue) -> tauri::plugin::Result<()> {
             app.manage(WatcherCollection::default());
             Ok(())
-    }
+        })
-
+        .build()
-    fn extend_api(&mut self, message: Invoke<R>) {
-        (self.invoke_handler)(message)
-    }
 }

plugins/sql/src/plugin.rs

@@ -14,8 +14,8 @@ use sqlx::{
 };
 use tauri::{
     command,
-    plugin::{Plugin, Result as PluginResult},
+    plugin::{Builder as PluginBuilder, TauriPlugin},
-    AppHandle, Invoke, Manager, RunEvent, Runtime, State,
+    AppHandle, Manager, RunEvent, Runtime, State,
 };
 use tokio::sync::Mutex;
 
@@ -92,7 +92,7 @@ struct DbInstances(Mutex<HashMap<String, Pool<Db>>>);
 struct Migrations(Mutex<HashMap<String, MigrationList>>);
 
 #[derive(Default, Deserialize)]
-struct PluginConfig {
+pub struct PluginConfig {
     #[serde(default)]
     preload: Vec<String>,
 }
@@ -300,49 +300,31 @@ async fn select(
     Ok(values)
 }
 
-/// Tauri SQL plugin.
+/// Tauri SQL plugin builder.
-pub struct TauriSql<R: Runtime> {
+pub struct Builder {
     migrations: Option<HashMap<String, MigrationList>>,
-    invoke_handler: Box<dyn Fn(Invoke<R>) + Send + Sync>,
 }
 
-impl<R: Runtime> Default for TauriSql<R> {
+impl Builder {
-    fn default() -> Self {
-        Self {
-            migrations: Some(Default::default()),
-            invoke_handler: Box::new(tauri::generate_handler![load, execute, select, close]),
-        }
-    }
-}
-
-impl<R: Runtime> TauriSql<R> {
     /// Add migrations to a database.
     #[must_use]
     pub fn add_migrations(mut self, db_url: &str, migrations: Vec<Migration>) -> Self {
         self.migrations
-            .as_mut()
+            .get_or_insert(Default::default())
-            .unwrap()
             .insert(db_url.to_string(), MigrationList(migrations));
         self
     }
-}
-
-impl<R: Runtime> Plugin<R> for TauriSql<R> {
-    fn name(&self) -> &'static str {
-        "sql"
-    }
 
-    fn initialize(&mut self, app: &AppHandle<R>, config: serde_json::Value) -> PluginResult<()> {
+    pub fn build<R: Runtime>(mut self) -> TauriPlugin<R, Option<PluginConfig>> {
-        tauri::async_runtime::block_on(async move {
+        PluginBuilder::new("sql")
-            let config: PluginConfig = if config.is_null() {
+            .invoke_handler(tauri::generate_handler![load, execute, select, close])
-                Default::default()
+            .setup_with_config(|app, config: Option<PluginConfig>| {
-            } else {
+                let config = config.unwrap_or_default();
-                serde_json::from_value(config)?
-            };
 
                 #[cfg(feature = "sqlite")]
                 create_dir_all(app_path(app)).expect("problems creating App directory!");
 
+                tauri::async_runtime::block_on(async move {
                     let instances = DbInstances::default();
                     let mut lock = instances.0.lock().await;
                     for db in config.preload {
@@ -363,17 +345,14 @@ impl<R: Runtime> Plugin<R> for TauriSql<R> {
                         lock.insert(db, pool);
                     }
                     drop(lock);
+
                     app.manage(instances);
                     app.manage(Migrations(Mutex::new(self.migrations.take().unwrap())));
+
                     Ok(())
                 })
-    }
+            })
-
+            .on_event(|app, event| {
-    fn extend_api(&mut self, message: Invoke<R>) {
-        (self.invoke_handler)(message)
-    }
-
-    fn on_event(&mut self, app: &AppHandle<R>, event: &RunEvent) {
                 if let RunEvent::Exit = event {
                     tauri::async_runtime::block_on(async move {
                         let instances = &*app.state::<DbInstances>();
@@ -383,5 +362,7 @@ impl<R: Runtime> Plugin<R> for TauriSql<R> {
                         }
                     });
                 }
+            })
+            .build()
     }
 }

plugins/upload/src/lib.rs

@@ -4,7 +4,11 @@
 
 use futures::TryStreamExt;
 use serde::{ser::Serializer, Serialize};
-use tauri::{command, plugin::Plugin, Invoke, Runtime, Window};
+use tauri::{
+    command,
+    plugin::{Builder as PluginBuilder, TauriPlugin},
+    Runtime, Window,
+};
 use tokio::fs::File;
 use tokio_util::codec::{BytesCodec, FramedRead};
 
@@ -82,25 +86,8 @@ fn file_to_body<R: Runtime>(id: u32, window: Window<R>, file: File) -> reqwest::
     ))
 }
 
-/// Tauri plugin.
+pub fn init<R: Runtime>() -> TauriPlugin<R> {
-pub struct Upload<R: Runtime> {
+    PluginBuilder::new("upload")
-    invoke_handler: Box<dyn Fn(Invoke<R>) + Send + Sync>,
+        .invoke_handler(tauri::generate_handler![upload])
-}
+        .build()
-
-impl<R: Runtime> Default for Upload<R> {
-    fn default() -> Self {
-        Self {
-            invoke_handler: Box::new(tauri::generate_handler![upload]),
-        }
-    }
-}
-
-impl<R: Runtime> Plugin<R> for Upload<R> {
-    fn name(&self) -> &'static str {
-        "upload"
-    }
-
-    fn extend_api(&mut self, message: Invoke<R>) {
-        (self.invoke_handler)(message)
-    }
 }