react-native-spike-sdk 2.4.3 → 2.4.5

package/android/src/main/java/com/spikesdk/SpikeSdkModule.kt

@@ -18,6 +18,8 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import java.time.OffsetDateTime
 import java.util.UUID
 
@@ -32,7 +34,8 @@ fun <I, O> ComponentActivity.registerActivityResultLauncher(
 class SpikeSdkModule(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext), LifecycleEventListener {
 
-    private val connections = mutableMapOf<String, SpikeConnection>()
+    // Do not use this directly, use `addConnection` and `getConnection` instead
+    private val _connections = mutableMapOf<String, SpikeConnection>()
 
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
 
@@ -85,7 +88,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
                 } else {
                     null
                 }
-                connections[uuid] = SpikeConnection.createConnection(
+                addConnection(connection = SpikeConnection.createConnection(
                     context = reactApplicationContext,
                     authToken = authToken,
                     customerEndUserId = customerEndUserId,
@@ -93,7 +96,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
                     callbackUrl = callbackUrl,
                     env = SpikeEnvironment.PROD,
                     logger = logger,
-                )
+                ), uuid = uuid)
                 promise.resolve(uuid)
             } catch (e: SpikeExceptions) {
                 promise.reject(e.mapException(), e.message)
@@ -103,38 +106,43 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
 
     @ReactMethod
     fun getAppId(uuid: String, promise: Promise) {
-        try {
-            val connection = connections[uuid] ?: return promise.reject(
-                SpikeExceptions.SpikeException(
-                    "Connection not found"
-                ).mapException(), "Connection not found"
-            )
-            val appId = connection.getAppId()
-            promise.resolve(appId)
-        } catch (e: SpikeExceptions) {
-            promise.reject(e.mapException(), e.message)
+        scope.launch {
+            try {
+                val connection = getConnection(uuid) ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException(
+                        "Connection not found"
+                    ).mapException(), "Connection not found"
+                )
+                val appId = connection.getAppId()
+                promise.resolve(appId)
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
         }
     }
 
     @ReactMethod
     fun getSpikeEndUserId(uuid: String, promise: Promise) {
-        try {
-            val connection = connections[uuid] ?: return promise.reject(
-                SpikeExceptions.SpikeException(
-                    "Connection not found"
-                ).mapException(), "Connection not found"
-            )
-            val spikeEndUserId = connection.getSpikeUserId()
-            promise.resolve(spikeEndUserId)
-        } catch (e: SpikeExceptions) {
-            promise.reject(e.mapException(), e.message)
+        scope.launch {
+            try {
+                val connection = getConnection(uuid) ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException(
+                        "Connection not found"
+                    ).mapException(), "Connection not found"
+                )
+                val spikeEndUserId = connection.getSpikeUserId()
+                promise.resolve(spikeEndUserId)
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
         }
     }
 
     @ReactMethod
     fun getCustomerEndUserId(uuid: String, promise: Promise) {
+        scope.launch {
         try {
-            val connection = connections[uuid] ?: return promise.reject(
+            val connection = getConnection(uuid) ?: return@launch promise.reject(
                 SpikeExceptions.SpikeException(
                     "Connection not found"
                 ).mapException(), "Connection not found"
@@ -144,21 +152,23 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         } catch (e: SpikeExceptions) {
             promise.reject(e.mapException(), e.message)
         }
+            }
     }
 
     @ReactMethod
     fun getCallbackUrl(uuid: String, promise: Promise) {
-        try {
-            val connection =
-                connections[uuid] ?: return promise.reject(
+        scope.launch {
+            try {
+                val connection = getConnection(uuid) ?: return@launch promise.reject(
                     SpikeExceptions.SpikeException(
                         "Connection not found"
                     ).mapException(), "Connection not found"
                 )
-            val callbackUrl = connection.getPostbackUrl()
-            promise.resolve(callbackUrl)
-        } catch (e: SpikeExceptions) {
-            promise.reject(e.mapException(), e.message)
+                val callbackUrl = connection.getPostbackUrl()
+                promise.resolve(callbackUrl)
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
         }
     }
 
@@ -167,7 +177,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     fun close(uuid: String, promise: Promise) {
         scope.launch {
             try {
-                val connection = connections[uuid] ?: return@launch promise.reject(
+                val connection = getConnection(uuid) ?: return@launch promise.reject(
                     SpikeExceptions.SpikeException(
                         "Connection not found"
                     ).mapException(), "Connection not found"
@@ -190,7 +200,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     ) {
         scope.launch {
             try {
-                val connection = connections[connectionUUID] ?: return@launch promise.reject(
+                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
                     SpikeExceptions.SpikeException(
                         "Connection not found"
                     ).mapException(), "Connection not found"
@@ -217,7 +227,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     ) {
         scope.launch {
             try {
-                val connection = connections[connectionUUID] ?: return@launch promise.reject(
+                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
                     SpikeExceptions.SpikeException(
                         "Connection not found"
                     ).mapException(), "Connection not found"
@@ -242,7 +252,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     ) {
         scope.launch {
             try {
-                val connection = connections[connectionUUID] ?: return@launch promise.reject(
+                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
                     SpikeExceptions.SpikeException(
                         "Connection not found"
                     ).mapException(), "Connection not found"
@@ -265,7 +275,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     ) {
         scope.launch {
             try {
-                val connection = connections[connectionUUID] ?: return@launch promise.reject(
+                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
                     SpikeExceptions.SpikeException(
                         "Connection not found"
                     ).mapException(), "Connection not found"
@@ -282,16 +292,18 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
 
     @ReactMethod
     fun manageHealthConnect(connectionUUID: String, promise: Promise) {
-        try {
-            val connection = connections[connectionUUID] ?: return promise.reject(
-                SpikeExceptions.SpikeException(
-                    "Connection not found"
-                ).mapException(), "Connection not found"
-            )
-            connection.manageHealthConnect()
-            promise.resolve(true)
-        } catch (e: SpikeExceptions) {
-            promise.reject(e.mapException(), e.message)
+        scope.launch {
+            try {
+                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException(
+                        "Connection not found"
+                    ).mapException(), "Connection not found"
+                )
+                connection.manageHealthConnect()
+                promise.resolve(true)
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
         }
     }
 
@@ -299,7 +311,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     fun checkPermissionsGranted(connectionUUID: String, dataType: String, promise: Promise) {
         scope.launch {
             try {
-                val connection = connections[connectionUUID] ?: return@launch promise.reject(
+                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
                     SpikeExceptions.SpikeException(
                         "Connection not found"
                     ).mapException(), "Connection not found"
@@ -320,7 +332,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     fun getHealthConnectAvailability(connectionUUID: String, promise: Promise) {
         scope.launch {
             try {
-                val connection = connections[connectionUUID] ?: return@launch promise.reject(
+                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
                     SpikeExceptions.SpikeException(
                         "Connection not found"
                     ).mapException(), "Connection not found"
@@ -337,7 +349,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     fun revokeAllPermissions(connectionUUID: String, promise: Promise) {
         scope.launch {
             try {
-                val connection = connections[connectionUUID] ?: return@launch promise.reject(
+                val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
                     SpikeExceptions.SpikeException(
                         "Connection not found"
                     ).mapException(), "Connection not found"
@@ -352,98 +364,117 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
 
     @ReactMethod
     fun requestHealthPermissions(connectionUUID: String, dataType: String, promise: Promise) {
-        val connection = connections[connectionUUID] ?: return promise.reject(
-            SpikeExceptions.SpikeException(
-                "Connection not found"
-            ).mapException(), "Connection not found"
-        )
-
-        val permissions =
-            connection.getRequiredHealthPermissionsMetadata(dataType.toSpikeDataType())
-
-        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.TIRAMISU) {
-             val intent = SpikeConnection.requestReadAuthorization().createIntent(
-                 reactApplicationContext, permissions
-             )
-
-            val availability = connection.getHealthConnectAvailability()
-            if (availability == HealthConnectAvailability.INSTALLED) {
-                reactApplicationContext.currentActivity?.startActivityForResult(
-                    intent,
-                    REQUEST_CODE
+        scope.launch {
+            val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
+                SpikeExceptions.SpikeException(
+                    "Connection not found"
+                ).mapException(), "Connection not found"
+            )
+
+            val permissions =
+                connection.getRequiredHealthPermissionsMetadata(dataType.toSpikeDataType())
+
+            if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.TIRAMISU) {
+                val intent = SpikeConnection.requestReadAuthorization().createIntent(
+                    reactApplicationContext, permissions
                 )
-                promise.resolve(true)
-            } else {
-                promise.reject(SpikeExceptions.SpikeException().mapException(), SpikeExceptions.SpikeException().message)
-            }
-        } else {
-            val activity = reactApplicationContext.currentActivity
-            if (activity is ComponentActivity) {
-                checkPermissionsFor = Triple(connectionUUID, setOf(dataType), promise)
-                val launcher =
-                    activity.registerActivityResultLauncher(
-                        SpikeConnection.requestReadAuthorization()
-                    ) {
 
+                val availability = connection.getHealthConnectAvailability()
+                if (availability == HealthConnectAvailability.INSTALLED) {
+                    reactApplicationContext.currentActivity?.startActivityForResult(
+                        intent,
+                        REQUEST_CODE
+                    )
+                    promise.resolve(true)
+                } else {
+                    promise.reject(
+                        SpikeExceptions.SpikeException().mapException(),
+                        SpikeExceptions.SpikeException().message
+                    )
+                }
+            } else {
+                val activity = reactApplicationContext.currentActivity
+                if (activity is ComponentActivity) {
+                    checkPermissionsFor = Triple(connectionUUID, setOf(dataType), promise)
+                    val launcher =
+                        activity.registerActivityResultLauncher(
+                            SpikeConnection.requestReadAuthorization()
+                        ) {
+
+                        }
+
+                    if (permissions.isNotEmpty()) {
+                        launcher.launch(permissions)
+                    } else {
+                        promise.resolve(false)
                     }
-
-                if (permissions.isNotEmpty()) {
-                    launcher.launch(permissions)
                 } else {
                     promise.resolve(false)
                 }
-            } else {
-                promise.resolve(false)
             }
         }
     }
 
     @ReactMethod
     fun requestMultipleHealthPermissions(connectionUUID: String, dataTypes: ReadableArray, promise: Promise) {
-        val connection = connections[connectionUUID] ?: return promise.reject(
-            SpikeExceptions.SpikeException(
-                "Connection not found"
-            ).mapException(), "Connection not found"
-        )
-
-        val permissions = mutableSetOf<String>()
-        dataTypes.toArrayList().forEach {
-            connection.getRequiredHealthPermissionsMetadata((it as String).toSpikeDataType()).forEach {
-                permissions.add(it)
-            }
-        }
-
-        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.TIRAMISU) {
-            val availability = connection.getHealthConnectAvailability()
-            if (permissions.isNotEmpty() && availability == HealthConnectAvailability.INSTALLED) {
-                val intent = SpikeConnection.requestReadAuthorization().createIntent(
-                    reactApplicationContext, permissions
-                )
+        scope.launch {
+            val connection = getConnection(connectionUUID) ?: return@launch promise.reject(
+                SpikeExceptions.SpikeException(
+                    "Connection not found"
+                ).mapException(), "Connection not found"
+            )
 
-                reactApplicationContext.currentActivity?.startActivityForResult(
-                    intent,
-                    REQUEST_CODE
-                )
-                promise.resolve(true)
-            } else {
-                promise.reject(SpikeExceptions.SpikeException().mapException(), SpikeExceptions.SpikeException().message)
+            val permissions = mutableSetOf<String>()
+            dataTypes.toArrayList().forEach {
+                connection.getRequiredHealthPermissionsMetadata((it as String).toSpikeDataType())
+                    .forEach {
+                        permissions.add(it)
+                    }
             }
-        } else {
-            val activity = reactApplicationContext.currentActivity
-            if (activity is ComponentActivity) {
-                checkPermissionsFor = Triple(connectionUUID, dataTypes.toArrayList().toSet() as Set<String>, promise)
-                val launcher =
-                    activity.registerActivityResultLauncher(
-                        SpikeConnection.requestReadAuthorization()
-                    ) {
 
-                    }
-                if (permissions.isNotEmpty()) {
-                    launcher.launch(permissions)
+            if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.TIRAMISU) {
+                val availability = connection.getHealthConnectAvailability()
+                if (permissions.isNotEmpty() && availability == HealthConnectAvailability.INSTALLED) {
+                    val intent = SpikeConnection.requestReadAuthorization().createIntent(
+                        reactApplicationContext, permissions
+                    )
+
+                    reactApplicationContext.currentActivity?.startActivityForResult(
+                        intent,
+                        REQUEST_CODE
+                    )
+                    promise.resolve(true)
                 } else {
-                    promise.reject(SpikeExceptions.SpikeException().mapException(), SpikeExceptions.SpikeException().message)            }
+                    promise.reject(
+                        SpikeExceptions.SpikeException().mapException(),
+                        SpikeExceptions.SpikeException().message
+                    )
+                }
             } else {
-                promise.resolve(false)
+                val activity = reactApplicationContext.currentActivity
+                if (activity is ComponentActivity) {
+                    checkPermissionsFor = Triple(
+                        connectionUUID,
+                        dataTypes.toArrayList().toSet() as Set<String>,
+                        promise
+                    )
+                    val launcher =
+                        activity.registerActivityResultLauncher(
+                            SpikeConnection.requestReadAuthorization()
+                        ) {
+
+                        }
+                    if (permissions.isNotEmpty()) {
+                        launcher.launch(permissions)
+                    } else {
+                        promise.reject(
+                            SpikeExceptions.SpikeException().mapException(),
+                            SpikeExceptions.SpikeException().message
+                        )
+                    }
+                } else {
+                    promise.resolve(false)
+                }
             }
         }
     }
@@ -504,4 +535,23 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         const val NAME = "SpikeSdk"
         const val REQUEST_CODE = 4200
     }
+
+    // Connections
+
+    private val mutex = Mutex()
+
+    // Add new connection to the dictionary in a thread-safe manner
+    private suspend fun addConnection(connection: SpikeConnection, uuid: String) {
+        mutex.withLock {
+            _connections[uuid] = connection
+        }
+    }
+
+    // Synchronised read for safe multithreaded usage
+    private suspend fun getConnection(uuid: String): SpikeConnection? {
+        mutex.withLock {
+            return _connections[uuid]
+        }
+    }
+
 }

package/ios/SpikeSdk.swift

@@ -9,13 +9,31 @@ class SpikeSdk: RCTEventEmitter {
         return true
     }
     
-    private var connections: [String: SpikeConnection] = [:]
-    
     override init() {
         super.init()
     }
     
-    // MARK: Spike SDK level
+    // 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:
@@ -41,7 +59,7 @@ class SpikeSdk: RCTEventEmitter {
                     customerEndUserId: customerEndUserId,
                     callbackUrl: callbackUrl != nil ? URL(string: callbackUrl!) : nil,
                     logger: logger)
-                connections[uuid] = spikeConnection
+                addConnection(spikeConnection, withUUID: uuid)
                 resolve(Void())
             } catch let error {
                 spikeReject(with: error, reject: reject)
@@ -59,7 +77,7 @@ class SpikeSdk: RCTEventEmitter {
                 var connectionsUUIDs: [String] = []
                 for connection in spikeConnections {
                     let uuid = UUID().uuidString
-                    connections[uuid] = connection
+                    addConnection(connection, withUUID: uuid)
                     connectionsUUIDs.append(uuid)
                 }
                 resolve(connectionsUUIDs)
@@ -104,7 +122,7 @@ class SpikeSdk: RCTEventEmitter {
     func getAppId(connectionUUID: String,
                   resolve: @escaping RCTPromiseResolveBlock,
                   reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] else {
+        guard let connection = getConnection(withUUID: connectionUUID) else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }
@@ -123,7 +141,7 @@ class SpikeSdk: RCTEventEmitter {
     func getSpikeEndUserId(connectionUUID: String,
                            resolve: @escaping RCTPromiseResolveBlock,
                            reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] else {
+        guard let connection = getConnection(withUUID: connectionUUID) else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }
@@ -142,7 +160,7 @@ class SpikeSdk: RCTEventEmitter {
     func getCustomerEndUserId(connectionUUID: String,
                               resolve: @escaping RCTPromiseResolveBlock,
                               reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] else {
+        guard let connection = getConnection(withUUID: connectionUUID) else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }
@@ -161,7 +179,7 @@ class SpikeSdk: RCTEventEmitter {
     func close(connectionUUID: String,
                resolve: @escaping RCTPromiseResolveBlock,
                reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] else {
+        guard let connection = getConnection(withUUID: connectionUUID) else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }
@@ -182,7 +200,7 @@ class SpikeSdk: RCTEventEmitter {
                      dataType: String,
                      resolve: @escaping RCTPromiseResolveBlock,
                      reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] else {
+        guard let connection = getConnection(withUUID: connectionUUID) else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }
@@ -214,7 +232,7 @@ class SpikeSdk: RCTEventEmitter {
                             toDateMillis: Double,
                             resolve: @escaping RCTPromiseResolveBlock,
                             reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] else {
+        guard let connection = getConnection(withUUID: connectionUUID) else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }
@@ -246,7 +264,7 @@ class SpikeSdk: RCTEventEmitter {
     func getCallbackUrl(connectionUUID: String,
                         resolve: @escaping RCTPromiseResolveBlock,
                         reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] else {
+        guard let connection = getConnection(withUUID: connectionUUID) else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }
@@ -267,7 +285,7 @@ class SpikeSdk: RCTEventEmitter {
                             dataType: String,
                             resolve: @escaping RCTPromiseResolveBlock,
                             reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] else {
+        guard let connection = getConnection(withUUID: connectionUUID) else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }
@@ -299,7 +317,7 @@ class SpikeSdk: RCTEventEmitter {
                                    toDateMillis: Double,
                                    resolve: @escaping RCTPromiseResolveBlock,
                                    reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] else {
+        guard let connection = getConnection(withUUID: connectionUUID) else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }
@@ -331,7 +349,7 @@ class SpikeSdk: RCTEventEmitter {
                                   dataTypes: [String],
                                   resolve: @escaping RCTPromiseResolveBlock,
                                   reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] else {
+        guard let connection = getConnection(withUUID: connectionUUID) else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }
@@ -353,7 +371,7 @@ class SpikeSdk: RCTEventEmitter {
     func getBackgroundDeliveryDataTypes(connectionUUID: String,
                                         resolve: @escaping RCTPromiseResolveBlock,
                                         reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] else {
+        guard let connection = getConnection(withUUID: connectionUUID) else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }
@@ -375,7 +393,7 @@ class SpikeSdk: RCTEventEmitter {
     func setListener(connectionUUID: String,
                      resolve: @escaping RCTPromiseResolveBlock,
                      reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] else {
+        guard let connection = getConnection(withUUID: connectionUUID) else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }

package/ios/SpikeSdk.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -1,4 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Workspace
    version = "1.0">
+   <FileRef
+      location = "self:">
+   </FileRef>
 </Workspace>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-spike-sdk",
-  "version": "2.4.3",
+  "version": "2.4.5",
   "iosVersion": "2.3.2",
   "description": "Spike API for health and productivity data from wearables and IoT devices",
   "main": "lib/commonjs/index",
@@ -86,7 +86,7 @@
   "engines": {
     "node": ">= 16.0.0"
   },
-  "packageManager": "^yarn@1.22.15",
+  "packageManager": "yarn@1.22.15",
   "jest": {
     "preset": "react-native",
     "modulePathIgnorePatterns": [