@billdog.io/react-native 1.0.0-beta.2

package/ios/BillDogVirtualCurrencyBridge.swift

@@ -0,0 +1,511 @@
+//
+//  BillDogVirtualCurrencyBridge.swift
+//  @billdog.io/react-native
+//
+//  Swift implementation for React Native Virtual Currency bridge
+//
+
+import Foundation
+import React
+
+@objc(BillDogVirtualCurrency)
+class BillDogVirtualCurrencyBridge: RCTEventEmitter {
+    
+    private var hasListeners = false
+    private var baseUrl: String?
+    private var apiKey: String?
+    private var customerId: String?
+    private var enableLogging = false
+    
+    override init() {
+        super.init()
+    }
+    
+    override static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+    
+    override func supportedEvents() -> [String]! {
+        return ["onBalanceChanged", "onTransaction"]
+    }
+    
+    override func startObserving() {
+        hasListeners = true
+    }
+    
+    override func stopObserving() {
+        hasListeners = false
+    }
+    
+    // MARK: - Initialization
+    
+    @objc
+    func initialize(_ config: NSDictionary,
+                   resolver resolve: @escaping RCTPromiseResolveBlock,
+                   rejecter reject: @escaping RCTPromiseRejectBlock) {
+        
+        guard let baseUrl = config["baseUrl"] as? String,
+              let apiKey = config["apiKey"] as? String,
+              let customerId = config["customerId"] as? String else {
+            reject("INVALID_CONFIG", "Missing required configuration parameters", nil)
+            return
+        }
+        
+        self.baseUrl = baseUrl
+        self.apiKey = apiKey
+        self.customerId = customerId
+        self.enableLogging = config["enableLogging"] as? Bool ?? false
+        
+        if enableLogging {
+            print("[BillDog] Virtual Currency initialized for customer: \(customerId)")
+        }
+        
+        resolve(nil)
+    }
+    
+    // MARK: - Balance Operations
+    
+    @objc
+    func getBalance(_ currencyId: String,
+                   resolver resolve: @escaping RCTPromiseResolveBlock,
+                   rejecter reject: @escaping RCTPromiseRejectBlock) {
+        
+        guard let customerId = self.customerId else {
+            reject("NOT_INITIALIZED", "Virtual Currency module not initialized", nil)
+            return
+        }
+        
+        fetchBalance(currencyId: currencyId, customerId: customerId) { result in
+            switch result {
+            case .success(let balance):
+                resolve(balance)
+            case .failure(let error):
+                reject("GET_BALANCE_ERROR", error.localizedDescription, error)
+            }
+        }
+    }
+    
+    @objc
+    func addCurrency(_ currencyId: String,
+                    amount: NSNumber,
+                    reason: String?,
+                    metadata: NSDictionary?,
+                    resolver resolve: @escaping RCTPromiseResolveBlock,
+                    rejecter reject: @escaping RCTPromiseRejectBlock) {
+        
+        guard let customerId = self.customerId else {
+            reject("NOT_INITIALIZED", "Virtual Currency module not initialized", nil)
+            return
+        }
+        
+        let amountValue = amount.doubleValue
+        
+        performTransaction(
+            currencyId: currencyId,
+            customerId: customerId,
+            amount: amountValue,
+            type: "earn",
+            reason: reason,
+            metadata: metadata as? [String: Any]
+        ) { result in
+            switch result {
+            case .success(let newBalance):
+                if self.hasListeners {
+                    self.sendEvent(withName: "onBalanceChanged", body: [
+                        "currencyId": currencyId,
+                        "newBalance": newBalance
+                    ])
+                    self.sendEvent(withName: "onTransaction", body: self.transactionEvent(
+                        currencyId: currencyId, amount: amountValue, type: "earn",
+                        reason: reason, newBalance: newBalance))
+                }
+                resolve(newBalance)
+            case .failure(let error):
+                reject("ADD_CURRENCY_ERROR", error.localizedDescription, error)
+            }
+        }
+    }
+    
+    @objc
+    func deductCurrency(_ currencyId: String,
+                       amount: NSNumber,
+                       reason: String?,
+                       metadata: NSDictionary?,
+                       resolver resolve: @escaping RCTPromiseResolveBlock,
+                       rejecter reject: @escaping RCTPromiseRejectBlock) {
+        
+        guard let customerId = self.customerId else {
+            reject("NOT_INITIALIZED", "Virtual Currency module not initialized", nil)
+            return
+        }
+        
+        let amountValue = amount.doubleValue
+        
+        performTransaction(
+            currencyId: currencyId,
+            customerId: customerId,
+            amount: -amountValue,
+            type: "spend",
+            reason: reason,
+            metadata: metadata as? [String: Any]
+        ) { result in
+            switch result {
+            case .success(let newBalance):
+                if self.hasListeners {
+                    self.sendEvent(withName: "onBalanceChanged", body: [
+                        "currencyId": currencyId,
+                        "newBalance": newBalance
+                    ])
+                    self.sendEvent(withName: "onTransaction", body: self.transactionEvent(
+                        currencyId: currencyId, amount: -amountValue, type: "spend",
+                        reason: reason, newBalance: newBalance))
+                }
+                resolve(newBalance)
+            case .failure(let error):
+                reject("DEDUCT_CURRENCY_ERROR", error.localizedDescription, error)
+            }
+        }
+    }
+    
+    @objc
+    func grantCurrency(_ currencyId: String,
+                      amount: NSNumber,
+                      reason: String?,
+                      resolver resolve: @escaping RCTPromiseResolveBlock,
+                      rejecter reject: @escaping RCTPromiseRejectBlock) {
+        
+        guard let customerId = self.customerId else {
+            reject("NOT_INITIALIZED", "Virtual Currency module not initialized", nil)
+            return
+        }
+        
+        let amountValue = amount.doubleValue
+        
+        performTransaction(
+            currencyId: currencyId,
+            customerId: customerId,
+            amount: amountValue,
+            type: "grant",
+            reason: reason,
+            metadata: nil
+        ) { result in
+            switch result {
+            case .success(let newBalance):
+                if self.hasListeners {
+                    self.sendEvent(withName: "onBalanceChanged", body: [
+                        "currencyId": currencyId,
+                        "newBalance": newBalance
+                    ])
+                    self.sendEvent(withName: "onTransaction", body: self.transactionEvent(
+                        currencyId: currencyId, amount: amountValue, type: "grant",
+                        reason: reason, newBalance: newBalance))
+                }
+                resolve(newBalance)
+            case .failure(let error):
+                reject("GRANT_CURRENCY_ERROR", error.localizedDescription, error)
+            }
+        }
+    }
+    
+    @objc
+    func getTransactionHistory(_ currencyId: String?,
+                              limit: NSNumber,
+                              resolver resolve: @escaping RCTPromiseResolveBlock,
+                              rejecter reject: @escaping RCTPromiseRejectBlock) {
+        
+        guard let customerId = self.customerId else {
+            reject("NOT_INITIALIZED", "Virtual Currency module not initialized", nil)
+            return
+        }
+        
+        fetchTransactionHistory(currencyId: currencyId, customerId: customerId, limit: limit.intValue) { result in
+            switch result {
+            case .success(let transactions):
+                resolve(transactions)
+            case .failure(let error):
+                reject("GET_HISTORY_ERROR", error.localizedDescription, error)
+            }
+        }
+    }
+    
+    @objc
+    func exchangeCurrency(_ fromCurrencyId: String,
+                         toCurrencyId: String,
+                         fromAmount: NSNumber,
+                         resolver resolve: @escaping RCTPromiseResolveBlock,
+                         rejecter reject: @escaping RCTPromiseRejectBlock) {
+        
+        guard let customerId = self.customerId else {
+            reject("NOT_INITIALIZED", "Virtual Currency module not initialized", nil)
+            return
+        }
+        
+        performExchange(
+            fromCurrencyId: fromCurrencyId,
+            toCurrencyId: toCurrencyId,
+            fromAmount: fromAmount.doubleValue,
+            customerId: customerId
+        ) { result in
+            switch result {
+            case .success(let exchangeResult):
+                if self.hasListeners {
+                    self.sendEvent(withName: "onBalanceChanged", body: [
+                        "currencyId": fromCurrencyId,
+                        "newBalance": exchangeResult["newFromBalance"] as Any
+                    ])
+                    self.sendEvent(withName: "onBalanceChanged", body: [
+                        "currencyId": toCurrencyId,
+                        "newBalance": exchangeResult["newToBalance"] as Any
+                    ])
+                }
+                resolve(exchangeResult)
+            case .failure(let error):
+                reject("EXCHANGE_ERROR", error.localizedDescription, error)
+            }
+        }
+    }
+    
+    @objc
+    func getAllCurrencies(_ resolve: @escaping RCTPromiseResolveBlock,
+                         rejecter reject: @escaping RCTPromiseRejectBlock) {
+        
+        guard let customerId = self.customerId else {
+            reject("NOT_INITIALIZED", "Virtual Currency module not initialized", nil)
+            return
+        }
+        
+        fetchAllCurrencies(customerId: customerId) { result in
+            switch result {
+            case .success(let currencies):
+                resolve(currencies)
+            case .failure(let error):
+                reject("GET_CURRENCIES_ERROR", error.localizedDescription, error)
+            }
+        }
+    }
+    
+    // MARK: - Event Helpers
+
+    /// Build the `onTransaction` event body from the data available after a
+    /// transactions POST (which returns only `new_balance`).
+    private func transactionEvent(currencyId: String, amount: Double, type: String,
+                                  reason: String?, newBalance: Double) -> [String: Any] {
+        var body: [String: Any] = [
+            "currencyId": currencyId,
+            "amount": amount,
+            "type": type,
+            "newBalance": newBalance,
+        ]
+        if let reason = reason { body["reason"] = reason }
+        return body
+    }
+
+    // MARK: - Response Helper
+
+    /// Parse a response body and descend into the `data` envelope. BillDog edge
+    /// functions wrap payloads in `{ success, data, meta }`
+    /// (supabase/functions/_shared/response.ts), so callers must read from `data`.
+    private func payload(_ data: Data?) -> [String: Any]? {
+        guard let data = data,
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            return nil
+        }
+        return (json["data"] as? [String: Any]) ?? json
+    }
+
+    // MARK: - API Helpers
+
+    private func fetchBalance(currencyId: String, customerId: String, completion: @escaping (Result<Double, Error>) -> Void) {
+        guard let baseUrl = self.baseUrl, let apiKey = self.apiKey else {
+            completion(.failure(NSError(domain: "BillDog", code: -1, userInfo: [NSLocalizedDescriptionKey: "Configuration missing"])))
+            return
+        }
+        
+        let urlString = "\(baseUrl)/virtual-currency/balances?currency_id=\(currencyId)&customer_id=\(customerId)"
+        guard let url = URL(string: urlString) else {
+            completion(.failure(NSError(domain: "BillDog", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid URL"])))
+            return
+        }
+        
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue(apiKey, forHTTPHeaderField: "X-BillDog-API-Key")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        
+        URLSession.shared.dataTask(with: request) { data, response, error in
+            if let error = error {
+                completion(.failure(error))
+                return
+            }
+            
+            guard let json = self.payload(data),
+                  let balance = (json["balance"] as? NSNumber)?.doubleValue else {
+                completion(.failure(NSError(domain: "BillDog", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid response"])))
+                return
+            }
+
+            completion(.success(balance))
+        }.resume()
+    }
+    
+    private func performTransaction(currencyId: String, customerId: String, amount: Double, type: String, reason: String?, metadata: [String: Any]?, completion: @escaping (Result<Double, Error>) -> Void) {
+        guard let baseUrl = self.baseUrl, let apiKey = self.apiKey else {
+            completion(.failure(NSError(domain: "BillDog", code: -1, userInfo: [NSLocalizedDescriptionKey: "Configuration missing"])))
+            return
+        }
+        
+        let urlString = "\(baseUrl)/virtual-currency/transactions"
+        guard let url = URL(string: urlString) else {
+            completion(.failure(NSError(domain: "BillDog", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid URL"])))
+            return
+        }
+        
+        var body: [String: Any] = [
+            "currency_id": currencyId,
+            "customer_id": customerId,
+            "amount": amount,
+            "type": type
+        ]
+        
+        if let reason = reason {
+            body["reason"] = reason
+        }
+        
+        if let metadata = metadata {
+            body["metadata"] = metadata
+        }
+        
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue(apiKey, forHTTPHeaderField: "X-BillDog-API-Key")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.httpBody = try? JSONSerialization.data(withJSONObject: body)
+        
+        URLSession.shared.dataTask(with: request) { data, response, error in
+            if let error = error {
+                completion(.failure(error))
+                return
+            }
+            
+            guard let json = self.payload(data),
+                  let newBalance = (json["new_balance"] as? NSNumber)?.doubleValue else {
+                completion(.failure(NSError(domain: "BillDog", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid response"])))
+                return
+            }
+
+            completion(.success(newBalance))
+        }.resume()
+    }
+    
+    private func fetchTransactionHistory(currencyId: String?, customerId: String, limit: Int, completion: @escaping (Result<[[String: Any]], Error>) -> Void) {
+        guard let baseUrl = self.baseUrl, let apiKey = self.apiKey else {
+            completion(.failure(NSError(domain: "BillDog", code: -1, userInfo: [NSLocalizedDescriptionKey: "Configuration missing"])))
+            return
+        }
+        
+        var urlString = "\(baseUrl)/virtual-currency/transactions/history?customer_id=\(customerId)&limit=\(limit)"
+        if let currencyId = currencyId {
+            urlString += "&currency_id=\(currencyId)"
+        }
+        
+        guard let url = URL(string: urlString) else {
+            completion(.failure(NSError(domain: "BillDog", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid URL"])))
+            return
+        }
+        
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue(apiKey, forHTTPHeaderField: "X-BillDog-API-Key")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        
+        URLSession.shared.dataTask(with: request) { data, response, error in
+            if let error = error {
+                completion(.failure(error))
+                return
+            }
+            
+            guard let json = self.payload(data),
+                  let transactions = json["transactions"] as? [[String: Any]] else {
+                completion(.failure(NSError(domain: "BillDog", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid response"])))
+                return
+            }
+
+            completion(.success(transactions))
+        }.resume()
+    }
+    
+    private func performExchange(fromCurrencyId: String, toCurrencyId: String, fromAmount: Double, customerId: String, completion: @escaping (Result<[String: Any], Error>) -> Void) {
+        guard let baseUrl = self.baseUrl, let apiKey = self.apiKey else {
+            completion(.failure(NSError(domain: "BillDog", code: -1, userInfo: [NSLocalizedDescriptionKey: "Configuration missing"])))
+            return
+        }
+        
+        let urlString = "\(baseUrl)/virtual-currency/exchange"
+        guard let url = URL(string: urlString) else {
+            completion(.failure(NSError(domain: "BillDog", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid URL"])))
+            return
+        }
+        
+        let body: [String: Any] = [
+            "from_currency_id": fromCurrencyId,
+            "to_currency_id": toCurrencyId,
+            "from_amount": fromAmount,
+            "customer_id": customerId
+        ]
+        
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue(apiKey, forHTTPHeaderField: "X-BillDog-API-Key")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.httpBody = try? JSONSerialization.data(withJSONObject: body)
+        
+        URLSession.shared.dataTask(with: request) { data, response, error in
+            if let error = error {
+                completion(.failure(error))
+                return
+            }
+            
+            guard let json = self.payload(data) else {
+                completion(.failure(NSError(domain: "BillDog", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid response"])))
+                return
+            }
+
+            completion(.success(json))
+        }.resume()
+    }
+    
+    private func fetchAllCurrencies(customerId: String, completion: @escaping (Result<[[String: Any]], Error>) -> Void) {
+        guard let baseUrl = self.baseUrl, let apiKey = self.apiKey else {
+            completion(.failure(NSError(domain: "BillDog", code: -1, userInfo: [NSLocalizedDescriptionKey: "Configuration missing"])))
+            return
+        }
+        
+        let urlString = "\(baseUrl)/virtual-currency/balances?customer_id=\(customerId)"
+        guard let url = URL(string: urlString) else {
+            completion(.failure(NSError(domain: "BillDog", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid URL"])))
+            return
+        }
+        
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue(apiKey, forHTTPHeaderField: "X-BillDog-API-Key")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        
+        URLSession.shared.dataTask(with: request) { data, response, error in
+            if let error = error {
+                completion(.failure(error))
+                return
+            }
+            
+            // All-balances route returns `data.balances = [{currency:{…}, balance}]`
+            // (NOT `currencies`); the JS layer normalizes the nested shape.
+            guard let json = self.payload(data),
+                  let balances = json["balances"] as? [[String: Any]] else {
+                completion(.failure(NSError(domain: "BillDog", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid response"])))
+                return
+            }
+
+            completion(.success(balances))
+        }.resume()
+    }
+}

package/junit.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<testsuites name="jest tests" tests="9" failures="0" errors="0" time="0.677">
+  <testsuite name="BillDog.purchase — canonical PurchaseResult contract" errors="0" failures="0" skipped="0" timestamp="2026-05-01T12:33:27" time="0.527" tests="6">
+    <testcase classname="BillDog.purchase — canonical PurchaseResult contract returns cancelled when no native bridge is wired" name="BillDog.purchase — canonical PurchaseResult contract returns cancelled when no native bridge is wired" time="0.001">
+    </testcase>
+    <testcase classname="BillDog.purchase — canonical PurchaseResult contract routes through host PurchaseController when registered" name="BillDog.purchase — canonical PurchaseResult contract routes through host PurchaseController when registered" time="0.001">
+    </testcase>
+    <testcase classname="BillDog.purchase — canonical PurchaseResult contract controller exception becomes a typed failure (NOT a throw)" name="BillDog.purchase — canonical PurchaseResult contract controller exception becomes a typed failure (NOT a throw)" time="0">
+    </testcase>
+    <testcase classname="BillDog.purchase — canonical PurchaseResult contract detaching the controller restores native-bridge fallback" name="BillDog.purchase — canonical PurchaseResult contract detaching the controller restores native-bridge fallback" time="0">
+    </testcase>
+    <testcase classname="BillDog.purchaseCustom — controller-only API without controller returns a typed failure" name="BillDog.purchaseCustom — controller-only API without controller returns a typed failure" time="0.001">
+    </testcase>
+    <testcase classname="BillDog.purchaseCustom — controller-only API with controller routes through it" name="BillDog.purchaseCustom — controller-only API with controller routes through it" time="0">
+    </testcase>
+  </testsuite>
+  <testsuite name="BillDog.restore — RestoreResult contract" errors="0" failures="0" skipped="0" timestamp="2026-05-01T12:33:28" time="0.028" tests="3">
+    <testcase classname="BillDog.restore — RestoreResult contract routes through host controller when registered" name="BillDog.restore — RestoreResult contract routes through host controller when registered" time="0.001">
+    </testcase>
+    <testcase classname="BillDog.restore — RestoreResult contract controller exception becomes a typed failure" name="BillDog.restore — RestoreResult contract controller exception becomes a typed failure" time="0">
+    </testcase>
+    <testcase classname="BillDog.restore — RestoreResult contract without controller and no bridge returns empty restored" name="BillDog.restore — RestoreResult contract without controller and no bridge returns empty restored" time="0.011">
+    </testcase>
+  </testsuite>
+</testsuites>

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@billdog.io/react-native",
+  "version": "1.0.0-beta.2",
+  "description": "React Native paywall rendering library for BillDog",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "test": "jest"
+  },
+  "keywords": [
+    "react-native",
+    "paywall",
+    "billdog",
+    "subscriptions",
+    "in-app-purchases"
+  ],
+  "author": "BillDog",
+  "license": "MIT",
+  "homepage": "https://billdog.app",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/billdogai/billdog.git",
+    "directory": "native-sdks/react-native"
+  },
+  "bugs": {
+    "url": "https://github.com/billdogai/billdog/issues"
+  },
+  "peerDependencies": {
+    "react": ">=16.8.0",
+    "react-native": ">=0.60.0",
+    "react-native-in-app-review": ">=4.0.0",
+    "react-native-webview": "^13.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react-native-in-app-review": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@react-native-async-storage/async-storage": "^1.19.0",
+    "pako": "^2.1.0",
+    "react-native-fs": "^2.20.0",
+    "react-native-svg": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/pako": "^2.0.3",
+    "@types/react": "^18.0.0",
+    "@types/react-native": "^0.70.0",
+    "jest": "^29.7.0",
+    "jest-junit": "^16.0.0",
+    "react": "^18.2.0",
+    "react-native": "0.72.17",
+    "react-native-webview": "^13.17.0",
+    "react-test-renderer": "^18.2.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.0.0"
+  }
+}

package/react-native.config.js

@@ -0,0 +1,13 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      ios: {
+        podspecPath: './BillDogVirtualCurrency.podspec',
+      },
+      android: {
+        sourceDir: './android',
+        packageImportPath: 'import io.billdog.virtualcurrency.BillDogVirtualCurrencyPackage;',
+      },
+    },
+  },
+};