@kingstinct/react-native-healthkit 12.1.2 → 12.2.0

package/ios/MedicationModule.swift

@@ -0,0 +1,259 @@
+//
+//  MedicationModule.swift
+//  Pods
+//
+//  Created by Robert Herber on 2025-12-10.
+//
+
+import HealthKit
+import NitroModules
+
+#if compiler(>=6.2)
+  @available(iOS 26.0, *)
+  func deserializeHKMedicationConceptIdentifier(base64String: String?) throws
+    -> HKHealthConceptIdentifier? {
+    return try fromBase64(base64String: base64String) as? HKHealthConceptIdentifier
+  }
+
+  @available(iOS 26.0, *)
+  func getLogStatus(_ logStatus: HKMedicationDoseEvent.LogStatus) throws
+    -> MedicationDoseEventLogStatus {
+    if let rawValue = Int32(exactly: logStatus.rawValue) {
+      if let logStatus = MedicationDoseEventLogStatus.init(rawValue: rawValue) {
+        return logStatus
+      }
+      throw runtimeErrorWithPrefix(
+        "Unable to convert HKMedicationDoseEvent.LogStatus with \(rawValue) to MedicationDoseEventLogStatus"
+      )
+    }
+    throw runtimeErrorWithPrefix(
+      "Unable to convert HKMedicationDoseEvent.LogStatus to MedicationDoseEventLogStatus")
+  }
+
+  @available(iOS 26.0, *)
+  func getScheduleType(_ scheduleType: HKMedicationDoseEvent.ScheduleType) throws
+    -> MedicationDoseEventScheduleType {
+    if let rawValue = Int32(exactly: scheduleType.rawValue) {
+      if let scheduleType = MedicationDoseEventScheduleType.init(rawValue: rawValue) {
+        return scheduleType
+      }
+      throw runtimeErrorWithPrefix(
+        "Unable to convert HKMedicationDoseEvent.ScheduleType with \(rawValue) to MedicationDoseEventScheduleType"
+      )
+    }
+    throw runtimeErrorWithPrefix(
+      "Unable to convert HKMedicationDoseEvent.ScheduleType to MedicationDoseEventScheduleType")
+  }
+
+  @available(iOS 26.0, *)
+  func serializeMedicationEvent(sample: HKMedicationDoseEvent) throws -> MedicationDoseEvent {
+    return MedicationDoseEvent(
+      scheduleType: try getScheduleType(sample.scheduleType),
+      medicationConceptIdentifier: try serializeMedicationConceptIdentifier(
+        sample.medicationConceptIdentifier),
+      scheduledDate: sample.scheduledDate,
+      scheduledDoseQuantity: sample.scheduledDoseQuantity,
+      doseQuantity: sample.doseQuantity,
+      logStatus: try getLogStatus(sample.logStatus),
+      unit: sample.unit.unitString,
+      sampleType: serializeSampleType(sample.sampleType),
+      startDate: sample.startDate,
+      endDate: sample.endDate,
+      hasUndeterminedDuration: sample.hasUndeterminedDuration,
+
+      metadataWeatherCondition: serializeWeatherCondition(
+        sample.metadata?[HKMetadataKeyWeatherCondition] as? HKWeatherCondition),
+      metadataWeatherHumidity: serializeUnknownQuantityTyped(
+        quantity: sample.metadata?[HKMetadataKeyWeatherHumidity] as? HKQuantity),
+      metadataWeatherTemperature: serializeUnknownQuantityTyped(
+        quantity: sample.metadata?[HKMetadataKeyWeatherTemperature] as? HKQuantity),
+      metadataInsulinDeliveryReason: serializeInsulinDeliveryReason(
+        sample.metadata?[HKMetadataKeyInsulinDeliveryReason] as? HKInsulinDeliveryReason),
+      metadataHeartRateMotionContext: serializeHeartRateMotionContext(
+        sample.metadata?[HKMetadataKeyHeartRateMotionContext] as? HKHeartRateMotionContext),
+
+      uuid: sample.uuid.uuidString,
+      sourceRevision: serializeSourceRevision(sample.sourceRevision),
+      device: serializeDevice(hkDevice: sample.device),
+      metadata: serializeMetadata(sample.metadata),
+
+      metadataExternalUUID: sample.metadata?[HKMetadataKeyExternalUUID] as? String,
+      metadataTimeZone: sample.metadata?[HKMetadataKeyTimeZone] as? String,
+      metadataWasUserEntered: sample.metadata?[HKMetadataKeyWasUserEntered] as? Bool,
+      metadataDeviceSerialNumber: sample.metadata?[HKMetadataKeyDeviceSerialNumber] as? String,
+      metadataUdiDeviceIdentifier: sample.metadata?[HKMetadataKeyUDIDeviceIdentifier] as? String,
+      metadataUdiProductionIdentifier: sample.metadata?[HKMetadataKeyUDIProductionIdentifier]
+        as? String,
+      metadataDigitalSignature: sample.metadata?[HKMetadataKeyDigitalSignature] as? String,
+      metadataDeviceName: sample.metadata?[HKMetadataKeyDeviceName] as? String,
+      metadataDeviceManufacturerName: sample.metadata?[HKMetadataKeyDeviceManufacturerName]
+        as? String,
+      metadataSyncIdentifier: sample.metadata?[HKMetadataKeySyncIdentifier] as? String,
+      metadataSyncVersion: sample.metadata?[HKMetadataKeySyncVersion] as? Double,
+      metadataWasTakenInLab: sample.metadata?[HKMetadataKeyWasTakenInLab] as? Bool,
+      metadataReferenceRangeLowerLimit: sample.metadata?[HKMetadataKeyReferenceRangeLowerLimit]
+        as? Double,
+      metadataReferenceRangeUpperLimit: sample.metadata?[HKMetadataKeyReferenceRangeUpperLimit]
+        as? Double,
+      metadataAlgorithmVersion: sample.metadata?[HKMetadataKeyAlgorithmVersion] as? Double
+    )
+  }
+
+  @available(iOS 26.0, *)
+  func serializeMedicationConceptIdentifier(_ identifier: HKHealthConceptIdentifier) throws
+    -> String {
+    if let base64String = toBase64(identifier) {
+      return base64String
+    }
+    throw runtimeErrorWithPrefix("Unable to serialize HKHealthConceptIdentifier")
+  }
+
+  @available(iOS 26.0, *)
+  func getGeneralForm(hkGeneralForm: HKMedicationGeneralForm) throws -> GeneralForm {
+    if let generalForm = GeneralForm.init(fromString: hkGeneralForm.rawValue) {
+      return generalForm
+    }
+    throw runtimeErrorWithPrefix(
+      "Unable to convert HKMedicationGeneralForm with \(hkGeneralForm.rawValue) to GeneralForm, no matching value found"
+    )
+  }
+
+  @available(iOS 26.0, *)
+  func serializeMedication(medication: HKUserAnnotatedMedication) throws -> UserAnnotatedMedication {
+    return UserAnnotatedMedication(
+      isArchived: medication.isArchived,
+      hasSchedule: medication.hasSchedule,
+      nickname: medication.nickname,
+      medication: MedicationConcept(
+        identifier: try serializeMedicationConceptIdentifier(medication.medication.identifier),
+        displayText: medication.medication.displayText,
+        generalForm: try getGeneralForm(hkGeneralForm: medication.medication.generalForm),
+        relatedCodings: medication.medication.relatedCodings.map({ c in
+          return RelatedCoding(system: c.system, code: c.code, version: c.version)
+        })
+      ),
+    )
+  }
+
+  class MedicationModule: HybridMedicationModuleSpec {
+    func queryMedications() -> Promise<[UserAnnotatedMedication]> {
+      return Promise.async {
+        if #available(iOS 26.0, *) {
+          let q = HKUserAnnotatedMedicationQueryDescriptor()
+
+          let medications = try await q.result(for: store)
+
+          return try medications.compactMap({ medication in
+            return try serializeMedication(medication: medication)
+          })
+        }
+        warnWithPrefix(
+          "queryMedications is only available on iOS 26 and above")
+        return []
+      }
+    }
+
+    func queryMedicationEvents(options: QueryOptionsWithSortOrder) -> Promise<[MedicationDoseEvent]> {
+      return Promise.async {
+        if #available(iOS 26.0, *) {
+          let predicate = createPredicateForSamples(options.filter)
+
+          let doseEvents = try await sampleQueryAsync(
+            sampleType: HKSeriesType.medicationDoseEventType(),
+            limit: options.limit,
+            predicate: predicate,
+            sortDescriptors: getSortDescriptors(ascending: options.ascending)
+          )
+
+          return try doseEvents.compactMap({ sample in
+            if let event = sample as? HKMedicationDoseEvent {
+              return try serializeMedicationEvent(sample: event)
+            }
+            return nil
+          })
+        }
+        warnWithPrefix("queryMedicationEvents is only available on iOS 26 and above")
+        return []
+      }
+    }
+
+    func requestMedicationsAuthorization() -> Promise<Bool> {
+      return Promise.async {
+        if #available(iOS 26.0, *) {
+          try await store.requestPerObjectReadAuthorization(
+            for: .userAnnotatedMedicationType(), predicate: nil)
+          return true
+        } else {
+          warnWithPrefix(
+            "requestMedicationsAuthorization is only available on iOS 26 and above"
+          )
+          return false
+        }
+      }
+    }
+
+    func queryMedicationEventsWithAnchor(options: QueryOptionsWithAnchor) -> Promise<
+      MedicationDoseEventsWithAnchorResponse
+    > {
+      return Promise.async {
+        if #available(iOS 26.0, *) {
+          let predicate = createPredicateForSamples(options.filter)
+
+          let response = try await sampleAnchoredQueryAsync(
+            sampleType: HKSeriesType.medicationDoseEventType(),
+            limit: options.limit,
+            queryAnchor: options.anchor,
+            predicate: predicate
+          )
+
+          let serializedSamples = try response.samples.compactMap { s in
+            if let sample = s as? HKMedicationDoseEvent {
+              return try serializeMedicationEvent(sample: sample)
+            }
+            return nil
+          }
+
+          return MedicationDoseEventsWithAnchorResponse(
+            samples: serializedSamples,
+            deletedSamples: response.deletedSamples,
+            newAnchor: response.newAnchor
+          )
+        }
+        throw runtimeErrorWithPrefix("queryMedicationEventsWithAnchor requires iOS 26.0 or later")
+      }
+    }
+  }
+
+#else
+  class MedicationModule: HybridMedicationModuleSpec {
+    func queryMedications() -> Promise<[UserAnnotatedMedication]> {
+      return Promise.async {
+        throw runtimeErrorWithPrefix("queryMedications needs to be built with XCode 26.0 or later")
+      }
+    }
+
+    func queryMedicationEvents(options: QueryOptionsWithSortOrder) -> Promise<[MedicationDoseEvent]> {
+      return Promise.async {
+        throw runtimeErrorWithPrefix(
+          "queryMedicationEvents needs to be built with XCode 26.0 or later")
+      }
+    }
+
+    func requestMedicationsAuthorization() -> Promise<Bool> {
+      return Promise.async {
+        throw runtimeErrorWithPrefix(
+          "requestMedicationsAuthorization needs to be built with XCode 26.0 or later")
+      }
+    }
+
+    func queryMedicationEventsWithAnchor(options: QueryOptionsWithAnchor)
+      -> Promise<MedicationDoseEventsWithAnchorResponse> {
+      return Promise.async {
+        throw runtimeErrorWithPrefix(
+          "queryMedicationEventsWithAnchor needs to be built with XCode 26.0 or later")
+      }
+    }
+
+  }
+
+#endif

