react-native-spike-sdk 0.2.10 → 1.0.0

package/ios/SpikeSdk.swift

@@ -4,176 +4,507 @@ import React
 
 @objc(SpikeSdk)
 class SpikeSdk: RCTEventEmitter {
-
+    
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+    
+    private var connections: [String: SpikeConnection] = [:]
+    
     override init() {
         super.init()
-
-        Spike.shared.delegate = self
     }
-
-    @objc(isBackgroundUpdateEnabled:withRejecter:)
-    func isBackgroundUpdateEnabled(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
-        resolve(Spike.shared.isBackgroundUpdateEnabled) 
+    
+    // MARK: Spike SDK level
+    
+    @objc(createConnection:
+            withAppId:
+            withAuthToken:
+            withCustomerEndUserId:
+            withUseLogger:
+            withResolver:withRejecter:)
+    func createConnection(uuid: String,
+                          appId: String,
+                          authToken: String,
+                          customerEndUserId: String,
+                          useLogger: Bool,
+                          resolve: @escaping RCTPromiseResolveBlock,
+                          reject: @escaping RCTPromiseRejectBlock) {
+        Task {
+            do {
+                let logger = useLogger ? createLogger(connectionUUID: uuid) : nil
+                let spikeConnection = try await Spike.createConnection(
+                    appId: appId,
+                    authToken: authToken,
+                    customerEndUserId: customerEndUserId,
+                    logger: logger)
+                connections[uuid] = spikeConnection
+                resolve(Void())
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
     }
-
-    @objc(enableDebug)
-    func enableDebug() {
-        Spike.shared.enableDebug()
+    
+    @objc(createWebhookConnection:
+            withAppId:
+            withAuthToken:
+            withCustomerEndUserId:
+            withCallbackUrl:
+            withUseLogger:
+            withResolver:
+            withRejecter:)
+    func createWebhookConnection(uuid: String,
+                                 appId: String,
+                                 authToken: String,
+                                 customerEndUserId: String,
+                                 callbackUrl: String,
+                                 useLogger: Bool,
+                                 resolve: @escaping RCTPromiseResolveBlock,
+                                 reject: @escaping RCTPromiseRejectBlock) {
+        guard let url = URL(string: callbackUrl) else {
+            spikeReject(with: SpikeWrapperException(), reject: reject)
+            return
+        }
+        Task {
+            do {
+                let logger = useLogger ? createLogger(connectionUUID: uuid) : nil
+                let spikeConnection = try await Spike.createConnection(
+                    appId: appId,
+                    authToken: authToken,
+                    customerEndUserId: customerEndUserId,
+                    callbackUrl: url,
+                    logger: logger)
+                connections[uuid] = spikeConnection
+                resolve(uuid)
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
     }
-
-    @objc(setup:withAuthToken:withUserId:)
-    func setup(clientId: String,
-            authToken: String,
-            userId: String) {
-        Spike.shared.setup(clientId: clientId, authToken: authToken, userId: userId)
+    
+    @objc(unpackConnection:
+            withConnection:
+            withUseLogger:
+            withResolver:
+            withRejecter:)
+    func unpackConnection(uuid: String,
+                          connection: String,
+                          useLogger: Bool,
+                          resolve: @escaping RCTPromiseResolveBlock,
+                          reject: @escaping RCTPromiseRejectBlock) {
+        Task {
+            do {
+                let logger = useLogger ? createLogger(connectionUUID: uuid) : nil
+                let spikeConnection = try await Spike.unpackConnection(connection: connection,
+                                                                       logger: logger)
+                connections[uuid] = spikeConnection
+                resolve(uuid)
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
     }
     
-    @objc(setupWithURL:withAuthToken:withUserId:withPostbackURL:)
-    func setupWithURL(clientId: String,
-            authToken: String,
-            userId: String,
-            postbackURL: String?) {
-        Spike.shared.setup(clientId: clientId, authToken: authToken, userId: userId, postbackURL: postbackURL)
+    @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
+                    connections[uuid] = connection
+                    connectionsUUIDs.append(uuid)
+                }
+                resolve(connectionsUUIDs)
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
     }
-
-    @objc(getCurrentUUID:withRejecter:)
-    func getCurrentUUID(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
-        resolve(Spike.shared.getCurrentUUID() ?? "")
+    
+    @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)
+            }
+        }
     }
     
-    @objc(clearData)
-    func clearData() {
-        Spike.shared.clearData()
+    @objc(initialize)
+    func initialize() {
+//        Spike.configure()
     }
-
-    @objc(getData:)
-    func getData(dataTypes: [String]) {
-        let types = extractDataTypes(dataTypes)
-        Spike.shared.getData(for: types)
+    
+    // MARK: SpikeConnection level
+    
+    @objc(getAppId:
+            withResolver:
+            withRejecter:)
+    func getAppId(connectionUUID: String,
+                  resolve: @escaping RCTPromiseResolveBlock,
+                  reject: @escaping RCTPromiseRejectBlock) {
+        guard let connection = connections[connectionUUID] else {
+            spikeReject(with: SpikeWrapperException(), reject: reject)
+            return
+        }
+        
+        do {
+            let value = try connection.getAppId()
+            resolve(value)
+        } catch let error {
+            spikeReject(with: error, reject: reject)
+        }
     }
     
-    @objc(getDataInRange:withStartDateMillis:withEndDateMillis:)
-    func getDataInRange(dataTypes: [String], startDateMillis: Double, endDateMillis: Double) {
-        let startDate = Date(timeIntervalSince1970: startDateMillis/1000)
-        let endDate = Date(timeIntervalSince1970: endDateMillis/1000)
-        let types = extractDataTypes(dataTypes)
-        Spike.shared.getData(for: types, from: startDate, to: endDate)
+    @objc(getSpikeEndUserId:
+            withResolver:
+            withRejecter:)
+    func getSpikeEndUserId(connectionUUID: String,
+                           resolve: @escaping RCTPromiseResolveBlock,
+                           reject: @escaping RCTPromiseRejectBlock) {
+        guard let connection = connections[connectionUUID] else {
+            spikeReject(with: SpikeWrapperException(), reject: reject)
+            return
+        }
+        
+        do {
+            let value = try connection.getSpikeEndUserId()
+            resolve(value)
+        } catch let error {
+            spikeReject(with: error, reject: reject)
+        }
     }
     
-    @objc(enableBackgroundDelivery:withResolver:withRejecter:)
-    func enableBackgroundDelivery(dataTypes: [String],
-            resolve:  @escaping RCTPromiseResolveBlock,
-            reject: RCTPromiseRejectBlock) {
-        let types = extractDataTypes(dataTypes)
-        Spike.shared.enableBackgroundDelivery(for: types) {
-            resolve(Void.self)
+    @objc(getCustomerEndUserId:
+            withResolver:
+            withRejecter:)
+    func getCustomerEndUserId(connectionUUID: String,
+                              resolve: @escaping RCTPromiseResolveBlock,
+                              reject: @escaping RCTPromiseRejectBlock) {
+        guard let connection = connections[connectionUUID] else {
+            spikeReject(with: SpikeWrapperException(), reject: reject)
+            return
+        }
+        
+        do {
+            let value = try connection.getCustomerEndUserId()
+            resolve(value)
+        } catch let error {
+            spikeReject(with: error, reject: reject)
         }
     }
     
-    @objc(disableAllBackgroundDelivery:withRejecter:)
-    func disableAllBackgroundDelivery(resolve:  @escaping RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
-        Spike.shared.disableAllBackgroundDelivery() {
-            resolve(Void.self)
+    @objc(close:
+            withResolver:
+            withRejecter:)
+    func close(connectionUUID: String,
+               resolve: @escaping RCTPromiseResolveBlock,
+               reject: @escaping RCTPromiseRejectBlock) {
+        guard let connection = connections[connectionUUID] else {
+            spikeReject(with: SpikeWrapperException(), reject: reject)
+            return
+        }
+        
+        do {
+            try connection.close()
+            resolve(Void())
+        } catch let error {
+            spikeReject(with: error, reject: reject)
         }
     }
-
-    override func supportedEvents() -> [String]! {
-        return [
-            "onInitialize", 
-            "onInitializationFailure", 
-            "onDataResult", 
-            "onDataFailure", 
-            "onWorkoutDataResult", 
-            "onWorkoutDataFailure", 
-            "onSleepAnalysisDataResult",
-            "onSleepAnalysisDataFailure",
-            "onLog",
-        ]
+    
+    @objc(pack:
+            withResolver:
+            withRejecter:)
+    func pack(connectionUUID: String,
+              resolve: @escaping RCTPromiseResolveBlock,
+              reject: @escaping RCTPromiseRejectBlock) {
+        guard let connection = connections[connectionUUID] else {
+            spikeReject(with: SpikeWrapperException(), reject: reject)
+            return
+        }
+        
+        do {
+            let value = try connection.pack()
+            resolve(value)
+        } catch let error {
+            spikeReject(with: error, reject: reject)
+        }
     }
-
-    override static func requiresMainQueueSetup() -> Bool {
-        return true
+    
+    @objc(extractData:
+            withDataType:
+            withResolver:
+            withRejecter:)
+    func extractData(connectionUUID: String,
+                     dataType: String,
+                     resolve: @escaping RCTPromiseResolveBlock,
+                     reject: @escaping RCTPromiseRejectBlock) {
+        guard let connection = connections[connectionUUID] else {
+            spikeReject(with: SpikeWrapperException(), reject: reject)
+            return
+        }
+        
+        Task {
+            do {
+                let result = try await SpikeDataTypeMapper.extractData(dataType,
+                                                                       connection: connection)
+                if let dataString = result {
+                    resolve(dataString)
+                } else {
+                    spikeReject(with: SpikeWrapperException(), reject: reject)
+                }
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
     }
-
-    private func extractDataTypes(_ types: [String]) -> [SpikeDataTypes] {
-        return types.compactMap { type in
-            switch (type) {
-            case "DataTypeStep":
-                return SpikeDataTypes.step
-            case "DataTypeHeartRate":
-                return SpikeDataTypes.heartRate
-            case "DataTypeRestingHeartRate":
-                return SpikeDataTypes.restingHeartRate
-            case "DataTypeActiveEnergy":
-                return SpikeDataTypes.activeEnergy
-            case "DataTypeBasalEnergy":
-                return SpikeDataTypes.basalEnergy
-            case "DataTypeAppleMoveTime":
-                return SpikeDataTypes.appleMoveTime
-            case "DataTypeAppleExerciseTime":
-                return SpikeDataTypes.appleExerciseTime
-            case "DataTypeDistanceWalkingRunning":
-                return SpikeDataTypes.distanceWalkingRunning
-            case "DataTypeFloors":
-                return SpikeDataTypes.floors
-            case "DataTypeWorkout":
-                return SpikeDataTypes.workout
-            case "DataTypeSleepAnalysis":
-                return SpikeDataTypes.sleepAnalysis
-            default:
-                return nil
+    
+    @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 = connections[connectionUUID] else {
+            spikeReject(with: SpikeWrapperException(), 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: SpikeWrapperException(), reject: reject)
+                }
+            } catch let error {
+                spikeReject(with: error, reject: reject)
             }
         }
     }
-}
-
-extension SpikeSdk: SpikeDelegate {
     
-    func spikeInitialized(with uuid: String) {
-        sendEvent(withName: "onInitialize", body: ["uuid": uuid])
+    // MARK: SpikeWebhookConnection level
+    
+    @objc(getCallbackUrl:
+            withResolver:
+            withRejecter:)
+    func getCallbackUrl(connectionUUID: String,
+                        resolve: @escaping RCTPromiseResolveBlock,
+                        reject: @escaping RCTPromiseRejectBlock) {
+        guard let connection = connections[connectionUUID] as? SpikeWebhookConnection else {
+            spikeReject(with: SpikeWrapperException(), reject: reject)
+            return
+        }
+        
+        do {
+            let value = try connection.getCallbackUrl()
+            resolve(value.absoluteString)
+        } catch let error {
+            spikeReject(with: error, reject: reject)
+        }
     }
     
-    func spikeInitializationFailure() {
-        sendEvent(withName: "onInitializationFailure", body: [:])
+    @objc(extractAndPostData:
+            withDataType:
+            withResolver:
+            withRejecter:)
+    func extractAndPostData(connectionUUID: String,
+                            dataType: String,
+                            resolve: @escaping RCTPromiseResolveBlock,
+                            reject: @escaping RCTPromiseRejectBlock) {
+        guard let connection = connections[connectionUUID] as? SpikeWebhookConnection else {
+            spikeReject(with: SpikeWrapperException(), reject: reject)
+            return
+        }
+        
+        Task {
+            do {
+                let result = try await SpikeDataTypeMapper.extractAndPostData(dataType,
+                                                                              connection: connection)
+                if let dataString = result {
+                    resolve(dataString)
+                } else {
+                    spikeReject(with: SpikeWrapperException(), reject: reject)
+                }
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
     }
     
-    func spikeDataResult(_ result: SpikeResult<SpikeResultData>) { 
-        if let dataString = try? String(data: JSONEncoder().encode(result), encoding: .utf8){
-            sendEvent(withName: "onDataResult", body: ["resultJson": dataString])
-        } else {
-            sendEvent(withName: "onDataResult", body: ["resultJson": "[]"])
+    @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 = connections[connectionUUID] as? SpikeWebhookConnection else {
+            spikeReject(with: SpikeWrapperException(), 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: SpikeWrapperException(), reject: reject)
+                }
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
         }
     }
     
-    func spikeDataFailure() {
-        sendEvent(withName: "onDataFailure", body: [:])
+    @objc(enableBackgroundDelivery:
+            withDataTypes:
+            withResolver:
+            withRejecter:)
+    func enableBackgroundDelivery(connectionUUID: String,
+                                  dataTypes: [String],
+                                  resolve: @escaping RCTPromiseResolveBlock,
+                                  reject: @escaping RCTPromiseRejectBlock) {
+        guard let connection = connections[connectionUUID] as? SpikeWebhookConnection else {
+            spikeReject(with: SpikeWrapperException(), 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)
+            }
+        }
     }
-
-    func spikeWorkoutDataResult(_ result: SpikeResult<SpikeWorkoutResultData>) {
-        if let dataString = try? String(data: JSONEncoder().encode(result), encoding: .utf8){
-            sendEvent(withName: "onWorkoutDataResult", body: ["resultJson": dataString])
-        } else {
-            sendEvent(withName: "onWorkoutDataResult", body: ["resultJson": "[]"])
+    
+    @objc(getBackgroundDeliveryDataTypes:
+            withResolver:
+            withRejecter:)
+    func getBackgroundDeliveryDataTypes(connectionUUID: String,
+                                        resolve: @escaping RCTPromiseResolveBlock,
+                                        reject: @escaping RCTPromiseRejectBlock) {
+        guard let connection = connections[connectionUUID] as? SpikeWebhookConnection else {
+            spikeReject(with: SpikeWrapperException(), 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)
+            }
         }
     }
     
-    func spikeWorkoutDataFailure() {
-        sendEvent(withName: "onWorkoutDataFailure", body: [:])
+    @objc(setListener:
+            withResolver:
+            withRejecter:)
+    func setListener(connectionUUID: String,
+                     resolve: @escaping RCTPromiseResolveBlock,
+                     reject: @escaping RCTPromiseRejectBlock) {
+        guard let connection = connections[connectionUUID] as? SpikeWebhookConnection else {
+            spikeReject(with: SpikeWrapperException(), reject: reject)
+            return
+        }
+        
+        do {
+            let listener = createListener(connectionUUID: connectionUUID)
+            try connection.setListener(listener: listener)
+            resolve(Void())
+        } catch let error {
+            spikeReject(with: error, reject: reject)
+        }
     }
-
-    func spikeSleepAnalysisDataResult(_ result: SpikeResult<SpikeSleepAnalysisResultData>) {
-        if let dataString = try? String(data: JSONEncoder().encode(result), encoding: .utf8){
-            sendEvent(withName: "onSleepAnalysisDataResult", body: ["resultJson": dataString])
-        } else {
-            sendEvent(withName: "onSleepAnalysisDataResult", body: ["resultJson": "[]"])
+    
+    // MARK: Supported events
+    
+    override func supportedEvents() -> [String]! {
+        return [
+            "onDebug",
+            "onInfo",
+            "onError",
+            "onSubmissionFailure",
+        ]
+    }
+    
+    // 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)
+            }
         }
     }
     
-    func spikeSleepAnalysisFailure() {
-        sendEvent(withName: "onSleepAnalysisDataFailure", body: [:])
+    private func createListener(connectionUUID: String) -> SpikeWebhookConnectionListener {
+        return SpikeConnectionListener(connectionUUID: connectionUUID) { [weak self] connectionUUID, webhookJob, exception in
+            let jobString = try? String(data: JSONEncoder().encode(webhookJob), encoding: .utf8)
+            let body = [
+                "connectionUUID": connectionUUID,
+                "exception": SpikeExceptionMapper.handleSpikeError(exception),
+                "webhookJob": jobString ?? ""
+            ]
+            self?.sendEvent(withName: "onSubmissionFailure", body: body)
+        }
     }
-
-    func spikeLog(_ log: String) {
-        sendEvent(withName: "onLog", body: ["log": log])
+    
+    private func spikeReject(with error: Error, reject: RCTPromiseRejectBlock) {
+        let errorString = SpikeExceptionMapper.handleSpikeError(error)
+        reject(errorString, errorString, error)
     }
+    
 }

package/lib/commonjs/DataModels/SpikeActivitiesStreamDataEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeActivitiesStreamDataEntry.js.map

package/lib/commonjs/DataModels/SpikeActivitiesStreamDataEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["DataModels/SpikeActivitiesStreamDataEntry.ts"],"mappings":""}

package/lib/commonjs/DataModels/SpikeActivitiesSummaryDataEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeActivitiesSummaryDataEntry.js.map

package/lib/commonjs/DataModels/SpikeActivitiesSummaryDataEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["DataModels/SpikeActivitiesSummaryDataEntry.ts"],"mappings":""}

package/lib/commonjs/DataModels/SpikeBreathingDataEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeBreathingDataEntry.js.map

package/lib/commonjs/DataModels/SpikeBreathingDataEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["DataModels/SpikeBreathingDataEntry.ts"],"mappings":""}

package/lib/commonjs/DataModels/SpikeCaloriesDataEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SpikeCaloriesDataEntry.js.map

package/lib/commonjs/DataModels/SpikeCaloriesDataEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["DataModels/SpikeCaloriesDataEntry.ts"],"mappings":""}