@kingstinct/react-native-healthkit 14.1.0 → 15.1.0

package/README.md

@@ -121,13 +121,13 @@ Some imperative examples:
       'HKQuantityTypeIdentifierInsulinDelivery',
       'IU',
       5.5,
+      new Date(),
+      new Date(),
       {
-        metadata: {
           // Metadata keys could be arbirtary string to store app-specific data.
           // To use built-in types from https://developer.apple.com/documentation/healthkit/samples/metadata_keys
           // you need to specify string values instead of variable names (by dropping MetadataKey from the name).
           HKInsulinDeliveryReason: HKInsulinDeliveryReason.basal,
-        },
       }
     );
 ```
@@ -154,6 +154,36 @@ Example:
   // etc..
 ```
 
+### Memory considerations for workouts and other native objects
+
+Workouts (and a few other results, like sources) are returned as *proxies*: native objects that keep the underlying `HKWorkout` alive so you can call follow-up functions such as `getWorkoutRoutes()`, `getStatistic()` or `getAllStatistics()` on them. The JavaScript garbage collector frees a proxy, and the HealthKit objects behind it, once it is no longer referenced. The library reports an estimate of each proxy's native size to the JS engine so it can schedule collections sensibly. Note that react-native-nitro-modules currently keeps a small fixed amount of bookkeeping (on the order of a hundred bytes) per native object it has handed to JS for the lifetime of the JS runtime, so memory will not return exactly to baseline even after collection. If you process large numbers of workouts in a loop you can release the HealthKit side eagerly by calling `dispose()` once you are done with a workout:
+
+```TypeScript
+const workouts = await queryWorkoutSamples({ limit: 0 })
+
+for (const workout of workouts) {
+  const routes = await workout.getWorkoutRoutes()
+  // ... do something with the routes
+  workout.dispose()
+}
+```
+
+After `dispose()` the proxy can no longer be used - calling any function or reading any property on it will throw. If you need to keep the data around, call `toJSON()` first to get a plain object and store that instead of the proxy:
+
+```TypeScript
+const plainWorkouts = workouts.map((workout) => {
+  const json = workout.toJSON()
+  workout.dispose()
+  return json
+})
+```
+
+Other tips for keeping memory in check when working with large datasets:
+- Query in chunks (for example per month, or with `limit` and anchors) instead of fetching everything at once.
+- Prefer statistics queries (`queryStatisticsForQuantity`, `queryStatisticsCollectionForQuantity`) over fetching every sample when you only need aggregates.
+- Keep plain data (from `toJSON()` or the sample queries) in React state rather than proxies.
+- `sourceRevision.source` on samples and `sources` on statistics are plain objects, not proxies. To filter queries by a source, get a `SourceProxy` from `querySources()` and match it by `bundleIdentifier`.
+
 ## Migration to 9.0.0
 
 There are a lot of under-the-hood changes in version 9.0.0, some of them are breaking (although I've tried to reduce it as much as possible).

package/app.plugin.js

@@ -1,94 +1,49 @@
-const {
-  withPlugins,
-  createRunOncePlugin,
-  withEntitlementsPlist,
-  withInfoPlist,
-} = require('@expo/config-plugins')
-
-/**
- * @typedef ConfigPlugin
- * @type {import('@expo/config-plugins').ConfigPlugin<T>}
- * @template T = void
- */
-
-/**
- * @typedef InfoPlistConfig
- * @type {{
- *  NSHealthShareUsageDescription?: string | boolean,
- *  NSHealthUpdateUsageDescription?: string | boolean
- * }}
- */
-
-/**
- * @typedef AppPluginConfig
- * @type {InfoPlistConfig & { background?: boolean }}
- */
-
-/**
- * @type {ConfigPlugin<{background: boolean}>}
- */
-const withEntitlementsPlugin = (
-  config,
-  /**
-   * @type {{background: boolean} | undefined}
-   * */
-  props,
-) =>
-  withEntitlementsPlist(config, (config) => {
-    config.modResults['com.apple.developer.healthkit'] = true
-
-    // background is enabled by default, but possible to opt-out from
-    // (haven't seen any drawbacks from having it enabled)
-    if (props?.background !== false) {
-      config.modResults['com.apple.developer.healthkit.background-delivery'] =
-        true
-    }
-
-    return config
-  })
-
-/**
- * @type {ConfigPlugin<InfoPlistConfig>}
- */
-const withInfoPlistPlugin = (
-  config,
-  /**
-   * @type {{NSHealthShareUsageDescription?: string | true, NSHealthUpdateUsageDescription?: string | false} | undefined}
-   * */
-  props,
-) =>
-  withInfoPlist(config, (config) => {
-    config.modResults.NSHealthShareUsageDescription =
-      typeof props?.NSHealthShareUsageDescription === 'string'
-        ? props.NSHealthShareUsageDescription
-        : typeof config.modResults.NSHealthShareUsageDescription === 'string'
-          ? config.modResults.NSHealthShareUsageDescription
-          : `${config.name} wants to read your health data`
-
-    if (props?.NSHealthUpdateUsageDescription !== false) {
-      config.modResults.NSHealthUpdateUsageDescription =
-        typeof props?.NSHealthUpdateUsageDescription === 'string'
-          ? props.NSHealthUpdateUsageDescription
-          : typeof config.modResults.NSHealthUpdateUsageDescription === 'string'
-            ? config.modResults.NSHealthUpdateUsageDescription
-            : `${config.name} wants to update your health data`
-    }
-
-    return config
-  })
-
-const pkg = require('./package.json')
-
-/**
- * @type {ConfigPlugin<AppPluginConfig>}
- */
-const healthkitAppPlugin = (config, props) =>
-  withPlugins(config, [
-    [withEntitlementsPlugin, props],
-    [withInfoPlistPlugin, props],
-  ])
-
-/**
- * @type {ConfigPlugin<AppPluginConfig>}
- */
-module.exports = createRunOncePlugin(healthkitAppPlugin, pkg.name, pkg.version)
+// GENERATED FILE - do not edit by hand (gitignored).
+// Compiled from app.plugin.ts by `bun run build:plugin`.
+// Expo loads this file, not the .ts source, so edit app.plugin.ts and rebuild.
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const package_json_1 = __importDefault(require("./package.json"));
+const withEntitlementsPlugin = (config, props) => {
+    return (0, config_plugins_1.withEntitlementsPlist)(config, (configPlist) => {
+        configPlist.modResults['com.apple.developer.healthkit'] = true;
+        // background is enabled by default, but possible to opt-out from
+        // (haven't seen any drawbacks from having it enabled)
+        if (props?.background !== false) {
+            configPlist.modResults['com.apple.developer.healthkit.background-delivery'] = true;
+        }
+        return configPlist;
+    });
+};
+const withInfoPlistPlugin = (config, props) => {
+    return (0, config_plugins_1.withInfoPlist)(config, (configPlist) => {
+        const existingShareDescription = configPlist.modResults.NSHealthShareUsageDescription;
+        configPlist.modResults.NSHealthShareUsageDescription =
+            typeof props?.NSHealthShareUsageDescription === 'string'
+                ? props.NSHealthShareUsageDescription
+                : typeof existingShareDescription === 'string'
+                    ? existingShareDescription
+                    : `${config.name ?? package_json_1.default.name} wants to read your health data`;
+        if (props?.NSHealthUpdateUsageDescription !== false) {
+            const existingUpdateDescription = configPlist.modResults.NSHealthUpdateUsageDescription;
+            configPlist.modResults.NSHealthUpdateUsageDescription =
+                typeof props?.NSHealthUpdateUsageDescription === 'string'
+                    ? props.NSHealthUpdateUsageDescription
+                    : typeof existingUpdateDescription === 'string'
+                        ? existingUpdateDescription
+                        : `${config.name ?? package_json_1.default.name} wants to update your health data`;
+        }
+        return configPlist;
+    });
+};
+const healthkitAppPlugin = (config, props) => {
+    return (0, config_plugins_1.withPlugins)(config, [
+        [withEntitlementsPlugin, props],
+        [withInfoPlistPlugin, props],
+    ]);
+};
+exports.default = (0, config_plugins_1.createRunOncePlugin)(healthkitAppPlugin, package_json_1.default.name, package_json_1.default.version);

package/app.plugin.ts

@@ -1,7 +1,6 @@
 import {
   type ConfigPlugin,
   createRunOncePlugin,
-  withAppDelegate,
   withEntitlementsPlist,
   withInfoPlist,
   withPlugins,
@@ -17,6 +16,12 @@ type InfoPlistConfig = {
 }
 
 type AppPluginConfig = InfoPlistConfig & {
+  /**
+   * Adds the background-delivery entitlement. Enabled by default; set to
+   * `false` to opt out. Launch-time observer registration needs no AppDelegate
+   * change: the pod hooks UIApplicationDidFinishLaunchingNotification itself
+   * (see ios/BackgroundLaunchHook.mm).
+   */
   background?: BackgroundConfig
 }
 
@@ -64,65 +69,10 @@ const withInfoPlistPlugin: ConfigPlugin<InfoPlistConfig> = (config, props) => {
   })
 }
 
