@kingstinct/react-native-healthkit 12.1.2 → 12.2.0

package/ios/CoreModule.swift

@@ -1,5 +1,6 @@
 import HealthKit
 import NitroModules
+
 //
 //  Core.swift
 //  Pods
@@ -11,368 +12,411 @@ var store = HKHealthStore.init()
 
 // Thread-safe cache with concurrent read/exclusive write access
 private let quantityTypeCacheQueue = DispatchQueue(
-    label: "com.kingstinct.healthkit.cache",
-    attributes: .concurrent
+  label: "com.kingstinct.healthkit.cache",
+  attributes: .concurrent
 )
 private var quantityTypeUnitCache = [HKQuantityType: HKUnit]()
 
 func getUnitToUse(unitOverride: String?, quantityType: HKQuantityType) async throws -> HKUnit {
-    if let unitOverride = unitOverride {
-        let unit = HKUnit(from: unitOverride)
-
-        if !quantityType.is(compatibleWith: unit) {
-            throw RuntimeError.error(withMessage: "[react-native-healthkit] Unit \(unitOverride) is incompatible with \(quantityType.identifier)")
-        }
-
-        return unit
-    }
+  if let unitOverride = unitOverride {
+    let unit = HKUnit(from: unitOverride)
 
-    if let preferredUnit = try await getPreferredUnitsInternal(quantityTypes: [quantityType]).first?.value {
-        return preferredUnit
+    if !quantityType.is(compatibleWith: unit) {
+      throw runtimeErrorWithPrefix(
+        "Unit \(unitOverride) is incompatible with quantityType \(quantityType.identifier)")
     }
 
-    throw RuntimeError.error(withMessage: "[react-native-healthkit] Must specify a unit for \(quantityType.identifier)")
-}
+    return unit
+  }
 
-func getPreferredUnitsInternal(quantityTypes: [HKQuantityType], forceUpdate: Bool? = false) async throws -> [HKQuantityType: HKUnit] {
+  if let preferredUnit = try await getPreferredUnitsInternal(quantityTypes: [quantityType]).first?
+    .value {
+    return preferredUnit
+  }
 
-    if forceUpdate != true {
-        // Thread-safe read: concurrent reads are allowed
-        let itemsInCache = quantityTypeCacheQueue.sync {
-            return quantityTypeUnitCache.filter {
-                quantityTypes.contains($0.key)
-            }
-        }
-        if itemsInCache.count == quantityTypes.count {
-            return itemsInCache
-        }
-    }
+  throw runtimeErrorWithPrefix("getUnitToUse: Must specify a unit for \(quantityType.identifier)")
+}
 
-    return try await withCheckedThrowingContinuation { continuation in
-        store.preferredUnits(for: Set(quantityTypes)) {
-            (typePerUnits: [HKQuantityType: HKUnit], error: Error?) in
-            if let error = error {
-                return continuation.resume(throwing: error)
-            }
+func getPreferredUnitsInternal(quantityTypes: [HKQuantityType], forceUpdate: Bool? = false)
+async throws -> [HKQuantityType: HKUnit] {
 
-            // Thread-safe write: barrier ensures exclusive access
-            quantityTypeCacheQueue.sync(flags: .barrier) {
-                typePerUnits.forEach { (type: HKQuantityType, unit: HKUnit) in
-                    quantityTypeUnitCache.updateValue(unit, forKey: type)
-                }
-            }
+  if quantityTypes.count == 0 {
+    return [:]
+  }
 
-            return continuation.resume(returning: typePerUnits)
+  if forceUpdate != true {
+    // Thread-safe read: concurrent reads are allowed
+    let itemsInCache = quantityTypeCacheQueue.sync {
+      return quantityTypeUnitCache.filter {
+        quantityTypes.contains($0.key)
+      }
+    }
+    if itemsInCache.count == quantityTypes.count {
+      return itemsInCache
+    }
+  }
+
+  return try await withCheckedThrowingContinuation { continuation in
+    store.preferredUnits(for: Set(quantityTypes)) {
+      (typePerUnits: [HKQuantityType: HKUnit], error: Error?) in
+      if let error = error {
+        return continuation.resume(throwing: error)
+      }
+
+      // Thread-safe write: barrier ensures exclusive access
+      quantityTypeCacheQueue.sync(flags: .barrier) {
+        typePerUnits.forEach { (type: HKQuantityType, unit: HKUnit) in
+          quantityTypeUnitCache.updateValue(unit, forKey: type)
         }
+      }
+
+      return continuation.resume(returning: typePerUnits)
     }
+  }
 }
 
 class CoreModule: HybridCoreModuleSpec {
-    func areObjectTypesAvailable(objectTypeIdentifiers: [ObjectTypeIdentifier]) -> [String: Bool] {
-        var dict = [String: Bool]()
-
-        for objectTypeIdentifier in objectTypeIdentifiers {
-            dict[objectTypeIdentifier.stringValue] = isObjectTypeAvailable(objectTypeIdentifier: objectTypeIdentifier)
-        }
-
-        return dict
-    }
+  func currentAppSource() -> any HybridSourceProxySpec {
+    return SourceProxy(source: HKSource.default())
+  }
 
-    func areObjectTypesAvailableAsync(objectTypeIdentifiers: [ObjectTypeIdentifier]) -> Promise<[String: Bool]> {
-        return Promise.resolved(withResult: areObjectTypesAvailable(objectTypeIdentifiers: objectTypeIdentifiers))
-    }
+  func areObjectTypesAvailable(objectTypeIdentifiers: [ObjectTypeIdentifier]) -> [String: Bool] {
+    var dict = [String: Bool]()
 
-    func isObjectTypeAvailable(objectTypeIdentifier: ObjectTypeIdentifier) -> Bool {
-        do {
-            _ = try objectTypeFrom(objectTypeIdentifier: objectTypeIdentifier)
-            return true
-        } catch {
-            return false
-        }
+    for objectTypeIdentifier in objectTypeIdentifiers {
+      dict[objectTypeIdentifier.stringValue] = isObjectTypeAvailable(
+        objectTypeIdentifier: objectTypeIdentifier)
     }
 
-    func isObjectTypeAvailableAsync(objectTypeIdentifier: ObjectTypeIdentifier) -> Promise<Bool> {
-        return Promise.resolved(withResult: isObjectTypeAvailable(objectTypeIdentifier: objectTypeIdentifier))
+    return dict
+  }
+
+  func areObjectTypesAvailableAsync(objectTypeIdentifiers: [ObjectTypeIdentifier]) -> Promise<
+    [String: Bool]
+  > {
+    return Promise.resolved(
+      withResult: areObjectTypesAvailable(objectTypeIdentifiers: objectTypeIdentifiers))
+  }
+
+  func isObjectTypeAvailable(objectTypeIdentifier: ObjectTypeIdentifier) -> Bool {
+    do {
+      _ = try objectTypeFrom(objectTypeIdentifier: objectTypeIdentifier)
+      return true
+    } catch {
+      return false
     }
+  }
 
-    func authorizationStatusFor(
-        type: ObjectTypeIdentifier
-    ) throws -> AuthorizationStatus {
-        let objectType = try objectTypeFrom(objectTypeIdentifier: type)
+  func isObjectTypeAvailableAsync(objectTypeIdentifier: ObjectTypeIdentifier) -> Promise<Bool> {
+    return Promise.resolved(
+      withResult: isObjectTypeAvailable(objectTypeIdentifier: objectTypeIdentifier))
+  }
 
-        let authStatus = store.authorizationStatus(for: objectType)
+  func authorizationStatusFor(
+    type: ObjectTypeIdentifier
+  ) throws -> AuthorizationStatus {
+    let objectType = try objectTypeFrom(objectTypeIdentifier: type)
 
-        if let authStatus = AuthorizationStatus(rawValue: Int32(authStatus.rawValue)) {
-            return authStatus
-        }
+    let authStatus = store.authorizationStatus(for: objectType)
 
-        throw RuntimeError.error(withMessage: "[react-native-healthkit] got unrecognized AuthorizationStatus with value \(authStatus.rawValue)")
+    if let authStatus = AuthorizationStatus(rawValue: Int32(authStatus.rawValue)) {
+      return authStatus
     }
 
-    func getRequestStatusForAuthorization(toCheck: AuthDataTypes) throws -> Promise<AuthorizationRequestStatus> {
-        let toShare = sampleTypesFromArray(typeIdentifiersWriteable: toCheck.toShare ?? [])
-        let toRead = objectTypesFromArray(typeIdentifiers: toCheck.toRead ?? [])
-
-        return Promise.async {
-            try await withCheckedThrowingContinuation { continuation in
-                if toShare.isEmpty && toRead.isEmpty {
-                  return continuation.resume(throwing: RuntimeError.error(withMessage: "[react-native-healthkit] Both toRead and toShare are empty, at least one data type must be specified to check authorization status"))
-                }
-                store.getRequestStatusForAuthorization(toShare: toShare, read: toRead) { status, error in
-                    if let error = error {
-                        continuation.resume(throwing: error)
-                    } else {
-                        if let authStatus = AuthorizationRequestStatus(rawValue: Int32(status.rawValue)) {
-                            continuation.resume(returning: authStatus)
-                        } else {
-                            continuation.resume(throwing: RuntimeError.error(withMessage: "Unrecognized authStatus returned: \(status.rawValue)"))
-                        }
-
-                    }
-                }
-            }
+    throw runtimeErrorWithPrefix(
+      "Got unrecognized AuthorizationStatus rawValue: \(authStatus.rawValue)")
+  }
+
+  func getRequestStatusForAuthorization(toCheck: AuthDataTypes) -> Promise<
+    AuthorizationRequestStatus
+  > {
+    return Promise.async {
+      let toShare = sampleTypesFromArray(typeIdentifiersWriteable: toCheck.toShare ?? [])
+      let toRead = objectTypesFromArray(typeIdentifiers: toCheck.toRead ?? [])
+
+      return try await withCheckedThrowingContinuation { continuation in
+        if toShare.isEmpty && toRead.isEmpty {
+          warnWithPrefix("Both toRead and toShare are empty, returning 'unnecessary' status")
+          return continuation.resume(
+            returning: .unnecessary
+          )
         }
-    }
-
-    func requestAuthorization(toRequest: AuthDataTypes) throws -> Promise<Bool> {
-        let share = sampleTypesFromArray(typeIdentifiersWriteable: toRequest.toShare ?? [])
-        let toRead = objectTypesFromArray(typeIdentifiers: toRequest.toRead ?? [])
-
-        return Promise.async {
-            try await withCheckedThrowingContinuation { continuation in
-                store.requestAuthorization(toShare: share, read: toRead) { status, error in
-                    if let error = error {
-                        continuation.resume(throwing: error)
-                    } else {
-                        continuation.resume(returning: status)
-                    }
-                }
+        return store.getRequestStatusForAuthorization(toShare: toShare, read: toRead) {
+          status, error in
+          if let error = error {
+            continuation.resume(throwing: error)
+          } else {
+            if let authStatus = AuthorizationRequestStatus(rawValue: Int32(status.rawValue)) {
+              continuation.resume(returning: authStatus)
+            } else {
+              continuation.resume(
+                throwing: runtimeErrorWithPrefix(
+                  "Unrecognized authStatus returned: \(status.rawValue)"))
             }
-        }
-    }
-
-    func querySources(identifier: SampleTypeIdentifier) throws -> Promise<[HybridSourceProxySpec]> {
-        let sampleType = try sampleTypeFrom(sampleTypeIdentifier: identifier)
-
-        return Promise.async {
-            try await withCheckedThrowingContinuation { continuation in
-                let query = HKSourceQuery(
-                    sampleType: sampleType,
-                    samplePredicate: nil
-                ) { (_: HKSourceQuery, sources: Set<HKSource>?, error: Error?) in
-                    if let error = error {
-                        continuation.resume(throwing: error)
-                        return
-                    }
-
-                    guard let sources = sources else {
-                      return continuation.resume(throwing: RuntimeError.error(withMessage: "[react-native-healthkit] Empty response for sample type \(identifier.stringValue)"))
-                    }
-
-                    let serializedSources = sources.map { source -> SourceProxy in
 
-                        return SourceProxy(
-                            source: source
-                        )
-                    }
-
-                    continuation.resume(returning: serializedSources)
-                }
-
-                store.execute(query)
-            }
+          }
         }
+      }
     }
-
-    func enableBackgroundDelivery(typeIdentifier: ObjectTypeIdentifier, updateFrequency: UpdateFrequency) throws -> Promise<Bool> {
-        if let frequency = HKUpdateFrequency(rawValue: Int(updateFrequency.rawValue)) {
-            let type = try objectTypeFrom(objectTypeIdentifier: typeIdentifier)
-            return Promise.async {
-                try await withCheckedThrowingContinuation { continuation in
-                    store.enableBackgroundDelivery(
-                        for: type,
-                        frequency: frequency
-                    ) { (success, error) in
-                        if let err = error {
-                            return continuation.resume(throwing: err)
-                        }
-                        return continuation.resume(returning: success)
-                    }
-                }
-            }
-        } else {
-            throw RuntimeError.error(withMessage: "Invalid update frequency value: \(updateFrequency)")
+  }
+
+  func requestAuthorization(toRequest: AuthDataTypes) -> Promise<Bool> {
+    return Promise.async {
+      let share = sampleTypesFromArray(typeIdentifiersWriteable: toRequest.toShare ?? [])
+      let toRead = objectTypesFromArray(typeIdentifiers: toRequest.toRead ?? [])
+
+      return try await withCheckedThrowingContinuation { continuation in
+        store.requestAuthorization(toShare: share, read: toRead) { status, error in
+          if let error = error {
+            continuation.resume(throwing: error)
+          } else {
+            continuation.resume(returning: status)
+          }
         }
+      }
     }
+  }
+
+  func querySources(identifier: SampleTypeIdentifier, filter: FilterForSamples?) -> Promise<
+    [HybridSourceProxySpec]
+  > {
+    return Promise.async {
+      let sampleType = try sampleTypeFrom(sampleTypeIdentifier: identifier)
+      let predicate = createPredicateForSamples(filter)
+
+      return try await withCheckedThrowingContinuation { continuation in
+        let query = HKSourceQuery(
+          sampleType: sampleType,
+          samplePredicate: predicate
+        ) { (_: HKSourceQuery, sources: Set<HKSource>?, error: Error?) in
+          if let error = error {
+            continuation.resume(throwing: error)
+            return
+          }
+
+          guard let sources = sources else {
+            return continuation.resume(
+              throwing: runtimeErrorWithPrefix(
+                "Empty response for sample type \(identifier.stringValue)"))
+          }
+
+          let serializedSources = sources.map { source -> SourceProxy in
+
+            return SourceProxy(
+              source: source
+            )
+          }
+
+          continuation.resume(returning: serializedSources)
+        }
 
-    func disableBackgroundDelivery(
-        typeIdentifier: ObjectTypeIdentifier
-    ) throws -> Promise<Bool> {
-        return Promise.async {
-            let type = try objectTypeFrom(objectTypeIdentifier: typeIdentifier)
-            return try await withCheckedThrowingContinuation { continuation in
-                store.disableBackgroundDelivery(
-                    for: type
-                ) { (success, error) in
-                    if let err = error {
-                        return continuation.resume(throwing: err)
-                    }
-                    return continuation.resume(returning: success)
-                }
+        store.execute(query)
+      }
+    }
+  }
+
+  func enableBackgroundDelivery(
+    typeIdentifier: ObjectTypeIdentifier, updateFrequency: UpdateFrequency
+  ) -> Promise<Bool> {
+    return Promise.async {
+      if let frequency = HKUpdateFrequency(rawValue: Int(updateFrequency.rawValue)) {
+        let type = try objectTypeFrom(objectTypeIdentifier: typeIdentifier)
+        return try await withCheckedThrowingContinuation { continuation in
+          store.enableBackgroundDelivery(
+            for: type,
+            frequency: frequency
+          ) { (success, error) in
+            if let err = error {
+              return continuation.resume(throwing: err)
             }
+            return continuation.resume(returning: success)
+          }
         }
+      } else {
+        throw runtimeErrorWithPrefix("Invalid update frequency rawValue: \(updateFrequency)")
+      }
     }
 
-    func disableAllBackgroundDelivery() throws -> Promise<Bool> {
-        return Promise.async {
-            try await withCheckedThrowingContinuation { continuation in
-                store.disableAllBackgroundDelivery(completion: { (success, error) in
-                    guard let err = error else {
-                        return continuation.resume(returning: success)
-                    }
-                    return continuation.resume(throwing: err)
-                })
-            }
+  }
+
+  func disableBackgroundDelivery(
+    typeIdentifier: ObjectTypeIdentifier
+  ) -> Promise<Bool> {
+    return Promise.async {
+      let type = try objectTypeFrom(objectTypeIdentifier: typeIdentifier)
+      return try await withCheckedThrowingContinuation { continuation in
+        store.disableBackgroundDelivery(
+          for: type
+        ) { (success, error) in
+          if let err = error {
+            return continuation.resume(throwing: err)
+          }
+          return continuation.resume(returning: success)
         }
+      }
     }
-
-    func unsubscribeQueryAsync(queryId: String) throws -> Promise<Bool> {
-        let result = try self.unsubscribeQuery(queryId: queryId)
-
-        return Promise.resolved(withResult: result)
+  }
+
+  func disableAllBackgroundDelivery() -> Promise<Bool> {
+    return Promise.async {
+      try await withCheckedThrowingContinuation { continuation in
+        store.disableAllBackgroundDelivery(completion: { (success, error) in
+          guard let err = error else {
+            return continuation.resume(returning: success)
+          }
+          return continuation.resume(throwing: err)
+        })
+      }
     }
+  }
 
-    func isHealthDataAvailableAsync() -> Promise<Bool> {
-        return Promise.resolved(withResult: HKHealthStore.isHealthDataAvailable())
+  func unsubscribeQueryAsync(queryId: String) -> Promise<Bool> {
+    return Promise.async {
+      return try self.unsubscribeQuery(queryId: queryId)
     }
+  }
 
-    func isProtectedDataAvailableAsync() -> Promise<Bool> {
-        return Promise.resolved(withResult: UIApplication.shared.isProtectedDataAvailable)
-    }
+  func isHealthDataAvailableAsync() -> Promise<Bool> {
+    return Promise.resolved(withResult: HKHealthStore.isHealthDataAvailable())
+  }
 
-    func isHealthDataAvailable() throws -> Bool {
-        return HKHealthStore.isHealthDataAvailable()
-    }
+  func isProtectedDataAvailableAsync() -> Promise<Bool> {
+    return Promise.resolved(withResult: UIApplication.shared.isProtectedDataAvailable)
+  }
 
-    func isProtectedDataAvailable() throws -> Bool {
-        return UIApplication.shared.isProtectedDataAvailable
-    }
+  func isHealthDataAvailable() -> Bool {
+    return HKHealthStore.isHealthDataAvailable()
+  }
 
-    func getPreferredUnits(identifiers: [QuantityTypeIdentifier], forceUpdate: Bool?) throws -> Promise<[IdentifierWithUnit]> {
-        return Promise.async {
+  func isProtectedDataAvailable() -> Bool {
+    return UIApplication.shared.isProtectedDataAvailable
+  }
 
-            let quantityTypes = identifiers.compactMap { identifier in
-                do {
-                    let quantityType = try initializeQuantityType(identifier.stringValue)
+  func getPreferredUnits(identifiers: [QuantityTypeIdentifier], forceUpdate: Bool?) -> Promise<
+    [IdentifierWithUnit]
+  > {
+    return Promise.async {
+      let quantityTypes = identifiers.compactMap { identifier in
+        do {
+          let quantityType = try initializeQuantityType(identifier.stringValue)
 
-                    return quantityType
-                } catch {
-                    print(error.localizedDescription)
-                    return nil
-                }
-            }
+          return quantityType
+        } catch {
+          warnWithPrefix("getPreferredUnits: \(error.localizedDescription)")
+          return nil
+        }
+      }
 
-            let typePerUnits = try await getPreferredUnitsInternal(quantityTypes: quantityTypes, forceUpdate: forceUpdate)
+      let typePerUnits = try await getPreferredUnitsInternal(
+        quantityTypes: quantityTypes, forceUpdate: forceUpdate)
 
-            let dic = typePerUnits.map { typePerUnit in
-                return IdentifierWithUnit(
-                    typeIdentifier: typePerUnit.key.identifier,
-                    unit: typePerUnit.value.unitString
-                )
-            }
+      let dic = typePerUnits.map { typePerUnit in
+        return IdentifierWithUnit(
+          typeIdentifier: typePerUnit.key.identifier,
+          unit: typePerUnit.value.unitString
+        )
+      }
 
-            return dic
-        }
+      return dic
     }
+  }
 
-    var _runningQueries: [String: HKQuery] = [:]
+  var _runningQueries: [String: HKQuery] = [:]
 
-    func deleteObjects(objectTypeIdentifier: ObjectTypeIdentifier, filter: FilterForSamples) throws -> Promise<Double> {
-        let predicate = try createPredicateForSamples(filter: filter)
-        let of = try objectTypeFrom(objectTypeIdentifier: objectTypeIdentifier)
+  func deleteObjects(objectTypeIdentifier: ObjectTypeIdentifier, filter: FilterForSamples)
+    -> Promise<Double> {
+    return Promise.async {
+      if let predicate = createPredicateForSamples(filter) {
 
-        return Promise.async {
-            return try await withCheckedThrowingContinuation { continuation in
-                store.deleteObjects(of: of, predicate: predicate) { (_, count, error) in
-                    if let error = error {
-                        continuation.resume(throwing: error)
-                    } else {
-                        continuation.resume(returning: Double(count))
-                    }
-                }
+        let of = try objectTypeFrom(objectTypeIdentifier: objectTypeIdentifier)
+        return try await withCheckedThrowingContinuation { continuation in
+          store.deleteObjects(of: of, predicate: predicate) { (_, count, error) in
+            if let error = error {
+              continuation.resume(throwing: error)
+            } else {
+              continuation.resume(returning: Double(count))
             }
+          }
         }
+      }
+      throw runtimeErrorWithPrefix("Unable to create predicate for deleting objects")
     }
 
-    func subscribeToObserverQuery(
-        typeIdentifier: SampleTypeIdentifier,
-        callback: @escaping (OnChangeCallbackArgs) -> Void
-    ) throws -> String {
-        let sampleType = try sampleTypeFrom(sampleTypeIdentifier: typeIdentifier)
+  }
 
-        let predicate = HKQuery.predicateForSamples(
-            withStart: Date.init(),
-            end: nil,
-            options: HKQueryOptions.strictStartDate
-        )
+  func subscribeToObserverQuery(
+    typeIdentifier: SampleTypeIdentifier,
+    callback: @escaping (OnChangeCallbackArgs) -> Void
+  ) throws -> String {
+    let sampleType = try sampleTypeFrom(sampleTypeIdentifier: typeIdentifier)
 
-        let queryId = UUID().uuidString
+    let predicate = HKQuery.predicateForSamples(
+      withStart: Date.init(),
+      end: nil,
+      options: HKQueryOptions.strictStartDate
+    )
 
-        let query = HKObserverQuery(
-            sampleType: sampleType,
-            predicate: predicate
-        ) {
-            (_: HKObserverQuery, handler: @escaping HKObserverQueryCompletionHandler, error: Error?)
-            in
+    let queryId = UUID().uuidString
 
-            DispatchQueue.main.async {
-                callback(OnChangeCallbackArgs(typeIdentifier: typeIdentifier, errorMessage: error?.localizedDescription))
-                handler()
-            }
-
-        }
-
-        store.execute(query)
+    let query = HKObserverQuery(
+      sampleType: sampleType,
+      predicate: predicate
+    ) {
+      (_: HKObserverQuery, handler: @escaping HKObserverQueryCompletionHandler, error: Error?)
+      in
 
-        self._runningQueries.updateValue(query, forKey: queryId)
+      DispatchQueue.main.async {
+        callback(
+          OnChangeCallbackArgs(
+            typeIdentifier: typeIdentifier, errorMessage: error?.localizedDescription))
+        handler()
+      }
 
-        return queryId
     }
 
-    func unsubscribeQuery(queryId: String) throws -> Bool {
-        guard let query = self._runningQueries[queryId] else {
-            throw RuntimeError.error(withMessage: "[react-native-healthkit] Query with id \(queryId) not found")
-        }
+    store.execute(query)
 
-        store.stop(query)
+    self._runningQueries.updateValue(query, forKey: queryId)
 
-        self._runningQueries.removeValue(forKey: queryId)
+    return queryId
+  }
 
-        return true
+  func unsubscribeQuery(queryId: String) throws -> Bool {
+    guard let query = self._runningQueries[queryId] else {
+      warnWithPrefix("unsubscribeQuery: Query with id \(queryId) not found")
+
+      return false
     }
 
-    func unsubscribeQueriesAsync(queryIds: [String]) throws -> Promise<Double> {
-        let successCount = self.unsubscribeQueries(queryIds: queryIds)
+    store.stop(query)
 
-        return Promise.resolved(withResult: successCount)
-    }
+    self._runningQueries.removeValue(forKey: queryId)
 
-    func unsubscribeQueries(queryIds: [String]) -> Double {
-        let successCounts = queryIds.map { queryId in
-            if let query = self._runningQueries[queryId] {
-                store.stop(query)
+    return true
+  }
 
-                self._runningQueries.removeValue(forKey: queryId)
+  func unsubscribeQueriesAsync(queryIds: [String]) -> Promise<Double> {
+    return Promise.async {
+      return self.unsubscribeQueries(queryIds: queryIds)
+    }
+  }
 
-                return true
-            }
+  func unsubscribeQueries(queryIds: [String]) -> Double {
+    let successCounts = queryIds.map { queryId in
+      if let query = self._runningQueries[queryId] {
+        store.stop(query)
 
-            print("Query with id \(queryId) not found, skipping unsubscribe")
+        self._runningQueries.removeValue(forKey: queryId)
 
-            return false
-        }
+        return true
+      }
 
-        return Double(successCounts.filter { $0 }.count)
+      warnWithPrefix("unsubscribeQueries: Query with id \(queryId) not found, skipping unsubscribe")
+
+      return false
     }
 
+    return Double(successCounts.filter { $0 }.count)
+  }
+
 }