@tinkerlandai/indiana-react-native 0.9.1 → 0.9.5

package/ios/IndianaBridge.m

@@ -0,0 +1,11 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+@interface RCT_EXTERN_MODULE(IndianaBridge, RCTEventEmitter)
+RCT_EXTERN_METHOD(create:(NSString *)configuration resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(identify:(NSString *)instanceId session:(NSString *)session resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(invoke:(NSString *)instanceId method:(NSString *)method input:(NSString *)input resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(reset:(NSString *)instanceId revision:(nonnull NSNumber *)revision resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(destroy:(NSString *)instanceId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(acknowledge:(NSString *)instanceId requestId:(NSString *)requestId accepted:(BOOL)accepted resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(provideCredential:(NSString *)instanceId requestId:(NSString *)requestId token:(NSString * _Nullable)token resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+@end

package/ios/IndianaBridge.swift

@@ -0,0 +1,275 @@
+import Foundation
+@preconcurrency import React
+import UIKit
+
+/// One scoped Customer client per JS SDK instance. No Server Key crosses this bridge.
+@MainActor @objc(IndianaBridge)
+final class IndianaBridge: RCTEventEmitter {
+    private struct Configuration: Decodable {
+        let baseUrl: String
+        let scope: IndianaScope
+        let timeout: Double
+        let credentialEvents: Bool?
+    }
+    @MainActor private final class Instance {
+        let client: IndianaClient
+        var revision = UUID()
+        var identitySequence = -1
+        var actions: [String: CheckedContinuation<Void, Error>] = [:]
+        var credentials: [String: CheckedContinuation<String, Error>] = [:]
+        var close: (() -> Void)?
+        var presentation: UUID?
+        init(_ client: IndianaClient) { self.client = client }
+    }
+    private var instances: [String: Instance] = [:]
+    @objc nonisolated override static func requiresMainQueueSetup() -> Bool { true }
+    @objc nonisolated override var methodQueue: DispatchQueue { .main }
+    nonisolated override func supportedEvents() -> [String]! { ["IndianaAction"] }
+    nonisolated override func invalidate() {
+        Task { @MainActor in
+            let owned = instances.values; instances.removeAll()
+            for value in owned {
+                value.revision = UUID(); value.close?(); cancelActions(value)
+                await value.client.reset()
+            }
+        }
+        super.invalidate()
+    }
+    private func cancelActions(_ owner: Instance) {
+        let pending = owner.actions.values; owner.actions.removeAll()
+        pending.forEach { $0.resume(throwing: IndianaClientError.identityChanged) }
+        let credentials = owner.credentials.values; owner.credentials.removeAll()
+        credentials.forEach { $0.resume(throwing: IndianaClientError.identityChanged) }
+    }
+    private func credential(_ id: String) async throws -> String {
+        let owner = try instance(id), request = UUID().uuidString
+        return try await withCheckedThrowingContinuation { continuation in
+            owner.credentials[request] = continuation
+            sendEvent(withName: "IndianaAction", body: ["instanceId": id, "requestId": request, "revision": owner.identitySequence, "kind": "credential"])
+            Task { @MainActor in
+                try? await Task.sleep(for: .seconds(45))
+                owner.credentials.removeValue(forKey: request)?.resume(throwing: IndianaClientError.temporaryUnavailable)
+            }
+        }
+    }
+    @objc(provideCredential:requestId:token:resolver:rejecter:)
+    func provideCredential(_ id: String, requestId: String, token: String?, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        do {
+            let owner = try instance(id)
+            if let continuation = owner.credentials.removeValue(forKey: requestId) {
+                if let token { continuation.resume(returning: token) }
+                else { continuation.resume(throwing: IndianaClientError.unauthenticated) }
+            }
+            resolve(nil)
+        } catch { fail(reject, error) }
+    }
+    private func action(_ owner: Instance, revision: UUID, _ payload: IndianaJSON) async throws {
+        guard owner.revision == revision else { throw IndianaClientError.identityChanged }
+        guard let id = instances.first(where: { $0.value === owner })?.key else { throw IndianaClientError.identityChanged }
+        let request = UUID().uuidString
+        try await withCheckedThrowingContinuation { continuation in
+            owner.actions[request] = continuation
+            do {
+                let object = try JSONSerialization.jsonObject(with: JSONEncoder().encode(payload))
+                sendEvent(withName: "IndianaAction", body: ["instanceId": id, "requestId": request, "revision": owner.identitySequence, "action": object])
+            } catch { owner.actions.removeValue(forKey: request)?.resume(throwing: error) }
+            Task { @MainActor in
+                try? await Task.sleep(for: .seconds(45))
+                owner.actions.removeValue(forKey: request)?.resume(throwing: IndianaClientError.temporaryUnavailable)
+            }
+        }
+    }
+    @objc(acknowledge:requestId:accepted:resolver:rejecter:)
+    func acknowledge(_ id: String, requestId: String, accepted: Bool, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        do {
+            let owner = try instance(id)
+            if let continuation = owner.actions.removeValue(forKey: requestId) {
+                if accepted { continuation.resume() } else { continuation.resume(throwing: IndianaClientError.unsupportedCapability) }
+            }
+            resolve(nil)
+        } catch { fail(reject, error) }
+    }
+
+    private func json(_ text: String) throws -> Data {
+        guard let data = text.data(using: .utf8), data.count <= 2_097_152 else { throw IndianaClientError.invalidResponse }
+        return data
+    }
+    private func instance(_ id: String) throws -> Instance {
+        guard let value = instances[id] else { throw IndianaClientError.invalidConfiguration }
+        return value
+    }
+    private func encode<T: Encodable>(_ value: T) throws -> String {
+        guard let text = String(data: try JSONEncoder().encode(value), encoding: .utf8) else { throw IndianaClientError.invalidResponse }
+        return text
+    }
+    private func fail(_ reject: RCTPromiseRejectBlock, _ error: Error) {
+        // Credentials and provider payloads never enter bridge error messages.
+        reject("INDIANA_NATIVE_ERROR", String(describing: type(of: error)), nil)
+    }
+
+    @objc(create:resolver:rejecter:)
+    func create(_ configuration: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        Task {
+        do {
+            let input = try JSONDecoder().decode(Configuration.self, from: json(configuration))
+            guard let url = URL(string: input.baseUrl) else { throw IndianaClientError.invalidConfiguration }
+            let id = UUID().uuidString
+            instances[id] = Instance(IndianaClient(configuration: try IndianaConfiguration(baseURL: url, scope: input.scope, timeout: input.timeout)))
+            if input.credentialEvents == true { await instances[id]!.client.setAccessTokenProvider { @MainActor [weak self] in
+                guard let self else { throw IndianaClientError.identityChanged }
+                return try await self.credential(id)
+            } }
+            resolve(id)
+        } catch { fail(reject, error) }
+        }
+    }
+
+    @objc(identify:session:resolver:rejecter:)
+    func identify(_ id: String, session: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        Task {
+            do {
+                let value = try instance(id)
+                let frame = try JSONDecoder().decode([String: IndianaJSON].self, from: json(session))
+                guard case .number(let number) = frame["revision"], number >= 0, number <= 9_007_199_254_740_991, number.rounded() == number, let credentials = frame["credentials"] else { throw IndianaClientError.invalidResponse }
+                let sequence = Int(number)
+                guard sequence >= value.identitySequence else { throw IndianaClientError.identityChanged }
+                value.identitySequence = sequence
+                let data = try JSONEncoder().encode(credentials)
+                value.revision = UUID(); value.close?(); value.close = nil; value.presentation = nil; cancelActions(value)
+                let token = try JSONDecoder().decode(String.self, from: data)
+                try await value.client.identify(customerToken: token)
+                resolve(nil)
+            } catch { fail(reject, error) }
+        }
+    }
+
+    @objc(reset:revision:resolver:rejecter:)
+    func reset(_ id: String, revision: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        Task {
+            do {
+                let value = try instance(id)
+                let number = revision.doubleValue
+                guard number.isFinite, number >= 0, number <= 9_007_199_254_740_991, number.rounded() == number else { throw IndianaClientError.invalidResponse }
+                guard revision.intValue >= value.identitySequence else { resolve(nil); return }
+                value.identitySequence = revision.intValue
+                value.revision = UUID(); value.close?(); value.close = nil; value.presentation = nil; cancelActions(value)
+                await value.client.reset()
+                resolve(nil)
+            } catch { fail(reject, error) }
+        }
+    }
+
+    @objc(destroy:resolver:rejecter:)
+    func destroy(_ id: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        Task {
+            guard let value = instances.removeValue(forKey: id) else { resolve(nil); return }
+            value.revision = UUID(); value.close?(); value.close = nil; cancelActions(value)
+            await value.client.reset()
+            resolve(nil)
+        }
+    }
+
+    @objc(invoke:method:input:resolver:rejecter:)
+    func invoke(_ id: String, method: String, input: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        Task {
+            do {
+                let owner = try instance(id), revision = owner.revision
+                let fields = try JSONDecoder().decode([String: IndianaJSON].self, from: json(input))
+                switch method {
+                case "restorePurchases":
+                    let results = try await owner.client.restorePurchases()
+                    guard revision == owner.revision else { throw IndianaClientError.identityChanged }
+                    resolve(try encode(results.map { try JSONDecoder().decode(IndianaJSON.self, from: $0) }))
+                case "purchaseSubscription", "switchSubscription":
+                    guard fields["accepted"] == .bool(true), let raw = fields["operationId"]?.string, let operationId = UUID(uuidString: raw) else { throw IndianaClientError.invalidResponse }
+                    let result = method == "purchaseSubscription"
+                        ? try await owner.client.purchaseSubscription(operationId: operationId, confirm: { _ in true })
+                        : try await owner.client.switchSubscription(operationId: operationId, confirm: { _ in true })
+                    guard revision == owner.revision else { throw IndianaClientError.identityChanged }
+                    resolve(String(data: result, encoding: .utf8))
+                case "manageSubscriptions":
+                    guard let scene = UIApplication.shared.connectedScenes.compactMap({ $0 as? UIWindowScene }).first(where: { $0.activationState == .foregroundActive }) else { throw IndianaClientError.unsupportedCapability }
+                    try await IndianaStoreSubscriptions.manage(in: scene)
+                    resolve("null")
+                case "showFunnel", "showPaywall", "showContent":
+                    try await present(owner, revision: revision, method: method, fields: fields, resolve: resolve, reject: reject)
+                default: throw IndianaClientError.unsupportedCapability
+                }
+            } catch { fail(reject, error) }
+        }
+    }
+
+    private func presenter() throws -> UIViewController {
+        guard let scene = UIApplication.shared.connectedScenes.compactMap({ $0 as? UIWindowScene }).first(where: { $0.activationState == .foregroundActive }),
+              var controller = scene.windows.first(where: { $0.isKeyWindow })?.rootViewController else { throw IndianaClientError.unsupportedCapability }
+        while let next = controller.presentedViewController { controller = next }
+        return controller
+    }
+
+    private func present(_ owner: Instance, revision: UUID, method: String, fields: [String: IndianaJSON], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) async throws {
+        guard owner.presentation == nil else { throw IndianaClientError.unsupportedCapability }
+        let presenter = try presenter()
+        let reservation = UUID()
+        owner.presentation = reservation
+        var shown = false
+        defer { if !shown, owner.presentation == reservation { owner.presentation = nil } }
+        var settled = false
+        var controller: UIViewController!
+        var release: (() -> Void)?
+        let finish: @MainActor @Sendable (IndianaJSON) -> Void = { value in
+            guard !settled else { return }; settled = true
+            if owner.presentation == reservation { owner.close = nil; owner.presentation = nil }
+            release?()
+            controller?.dismiss(animated: true)
+            let result = owner.revision == revision ? value : .object(["status": .string("dismissed")])
+            do { resolve(try self.encode(result)) } catch { self.fail(reject, error) }
+        }
+        let dismissed: @MainActor @Sendable () -> Void = { finish(.object(["status": .string("dismissed")])) }
+        let failed: @MainActor @Sendable (Error) -> Void = { error in
+            guard !settled else { return }; settled = true
+            if owner.presentation == reservation { owner.close = nil; owner.presentation = nil }
+            release?()
+            controller?.dismiss(animated: true); self.fail(reject, error)
+        }
+        let purchase: @MainActor @Sendable (IndianaJSON) async throws -> Void = { operation in
+            guard owner.revision == revision else { throw IndianaClientError.identityChanged }
+            guard let raw = operation.object?["operationId"]?.string, let id = UUID(uuidString: raw) else { throw IndianaClientError.invalidResponse }
+            _ = try await owner.client.purchaseSubscription(operationId: id, confirm: { _ in true })
+        }
+        if method == "showFunnel" {
+            guard let token = fields["runToken"]?.string else { throw IndianaClientError.invalidResponse }
+            let session = try await owner.client.funnel(runToken: token)
+            let view = IndianaFunnelViewController(session: session)
+            view.onPurchase = purchase; view.onDismiss = dismissed; view.onError = failed
+            view.onEvent = { name in try await self.action(owner, revision: revision, .object(["type": .string("event"), "name": .string(name)])) }
+            view.onComplete = { run in
+                do { finish(.object(["status": .string("complete"), "result": try JSONDecoder().decode(IndianaJSON.self, from: JSONEncoder().encode(run))])) }
+                catch { failed(error) }
+            }
+            controller = view
+            release = { Task { await view.close() } }
+        } else if method == "showPaywall" {
+            guard let raw = fields["provider"]?.string, let provider = IndianaSubscriptionProvider(rawValue: raw), let currency = fields["currency"]?.string else { throw IndianaClientError.invalidResponse }
+            let session = try await owner.client.paywall(paywallId: fields["paywallId"]?.string.flatMap(UUID.init(uuidString:)), paywallVersionId: fields["paywallVersionId"]?.string.flatMap(UUID.init(uuidString:)), provider: provider, currency: currency, locale: fields["locale"]?.string ?? "en")
+            let view = IndianaPaywallViewController(session: session)
+            view.onPurchase = purchase; view.onDismiss = dismissed; view.onError = failed
+            view.onEvent = { name in try await self.action(owner, revision: revision, .object(["type": .string("event"), "name": .string(name)])) }
+            view.onComplete = { result in finish(.object(["status": .string("complete"), "result": result])) }
+            controller = view
+            release = { Task { await view.close() } }
+        } else {
+            guard let selector = fields["selector"], let kind = fields["kind"] else { throw IndianaClientError.invalidResponse }
+            let session = try await owner.client.content(["kind": kind, "selector": selector], locale: fields["locale"]?.string ?? "en", inputs: fields["inputs"]?.object ?? [:])
+            let view = IndianaContentViewController(session: session)
+            view.onDismiss = dismissed; view.onError = failed
+            view.onAction = { payload in try await self.action(owner, revision: revision, payload) }
+            controller = view
+            release = { Task { await session.close() } }
+        }
+        guard revision == owner.revision, owner.presentation == reservation else { release?(); throw IndianaClientError.identityChanged }
+        owner.close = dismissed
+        controller.isModalInPresentation = true
+        presenter.present(controller, animated: true)
+        shown = true
+    }
+}