Refactoring

Author: Choochmeque

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "tauri-plugin-iap"
 version = "0.2.1"
-authors = [ "You" ]
+authors = ["You"]
 description = "A Tauri v2 plugin that enables In-App Purchases (IAP)"
 edition = "2021"
 rust-version = "1.77.2"
@@ -12,20 +12,37 @@ repository = "https://github.com/Choochmeque/tauri-plugin-iap"
 
 [features]
 default = ["unstable"]
-unstable = ["dep:swift-bridge", "dep:serde_json", "dep:objc2", "dep:objc2-core-foundation", "dep:objc2-security"]
+unstable = [
+    "dep:swift-bridge",
+    "dep:serde_json",
+    "dep:objc2",
+    "dep:objc2-core-foundation",
+    "dep:objc2-security",
+]
 
 [dependencies]
 tauri = { version = "2.7.0" }
 serde = "1.0"
 thiserror = "2"
 
 [target.'cfg(target_os = "macos")'.dependencies]
-swift-bridge = { version = "0.1", features = ["async"], optional = true}
+swift-bridge = { version = "0.1", features = ["async"], optional = true }
 serde_json = { version = "1.0", optional = true }
 objc2 = { version = "0.6", optional = true }
 objc2-core-foundation = { version = "0.3", optional = true }
 objc2-security = { version = "0.3", optional = true }
 
+[target.'cfg(target_os = "windows")'.dependencies]
+windows = { version = "0.61", features = [
+    "Foundation",
+    "Foundation_Collections",
+    "Services_Store",
+    "System",
+] }
+windows-result = "0.3"
+windows-collections = "0.2"
+serde_json = "1.0"
+
 [build-dependencies]
 tauri-plugin = { version = "2.3.0", features = ["build"] }
 

src/error.rs

@@ -2,16 +2,63 @@ use serde::{ser::Serializer, Serialize};
 
 pub type Result<T> = std::result::Result<T, Error>;
 
+/// Replica of the tauri::plugin::mobile::ErrorResponse for desktop platforms.
+#[cfg(desktop)]
+#[derive(Debug, thiserror::Error, Clone, serde::Deserialize)]
+pub struct ErrorResponse<T = ()> {
+    /// Error code.
+    pub code: Option<String>,
+    /// Error message.
+    pub message: Option<String>,
+    /// Optional error data.
+    #[serde(flatten)]
+    pub data: T,
+}
+
+#[cfg(desktop)]
+impl<T> std::fmt::Display for ErrorResponse<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(code) = &self.code {
+            write!(f, "[{code}]")?;
+            if self.message.is_some() {
+                write!(f, " - ")?;
+            }
+        }
+        if let Some(message) = &self.message {
+            write!(f, "{message}")?;
+        }
+        Ok(())
+    }
+}
+
+/// Replica of the tauri::plugin::mobile::PluginInvokeError for desktop platforms.
+#[cfg(desktop)]
+#[derive(Debug, thiserror::Error)]
+pub enum PluginInvokeError {
+    /// Error returned from direct desktop plugin.
+    #[error(transparent)]
+    InvokeRejected(#[from] ErrorResponse),
+    /// Failed to deserialize response.
+    #[error("failed to deserialize response: {0}")]
+    CannotDeserializeResponse(serde_json::Error),
+    /// Failed to serialize request payload.
+    #[error("failed to serialize payload: {0}")]
+    CannotSerializePayload(serde_json::Error),
+}
+
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
     #[error(transparent)]
     Io(#[from] std::io::Error),
     #[cfg(mobile)]
     #[error(transparent)]
     PluginInvoke(#[from] tauri::plugin::mobile::PluginInvokeError),
-    #[cfg(all(target_os = "macos", feature = "unstable"))]
+    #[cfg(desktop)]
+    #[error(transparent)]
+    PluginInvoke(#[from] crate::error::PluginInvokeError),
+    #[cfg(target_os = "windows")]
     #[error(transparent)]
-    PluginInvoke(#[from] serde_json::Error),
+    WindowsApi(#[from] windows_result::Error),
 }
 
 impl Serialize for Error {

src/lib.rs

@@ -6,7 +6,6 @@ use tauri::{
 pub use models::*;
 
 #[cfg(any(
-    target_os = "windows",
     target_os = "linux",
     all(target_os = "macos", not(feature = "unstable"))
 ))]
@@ -15,6 +14,8 @@ mod desktop;
 mod macos;
 #[cfg(mobile)]
 mod mobile;
+#[cfg(target_os = "windows")]
+mod windows;
 
 mod commands;
 mod error;
@@ -23,7 +24,6 @@ mod models;
 pub use error::{Error, Result};
 
 #[cfg(any(
-    target_os = "windows",
     target_os = "linux",
     all(target_os = "macos", not(feature = "unstable"))
 ))]
@@ -32,6 +32,8 @@ use desktop::Iap;
 use macos::Iap;
 #[cfg(mobile)]
 use mobile::Iap;
+#[cfg(target_os = "windows")]
+use windows::Iap;
 
 /// Extensions to [`tauri::App`], [`tauri::AppHandle`] and [`tauri::Window`] to access the iap APIs.
 pub trait IapExt<R: Runtime> {
@@ -60,8 +62,9 @@ pub fn init<R: Runtime>() -> TauriPlugin<R> {
             let iap = macos::init(app, api)?;
             #[cfg(mobile)]
             let iap = mobile::init(app, api)?;
+            #[cfg(target_os = "windows")]
+            let iap = windows::init(app, api)?;
             #[cfg(any(
-                target_os = "windows",
                 target_os = "linux",
                 all(target_os = "macos", not(feature = "unstable"))
             ))]

