Added appAccountToken for ios

Author: Choochmeque

guest-js/index.ts

@@ -1,10 +1,16 @@
 import { invoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
 
+/**
+ * Response from IAP initialization
+ */
 export interface InitializeResponse {
   success: boolean;
 }
 
+/**
+ * Represents a pricing phase for subscription products
+ */
 export interface PricingPhase {
   formattedPrice: string;
   priceCurrencyCode: string;
@@ -14,13 +20,19 @@ export interface PricingPhase {
   recurrenceMode: number;
 }
 
+/**
+ * Subscription offer details including pricing phases
+ */
 export interface SubscriptionOffer {
   offerToken: string;
   basePlanId: string;
   offerId?: string;
   pricingPhases: PricingPhase[];
 }
 
+/**
+ * Product information from the app store
+ */
 export interface Product {
   productId: string;
   title: string;
@@ -32,10 +44,16 @@ export interface Product {
   subscriptionOfferDetails?: SubscriptionOffer[];
 }
 
+/**
+ * Response containing products fetched from the store
+ */
 export interface GetProductsResponse {
   products: Product[];
 }
 
+/**
+ * Purchase transaction information
+ */
 export interface Purchase {
   orderId?: string;
   packageName: string;
@@ -49,10 +67,16 @@ export interface Purchase {
   signature: string;
 }
 
+/**
+ * Response containing restored purchases
+ */
 export interface RestorePurchasesResponse {
   purchases: Purchase[];
 }
 
+/**
+ * Historical purchase record
+ */
 export interface PurchaseHistoryRecord {
   productId: string;
   purchaseTime: number;
@@ -62,20 +86,32 @@ export interface PurchaseHistoryRecord {
   signature: string;
 }
 
+/**
+ * Response containing purchase history
+ */
 export interface GetPurchaseHistoryResponse {
   history: PurchaseHistoryRecord[];
 }
 
+/**
+ * Response from acknowledging a purchase
+ */
 export interface AcknowledgePurchaseResponse {
   success: boolean;
 }
 
+/**
+ * Purchase state enumeration
+ */
 export enum PurchaseState {
   PURCHASED = 0,
   CANCELED = 1,
   PENDING = 2,
 }
 
+/**
+ * Current status of a product for the user
+ */
 export interface ProductStatus {
   productId: string;
   isOwned: boolean;
@@ -87,16 +123,51 @@ export interface ProductStatus {
   purchaseToken?: string;
 }
 
+/**
+ * Optional parameters for purchase requests
+ */
 export interface PurchaseOptions {
+  /** Offer token for subscription products (Android) */
   offerToken?: string;
+  /** Obfuscated account identifier for fraud prevention (Android only) */
   obfuscatedAccountId?: string;
+  /** Obfuscated profile identifier for fraud prevention (Android only) */
   obfuscatedProfileId?: string;
+  /** App account token - must be a valid UUID string (iOS only) */
+  appAccountToken?: string;
 }
 
+/**
+ * Initialize the IAP plugin.
+ * Must be called before any other IAP operations.
+ * 
+ * @returns Promise resolving to initialization status
+ * @example
+ * ```typescript
+ * const result = await initialize();
+ * if (result.success) {
+ *   console.log('IAP initialized successfully');
+ * }
+ * ```
+ */
 export async function initialize(): Promise<InitializeResponse> {
   return await invoke<InitializeResponse>("plugin:iap|initialize");
 }
 
+/**
+ * Fetch product information from the app store.
+ * 
+ * @param productIds - Array of product identifiers to fetch
+ * @param productType - Type of products: "subs" for subscriptions, "inapp" for one-time purchases
+ * @returns Promise resolving to product information
+ * @example
+ * ```typescript
+ * const { products } = await getProducts(
+ *   ['com.example.premium', 'com.example.remove_ads'],
+ *   'inapp'
+ * );
+ * ```
+ */
 export async function getProducts(
   productIds: string[],
   productType: "subs" | "inapp" = "subs",
@@ -109,6 +180,31 @@ export async function getProducts(
   });
 }
 
+/**
+ * Initiate a purchase for the specified product.
+ * 
+ * @param productId - Product identifier to purchase
+ * @param productType - Type of product: "subs" or "inapp"
+ * @param options - Optional purchase parameters (platform-specific)
+ * @returns Promise resolving to purchase transaction details
+ * @example
+ * ```typescript
+ * // Simple purchase
+ * const purchase = await purchase('com.example.premium', 'subs');
+ * 
+ * // With options (iOS)
+ * const purchase = await purchase('com.example.premium', 'subs', {
+ *   appAccountToken: '550e8400-e29b-41d4-a716-446655440000' // Must be valid UUID
+ * });
+ * 
+ * // With options (Android)
+ * const purchase = await purchase('com.example.premium', 'subs', {
+ *   offerToken: 'offer_token_here',
+ *   obfuscatedAccountId: 'user_account_id',
+ *   obfuscatedProfileId: 'user_profile_id'
+ * });
+ * ```
+ */
 export async function purchase(
   productId: string,
   productType: "subs" | "inapp" = "subs",
@@ -123,6 +219,19 @@ export async function purchase(
   });
 }
 
+/**
+ * Restore user's previous purchases.
+ * 
+ * @param productType - Type of products to restore: "subs" or "inapp"
+ * @returns Promise resolving to list of restored purchases
+ * @example
+ * ```typescript
+ * const { purchases } = await restorePurchases('subs');
+ * purchases.forEach(purchase => {
+ *   console.log(`Restored: ${purchase.productId}`);
+ * });
+ * ```
+ */
 export async function restorePurchases(
   productType: "subs" | "inapp" = "subs",
 ): Promise<RestorePurchasesResponse> {
@@ -136,12 +245,40 @@ export async function restorePurchases(
   );
 }
 
+/**
+ * Get the user's purchase history.
+ * Note: Not supported on all platforms.
+ * 
+ * @returns Promise resolving to purchase history
+ * @example
+ * ```typescript
+ * const { history } = await getPurchaseHistory();
+ * history.forEach(record => {
+ *   console.log(`Purchase: ${record.productId} at ${record.purchaseTime}`);
+ * });
+ * ```
+ */
 export async function getPurchaseHistory(): Promise<GetPurchaseHistoryResponse> {
   return await invoke<GetPurchaseHistoryResponse>(
     "plugin:iap|get_purchase_history",
   );
 }
 
+/**
+ * Acknowledge a purchase (Android only).
+ * Purchases must be acknowledged within 3 days or they will be refunded.
+ * iOS automatically acknowledges purchases.
+ * 
+ * @param purchaseToken - Purchase token from the transaction
+ * @returns Promise resolving to acknowledgment status
+ * @example
+ * ```typescript
+ * const result = await acknowledgePurchase(purchase.purchaseToken);
+ * if (result.success) {
+ *   console.log('Purchase acknowledged');
+ * }
+ * ```
+ */
 export async function acknowledgePurchase(
   purchaseToken: string,
 ): Promise<AcknowledgePurchaseResponse> {
@@ -155,6 +292,24 @@ export async function acknowledgePurchase(
   );
 }
 
+/**
+ * Get the current status of a product for the user.
+ * Checks if the product is owned, expired, or available for purchase.
+ * 
+ * @param productId - Product identifier to check
+ * @param productType - Type of product: "subs" or "inapp"
+ * @returns Promise resolving to product status
+ * @example
+ * ```typescript
+ * const status = await getProductStatus('com.example.premium', 'subs');
+ * if (status.isOwned) {
+ *   console.log('User owns this product');
+ *   if (status.isAutoRenewing) {
+ *     console.log('Subscription is auto-renewing');
+ *   }
+ * }
+ * ```
+ */
 export async function getProductStatus(
   productId: string,
   productType: "subs" | "inapp" = "subs",
@@ -167,7 +322,25 @@ export async function getProductStatus(
   });
 }
 
-// Event listener for purchase updates
+/**
+ * Listen for purchase updates.
+ * This event is triggered when a purchase state changes.
+ * 
+ * @param callback - Function to call when a purchase is updated
+ * @returns Cleanup function to stop listening
+ * @example
+ * ```typescript
+ * const unsubscribe = onPurchaseUpdated((purchase) => {
+ *   console.log(`Purchase updated: ${purchase.productId}`);
+ *   if (purchase.purchaseState === PurchaseState.PURCHASED) {
+ *     // Handle successful purchase
+ *   }
+ * });
+ * 
+ * // Later, stop listening
+ * unsubscribe();
+ * ```
+ */
 export function onPurchaseUpdated(
   callback: (purchase: Purchase) => void,
 ): () => void {

ios/Sources/IapPlugin.swift

@@ -14,6 +14,7 @@ class PurchaseArgs: Decodable {
     let productId: String
     let productType: String?
     let offerToken: String?
+    let appAccountToken: String?
 }
 
 class RestorePurchasesArgs: Decodable {
@@ -157,8 +158,22 @@ class IapPlugin: Plugin {
                 return
             }
 
-            // Initiate purchase
-            let result = try await product.purchase()
+            // Prepare purchase options
+            var purchaseOptions: Set<Product.PurchaseOption> = []
+            
+            // Add appAccountToken if provided (must be a valid UUID)
+            if let appAccountToken = args.appAccountToken {
+                guard let uuid = UUID(uuidString: appAccountToken) else {
+                    invoke.reject("Invalid appAccountToken: must be a valid UUID string")
+                    return
+                }
+                purchaseOptions.insert(.appAccountToken(uuid))
+            }
+            
+            // Initiate purchase with options
+            let result = purchaseOptions.isEmpty 
+                ? try await product.purchase()
+                : try await product.purchase(options: purchaseOptions)
 
             switch result {
             case .success(let verification):

src/commands.rs

@@ -22,11 +22,8 @@ pub(crate) async fn purchase<R: Runtime>(
     app: AppHandle<R>,
     payload: PurchaseRequest,
 ) -> Result<Purchase> {
-    app.iap().purchase(
-        payload.product_id,
-        payload.product_type,
-        payload.options,
-    )
+    app.iap()
+        .purchase(payload.product_id, payload.product_type, payload.options)
 }
 
 #[command]

src/models.rs

@@ -74,6 +74,8 @@ pub struct PurchaseOptions {
     pub obfuscated_account_id: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub obfuscated_profile_id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub app_account_token: Option<String>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]