@virex-tech/paywallo-sdk 1.5.4 → 2.0.1

package/ios/PaywalloNotifications.m

@@ -0,0 +1,22 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(PaywalloNotifications, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(requestPermission:(nonnull NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(hasPermission:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getToken:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(registerForPush:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getInitialNotification:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/PaywalloNotifications.swift

@@ -0,0 +1,250 @@
+import Foundation
+import React
+import UserNotifications
+
+@objc(PaywalloNotifications)
+class PaywalloNotifications: RCTEventEmitter {
+
+    // MARK: - Event Names
+    private static let tokenRefreshEvent = "PaywalloTokenRefresh"
+    private static let messageReceivedEvent = "PaywalloMessageReceived"
+    private static let notificationOpenedEvent = "PaywalloNotificationOpened"
+
+    // MARK: - Pre-subscribe buffer
+    private var _hasListeners = false
+    private var preSubscribeBuffer: [[String: Any]] = []
+    private let bufferQueue = DispatchQueue(label: "com.paywallo.notifications.buffer")
+    private static let maxBufferSize = 100
+
+    // MARK: - State
+    private static var latestAPNSToken: String?
+    private static var initialNotification: [String: Any]?
+
+    // MARK: - RCTEventEmitter Overrides
+
+    override static func requiresMainQueueSetup() -> Bool { return true }
+
+    override func supportedEvents() -> [String] {
+        return [
+            PaywalloNotifications.tokenRefreshEvent,
+            PaywalloNotifications.messageReceivedEvent,
+            PaywalloNotifications.notificationOpenedEvent,
+        ]
+    }
+
+    override func startObserving() {
+        bufferQueue.sync { _hasListeners = true }
+        drainPreSubscribeBuffer()
+    }
+
+    override func stopObserving() {
+        bufferQueue.sync { _hasListeners = false }
+    }
+
+    // MARK: - Buffer Management
+
+    private func bufferOrEmit(eventName: String, body: [String: Any]) {
+        let shouldEmit: Bool = bufferQueue.sync {
+            if _hasListeners { return true }
+            var entry = body
+            entry["_eventName"] = eventName
+            if preSubscribeBuffer.count >= PaywalloNotifications.maxBufferSize {
+                preSubscribeBuffer.removeFirst()
+            }
+            preSubscribeBuffer.append(entry)
+            return false
+        }
+        if shouldEmit {
+            DispatchQueue.main.async {
+                self.sendEvent(withName: eventName, body: body)
+            }
+        }
+    }
+
+    private func drainPreSubscribeBuffer() {
+        let drained: [[String: Any]] = bufferQueue.sync {
+            let copy = preSubscribeBuffer
+            preSubscribeBuffer.removeAll()
+            return copy
+        }
+        for entry in drained {
+            var body = entry
+            guard let eventName = body.removeValue(forKey: "_eventName") as? String else { continue }
+            DispatchQueue.main.async {
+                self.sendEvent(withName: eventName, body: body)
+            }
+        }
+    }
+
+    // MARK: - Public Methods (exposed to JS)
+
+    @objc(requestPermission:resolve:reject:)
+    func requestPermission(
+        _ options: NSDictionary,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        let provisional = options["provisional"] as? Bool ?? false
+        let center = UNUserNotificationCenter.current()
+
+        var authOptions: UNAuthorizationOptions = [.alert, .sound, .badge]
+        if provisional {
+            authOptions.insert(.provisional)
+        }
+
+        center.requestAuthorization(options: authOptions) { [weak self] _, error in
+            guard let self = self else {
+                DispatchQueue.main.async { reject("MODULE_RELEASED", "Module was released", nil) }
+                return
+            }
+
+            if let error = error {
+                DispatchQueue.main.async { reject("PERMISSION_ERROR", error.localizedDescription, error) }
+                return
+            }
+
+            self.getPermissionStatusString { status in
+                DispatchQueue.main.async { resolve(status) }
+            }
+        }
+    }
+
+    @objc(hasPermission:reject:)
+    func hasPermission(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        getPermissionStatusString { status in
+            DispatchQueue.main.async { resolve(status) }
+        }
+    }
+
+    @objc(getToken:reject:)
+    func getToken(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        DispatchQueue.main.async {
+            if let token = PaywalloNotifications.latestAPNSToken {
+                resolve(token)
+            } else {
+                resolve(nil)
+            }
+        }
+    }
+
+    @objc(registerForPush:reject:)
+    func registerForPush(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        DispatchQueue.main.async {
+            UIApplication.shared.registerForRemoteNotifications()
+            resolve(true)
+        }
+    }
+
+    @objc(getInitialNotification:reject:)
+    func getInitialNotification(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        DispatchQueue.main.async {
+            if let notification = PaywalloNotifications.initialNotification {
+                PaywalloNotifications.initialNotification = nil
+                resolve(notification)
+            } else {
+                resolve(nil)
+            }
+        }
+    }
+
+    // MARK: - Permission Helper
+
+    private func getPermissionStatusString(completion: @escaping (String) -> Void) {
+        UNUserNotificationCenter.current().getNotificationSettings { settings in
+            let status: String
+            switch settings.authorizationStatus {
+            case .authorized: status = "granted"
+            case .denied: status = "denied"
+            case .provisional: status = "provisional"
+            case .notDetermined: status = "notDetermined"
+            case .ephemeral: status = "ephemeral"
+            @unknown default: status = "notDetermined"
+            }
+            DispatchQueue.main.async { completion(status) }
+        }
+    }
+
+    // MARK: - Payload Extraction
+
+    private static func extractPayload(from userInfo: [AnyHashable: Any]) -> [String: Any] {
+        var payload: [String: Any] = [:]
+
+        if let aps = userInfo["aps"] as? [String: Any] {
+            if let alert = aps["alert"] as? [String: Any] {
+                payload["title"] = alert["title"] as? String ?? ""
+                payload["body"] = alert["body"] as? String ?? ""
+            } else if let alert = aps["alert"] as? String {
+                payload["body"] = alert
+            }
+        }
+
+        var data: [String: String] = [:]
+        for (key, value) in userInfo {
+            guard let key = key as? String, key != "aps" else { continue }
+            data[key] = "\(value)"
+        }
+        if !data.isEmpty {
+            payload["data"] = data
+        }
+
+        return payload
+    }
+
+    // MARK: - Init: observe token from AppDelegate
+
+    override init() {
+        super.init()
+
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(onAPNSTokenReceived(_:)),
+            name: NSNotification.Name("PaywalloAPNSTokenReceived"), object: nil
+        )
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(onRemoteNotificationReceived(_:)),
+            name: NSNotification.Name("PaywalloRemoteNotificationReceived"), object: nil
+        )
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(onNotificationOpened(_:)),
+            name: NSNotification.Name("PaywalloNotificationOpened"), object: nil
+        )
+
+        // Check if a token was already captured before this observer registered (race condition fix)
+        if let existing = PaywalloNotifications.latestAPNSToken {
+            bufferOrEmit(eventName: PaywalloNotifications.tokenRefreshEvent, body: ["token": existing])
+        }
+    }
+
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+    }
+
+    @objc private func onAPNSTokenReceived(_ notification: Notification) {
+        guard let token = notification.userInfo?["token"] as? String else { return }
+        DispatchQueue.main.async {
+            PaywalloNotifications.latestAPNSToken = token
+            self.bufferOrEmit(eventName: PaywalloNotifications.tokenRefreshEvent, body: ["token": token])
+        }
+    }
+
+    @objc private func onRemoteNotificationReceived(_ notification: Notification) {
+        guard let payload = notification.userInfo?["payload"] as? [String: Any] else { return }
+        bufferOrEmit(eventName: PaywalloNotifications.messageReceivedEvent, body: payload)
+    }
+
+    @objc private func onNotificationOpened(_ notification: Notification) {
+        guard let payload = notification.userInfo?["payload"] as? [String: Any] else { return }
+        bufferOrEmit(eventName: PaywalloNotifications.notificationOpenedEvent, body: payload)
+    }
+}

package/ios/PaywalloStoreKit.m

@@ -1,6 +1,9 @@
 #import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
 
-@interface RCT_EXTERN_MODULE(PaywalloStoreKit, NSObject)
+@interface RCT_EXTERN_MODULE(PaywalloStoreKit, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(supportedEvents)
 
 RCT_EXTERN_METHOD(getProducts:(NSArray *)productIds
                   resolve:(RCTPromiseResolveBlock)resolve

package/ios/PaywalloStoreKit.swift

@@ -1,11 +1,28 @@
 import Foundation
 import StoreKit
+import React
 
 @available(iOS 15.0, *)
 @objc(PaywalloStoreKit)
-class PaywalloStoreKit: NSObject {
+class PaywalloStoreKit: RCTEventEmitter {
 
   private var updateListenerTask: Task<Void, Never>?
+  private var hasListeners = false
+
+  // Buffer for transaction events that arrive before JS subscribes via
+  // NativeEventEmitter. StoreKit 2 starts delivering Transaction.updates
+  // as soon as the module is constructed (cold start), but JS may not
+  // have called addListener yet. Without buffering, those payloads are
+  // silently dropped and sales go untracked.
+  // In-memory only; capped at maxBufferedEvents to avoid unbounded growth.
+  private var preSubscribeBuffer: [[String: Any]] = []
+  private let bufferQueue = DispatchQueue(label: "com.paywallo.storekit.buffer")
+  private static let maxBufferedEvents = 100
+
+  // Event name emitted for every StoreKit 2 Transaction.updates signal
+  // (renewals, refunds, cancellations). JS side subscribes via
+  // NativeEventEmitter and fans the payload out to the EventBatcher.
+  private static let transactionUpdateEvent = "PaywalloTransactionUpdate"
 
   override init() {
     super.init()
@@ -16,22 +33,154 @@ class PaywalloStoreKit: NSObject {
     updateListenerTask?.cancel()
   }
 
+  // MARK: - RCTEventEmitter overrides
+
+  override func supportedEvents() -> [String]! {
+    return [PaywalloStoreKit.transactionUpdateEvent]
+  }
+
+  override func startObserving() {
+    hasListeners = true
+    drainPreSubscribeBuffer()
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(handleAppForeground),
+      name: UIApplication.didBecomeActiveNotification,
+      object: nil
+    )
+  }
+
+  override func stopObserving() {
+    hasListeners = false
+    NotificationCenter.default.removeObserver(self, name: UIApplication.didBecomeActiveNotification, object: nil)
+  }
+
+  @objc private func handleAppForeground() {
+    guard updateListenerTask == nil || updateListenerTask!.isCancelled else { return }
+    #if DEBUG
+    print("[Paywallo:StoreKit] Restarting transaction listener after foreground")
+    #endif
+    startTransactionListener()
+  }
+
+  /// Drains any transaction events that were buffered before JS subscribed,
+  /// emitting them in FIFO order. Called from `startObserving()` once the
+  /// JS-side NativeEventEmitter has registered its listener.
+  private func drainPreSubscribeBuffer() {
+    let buffered: [[String: Any]] = bufferQueue.sync {
+      let copy = preSubscribeBuffer
+      preSubscribeBuffer.removeAll()
+      return copy
+    }
+    guard !buffered.isEmpty else { return }
+    #if DEBUG
+    print("[Paywallo:StoreKit] Draining \(buffered.count) pre-subscribe transaction event(s)")
+    #endif
+    for payload in buffered {
+      sendEvent(withName: PaywalloStoreKit.transactionUpdateEvent, body: payload)
+    }
+  }
+
+  override static func requiresMainQueueSetup() -> Bool {
+    return false
+  }
+
   // MARK: - Transaction Listener
 
   private func startTransactionListener() {
     updateListenerTask = Task { [weak self] in
       for await result in Transaction.updates {
-        guard let _ = self else { return }
+        guard let self = self else { return }
         if case .verified(let transaction) = result {
           #if DEBUG
-          print("[Paywallo:StoreKit] Transaction update: \(transaction.productID) status=\(transaction.revocationDate != nil ? "revoked" : "active") id=\(transaction.id)")
+          print("[Paywallo:StoreKit] Transaction update: \(transaction.productID) revoked=\(transaction.revocationDate != nil) id=\(transaction.id)")
           #endif
+          await self.emitTransactionUpdate(transaction)
           await transaction.finish()
         }
       }
     }
   }
 
+  /// Classifies a StoreKit 2 `Transaction` coming from `Transaction.updates`
+  /// into one of three domain events — `renewed`, `refunded`, `canceled` —
+  /// and forwards a minimal payload to JS via RCTEventEmitter.
+  ///
+  /// Classification rules:
+  /// - `revocationDate != nil` + `revocationReason == .developerIssue` → `canceled`
+  /// - `revocationDate != nil` (any other reason, incl. `.other`) → `refunded`
+  /// - otherwise → `renewed` (auto-renewable subscription renewal or
+  ///   restored purchase)
+  private func emitTransactionUpdate(_ transaction: Transaction) async {
+    let type: String
+    if transaction.revocationDate != nil {
+      if let reason = transaction.revocationReason, reason == .developerIssue {
+        type = "canceled"
+      } else {
+        type = "refunded"
+      }
+    } else {
+      type = "renewed"
+    }
+
+    var payload: [String: Any] = [
+      "type": type,
+      "transactionId": String(transaction.id),
+      "productId": transaction.productID,
+    ]
+
+    // Best-effort amount + currency lookup. Products are cached on the JS
+    // side but StoreKit 2 also lets us fetch by id synchronously-ish; if
+    // the fetch fails we simply omit the fields (server-side webhook will
+    // still carry the truth).
+    if let priceInfo = await resolveProductPrice(productId: transaction.productID) {
+      payload["amount"] = priceInfo.amount
+      payload["currency"] = priceInfo.currency
+    }
+
+    if hasListeners {
+      sendEvent(withName: PaywalloStoreKit.transactionUpdateEvent, body: payload)
+    } else {
+      // JS not yet subscribed (cold-start race). Buffer up to
+      // maxBufferedEvents; drop oldest on overflow to bound memory.
+      bufferQueue.sync {
+        if preSubscribeBuffer.count >= PaywalloStoreKit.maxBufferedEvents {
+          preSubscribeBuffer.removeFirst()
+          #if DEBUG
+          print("[Paywallo:StoreKit] Pre-subscribe buffer overflow — dropping oldest event")
+          #endif
+        }
+        preSubscribeBuffer.append(payload)
+      }
+      #if DEBUG
+      print("[Paywallo:StoreKit] Buffered transaction event (no JS listener yet): \(transaction.productID)")
+      #endif
+    }
+  }
+
+  private func resolveProductPrice(productId: String) async -> (amount: Double, currency: String)? {
+    do {
+      let products = try await Product.products(for: [productId])
+      guard let product = products.first else { return nil }
+      let amount = NSDecimalNumber(decimal: product.price).doubleValue
+      var currency: String = "USD"
+      if let json = try? JSONSerialization.jsonObject(with: product.jsonRepresentation) as? [String: Any],
+         let attrs = json["attributes"] as? [String: Any],
+         let offers = attrs["offers"] as? [[String: Any]],
+         let firstOffer = offers.first,
+         let currencyCode = firstOffer["currencyCode"] as? String {
+        currency = currencyCode
+      } else if #available(iOS 16, *) {
+        currency = Locale.current.currency?.identifier ?? "USD"
+      } else {
+        currency = Locale.current.currencyCode ?? "USD"
+      }
+      return (amount, currency)
+    } catch {
+      return nil
+    }
+  }
+
   // MARK: - Get Products
 
   @objc
@@ -263,9 +412,4 @@ class PaywalloStoreKit: NSObject {
       return "P\(period.value)D"
     }
   }
-
-  @objc
-  static func requiresMainQueueSetup() -> Bool {
-    return false
-  }
 }

package/ios/PaywalloWebView.m

@@ -195,7 +195,7 @@
     // data:, and blob: — to prevent mixed-content and injection attacks.
     NSString *scheme = url.scheme.lowercaseString;
     NSSet<NSString *> *allowedSchemes = [NSSet setWithObjects:
-        @"https", @"about", @"mailto", @"itms-apps", @"itms-services", nil];
+        @"https", @"about", @"mailto", @"itms-apps", nil];
     if (scheme && ![allowedSchemes containsObject:scheme]) {
         decisionHandler(WKNavigationActionPolicyCancel);
         return;
@@ -203,8 +203,7 @@
 
     // mailto: and App Store links must be opened by the OS, not loaded inside the WebView.
     if ([scheme isEqualToString:@"mailto"] ||
-        [scheme isEqualToString:@"itms-apps"] ||
-        [scheme isEqualToString:@"itms-services"]) {
+        [scheme isEqualToString:@"itms-apps"]) {
         [[UIApplication sharedApplication] openURL:url options:@{} completionHandler:nil];
         decisionHandler(WKNavigationActionPolicyCancel);
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@virex-tech/paywallo-sdk",
-  "version": "1.5.4",
+  "version": "2.0.1",
   "description": "SDK React Native para integração com Paywallo - Paywalls, Subscriptions e Analytics",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -11,7 +11,8 @@
       "react-native": "./dist/index.mjs",
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist",
@@ -42,7 +43,9 @@
     "react-native",
     "mobile",
     "subscription",
-    "paywallo"
+    "paywallo",
+    "push-notifications",
+    "fcm"
   ],
   "author": "Virex Tech",
   "license": "MIT",
@@ -62,11 +65,15 @@
     "node": ">=18.0.0"
   },
   "peerDependencies": {
+    "@react-native-firebase/app": "^22.0.0",
     "expo-tracking-transparency": "*",
     "react": "*",
     "react-native": "*"
   },
   "peerDependenciesMeta": {
+    "@react-native-firebase/app": {
+      "optional": true
+    },
     "expo-tracking-transparency": {
       "optional": true
     }
@@ -86,6 +93,6 @@
     "vitest": "^4.1.2"
   },
   "dependencies": {
-    "@virex-tech/paywallo-sdk": "^1.5.2"
+    "zod": "^4.3.6"
   }
 }