src/macos.rs

@@ -18,11 +18,12 @@ mod codesign {
             let self_code_ptr = NonNull::<*mut SecCode>::new_unchecked(&mut self_code);
             let status = SecCode::copy_self(SecCSFlags::empty(), self_code_ptr);
             if status != 0 {
-                return Err(std::io::Error::new(
-                    std::io::ErrorKind::Other,
-                    format!("Failed to get code reference: OSStatus {}", status),
-                )
-                .into());
+                let error_response = crate::error::ErrorResponse {
+                    code: Some(status.to_string()),
+                    message: Some(format!("Failed to get code reference: OSStatus {status}")),
+                    data: (),
+                };
+                return Err(crate::error::PluginInvokeError::InvokeRejected(error_response).into());
             }
 
             // 2) Validate the dynamic code - this checks if the signature is valid
@@ -32,11 +33,14 @@ mod codesign {
             let self_code_ref = self_code_ptr.as_ref().as_ref().unwrap();
             let status = SecCode::check_validity(self_code_ref, validity_flags, None);
             if status != 0 {
-                return Err(std::io::Error::new(
-                    std::io::ErrorKind::Other,
-                    format!("Code signature validation failed: OSStatus {}", status),
-                )
-                .into());
+                let error_response = crate::error::ErrorResponse {
+                    code: Some(status.to_string()),
+                    message: Some(format!(
+                        "Code signature validation failed: OSStatus {status}"
+                    )),
+                    data: (),
+                };
+                return Err(crate::error::PluginInvokeError::InvokeRejected(error_response).into());
             }
 
             Ok(())
@@ -80,10 +84,18 @@ impl<R: Runtime> Iap<R> {
     fn to_result<T: serde::de::DeserializeOwned>(bridged: ffi::FFIResult) -> crate::Result<T> {
         match bridged {
             ffi::FFIResult::Ok(response) => {
-                let parsed: T = serde_json::from_str(&response)?;
+                let parsed: T = serde_json::from_str(&response)
+                    .map_err(crate::error::PluginInvokeError::CannotDeserializeResponse)?;
                 Ok(parsed)
             }
-            ffi::FFIResult::Err(err) => Err(std::io::Error::other(err).into()),
+            ffi::FFIResult::Err(err) => {
+                let error_response = crate::error::ErrorResponse {
+                    code: None,
+                    message: Some(err),
+                    data: (),
+                };
+                Err(crate::error::PluginInvokeError::InvokeRejected(error_response).into())
+            }
         }
     }