Attempt to fix tauri plugin init

Author: AnthonyRonning

frontend/src-tauri/capabilities/default.json

@@ -28,6 +28,7 @@
         }
       ]
     },
-    "sign-in-with-apple:default"
+    "sign-in-with-apple:default",
+    "store:allow-get-region"
   ]
 }

frontend/src-tauri/capabilities/mobile-ios.json

@@ -29,6 +29,7 @@
         }
       ]
     },
-    "sign-in-with-apple:default"
+    "sign-in-with-apple:default",
+    "store:allow-get-region"
   ]
 }

frontend/src/utils/region-gate.ts

@@ -8,31 +8,58 @@ const US_CODES = ["USA", "ASM", "GUM", "PRI", "VIR", "MNP", "UMI"]; // US and te
  * Note: The Swift code returns "UNKNOWN" if it can't determine the region.
  */
 export async function getStoreRegion(): Promise<string> {
-  console.log("[Region Gate] Attempting to invoke plugin:store|get_region...");
+  // First, check if we're running on iOS
+  let isIOSPlatform = false;
   try {
+    console.log("[Region Gate] Checking if running on iOS...");
+    const { isTauri } = await import("@tauri-apps/api/core");
+    const isTauriEnv = await isTauri();
+
+    if (isTauriEnv) {
+      const { type } = await import("@tauri-apps/plugin-os");
+      const platform = await type();
+      isIOSPlatform = platform === "ios";
+      console.log("[Region Gate] Platform check:", platform, "iOS:", isIOSPlatform);
+    } else {
+      console.log("[Region Gate] Not in Tauri environment");
+      return "NOT_TAURI";
+    }
+  } catch (e) {
+    console.error("[Region Gate] Error checking platform:", e);
+    return "PLATFORM_ERROR";
+  }
+
+  // If not on iOS, no need to call the plugin
+  if (!isIOSPlatform) {
+    console.log("[Region Gate] Not on iOS, skipping region check");
+    return "NOT_IOS";
+  }
+
+  // We're on iOS, try to get the App Store region
+  console.log("[Region Gate] On iOS, invoking store plugin...");
+  try {
+    // Using the same pattern as sign-in-with-apple
     const code = await invoke<string>("plugin:store|get_region");
-    console.log("[Region Gate] Success! Store region code:", code);
+    console.log("[Region Gate] Successfully got region code:", code);
     return code;
   } catch (error) {
-    console.error("[Region Gate] Error invoking plugin:", error);
-    console.error("[Region Gate] Stack trace:", new Error().stack);
+    // Format error consistently with other plugin patterns
+    console.error("[Region Gate] Error getting region:", error);
 
-    // Return the error message for diagnosis
-    let errorMsg = "Error: ";
     if (error instanceof Error) {
-      errorMsg += error.message;
+      console.error("[Region Gate] Error name:", error.name);
+      console.error("[Region Gate] Error message:", error.message);
+      return `ERROR:${error.name}:${error.message.substring(0, 50)}`;
     } else if (typeof error === "string") {
-      errorMsg += error;
+      return `ERROR:${error.substring(0, 50)}`;
     } else {
-      errorMsg += JSON.stringify(error);
+      try {
+        const errorStr = JSON.stringify(error).substring(0, 50);
+        return `ERROR:JSON:${errorStr}`;
+      } catch {
+        return "ERROR:UNKNOWN";
+      }
     }
-
-    // Truncate if the error message is too long
-    if (errorMsg.length > 30) {
-      errorMsg = errorMsg.substring(0, 27) + "...";
-    }
-
-    return errorMsg;
   }
 }
 

plugins/store/src/mobile.rs

@@ -12,12 +12,19 @@ pub fn init<R: Runtime, C: DeserializeOwned>(
     _app: &AppHandle<R>,
     api: PluginApi<R, C>,
 ) -> crate::Result<Store<R>> {
+    // For iOS, use the actual plugin
     #[cfg(target_os = "ios")]
-    let handle = api.register_ios_plugin(init_plugin_store)?;
+    let handle = {
+        println!("[Store Plugin] Registering iOS plugin");
+        let handle = api.register_ios_plugin(init_plugin_store)?;
+        println!("[Store Plugin] Successfully registered iOS plugin");
+        handle
+    };
 
+    // For other platforms, use a dummy handle
     #[cfg(not(target_os = "ios"))]
     let handle = {
-        // Dummy handle for non-iOS platforms
+        println!("[Store Plugin] Creating dummy handle for non-iOS platform");
         let handle: PluginHandle<R> = unsafe { std::mem::zeroed() };
         handle
     };
@@ -30,9 +37,23 @@ pub struct Store<R: Runtime>(PluginHandle<R>);
 
 impl<R: Runtime> Store<R> {
     pub fn get_region(&self) -> crate::Result<String> {
-        self.0
-            .run_mobile_plugin("getRegion", ())
-            .map_err(Into::into)
+        println!("[Store Plugin] Calling getRegion");
+        #[cfg(target_os = "ios")]
+        let result = self.0.run_mobile_plugin("getRegion", ());
+        
+        #[cfg(not(target_os = "ios"))]
+        let result = {
+            println!("[Store Plugin] Non-iOS platform, returning UNKNOWN");
+            Ok(String::from("UNKNOWN"))
+        };
+        
+        // Log the result and convert any errors
+        match &result {
+            Ok(region) => println!("[Store Plugin] getRegion success: {}", region),
+            Err(e) => println!("[Store Plugin] getRegion error: {:?}", e),
+        }
+        
+        result.map_err(Into::into)
     }
 }