feat: add support for custom headers in addPassFromUrl (#41)

* feat: add support for custom headers in addPassFromUrl

Updates addPassFromUrl to accept optional headers parameter for authenticated requests. Changes iOS implementation from direct Data(contentsOf:) to URLSession with proper header and error handling.

* fix(ios): resolve promise when pass already exists in wallet

Set completion handler before calling showViewController so that
when containsPass() returns true, the completion callback is properly
invoked instead of being nil.

* feat: add detailed error codes to addPassFromUrl

- Change completion handler to return error code and message
- Use Promise rejection instead of resolve(false) for failures
- Add specific error codes: INVALID_URL, NETWORK_ERROR, HTTP_ERROR,
  INVALID_DATA, INVALID_PASS, PASS_ALREADY_EXISTS, NO_VIEW_CONTROLLER,
  CONTROLLER_ERROR, USER_CANCELLED
- Export WalletErrorCode and WalletError types for TypeScript consumers

* chore: add .yarn/ to gitignore

* fix: address code review issues in addPassFromUrl

- Accept all 2xx HTTP status codes, not just 200
- Replace deprecated keyWindow with UIWindowScene API
- Remove redundant message property from WalletError type

* feat(android): implement addPassFromUrl with URL fetch and headers

- Fetch JWT from URL with optional custom headers support
- Pass fetched JWT to Google Wallet savePassesJwt API
- Add consistent error codes: INVALID_URL, NETWORK_ERROR, HTTP_ERROR,
  NO_ACTIVITY, API_ERROR, GENERAL_ERROR
- Remove Linking.openURL fallback, use native implementation
- Update WalletErrorCode type with Android-specific codes

Author: mgcrea

.gitignore

@@ -46,6 +46,7 @@ node_modules/
 npm-debug.log
 yarn-debug.log
 yarn-error.log
+.yarn/
 
 # BUCK
 buck-out/

android/src/main/java/com/reactnativewalletmanager/WalletManagerModule.kt

@@ -5,9 +5,13 @@ import android.content.Intent;
 import com.facebook.react.bridge.BaseActivityEventListener;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
 import com.google.android.gms.pay.PayClient;
 import com.google.android.gms.pay.Pay;
 import com.google.android.gms.pay.PayApiAvailabilityStatus;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.MalformedURLException;
 
 class WalletManagerModule(reactContext: ReactApplicationContext) : NativeWalletManagerSpec(reactContext) {
 
@@ -93,8 +97,71 @@ class WalletManagerModule(reactContext: ReactApplicationContext) : NativeWalletM
     promise.reject("UNSUPPORTED_PLATFORM", "This function is not supported on Android.")
   }
 
-  override fun addPassFromUrl(url: String, promise: Promise) {
-    promise.reject("UNSUPPORTED_PLATFORM", "This function is not supported on Android.")
+  override fun addPassFromUrl(url: String, headers: ReadableMap?, promise: Promise) {
+    val activity = currentActivity
+    if (activity == null) {
+      promise.reject("NO_ACTIVITY", "Current activity is unavailable")
+      return
+    }
+
+    // Validate URL before starting network request
+    val parsedUrl: URL
+    try {
+      parsedUrl = URL(url)
+    } catch (e: MalformedURLException) {
+      promise.reject("INVALID_URL", "The URL is invalid")
+      return
+    }
+
+    // Run network request on background thread
+    Thread {
+      var connection: HttpURLConnection? = null
+      try {
+        connection = parsedUrl.openConnection() as HttpURLConnection
+        connection.requestMethod = "GET"
+
+        // Add custom headers
+        headers?.let { map ->
+          val iterator = map.keySetIterator()
+          while (iterator.hasNextKey()) {
+            val key = iterator.nextKey()
+            connection.setRequestProperty(key, map.getString(key))
+          }
+        }
+
+        val responseCode = connection.responseCode
+        if (responseCode !in 200..299) {
+          promise.reject("HTTP_ERROR", "HTTP $responseCode")
+          return@Thread
+        }
+
+        val jwt = connection.inputStream.bufferedReader().use { it.readText() }
+
+        // Save to Google Wallet on main thread
+        activity.runOnUiThread {
+          addPassPromise = promise
+          try {
+            walletClient.savePassesJwt(jwt, activity, ADD_TO_GOOGLE_WALLET_REQUEST_CODE)
+          } catch (e: Exception) {
+            addPassPromise = null
+            when (e) {
+              is com.google.android.gms.common.api.ApiException -> {
+                val statusCode = e.statusCode
+                val statusMessage = com.google.android.gms.common.api.CommonStatusCodes.getStatusCodeString(statusCode)
+                promise.reject("API_ERROR", "Google Pay API error: $statusCode - $statusMessage")
+              }
+              else -> {
+                promise.reject("GENERAL_ERROR", e.message ?: "Failed to save pass")
+              }
+            }
+          }
+        }
+      } catch (e: Exception) {
+        promise.reject("NETWORK_ERROR", e.message ?: "Network request failed")
+      } finally {
+        connection?.disconnect()
+      }
+    }.start()
   }
 
   override fun hasPass(cardIdentifier: String, serialNumber: String?, promise: Promise) {

ios/WalletManager.mm

@@ -22,10 +22,14 @@ @implementation NativeWalletManager
     return std::make_shared<facebook::react::NativeWalletManagerSpecJSI>(params);
 }
 
-- (void)addPassFromUrl:(nonnull NSString *)url resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
-  [walletManager addPassFromUrl:url completion:^(BOOL added) {
-         resolve(@(added));
-     }];
+- (void)addPassFromUrl:(nonnull NSString *)url headers:(nullable NSDictionary *)headers resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+  [walletManager addPassFromUrl:url headers:headers completion:^(BOOL success, NSString *errorCode, NSString *errorMessage) {
+    if (success) {
+      resolve(@(YES));
+    } else {
+      reject(errorCode, errorMessage, nil);
+    }
+  }];
 }
 
 - (void)addPassToGoogleWallet:(nonnull NSString *)jwt resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {

ios/WalletManagerImpl.swift

@@ -12,7 +12,7 @@ import PassKit
 public class WalletManagerImpl: NSObject, @preconcurrency PKAddPassesViewControllerDelegate {
   private var pass: PKPass?
   private var passLibrary: PKPassLibrary?
-  private var completion: ((Bool) -> Void)?
+  private var completion: ((Bool, String?, String?) -> Void)?
 
   // MARK: - canAddPasses
 
@@ -36,24 +36,55 @@ public class WalletManagerImpl: NSObject, @preconcurrency PKAddPassesViewControl
 
   // MARK: - addPassFromUrl
 
-  @MainActor @objc(addPassFromUrl:completion:)
+  @MainActor @objc(addPassFromUrl:headers:completion:)
   public func addPassFromUrl(_ passUrlString: String,
-                             completion: @escaping (Bool) -> Void
+                             headers: [String: String]?,
+                             completion: @escaping (Bool, String?, String?) -> Void
   ) {
     guard let url = URL(string: passUrlString) else {
-      completion(false)
-      print("wallet", "The pass URL is invalid")
+      completion(false, "INVALID_URL", "The pass URL is invalid")
       return
     }
-    
-    guard let data = try? Data(contentsOf: url) else {
-      completion(false)
-      print("wallet", "The pass data is invalid")
-      return
+
+    var request = URLRequest(url: url)
+    request.httpMethod = "GET"
+
+    // Add custom headers (for authentication)
+    if let headers = headers {
+      for (key, value) in headers {
+        request.setValue(value, forHTTPHeaderField: key)
+      }
     }
-    
-    self.showViewController(with: data)
-    self.completion = completion
+
+    URLSession.shared.dataTask(with: request) { [weak self] data, response, error in
+      guard let self = self else { return }
+
+      if let error = error {
+        DispatchQueue.main.async {
+          completion(false, "NETWORK_ERROR", error.localizedDescription)
+        }
+        return
+      }
+
+      if let httpResponse = response as? HTTPURLResponse, !(200...299).contains(httpResponse.statusCode) {
+        DispatchQueue.main.async {
+          completion(false, "HTTP_ERROR", "HTTP \(httpResponse.statusCode)")
+        }
+        return
+      }
+
+      guard let data = data else {
+        DispatchQueue.main.async {
+          completion(false, "INVALID_DATA", "No data received")
+        }
+        return
+      }
+
+      DispatchQueue.main.async {
+        self.completion = completion
+        self.showViewController(with: data)
+      }
+    }.resume()
   }
 
   // MARK: - hasPass
@@ -113,22 +144,25 @@ public class WalletManagerImpl: NSObject, @preconcurrency PKAddPassesViewControl
 
   @MainActor private func showViewController(with data: Data) {
     guard let pass = try? PKPass(data: data) else {
-      addPassCompletion(false)
-      print("wallet", "The pass is invalid")
+      addPassCompletion(false, "INVALID_PASS", "Failed to parse pass data")
       return
     }
 
     self.pass = pass
     self.passLibrary = PKPassLibrary()
 
     if self.passLibrary?.containsPass(pass) == true {
-      addPassCompletion(false)
-      return print("wallet", "pass already added")
+      addPassCompletion(false, "PASS_ALREADY_EXISTS", "This pass is already in your wallet")
+      return
     }
 
-    guard let root = UIApplication.shared.keyWindow?.rootViewController else {
-      addPassCompletion(false)
-      return print("wallet", "No rootViewController found")
+    guard let windowScene = UIApplication.shared.connectedScenes
+      .compactMap({ $0 as? UIWindowScene })
+      .first(where: { $0.activationState == .foregroundActive }),
+      let root = windowScene.windows.first(where: { $0.isKeyWindow })?.rootViewController
+    else {
+      addPassCompletion(false, "NO_VIEW_CONTROLLER", "No root view controller found")
+      return
     }
 
     var top = root
@@ -137,8 +171,8 @@ public class WalletManagerImpl: NSObject, @preconcurrency PKAddPassesViewControl
     }
 
     guard let controller = PKAddPassesViewController(pass: pass) else {
-      addPassCompletion(false)
-      return print("wallet", "no PKAddPassesViewController")
+      addPassCompletion(false, "CONTROLLER_ERROR", "Failed to create pass controller")
+      return
     }
     controller.delegate = self
 
@@ -154,7 +188,12 @@ public class WalletManagerImpl: NSObject, @preconcurrency PKAddPassesViewControl
       if
          let pass = self.pass,
          let library = self.passLibrary {
-        addPassCompletion(library.containsPass(pass))
+        let wasAdded = library.containsPass(pass)
+        if wasAdded {
+          addPassCompletion(true, nil, nil)
+        } else {
+          addPassCompletion(false, "USER_CANCELLED", "User cancelled or declined to add pass")
+        }
       }
       self.passLibrary = nil
       self.pass = nil
@@ -163,9 +202,9 @@ public class WalletManagerImpl: NSObject, @preconcurrency PKAddPassesViewControl
   }
 
   // MARK: - Helper
-  
-  private func addPassCompletion(_ result: Bool) {
-    self.completion?(result)
+
+  private func addPassCompletion(_ success: Bool, _ errorCode: String?, _ errorMessage: String?) {
+    self.completion?(success, errorCode, errorMessage)
     self.completion = nil
   }
 

src/index.tsx

@@ -1,6 +1,33 @@
-import { Linking, Platform } from 'react-native';
+import { Platform } from 'react-native';
 import WalletManager from './specs/NativeWalletManager';
 
+/**
+ * Error codes that can be thrown by addPassFromUrl
+ */
+export type WalletErrorCode =
+  // Shared error codes
+  | 'INVALID_URL'
+  | 'NETWORK_ERROR'
+  | 'HTTP_ERROR'
+  | 'USER_CANCELLED'
+  // iOS-specific error codes
+  | 'INVALID_DATA'
+  | 'INVALID_PASS'
+  | 'PASS_ALREADY_EXISTS'
+  | 'NO_VIEW_CONTROLLER'
+  | 'CONTROLLER_ERROR'
+  // Android-specific error codes
+  | 'NO_ACTIVITY'
+  | 'API_ERROR'
+  | 'GENERAL_ERROR';
+
+/**
+ * Error object thrown when addPassFromUrl fails
+ */
+export type WalletError = Error & {
+  code: WalletErrorCode;
+};
+
 export default {
   canAddPasses: async () => {
     return await WalletManager.canAddPasses();
@@ -19,10 +46,8 @@ export default {
     }
     return await WalletManager.addPassToGoogleWallet(jwt);
   },
-  addPassFromUrl:
-    Platform.OS === 'ios'
-      ? WalletManager.addPassFromUrl
-      : (url: string) => Linking.openURL(url),
+  addPassFromUrl: (url: string, headers?: Record<string, string>) =>
+    WalletManager.addPassFromUrl(url, headers ?? null),
   hasPass: async (cardIdentifier: string, serialNumber?: string) => {
     if (Platform.OS === 'android') {
       throw new Error('hasPass method not available on Android');

src/specs/NativeWalletManager.ts

@@ -3,7 +3,7 @@ import { TurboModule, TurboModuleRegistry } from 'react-native';
 export interface Spec extends TurboModule {
   canAddPasses(): Promise<boolean>;
   showAddPassControllerFromFile(url: string): Promise<boolean>;
-  addPassFromUrl(url: string): Promise<boolean>;
+  addPassFromUrl(url: string, headers: Object | null): Promise<boolean>;
   hasPass(
     cardIdentifier: string,
     serialNumber: string | null