react-native-spike-sdk 4.6.13 → 4.8.13-beta.1

package/ios/SpikeSdk.m

@@ -5,86 +5,9 @@
 
 // MARK: Spike SDK level
 
-RCT_EXTERN_METHOD(createConnection: (NSString)uuid
-                  withAppId: (NSString)appId
-                  withAuthToken: (NSString)authToken
-                  withCustomerEndUserId: (NSString)customerEndUserId
-                  withCallbackUrl: (NSString)callbackUrl
-                  withUseLogger: (BOOL)useLogger
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(getBackgroundConnections: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(ensurePermissionsAreGranted: (NSArray<NSString>)permissions
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
 RCT_EXTERN_METHOD(isHealthDataAvailable: (RCTPromiseResolveBlock)resolve
                   withRejecter: (RCTPromiseRejectBlock)reject)
 
-// MARK: SpikeConnection level
-
-RCT_EXTERN_METHOD(getAppId: (NSString)connectionUUID
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(getSpikeEndUserId: (NSString)connectionUUID
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(getCustomerEndUserId: (NSString)connectionUUID
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(close: (NSString)connectionUUID
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(extractData: (NSString)connectionUUID
-                  withDataType: (NSString)dataType
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(extractDataInRange: (NSString)connectionUUID
-                  withDataType: (NSString)dataType
-                  withFromDateMillis: (double)fromDateMillis
-                  withToDateMillis: (double)toDateMillis
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
-// MARK: SpikeWebhookConnection level
-
-RCT_EXTERN_METHOD(getCallbackUrl: (NSString)connectionUUID
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(extractAndPostData: (NSString)connectionUUID
-                  withDataType: (NSString)dataType
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(extractAndPostDataInRange: (NSString)connectionUUID
-                  withDataType: (NSString)dataType
-                  withFromDateMillis: (double)fromDateMillis
-                  withToDateMillis: (double)toDateMillis
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(enableBackgroundDelivery: (NSString)connectionUUID
-                  withDataTypes: (NSArray<NSString>)dataTypes
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(getBackgroundDeliveryDataTypes: (NSString)connectionUUID
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(setListener: (NSString)connectionUUID
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
 // MARK: - New API - V3
 
 // MARK: Spike SDK level
@@ -96,6 +19,11 @@ RCT_EXTERN_METHOD(createConnectionAPIv3: (NSString)uuid
                   withResolver: (RCTPromiseResolveBlock)resolve
                   withRejecter: (RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(createConnectionAPIv3WithAuthToken: (NSString)uuid
+                  withAuthToken: (NSString)authToken
+                  withResolver: (RCTPromiseResolveBlock)resolve
+                  withRejecter: (RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(closeV3: (NSString)connectionUUID
                   withResolver: (RCTPromiseResolveBlock)resolve
                   withRejecter: (RCTPromiseRejectBlock)reject)
@@ -186,8 +114,6 @@ RCT_EXTERN_METHOD(getSleep: (NSString)connectionUUID
                   withResolver: (RCTPromiseResolveBlock)resolve
                   withRejecter: (RCTPromiseRejectBlock)reject)
 
-// V3 has to be added because "enableBackgroundDelivery"
-// method from old sdk is still present
 RCT_EXTERN_METHOD(enableBackgroundDeliveryV3: (NSString)connectionUUID
                   withStatistics: (NSArray<NSString>)statistics
                   metrics: (NSArray<NSString>)metrics

package/ios/SpikeSdk.swift

@@ -1,5 +1,7 @@
 import Foundation
+import BackgroundTasks
 import SpikeSDK
+import SwiftUI
 import React
 
 @objc(SpikeSdk)
@@ -13,79 +15,9 @@ class SpikeSdk: RCTEventEmitter {
         super.init()
     }
     
-    // MARK: - Connections dictionary
-    
-    /// Do not use this directly, use `addConnection` and `getConnection` instead
-    private var _connections: [String: SpikeConnection] = [:]
-    private let queue = DispatchQueue(label: "com.spike.rn.SpikeSdk.connections")
-    
-    /// Add new connection to the dictionary in a thread-safe manner
-    private func addConnection(_ connection: SpikeConnection, withUUID uuid: String) {
-        queue.sync {
-            _connections[uuid] = connection
-        }
-    }
-    
-    /// Synchronised read for safe multithreaded usage
-    private func getConnection(withUUID uuid: String) -> SpikeConnection? {
-        queue.sync {
-            _connections[uuid]
-        }
-    }
-    
     // MARK: - Spike SDK level
-        
-    @objc(createConnection:
-            withAppId:
-            withAuthToken:
-            withCustomerEndUserId:
-            withCallbackUrl:
-            withUseLogger:
-            withResolver:withRejecter:)
-    func createConnection(uuid: String,
-                          appId: String,
-                          authToken: String,
-                          customerEndUserId: String,
-                          callbackUrl: String?,
-                          useLogger: Bool,
-                          resolve: @escaping RCTPromiseResolveBlock,
-                          reject: @escaping RCTPromiseRejectBlock) {
-        Task {
-            do {
-                let logger = useLogger ? self.createLogger(connectionUUID: uuid) : nil
-                let spikeConnection = try await Spike.createConnection(
-                    appId: appId,
-                    authToken: authToken,
-                    customerEndUserId: customerEndUserId,
-                    callbackUrl: callbackUrl != nil ? URL(string: callbackUrl!) : nil,
-                    logger: logger)
-                addConnection(spikeConnection, withUUID: uuid)
-                resolve(Void())
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
-    @objc(getBackgroundConnections:
-            withRejecter:)
-    func getBackgroundConnections(resolve: @escaping RCTPromiseResolveBlock,
-                                  reject: @escaping RCTPromiseRejectBlock) {
-        Task {
-            do {
-                let spikeConnections = try await Spike.getBackgroundConnections()
-                var connectionsUUIDs: [String] = []
-                for connection in spikeConnections {
-                    let uuid = UUID().uuidString
-                    addConnection(connection, withUUID: uuid)
-                    connectionsUUIDs.append(uuid)
-                }
-                resolve(connectionsUUIDs)
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
+
+    private let queue = DispatchQueue(label: "com.spike.rn.SpikeSdk.connections")
 
     @objc(isHealthDataAvailable:
             withRejecter:)
@@ -96,359 +28,17 @@ class SpikeSdk: RCTEventEmitter {
             resolve(isAvailable)
         }
     }
-    
-    @objc(ensurePermissionsAreGranted:
-            withResolver:
-            withRejecter:)
-    func ensurePermissionsAreGranted(permissions: [String],
-                                     resolve: @escaping RCTPromiseResolveBlock,
-                                     reject: @escaping RCTPromiseRejectBlock) {
-        Task {
-            do {
-                let dataTypes = permissions.map { SpikeDataTypeMapper.mapDataType($0) }
-                try await Spike.ensurePermissionsAreGranted(permissions: dataTypes)
-                resolve(Void())
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
-    // MARK: SpikeConnection level
-    
-    @objc(getAppId:
-            withResolver:
-            withRejecter:)
-    func getAppId(connectionUUID: String,
-                  resolve: @escaping RCTPromiseResolveBlock,
-                  reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        do {
-            let value = try connection.getAppId()
-            resolve(value)
-        } catch let error {
-            spikeReject(with: error, reject: reject)
-        }
-    }
-    
-    @objc(getSpikeEndUserId:
-            withResolver:
-            withRejecter:)
-    func getSpikeEndUserId(connectionUUID: String,
-                           resolve: @escaping RCTPromiseResolveBlock,
-                           reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        do {
-            let value = try connection.getSpikeEndUserId()
-            resolve(value)
-        } catch let error {
-            spikeReject(with: error, reject: reject)
-        }
-    }
-    
-    @objc(getCustomerEndUserId:
-            withResolver:
-            withRejecter:)
-    func getCustomerEndUserId(connectionUUID: String,
-                              resolve: @escaping RCTPromiseResolveBlock,
-                              reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        do {
-            let value = try connection.getCustomerEndUserId()
-            resolve(value)
-        } catch let error {
-            spikeReject(with: error, reject: reject)
-        }
-    }
-    
-    @objc(close:
-            withResolver:
-            withRejecter:)
-    func close(connectionUUID: String,
-               resolve: @escaping RCTPromiseResolveBlock,
-               reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        do {
-            try connection.close()
-            resolve(Void())
-        } catch let error {
-            spikeReject(with: error, reject: reject)
-        }
-    }
-    
-    @objc(extractData:
-            withDataType:
-            withResolver:
-            withRejecter:)
-    func extractData(connectionUUID: String,
-                     dataType: String,
-                     resolve: @escaping RCTPromiseResolveBlock,
-                     reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        Task {
-            do {
-                let result = try await SpikeDataTypeMapper.extractData(dataType,
-                                                                       connection: connection)
-                if let dataString = result {
-                    resolve(dataString)
-                } else {
-                    spikeReject(with: SpikeDataExtractionException(), reject: reject)
-                }
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
-    @objc(extractDataInRange:
-            withDataType:
-            withFromDateMillis:
-            withToDateMillis:
-            withResolver:
-            withRejecter:)
-    func extractDataInRange(connectionUUID: String,
-                            dataType: String,
-                            fromDateMillis: Double,
-                            toDateMillis: Double,
-                            resolve: @escaping RCTPromiseResolveBlock,
-                            reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        Task {
-            do {
-                let fromDate = Date(timeIntervalSince1970: fromDateMillis/1000)
-                let toDate = Date(timeIntervalSince1970: toDateMillis/1000)
-                let result = try await SpikeDataTypeMapper.extractDataInRange(dataType,
-                                                                              connection: connection,
-                                                                              from: fromDate,
-                                                                              to: toDate)
-                if let dataString = result {
-                    resolve(dataString)
-                } else {
-                    spikeReject(with: SpikeDataExtractionException(), reject: reject)
-                }
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
-    // MARK: SpikeWebhookConnection level
-    
-    @objc(getCallbackUrl:
-            withResolver:
-            withRejecter:)
-    func getCallbackUrl(connectionUUID: String,
-                        resolve: @escaping RCTPromiseResolveBlock,
-                        reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        do {
-            let value = try connection.getCallbackUrl()
-            resolve(value.absoluteString)
-        } catch let error {
-            spikeReject(with: error, reject: reject)
-        }
-    }
-    
-    @objc(extractAndPostData:
-            withDataType:
-            withResolver:
-            withRejecter:)
-    func extractAndPostData(connectionUUID: String,
-                            dataType: String,
-                            resolve: @escaping RCTPromiseResolveBlock,
-                            reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        Task {
-            do {
-                let result = try await SpikeDataTypeMapper.extractAndPostData(dataType,
-                                                                              connection: connection)
-                if let dataString = result {
-                    resolve(dataString)
-                } else {
-                    spikeReject(with: SpikeDataExtractionException(), reject: reject)
-                }
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
-    @objc(extractAndPostDataInRange:
-            withDataType:
-            withFromDateMillis:
-            withToDateMillis:
-            withResolver:
-            withRejecter:)
-    func extractAndPostDataInRange(connectionUUID: String,
-                                   dataType: String,
-                                   fromDateMillis: Double,
-                                   toDateMillis: Double,
-                                   resolve: @escaping RCTPromiseResolveBlock,
-                                   reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        Task {
-            do {
-                let fromDate = Date(timeIntervalSince1970: fromDateMillis/1000)
-                let toDate = Date(timeIntervalSince1970: toDateMillis/1000)
-                let result = try await SpikeDataTypeMapper.extractAndPostDataInRange(dataType,
-                                                                                     connection: connection,
-                                                                                     from: fromDate,
-                                                                                     to: toDate)
-                if let dataString = result {
-                    resolve(dataString)
-                } else {
-                    spikeReject(with: SpikeDataExtractionException(), reject: reject)
-                }
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
-    @objc(enableBackgroundDelivery:
-            withDataTypes:
-            withResolver:
-            withRejecter:)
-    func enableBackgroundDelivery(connectionUUID: String,
-                                  dataTypes: [String],
-                                  resolve: @escaping RCTPromiseResolveBlock,
-                                  reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        Task {
-            do {
-                let types = dataTypes.map { SpikeDataTypeMapper.mapDataType($0) }
-                try await connection.enableBackgroundDelivery(dataTypes: types)
-                resolve(Void())
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
-    @objc(getBackgroundDeliveryDataTypes:
-            withResolver:
-            withRejecter:)
-    func getBackgroundDeliveryDataTypes(connectionUUID: String,
-                                        resolve: @escaping RCTPromiseResolveBlock,
-                                        reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        Task {
-            do {
-                let dataTypes = try await connection.getBackgroundDeliveryDataTypes()
-                let dataTypesString = dataTypes.map { SpikeDataTypeMapper.mapDataTypeToString($0) }
-                resolve(dataTypesString)
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
-    @objc(setListener:
-            withResolver:
-            withRejecter:)
-    func setListener(connectionUUID: String,
-                     resolve: @escaping RCTPromiseResolveBlock,
-                     reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = getConnection(withUUID: connectionUUID) else {
-            spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
-            return
-        }
-        
-        do {
-            let listener = createListener(connectionUUID: connectionUUID)
-            try connection.setListener(listener: listener)
-            resolve(Void())
-        } catch let error {
-            spikeReject(with: error, reject: reject)
-        }
-    }
-    
+
     // MARK: Supported events
-    
+
     override func supportedEvents() -> [String]! {
         return [
-            "onDebug",
-            "onInfo",
-            "onError",
-            "onBackgroundLog",
             "onSdkLog",
         ]
     }
-    
-    // MARK: Private methods
-    
-    private func createLogger(connectionUUID: String) -> SpikeLogger {
-        return SpikeConnectionLogger(connectionUUID: connectionUUID) { [weak self] connectionUUID, level, message in
-            let body = [
-                "connectionUUID": connectionUUID,
-                "message": message
-            ]
-            switch level {
-            case .debug:
-                self?.sendEvent(withName: "onDebug", body: body)
-            case .info:
-                self?.sendEvent(withName: "onInfo", body: body)
-            case .error:
-                self?.sendEvent(withName: "onError", body: body)
-            }
-        }
-    }
 
-    private func createListener(connectionUUID: String) -> SpikeBackgroundDeliveriesLogger {
-        return SpikeConnectionListener(connectionUUID: connectionUUID) { [weak self] connectionUUID, log in
-            let body = [
-                "connectionUUID": connectionUUID,
-                "log": log
-            ]
-            self?.sendEvent(withName: "onBackgroundLog", body: body)
-        }
-    }
+    // MARK: Private methods
 
-    
     private func spikeReject(with error: Error, reject: RCTPromiseRejectBlock) {
         let message = (error as? SpikeException)?.description
         reject(
@@ -512,6 +102,27 @@ class SpikeSdk: RCTEventEmitter {
         }
     }
     
+    @objc(createConnectionAPIv3WithAuthToken:
+            withAuthToken:
+            withResolver:withRejecter:)
+    func createConnectionWithAuthToken(uuid: String,
+                                       authToken: String,
+                                       resolve: @escaping RCTPromiseResolveBlock,
+                                       reject: @escaping RCTPromiseRejectBlock) {
+        Task {
+            do {
+                let connection = try await Spike.createConnectionAPIv3(
+                    authToken: authToken
+                )
+                addConnectionV3(connection, withUUID: uuid)
+                resolve(Void())
+
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
+    }
+    
     @objc(closeV3:
             withResolver:
             withRejecter:)