package/ios/PredicateHelpers.swift

@@ -0,0 +1,334 @@
+//
+//  PredicateHelpers.swift
+//  Pods
+//
+//  Created by Robert Herber on 2025-12-10.
+//
+
+import HealthKit
+
+func createSourcePredicate(_ sources: [HybridSourceProxySpec]?) -> NSPredicate? {
+  if let sources = sources {
+
+    let sourceSet = Set(
+      sources.compactMap({ source in
+        return (source as? SourceProxy)?.source
+      }))
+    if sourceSet.count > 0 {
+      return HKQuery.predicateForObjects(from: sourceSet)
+    }
+  }
+  return nil
+}
+
+func createDurationFilter(_ duration: WorkoutDurationPredicate?) -> NSPredicate? {
+  if let duration = duration {
+    if let predicateOperator = NSComparisonPredicate.Operator(
+      rawValue: UInt(duration.predicateOperator.rawValue)) {
+      return HKQuery.predicateForWorkouts(
+        with: predicateOperator, duration: duration.durationInSeconds)
+    } else {
+      warnWithPrefix(
+        "Unsupported operator in duration filter: \(duration.predicateOperator.rawValue)")
+    }
+  }
+  return nil
+}
+
+func createWorkoutActivityTypeFilter(_ workoutActivityType: WorkoutActivityType?) -> NSPredicate? {
+  if let workoutActivityType = workoutActivityType {
+    if let workoutActivityType = HKWorkoutActivityType.init(
+      rawValue: UInt(workoutActivityType.rawValue)) {
+      return HKQuery.predicateForWorkouts(with: workoutActivityType)
+    } else {
+      warnWithPrefix("Unsupported workout activity type in filter: \(workoutActivityType.rawValue)")
+    }
+  }
+  return nil
+}
+
+func createPredicateForWorkoutBase(_ filter: FilterForWorkoutsBase?) -> NSPredicate? {
+  if let filter = filter {
+    let allFilters = [
+      createMetadataPredicate(filter.metadata),
+      createUUIDPredicate(filter.uuid),
+      createUUIDsPredicate(uuids: filter.uuids),
+      createDatePredicate(filter.date),
+      createWorkoutActivityTypeFilter(filter.workoutActivityType),
+      createDurationFilter(filter.duration),
+      createSourcePredicate(filter.sources),
+    ].compactMap { $0 }
+
+    return allFilters.count > 1
+      ? NSCompoundPredicate.init(andPredicateWithSubpredicates: allFilters)
+      : allFilters.first
+  }
+  return nil
+}
+
+func getPredicateForWorkoutBase(_ filter: FilterForWorkouts?) -> FilterForWorkoutsBase? {
+  if let filter = filter {
+    return FilterForWorkoutsBase(
+      workoutActivityType: filter.workoutActivityType,
+      duration: filter.duration,
+      uuid: filter.uuid,
+      uuids: filter.uuids,
+      metadata: filter.metadata,
+      date: filter.date,
+      sources: filter.sources
+    )
+  }
+  return nil
+}
+
+func createCompoundOrPredicateForWorkout(OR: [FilterForWorkoutsBase]?) -> NSPredicate? {
+  if let OR = OR {
+    let orPredicates = OR.compactMap({ filter in
+      return createPredicateForWorkoutBase(filter)
+    })
+
+    let compoundOr =
+      orPredicates.count > 1
+      ? NSCompoundPredicate.init(orPredicateWithSubpredicates: orPredicates)
+      : orPredicates.first
+
+    if orPredicates.count < 2 {
+      warnWithPrefix("Workout filter OR clause contains less than 2 valid predicates.")
+    }
+    return compoundOr
+  }
+
+  return nil
+}
+
+func createNotPredicateForWorkout(NOT: [FilterForWorkoutsBase]?) -> NSPredicate? {
+  if let NOT = NOT {
+    let notPredicates = NOT.compactMap({ filter in
+      if let pred = createPredicateForWorkoutBase(filter) {
+        return NSCompoundPredicate.init(notPredicateWithSubpredicate: pred)
+      }
+      return nil
+    })
+
+    return notPredicates.count > 1
+      ? NSCompoundPredicate.init(andPredicateWithSubpredicates: notPredicates)
+      : notPredicates.first
+  }
+
+  return nil
+}
+
+func createAndPredicateForWorkout(AND: [FilterForWorkoutsBase]?) -> NSPredicate? {
+  if let AND = AND {
+    let andPredicates = AND.compactMap({ filter in
+      return createPredicateForWorkoutBase(filter)
+    })
+    return andPredicates.count > 1
+      ? NSCompoundPredicate.init(andPredicateWithSubpredicates: andPredicates)
+      : andPredicates.first
+  }
+  return nil
+}
+
+func createPredicateForWorkout(_ filter: FilterForWorkouts?) -> NSPredicate? {
+  if let filter = filter {
+    let allPredicates = [
+      createPredicateForWorkoutBase(
+        getPredicateForWorkoutBase(filter)
+      ),
+      createCompoundOrPredicateForWorkout(OR: filter.OR),
+      createNotPredicateForWorkout(NOT: filter.NOT),
+      createAndPredicateForWorkout(AND: filter.AND),
+    ].compactMap { $0 }
+
+    return allPredicates.count > 1
+      ? NSCompoundPredicate.init(andPredicateWithSubpredicates: allPredicates) : allPredicates.first
+  }
+  return nil
+}
+
+func createDatePredicate(_ dateFilter: DateFilter?) -> NSPredicate? {
+  if let dateFilter = dateFilter {
+    let strictStartDate = dateFilter.strictStartDate ?? false
+    let strictEndDate = dateFilter.strictEndDate ?? false
+
+    let options: HKQueryOptions =
+      strictStartDate && strictEndDate
+      ? [.strictStartDate, .strictEndDate]
+      : strictEndDate
+        ? .strictEndDate
+        : strictStartDate
+          ? .strictStartDate
+          : []
+
+    return HKQuery.predicateForSamples(
+      withStart: dateFilter.startDate,
+      end: dateFilter.endDate,
+      options: options
+    )
+  }
+  return nil
+}
+
+func createUUIDsPredicate(uuids: [String]?) -> NSPredicate? {
+  if let uuids = uuids {
+    let uuids = uuids.compactMap { uuidStr -> UUID? in
+      do {
+        let uuid = try initializeUUID(uuidStr)
+        return uuid
+      } catch {
+        warnWithPrefix(error.localizedDescription)
+        return nil
+      }
+    }
+    return HKQuery.predicateForObjects(with: Set(uuids))
+  }
+  return nil
+}
+
+func createUUIDPredicate(_ uuid: String?) -> NSPredicate? {
+  if let uuidStr = uuid {
+    do {
+      let uuid = try initializeUUID(uuidStr)
+      return HKQuery.predicateForObject(with: uuid)
+    } catch {
+      warnWithPrefix("createUUIDPredicate: \(error.localizedDescription)")
+      return nil
+    }
+  }
+  return nil
+}
+
+func getComparisonPredicateOperator(_ op: ComparisonPredicateOperator?) -> NSComparisonPredicate
+  .Operator? {
+  if let rawValue = op?.rawValue {
+    if let op = NSComparisonPredicate.Operator.init(rawValue: UInt(rawValue)) {
+      return op
+    } else {
+      warnWithPrefix(
+        "getComparisonPredicateOperator: Unsupported operator in metadata filter: \(rawValue)")
+    }
+  }
+  return nil
+}
+
+func createMetadataPredicate(_ metadata: PredicateWithMetadataKey?) -> NSPredicate? {
+  if let metadata = metadata {
+
+    guard let valueVariant = metadata.value else {
+      return HKQuery.predicateForObjects(withMetadataKey: metadata.withMetadataKey)
+    }
+
+    let actualValue: Any
+
+    switch valueVariant {
+    case .first(let boolValue):
+      actualValue = NSNumber(value: boolValue ? 1 : 0)
+    case .second(let stringValue):
+      actualValue = stringValue
+    case .third(let doubleValue):
+      actualValue = NSNumber(value: doubleValue)
+    case .fourth(let dateValue):
+      actualValue = dateValue
+    }
+
+    if let operatorType = metadata.operatorType != nil
+      ? getComparisonPredicateOperator(metadata.operatorType)
+      : .equalTo {
+      return HKQuery.predicateForObjects(
+        withMetadataKey: metadata.withMetadataKey,
+        operatorType: operatorType,
+        value: actualValue
+      )
+    }
+
+  }
+  return nil
+}
+
+func createPredicateForSamplesBase(_ filter: FilterForSamplesBase?) -> NSPredicate? {
+  if let filter = filter {
+    let w = filter.workout as? WorkoutProxy
+
+    let allFilters = [
+      createUUIDPredicate(filter.uuid),
+      createUUIDsPredicate(uuids: filter.uuids),
+      createDatePredicate(filter.date),
+      w?.workoutPredicate,
+      createMetadataPredicate(filter.metadata),
+      createSourcePredicate(filter.sources),
+    ].compactMap { $0 }
+
+    return allFilters.count > 1
+      ? NSCompoundPredicate.init(andPredicateWithSubpredicates: allFilters)
+      : allFilters.first
+  }
+  return nil
+}
+
+func createAndPredicateForSamples(_ AND: [FilterForSamplesBase]?) -> NSPredicate? {
+  if let filter = AND {
+    let allFilters = filter.compactMap { createPredicateForSamplesBase($0) }
+
+    return allFilters.count > 1
+      ? NSCompoundPredicate.init(andPredicateWithSubpredicates: allFilters)
+      : allFilters.first
+  }
+  return nil
+}
+
+func createNotPredicateForSamples(NOT: [FilterForSamplesBase]?) -> NSPredicate? {
+  if let filter = NOT {
+    if let allFilters = createAndPredicateForSamples(filter) {
+      return NSCompoundPredicate.init(notPredicateWithSubpredicate: allFilters)
+    }
+  }
+  return nil
+}
+
+func createOrPredicateForSamples(OR: [FilterForSamplesBase]?) -> NSPredicate? {
+  if let filter = OR {
+    let allFilters = filter.compactMap({ createPredicateForSamplesBase($0) })
+
+    if allFilters.count < 2 {
+      warnWithPrefix(
+        "Sample filter OR clause contains less than 2 valid predicates, which makes it redundant.")
+    }
+
+    return allFilters.count > 1
+      ? NSCompoundPredicate.init(orPredicateWithSubpredicates: allFilters)
+      : allFilters.first
+  }
+  return nil
+}
+
+func getPredicateForSamplesBase(_ filter: FilterForSamples?) -> FilterForSamplesBase? {
+  if let filter = filter {
+    return FilterForSamplesBase(
+      uuid: filter.uuid,
+      uuids: filter.uuids,
+      metadata: filter.metadata,
+      date: filter.date,
+      workout: filter.workout,
+      sources: filter.sources
+    )
+  }
+  return nil
+}
+
+func createPredicateForSamples(_ filter: FilterForSamples?) -> NSPredicate? {
+  if let filter = filter {
+    let allPredicates = [
+      createPredicateForSamplesBase(
+        getPredicateForSamplesBase(filter)
+      ),
+      createOrPredicateForSamples(OR: filter.OR),
+      createAndPredicateForSamples(filter.AND),
+      createNotPredicateForSamples(NOT: filter.NOT),
+    ].compactMap { $0 }
+
+    return allPredicates.count > 1
+      ? NSCompoundPredicate.init(andPredicateWithSubpredicates: allPredicates) : allPredicates.first
+  }
+  return nil
+}