-const withAppDelegatePlugin: ConfigPlugin<{
-  background?: BackgroundConfig
-}> = (config, props) => {
-  if (props?.background === false) {
-    return config
-  }
-
-  return withAppDelegate(config, (configDelegate) => {
-    const contents = configDelegate.modResults.contents
-
-    // Add import for HealthKit if not already present
-    if (!contents.includes('import HealthKit')) {
-      configDelegate.modResults.contents =
-        configDelegate.modResults.contents.replace(
-          /^(import .+\n)/m,
-          '$1import HealthKit\n',
-        )
-    }
-
-    // Insert BackgroundDeliveryManager setup into didFinishLaunchingWithOptions
-    const setupCall =
-      '    BackgroundDeliveryManager.shared.setupBackgroundObservers()\n'
-
-    if (
-      !configDelegate.modResults.contents.includes('BackgroundDeliveryManager')
-    ) {
-      // Match the opening of didFinishLaunchingWithOptions and insert after the
-      // opening brace. `[^{]*` rather than `.+` for two reasons: `.` does not
-      // match newlines, and Expo SDK 54+ templates spread this signature over
-      // several lines; and refusing to cross a `{` keeps the match from
-      // spanning out of an earlier `application(...)` overload into this one.
-      const withSetup = configDelegate.modResults.contents.replace(
-        /(func application\([^{]*didFinishLaunchingWithOptions[^{]*\{)\n/,
-        `$1\n${setupCall}`,
-      )
-
-      if (withSetup === configDelegate.modResults.contents) {
-        // Don't fail the build, but don't fail silently either — background
-        // delivery just won't survive app termination, which is otherwise
-        // very hard to trace back to here.
-        console.warn(
-          '[react-native-healthkit] Could not find didFinishLaunchingWithOptions in AppDelegate; ' +
-            'BackgroundDeliveryManager.shared.setupBackgroundObservers() was not inserted. ' +
-            'HealthKit background delivery will not work until it is added manually.',
-        )
-      }
-
-      configDelegate.modResults.contents = withSetup
-    }
-
-    return configDelegate
-  })
-}
-
 const healthkitAppPlugin: ConfigPlugin<AppPluginConfig> = (config, props) => {
   return withPlugins(config, [
     [withEntitlementsPlugin, props],
     [withInfoPlistPlugin, props],
-    [withAppDelegatePlugin, props],
   ])
 }
 

package/ios/BackgroundDeliveryManager.swift

@@ -9,13 +9,15 @@ private let bgLog = OSLog(subsystem: "com.kingstinct.healthkit", category: "Back
 /// be set up in `application(_:didFinishLaunchingWithOptions:)` to receive background
 /// delivery callbacks after the app has been terminated.
 ///
-/// Usage from AppDelegate.swift:
-///   BackgroundDeliveryManager.shared.setupBackgroundObservers()
+/// `BackgroundLaunchHook.mm` calls `setupBackgroundObservers()` on
+/// UIApplicationDidFinishLaunchingNotification, so no AppDelegate change is needed.
+/// The `@objc(BackgroundDeliveryManager)` name is what that hook looks up at runtime.
 ///
 /// The types to observe are persisted in UserDefaults by `configureBackgroundTypes()`
 /// called from JS. On subsequent cold launches, the manager reads these and registers
 /// observers immediately, queuing any events until JS subscribes via `drainPendingEvents()`.
-@objc public class BackgroundDeliveryManager: NSObject {
+@objc(BackgroundDeliveryManager)
+public class BackgroundDeliveryManager: NSObject {
   @objc public static let shared = BackgroundDeliveryManager()
 
   private let healthStore = HKHealthStore()
@@ -37,18 +39,23 @@ private let bgLog = OSLog(subsystem: "com.kingstinct.healthkit", category: "Back
     super.init()
   }
 
-  /// Call this from AppDelegate.didFinishLaunchingWithOptions to register observer queries
-  /// for any previously configured background delivery types.
+  /// Registers observer queries for any previously configured background delivery
+  /// types. Called at launch by `BackgroundLaunchHook.mm`; safe to call again.
   @objc public func setupBackgroundObservers() {
     guard HKHealthStore.isHealthDataAvailable() else { return }
 
     guard let typeIdentifiers = UserDefaults.standard.stringArray(forKey: BackgroundDeliveryManager.typesKey) else {
+      os_log("launch: no background delivery types configured, nothing to register", log: bgLog, type: .debug)
       return
     }
 
     let frequencyRaw = UserDefaults.standard.integer(forKey: BackgroundDeliveryManager.frequencyKey)
     let frequency = HKUpdateFrequency(rawValue: frequencyRaw) ?? .immediate
 
+    os_log(
+      "launch: registering %d background observer(s): %{public}@", log: bgLog, type: .info,
+      typeIdentifiers.count, typeIdentifiers.joined(separator: ", "))
+
     registerObservers(typeIdentifiers: typeIdentifiers, frequency: frequency)
   }
 
@@ -250,7 +257,7 @@ private let bgLog = OSLog(subsystem: "com.kingstinct.healthkit", category: "Back
       return HKSampleType.quantityType(forIdentifier: typeId)
     }
     if identifier.starts(with: "HKCategoryTypeIdentifier") {
-      let typeId = HKCategoryTypeIdentifier(rawValue: identifier)
+      let typeId = hkCategoryTypeIdentifier(fromIdentifierName: identifier)
       return HKSampleType.categoryType(forIdentifier: typeId)
     }
     if identifier == "HKWorkoutTypeIdentifier" {

package/ios/BackgroundLaunchHook.mm

@@ -0,0 +1,41 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+/// Registers the launch-time observer setup without any AppDelegate changes.
+///
+/// `+load` runs when the binary is loaded, before `main`. It subscribes to
+/// UIApplicationDidFinishLaunchingNotification, which UIKit posts synchronously
+/// right after `application(_:didFinishLaunchingWithOptions:)` returns and
+/// before the run loop continues, so observer queries are still registered
+/// during launch as HealthKit background delivery requires. The manager is
+/// looked up by name at runtime: importing this pod's Swift module from the
+/// app's AppDelegate would drag NitroModules' C++ headers into a target
+/// compiled without C++ interop and fail to build.
+@interface BackgroundLaunchHook : NSObject
+@end
+
+@implementation BackgroundLaunchHook
+
++ (void)load {
+  [[NSNotificationCenter defaultCenter]
+      addObserverForName:UIApplicationDidFinishLaunchingNotification
+                  object:nil
+                   queue:nil
+              usingBlock:^(NSNotification *_Nonnull note) {
+                Class managerClass = NSClassFromString(@"BackgroundDeliveryManager");
+                SEL sharedSelector = NSSelectorFromString(@"shared");
+                SEL setupSelector = NSSelectorFromString(@"setupBackgroundObservers");
+                if (managerClass == nil || ![managerClass respondsToSelector:sharedSelector]) {
+                  return;
+                }
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+                id shared = [managerClass performSelector:sharedSelector];
+                if ([shared respondsToSelector:setupSelector]) {
+                  [shared performSelector:setupSelector];
+                }
+#pragma clang diagnostic pop
+              }];
+}
+
+@end

package/ios/Constants.swift

@@ -34,3 +34,27 @@ let SpeedUnit =  HKUnit(from: "m/s") // HKUnit.meter().unitDivided(by: HKUnit.se
 let METUnit = HKUnit(from: "kcal/hr·kg")
 
 let DEFAULT_QUERY_LIMIT = 20
+
+/// Apple renamed `HKCategoryTypeIdentifierAudioExposureEvent` to
+/// `HKCategoryTypeIdentifierEnvironmentalAudioExposureEvent` in iOS 14, but the new
+/// constant still carries the old raw string at runtime. Building the identifier from the
+/// modern name as a raw string therefore makes `categoryType(forIdentifier:)` return nil,
+/// and samples read back from HealthKit report the legacy name. These helpers translate
+/// in both directions so JS only ever sees the modern identifier.
+let HKCategoryTypeIdentifierEnvironmentalAudioExposureEvent_NAME =
+  "HKCategoryTypeIdentifierEnvironmentalAudioExposureEvent"
+let HKCategoryTypeIdentifierAudioExposureEvent_NAME = "HKCategoryTypeIdentifierAudioExposureEvent"
+
+func hkCategoryTypeIdentifier(fromIdentifierName name: String) -> HKCategoryTypeIdentifier {
+  if name == HKCategoryTypeIdentifierEnvironmentalAudioExposureEvent_NAME {
+    return .environmentalAudioExposureEvent
+  }
+  return HKCategoryTypeIdentifier(rawValue: name)
+}
+
+func categoryTypeIdentifierName(fromHealthKitIdentifier identifier: String) -> String {
+  if identifier == HKCategoryTypeIdentifierAudioExposureEvent_NAME {
+    return HKCategoryTypeIdentifierEnvironmentalAudioExposureEvent_NAME
+  }
+  return identifier
+}

package/ios/CoreModule.swift

@@ -320,7 +320,11 @@ class CoreModule: HybridCoreModuleSpec {
   }
 
   func isProtectedDataAvailableAsync() -> Promise<Bool> {
-    return Promise.resolved(withResult: UIApplication.shared.isProtectedDataAvailable)
+    return Promise.async {
+      return await MainActor.run {
+        UIApplication.shared.isProtectedDataAvailable
+      }
+    }
   }
 
   func isHealthDataAvailable() -> Bool {

package/ios/Helpers.swift

@@ -172,7 +172,7 @@ func deserializeHKQueryAnchor(base64String: String?) throws -> HKQueryAnchor? {
 }
 
 func initializeCategoryType(_ identifier: String) throws -> HKCategoryType {
-  let identifier = HKCategoryTypeIdentifier(rawValue: identifier)
+  let identifier = hkCategoryTypeIdentifier(fromIdentifierName: identifier)
   if let sampleType = HKSampleType.categoryType(forIdentifier: identifier) {
     return sampleType
   }
@@ -483,3 +483,31 @@ func buildStatisticsOptions(statistics: [StatisticsOptions], quantityType: HKQua
   }
   return opts
 }
+
+private let storeReopenRetryDelay: UInt64 = 1_000_000_000
+
+/// HealthKit seals its store the moment the device locks and re-opens it a beat
+/// after it unlocks, and iOS can resume the app inside that beat. A query that
+/// hits the gap fails with `errorDatabaseInaccessible` although protected data is
+/// reported available — the store is re-opening, not sealed. Runs `operation`
+/// and, on exactly that refusal, gives it one more attempt after a short delay.
+/// A refusal while protected data is unavailable is the sealed store itself and
+/// is thrown as-is, as is every other error.
+func retryingWhileStoreReopens<T>(
+  _ operation: () async throws -> T
+) async throws -> T {
+  do {
+    return try await operation()
+  } catch {
+    let nsError = error as NSError
+    guard nsError.domain == HKError.errorDomain,
+      nsError.code == HKError.Code.errorDatabaseInaccessible.rawValue
+    else { throw error }
+    let protectedDataAvailable = await MainActor.run {
+      UIApplication.shared.isProtectedDataAvailable
+    }
+    guard protectedDataAvailable else { throw error }
+    try await Task.sleep(nanoseconds: storeReopenRetryDelay)
+    return try await operation()
+  }
+}

package/ios/MemoryEstimation.swift

@@ -0,0 +1,83 @@
+//
+//  MemoryEstimation.swift
+//  Pods
+//
+//  Rough estimates of the native heap kept alive by HybridObject proxies,
+//  reported to Nitro via `memorySize` so the JS garbage collector can account
+//  for memory it cannot see. Precision is not the goal; the right order of
+//  magnitude per object is.
+//
+
+import HealthKit
+
+/// Approximate per-object bridging overhead of a Nitro HybridObject that Nitro
+/// does not account for itself. The generated `*Spec_cxx.swift` adds the Swift
+/// implementation instance via `MemoryHelper.getSizeOf`; this covers the rest:
+/// the Swift `_cxx` bridge class, the C++ `HybridObject` with its per-runtime
+/// cache map, the `shared_ptr` control block and the reference-state records
+/// behind the JS weak reference. Add it once, in each proxy's `memorySize`.
+let nitroHybridObjectOverheadBytes = 512
+
+/// Rough size of an `NSString` on the heap, including its object header.
+func estimateStringMemorySize(_ value: String?) -> Int {
+  guard let value = value else {
+    return 0
+  }
+  return 32 + value.utf16.count * 2
+}
+
+/// Rough size of a `metadata` dictionary as HealthKit keeps it in memory.
+func estimateMetadataMemorySize(_ metadata: [String: Any]?) -> Int {
+  guard let metadata = metadata, !metadata.isEmpty else {
+    return 0
+  }
+  // NSDictionary header plus one bucket per entry.
+  var total = 64 + metadata.count * 48
+  for (key, value) in metadata {
+    total += estimateStringMemorySize(key)
+    if let string = value as? String {
+      total += estimateStringMemorySize(string)
+    } else if value is HKQuantity {
+      // HKQuantity: object header, unit object, double.
+      total += 128
+    } else {
+      // NSNumber, NSDate and friends are small tagged or boxed objects.
+      total += 32
+    }
+  }
+  return total
+}
+
+/// Rough size of one `HKStatistics` entry: the object itself plus the
+/// sum/min/max/average/most-recent quantities and their date interval.
+let estimatedStatisticsEntryMemorySize = 512
+
+/// Estimate of the `HKWorkout` object graph only; the proxy adds Nitro's
+/// bridging overhead on top.
+func estimateWorkoutMemorySize(_ workout: HKWorkout) -> Int {
+  // HKWorkout object, uuid, dates, HKSourceRevision (+HKSource), HKDevice,
+  // and the four total quantities.
+  var total = 1_024
+  total += estimateMetadataMemorySize(workout.metadata)
+
+  if let events = workout.workoutEvents {
+    for event in events {
+      // HKWorkoutEvent: object header, type, NSDateInterval.
+      total += 128 + estimateMetadataMemorySize(event.metadata)
+    }
+  }
+
+  if #available(iOS 16.0, *) {
+    total += workout.allStatistics.count * estimatedStatisticsEntryMemorySize
+
+    for activity in workout.workoutActivities {
+      // HKWorkoutActivity: object header, uuid, dates, HKWorkoutConfiguration.
+      total += 512
+      total += estimateMetadataMemorySize(activity.metadata)
+      total += activity.workoutEvents.count * 128
+      total += activity.allStatistics.count * estimatedStatisticsEntryMemorySize
+    }
+  }
+
+  return total
+}

package/ios/QuantityTypeModule.swift

@@ -53,7 +53,7 @@ func queryStatisticsForQuantityInternal(
 
 func serializeStatistics(gottenStats: HKStatistics, unit: HKUnit) -> QueryStatisticsResponse {
   let sources = gottenStats.sources?.map { source in
-    return serializeSource(source)
+    return serializeSourceStruct(source)
   } ?? []
 
   var averageQuantity: Quantity?
@@ -244,7 +244,7 @@ func serializeStatisticsPerSource(gottenStats: HKStatistics, unit: HKUnit)
       }
 
       return QueryStatisticsResponseFromSingleSource(
-        source: serializeSource(source),
+        source: serializeSourceStruct(source),
         startDate: gottenStats.startDate,
         endDate: gottenStats.endDate,
         duration: duration,
@@ -313,11 +313,13 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
     return Promise.async {
       let quantityType = try initializeQuantityType(identifier.stringValue)
 
-      if let gottenStats = try await queryStatisticsForQuantityInternal(
-        quantityType: quantityType,
-        statistics: statistics,
-        options: options
-      ) {
+      if let gottenStats = try await retryingWhileStoreReopens({
+        try await queryStatisticsForQuantityInternal(
+          quantityType: quantityType,
+          statistics: statistics,
+          options: options
+        )
+      }) {
         let unit = try await getUnitToUse(
           unitOverride: options?.unit,
           quantityType: quantityType
@@ -336,13 +338,15 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
     return Promise.async {
       let quantityType = try initializeQuantityType(identifier.stringValue)
 
-      if let statistics = try await queryStatisticsCollectionForQuantityInternal(
-        quantityType: quantityType,
-        statistics: statistics,
-        anchorDate: anchorDate,
-        intervalComponents: intervalComponents,
-        options: options
-      ) {
+      if let statistics = try await retryingWhileStoreReopens({
+        try await queryStatisticsCollectionForQuantityInternal(
+          quantityType: quantityType,
+          statistics: statistics,
+          anchorDate: anchorDate,
+          intervalComponents: intervalComponents,
+          options: options
+        )
+      }) {
 
         let unit = try await getUnitToUse(
           unitOverride: options?.unit,
@@ -385,11 +389,13 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
     return Promise.async {
       let quantityType = try initializeQuantityType(identifier.stringValue)
 
-      if let gottenStats = try await queryStatisticsForQuantityInternal(
-        quantityType: quantityType,
-        statistics: statistics,
-        options: options
-      ) {
+      if let gottenStats = try await retryingWhileStoreReopens({
+        try await queryStatisticsForQuantityInternal(
+          quantityType: quantityType,
+          statistics: statistics,
+          options: options
+        )
+      }) {
         let unit = try await getUnitToUse(
           unitOverride: options?.unit,
           quantityType: quantityType
@@ -412,13 +418,15 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
     return Promise.async {
       let quantityType = try initializeQuantityType(identifier.stringValue)
 
-      if let statistics = try await queryStatisticsCollectionForQuantityInternal(
-        quantityType: quantityType,
-        statistics: statistics,
-        anchorDate: anchorDate,
-        intervalComponents: intervalComponents,
-        options: options
-      ) {
+      if let statistics = try await retryingWhileStoreReopens({
+        try await queryStatisticsCollectionForQuantityInternal(
+          quantityType: quantityType,
+          statistics: statistics,
+          anchorDate: anchorDate,
+          intervalComponents: intervalComponents,
+          options: options
+        )
+      }) {
         let unit = try await getUnitToUse(
           unitOverride: options?.unit,
           quantityType: quantityType