expo-iap 3.0.8 → 3.1.1-rc.1

package/expo-module.config.json

@@ -1,9 +1,16 @@
 {
-  "platforms": ["ios", "android"],
+  "platforms": [
+    "ios",
+    "android"
+  ],
   "ios": {
-    "modules": ["ExpoIapModule"]
+    "modules": [
+      "OneSideModule"
+    ]
   },
   "android": {
-    "modules": ["expo.modules.iap.ExpoIapModule"]
+    "modules": [
+      "expo.modules.iap.ExpoIapModule"
+    ]
   }
 }

package/ios/ExpoIap.podspec

@@ -1,6 +1,7 @@
 require 'json'
 
 package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+versions = JSON.parse(File.read(File.join(__dir__, '..', 'openiap-versions.json')))
 
 Pod::Spec.new do |s|
   s.name           = 'ExpoIap'
@@ -16,12 +17,12 @@ Pod::Spec.new do |s|
   # Even though StoreKit 2 requires iOS/tvOS 15.0+, keep both at 13.4 for compatibility with affected Expo SDKs
   # The iOS/tvOS 15.0+ requirement is enforced at build time in source code via @available annotations
   s.platforms      = { :ios => '13.4', :tvos => '13.4' }
-  s.swift_version  = '5.4'
+  s.swift_version  = '5.9'
   s.source         = { git: 'https://github.com/hyochan/expo-iap' }
   s.static_framework = true
 
   s.dependency 'ExpoModulesCore'
-  s.dependency 'openiap', '1.1.12'
+  s.dependency 'openiap', versions['apple']
 
   # Swift/Objective-C compatibility
   s.pod_target_xcconfig = {

package/ios/ExpoIapHelper.swift

@@ -0,0 +1,96 @@
+import Foundation
+import OpenIAP
+
+enum ExpoIapHelper {
+    static func sanitizeDictionary(_ dictionary: [String: Any?]) -> [String: Any] {
+        var result: [String: Any] = [:]
+        for (key, value) in dictionary {
+            if let value {
+                result[key] = value
+            }
+        }
+        return result
+    }
+
+    static func sanitizeArray(_ array: [[String: Any?]]) -> [[String: Any]] {
+        array.map { sanitizeDictionary($0) }
+    }
+
+    // Overloads to support already-sanitized payloads (e.g., serialized OpenIAP responses)
+    static func sanitizeDictionary(_ dictionary: [String: Any]) -> [String: Any] {
+        dictionary
+    }
+
+    static func sanitizeArray(_ array: [[String: Any]]) -> [[String: Any]] {
+        array
+    }
+
+    static func parseProductQueryType(_ rawValue: String?) -> ProductQueryType {
+        guard let raw = rawValue?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else {
+            return .all
+        }
+        switch raw.lowercased() {
+        case "inapp", ProductQueryType.inApp.rawValue:
+            return .inApp
+        case ProductQueryType.subs.rawValue:
+            return .subs
+        case ProductQueryType.all.rawValue:
+            return .all
+        default:
+            return .all
+        }
+    }
+
+    static func decodeProductRequest(from payload: [String: Any]) throws -> ProductRequest {
+        if let skus = payload["skus"] as? [String], !skus.isEmpty {
+            let type = parseProductQueryType(payload["type"] as? String)
+            return try OpenIapSerialization.productRequest(skus: skus, type: type)
+        }
+
+        let indexedSkus = payload.keys
+            .compactMap { Int($0) }
+            .sorted()
+            .compactMap { payload[String($0)] as? String }
+
+        if !indexedSkus.isEmpty {
+            return try OpenIapSerialization.productRequest(skus: indexedSkus, type: .all)
+        }
+
+        if let request = try? OpenIapSerialization.decode(object: payload, as: ProductRequest.self) {
+            return request
+        }
+
+        throw PurchaseError.emptySkuList()
+    }
+
+    static func decodeRequestPurchaseProps(from payload: [String: Any]) throws -> RequestPurchaseProps {
+        if payload["requestPurchase"] != nil || payload["requestSubscription"] != nil {
+            return try OpenIapSerialization.decode(object: payload, as: RequestPurchaseProps.self)
+        }
+
+        if let request = payload["request"] {
+            let parsedType = parseProductQueryType(payload["type"] as? String)
+            let purchaseType: ProductQueryType = parsedType == .all ? .inApp : parsedType
+            var normalized: [String: Any] = ["type": purchaseType.rawValue]
+            switch purchaseType {
+            case .subs:
+                normalized["requestSubscription"] = request
+            case .inApp:
+                normalized["requestPurchase"] = request
+            case .all:
+                break
+            }
+            return try OpenIapSerialization.decode(object: normalized, as: RequestPurchaseProps.self)
+        }
+
+        if payload["sku"] != nil {
+            let normalized: [String: Any] = [
+                "type": ProductQueryType.inApp.rawValue,
+                "requestPurchase": ["ios": payload]
+            ]
+            return try OpenIapSerialization.decode(object: normalized, as: RequestPurchaseProps.self)
+        }
+
+        throw PurchaseError.make(code: .developerError, message: "Invalid request payload")
+    }
+}

package/ios/ExpoIapLog.swift

@@ -0,0 +1,127 @@
+import Foundation
+#if canImport(os)
+import os
+#endif
+
+enum ExpoIapLog {
+    enum Level: String {
+        case debug
+        case info
+        case warn
+        case error
+    }
+
+    private static var isEnabled: Bool = {
+        #if DEBUG
+        true
+        #else
+        false
+        #endif
+    }()
+
+    private static var customHandler: ((Level, String) -> Void)?
+
+    static func setEnabled(_ enabled: Bool) {
+        isEnabled = enabled
+    }
+
+    static func setHandler(_ handler: ((Level, String) -> Void)?) {
+        customHandler = handler
+    }
+
+    static func debug(_ message: String) { log(.debug, message) }
+    static func info(_ message: String) { log(.info, message) }
+    static func warn(_ message: String) { log(.warn, message) }
+    static func error(_ message: String) { log(.error, message) }
+
+    static func payload(_ name: String, payload: Any?) {
+        debug("\(name) payload: \(stringify(payload))")
+    }
+
+    static func result(_ name: String, value: Any?) {
+        debug("\(name) result: \(stringify(value))")
+    }
+
+    static func failure(_ name: String, error: Error) {
+        ExpoIapLog.error("\(name) failed: \(error.localizedDescription)")
+    }
+
+    private static func log(_ level: Level, _ message: String) {
+        guard isEnabled else { return }
+
+        if let handler = customHandler {
+            handler(level, message)
+            return
+        }
+
+        #if canImport(os)
+        let logger = Logger(subsystem: "dev.hyo.expo-iap", category: "ExpoIap")
+        let formatted = "[ExpoIap] \(message)"
+        switch level {
+        case .debug:
+            logger.debug("\(formatted, privacy: .public)")
+        case .info:
+            logger.info("\(formatted, privacy: .public)")
+        case .warn:
+            logger.warning("\(formatted, privacy: .public)")
+        case .error:
+            logger.error("\(formatted, privacy: .public)")
+        }
+        #else
+        NSLog("[ExpoIap][%@] %@", level.rawValue.uppercased(), message)
+        #endif
+    }
+
+    private static func stringify(_ value: Any?) -> String {
+        guard let sanitized = sanitize(value) else {
+            return "null"
+        }
+
+        if JSONSerialization.isValidJSONObject(sanitized),
+           let data = try? JSONSerialization.data(withJSONObject: sanitized, options: []) {
+            return String(data: data, encoding: .utf8) ?? String(describing: sanitized)
+        }
+
+        return String(describing: sanitized)
+    }
+
+    private static func sanitize(_ value: Any?) -> Any? {
+        guard let value else { return nil }
+
+        if let dictionary = value as? [String: Any] {
+            return sanitizeDictionary(dictionary)
+        }
+
+        if let optionalDictionary = value as? [String: Any?] {
+            var compact: [String: Any] = [:]
+            for (key, optionalValue) in optionalDictionary {
+                if let optionalValue {
+                    compact[key] = optionalValue
+                }
+            }
+            return sanitizeDictionary(compact)
+        }
+
+        if let array = value as? [Any] {
+            return array.compactMap { sanitize($0) }
+        }
+
+        if let optionalArray = value as? [Any?] {
+            return optionalArray.compactMap { sanitize($0) }
+        }
+
+        return value
+    }
+
+    private static func sanitizeDictionary(_ dictionary: [String: Any]) -> [String: Any] {
+        var sanitized: [String: Any] = [:]
+        for (key, value) in dictionary {
+            if key.lowercased().contains("token") {
+                sanitized[key] = "hidden"
+            } else if let sanitizedValue = sanitize(value) {
+                sanitized[key] = sanitizedValue
+            }
+        }
+        return sanitized
+    }
+}