@tryterra/react-native 0.0.0-stage → 2.1.0

package/ios/TerraBridgeCore/BridgeBootstrap.swift

@@ -0,0 +1,89 @@
+import Foundation
+import TerraSDK
+
+public enum BridgeBootstrap {
+    /// The Info.plist key carrying the developer id.
+    public static let devIDKey = "TerraDevID"
+
+    public struct Configuration: Sendable, Equatable {
+        public let devID: String
+
+        public init(devID: String) {
+            self.devID = devID
+        }
+
+        /// The configuration in `bundle`'s Info.plist, or nil when it names no dev id.
+        public init?(bundle: Bundle) {
+            guard let devID = (bundle.object(forInfoDictionaryKey: BridgeBootstrap.devIDKey) as? String)?
+                .trimmingCharacters(in: .whitespacesAndNewlines), !devID.isEmpty
+            else { return nil }
+            self.init(devID: devID)
+        }
+    }
+
+    private static let parked = Locked<TerraBridge?>(nil)
+
+    /// The bridge bootstrap parked, or nil when it has not run.
+    public static var current: TerraBridge? { parked.withLock { $0 } }
+
+    @discardableResult
+    public static func bootstrap(bundle: Bundle = .main) -> TerraBridge? {
+        guard let configuration = Configuration(bundle: bundle) else { return nil }
+        return bootstrap(configuration)
+    }
+
+    @discardableResult
+    public static func bootstrap(_ configuration: Configuration) -> TerraBridge {
+        bootstrap(configuration, register: registerBackgroundSync) { provider in
+            Terra(devID: configuration.devID, tokenProvider: provider)
+        }
+    }
+
+    static func bootstrap(
+        _ configuration: Configuration,
+        register: (Terra) -> Bool,
+        client: (_ tokenProvider: @escaping TerraBridge.TokenProvider) -> Terra
+    ) -> TerraBridge {
+        parked.withLock { parked in
+            if let existing = parked { return existing }
+            let host = LaunchHost(devID: configuration.devID)
+            let bridge = TerraBridge(host: host, client: client)
+            host.registered.withLock { $0 = register(bridge.terra) }
+            parked = bridge
+            return bridge
+        }
+    }
+
+    public static func attach(
+        missingLine: String,
+        emit: @escaping @Sendable (_ subscriptionId: String, _ message: String) -> Void
+    ) throws(BridgeRejection) -> BridgeSession {
+        guard let bridge = current else {
+            throw BridgeRejection(payload: Rejections.payload(for: BridgeError.notBootstrapped(line: missingLine)))
+        }
+        return bridge.attach(emit: emit)
+    }
+
+    static func reset() {
+        parked.withLock { $0 = nil }
+    }
+
+    private static func registerBackgroundSync(_ terra: Terra) -> Bool {
+        #if os(iOS)
+        return BackgroundSync.register(terra: terra)
+        #else
+        return false
+        #endif
+    }
+}
+
+final class LaunchHost: BridgeHost {
+    let devID: String?
+    let registered = Locked(false)
+
+    init(devID: String) {
+        self.devID = devID
+    }
+
+    func backgroundRegistered() async -> Bool { registered.withLock { $0 } }
+}

package/ios/TerraBridgeCore/BridgeHost.swift

@@ -0,0 +1,13 @@
+import Foundation
+
+/// The parts of an op that are not the SDK: the bootstrap's own record of what it set up.
+///
+/// A seam so that everything in front of it runs on a macOS host with no simulator. The production
+/// conformance belongs to bootstrap (P5), which is the code that registered the task.
+public protocol BridgeHost: Sendable {
+    /// The dev id the native bootstrap was configured with.
+    var devID: String? { get }
+
+    /// Whether bootstrap registered background sync at launch. False is a host setup bug.
+    func backgroundRegistered() async -> Bool
+}

package/ios/TerraBridgeCore/Conversions.swift

@@ -0,0 +1,467 @@
+import Foundation
+import TerraSDK
+
+/// Between the SDK's types and the generated wire DTOs.
+///
+/// Every `switch` is exhaustive with no `default`, so a case added on either side is a compile
+/// error here rather than a value that maps to something plausible. Unqualified names are the
+/// generated wire types; the SDK's are spelled `TerraSDK.`.
+enum Conversions {
+
+    // MARK: Input the decoder accepted and the SDK cannot
+
+    /// A string field that decoded but is not the instant or id it names. Reported as the same
+    /// `bridge.invalid_payload` the generated decoder raises, with the path and never the value.
+    static func instant(_ text: String, at path: String) throws -> Date {
+        guard let date = BridgeInstant.parse(text) else { throw BridgeError.invalidPayload(path: path) }
+        return date
+    }
+
+    static func uuid(_ text: String, at path: String) throws -> UUID {
+        guard let id = UUID(uuidString: text) else { throw BridgeError.invalidPayload(path: path) }
+        return id
+    }
+
+    static func interval(start: String, end: String, at path: String) throws -> DateInterval {
+        let from = try instant(start, at: "\(path).start")
+        let to = try instant(end, at: "\(path).end")
+        guard from <= to else { throw BridgeError.invalidPayload(path: "\(path).end") }
+        return DateInterval(start: from, end: to)
+    }
+
+    /// The calendar day an instant falls on in `zone`, as `yyyy-MM-dd`.
+    static func localDate(_ date: Date, in zone: TimeZone) -> String {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = zone
+        let parts = calendar.dateComponents([.year, .month, .day], from: date)
+        return day(year: parts.year ?? 0, month: parts.month ?? 0, day: parts.day ?? 0)
+    }
+
+    static func localDate(_ components: DateComponents) -> String {
+        day(year: components.year ?? 0, month: components.month ?? 0, day: components.day ?? 0)
+    }
+
+    private static func day(year: Int, month: Int, day: Int) -> String {
+        String(format: "%04d-%02d-%02d", year, month, day)
+    }
+
+    // MARK: Enums
+
+    // Swift 6 requires `@unknown default` for TerraSDK's non-frozen binary enums.
+
+    static func source(_ wire: Source?) throws -> TerraSDK.Source {
+        switch wire ?? .health {
+        case .health: return .health
+        case .samsungHealth: throw BridgeError.unsupportedOnPlatform(op: "samsungHealth")
+        }
+    }
+
+    static func source(_ source: TerraSDK.Source) -> Source {
+        switch source {
+        case .health: return .health
+        @unknown default: return .health
+        }
+    }
+
+    static func endUser(_ wire: EndUser) -> TerraSDK.EndUser {
+        switch wire {
+        case .reference(let id): return .reference(id)
+        case .anonymous: return .anonymous
+        }
+    }
+
+    static func category(_ wire: DataCategory) -> TerraSDK.DataCategory {
+        switch wire {
+        case .activity: return .activity
+        case .body: return .body
+        case .daily: return .daily
+        case .sleep: return .sleep
+        case .nutrition: return .nutrition
+        }
+    }
+
+    /// Nil for the categories the surface excludes: there is no wire name to report them under.
+    static func category(_ category: TerraSDK.DataCategory) -> DataCategory? {
+        switch category {
+        case .activity: return .activity
+        case .body: return .body
+        case .daily: return .daily
+        case .sleep: return .sleep
+        case .nutrition: return .nutrition
+        case .menstruation, .athlete, .healthObservation: return nil
+        @unknown default: return nil
+        }
+    }
+
+    static func permissionStatus(_ status: TerraSDK.PermissionStatus) -> PermissionStatus {
+        switch status {
+        case .granted: return .granted
+        case .denied: return .denied
+        case .notDetermined: return .notDetermined
+        case .notDisclosed: return .notDisclosed
+        case .unavailable: return .unavailable
+        case .unsupported: return .unsupported
+        @unknown default: return .unavailable
+        }
+    }
+
+    static func motionContext(_ context: TerraSDK.MotionContext) -> MotionContext {
+        switch context {
+        case .unknown: return .unknown
+        case .sedentary: return .sedentary
+        case .active: return .active
+        @unknown default: return .unknown
+        }
+    }
+
+    static func deviceType(_ type: TerraSDK.DeviceType) -> String {
+        switch type {
+        case .phone: return "phone"
+        case .scale: return "scale"
+        case .sensor: return "sensor"
+        @unknown default: return "unknown"
+        }
+    }
+
+    // MARK: Unions
+
+    static func timeRange(_ wire: TimeRange, at path: String) throws -> TerraSDK.TimeRange {
+        switch wire {
+        case .lastHours(let hours): return .lastHours(hours)
+        case .lastDays(let days): return .lastDays(days)
+        case .today: return .today
+        case .between(let start, let end):
+            let window = try interval(start: start, end: end, at: path)
+            return .between(window.start, window.end)
+        }
+    }
+
+    static func sleepStage(_ stage: TerraSDK.SleepStage) -> SleepStage {
+        switch stage {
+        case .inBed: return .inBed
+        case .awake: return .awake
+        case .asleep: return .asleep
+        case .light: return .light
+        case .deep: return .deep
+        case .rem: return .rem
+        case .unknown(let raw): return .unknown(raw: raw)
+        @unknown default: return .unknown(raw: String(describing: stage))
+        }
+    }
+
+    static func sleepStage(_ wire: SleepStage) -> TerraSDK.SleepStage {
+        switch wire {
+        case .inBed: return .inBed
+        case .awake: return .awake
+        case .asleep: return .asleep
+        case .light: return .light
+        case .deep: return .deep
+        case .rem: return .rem
+        case .unknown(let raw): return .unknown(raw)
+        }
+    }
+
+    static func activity(_ activity: TerraSDK.WorkoutActivity) -> WorkoutActivity {
+        switch activity {
+        case .running: return .running
+        case .walking: return .walking
+        case .cycling: return .cycling
+        case .swimming: return .swimming
+        case .strengthTraining: return .strengthTraining
+        case .other(let label): return .other(label: label)
+        @unknown default: return .other(label: String(describing: activity))
+        }
+    }
+
+    static func activity(_ wire: WorkoutActivity) -> TerraSDK.WorkoutActivity {
+        switch wire {
+        case .running: return .running
+        case .walking: return .walking
+        case .cycling: return .cycling
+        case .swimming: return .swimming
+        case .strengthTraining: return .strengthTraining
+        case .other(let label): return .other(label)
+        }
+    }
+
+    /// The order a grant is listed in. Android sorts by the same names, so one grant is one byte
+    /// sequence on both platforms.
+    static func sortKey(_ activity: WorkoutActivity) -> String {
+        switch activity {
+        case .running: return "Running"
+        case .walking: return "Walking"
+        case .cycling: return "Cycling"
+        case .swimming: return "Swimming"
+        case .strengthTraining: return "Strength Training"
+        case .other(let label): return label
+        }
+    }
+
+    static func diagnosticsState(_ state: TerraSDK.DiagnosticsState) -> DiagnosticsState {
+        switch state {
+        case .healthy: return .healthy
+        case .quiet(let since): return .quiet(since: BridgeInstant.format(since))
+        // Apple does not disclose why, so the reason is absent rather than guessed.
+        case .backgroundRestricted: return .backgroundRestricted(reason: nil)
+        case .backgroundRefreshUnscheduled: return .backgroundRefreshUnscheduled
+        case .pendingRetry: return .pendingRetry
+        case .linkRevoked: return .linkRevoked
+        case .devIDMismatch: return .devIDMismatch
+        @unknown default: return .pendingRetry
+        }
+    }
+
+    // MARK: Records
+
+    static func connection(_ connection: TerraSDK.Connection) -> Connection {
+        Connection(source: source(connection.source), userId: connection.userID)
+    }
+
+    static func sampleSource(_ source: TerraSDK.SampleSource) -> SampleSource {
+        SampleSource(
+            name: source.name,
+            bundleId: source.bundleID,
+            productType: source.productType,
+            deviceType: source.deviceType.map(deviceType))
+    }
+
+    static func heartRate(_ sample: TerraSDK.HeartRateSample) -> HeartRateSample {
+        HeartRateSample(
+            id: sample.id.uuidString,
+            time: BridgeInstant.format(sample.time),
+            beatsPerMinute: sample.beatsPerMinute,
+            source: sampleSource(sample.source),
+            motionContext: sample.motionContext.map(motionContext),
+            userEntered: sample.userEntered,
+            timeZone: sample.timeZone?.identifier)
+    }
+
+    static func steps(_ sample: TerraSDK.StepCount) -> StepCount {
+        StepCount(
+            id: sample.id,
+            start: BridgeInstant.format(sample.interval.start),
+            end: BridgeInstant.format(sample.interval.end),
+            steps: sample.steps,
+            source: sampleSource(sample.source),
+            userEntered: sample.userEntered,
+            timeZone: sample.timeZone?.identifier)
+    }
+
+    static func segment(_ segment: TerraSDK.SleepSegment) -> SleepSegment {
+        SleepSegment(
+            id: segment.id.uuidString,
+            start: BridgeInstant.format(segment.interval.start),
+            end: BridgeInstant.format(segment.interval.end),
+            stage: sleepStage(segment.stage),
+            source: sampleSource(segment.source),
+            userEntered: segment.userEntered,
+            timeZone: segment.timeZone?.identifier)
+    }
+
+    static func workout(_ workout: TerraSDK.Workout) -> Workout {
+        Workout(
+            id: workout.id.uuidString,
+            start: BridgeInstant.format(workout.interval.start),
+            end: BridgeInstant.format(workout.interval.end),
+            activity: activity(workout.activity),
+            activityTypeCode: workout.activityTypeCode,
+            indoor: workout.indoor,
+            activeEnergyKilocalories: workout.activeEnergyKilocalories,
+            distanceMeters: workout.distanceMeters,
+            source: sampleSource(workout.source),
+            userEntered: workout.userEntered,
+            timeZone: workout.timeZone?.identifier)
+    }
+
+    /// A day, not an instant: sending the instant would let the receiver re-derive the day in its
+    /// own zone and get a different one either side of midnight.
+    static func change(_ change: TerraSDK.HealthChange, zone: TimeZone) -> HealthChange? {
+        category(change.category).map { HealthChange(category: $0, day: localDate(change.day, in: zone)) }
+    }
+
+    /// `@unknown default` because the binary SDK is built with library evolution, where this enum
+    /// can grow; `SchemaParityTests` is what fails when it does. A status this build predates
+    /// reads as one it cannot schedule on.
+    static func schedulingStatus(_ status: TerraSDK.WorkoutSchedulingStatus) -> WorkoutSchedulingStatus {
+        switch status {
+        case .unsupported: .unsupported
+        case .notDetermined: .notDetermined
+        case .denied: .denied
+        case .authorized: .authorized
+        @unknown default: .unsupported
+        }
+    }
+
+    static func plannedWorkout(_ plan: TerraSDK.PlannedWorkout) -> PlannedWorkout {
+        PlannedWorkout(
+            id: plan.id,
+            plannedOn: localDate(plan.plannedOn),
+            activity: activity(plan.activity),
+            title: plan.title,
+            completedAt: plan.completedAt.map(BridgeInstant.format))
+    }
+
+    /// Sorted, because a `Set` has no order and JSON has no set.
+    static func access(_ access: TerraSDK.HealthAccess) -> HealthAccess {
+        HealthAccess(
+            read: access.read.compactMap(category).sorted { $0.rawValue < $1.rawValue },
+            write: access.write.compactMap(category).sorted { $0.rawValue < $1.rawValue },
+            workouts: ordered(access.workouts
+                .map { WorkoutScope(activity: activity($0.activity), energy: $0.energy, distance: $0.distance) }))
+    }
+
+    static func ordered(_ scopes: [WorkoutScope]) -> [WorkoutScope] {
+        scopes.sorted { ($0.sortKey, $0.wireKey) < ($1.sortKey, $1.wireKey) }
+    }
+
+    static func scope(_ wire: WorkoutScope) -> TerraSDK.WorkoutScope {
+        TerraSDK.WorkoutScope(activity: activity(wire.activity), energy: wire.energy, distance: wire.distance)
+    }
+
+    // MARK: Diagnostics
+
+    /// The SDK's own `Encodable` spelling, with the bridge's instant format. Not reshaped: a second
+    /// encoding here would be a contract no vector pins.
+    static func event(_ event: TerraSDK.TerraEvent) throws -> TerraEvent {
+        let encoder = JSONEncoder()
+        encoder.dateEncodingStrategy = .custom { date, encoder in
+            var container = encoder.singleValueContainer()
+            try container.encode(BridgeInstant.format(date))
+        }
+        let json = try BridgeDispatch.makeDecoder().decode(TerraEvent.self, from: encoder.encode(event))
+        try TerraEventEnvelope.validate(json)
+        return json
+    }
+
+    static func report(_ report: TerraSDK.SupportReport) throws -> SupportReport {
+        SupportReport(
+            sdkVersion: report.sdkVersion,
+            generatedAt: BridgeInstant.format(report.generatedAt),
+            state: diagnosticsState(report.state),
+            lastDelivery: report.lastDelivery.map(BridgeInstant.format),
+            isConnected: report.isConnected,
+            requestedCategories: report.requestedCategories,
+            requestedWrites: report.requestedWrites,
+            requestedWorkouts: report.requestedWorkouts,
+            recentEvents: try report.recentEvents.map(event))
+    }
+
+    // MARK: Write entries
+
+    /// An absent record id is left to the SDK's own default rather than minted here.
+    static func entry(_ wire: HeartRateEntry, at path: String) throws -> TerraSDK.HeartRateEntry {
+        let time = try instant(wire.time, at: "\(path).time")
+        guard let id = wire.recordId else { return .init(time: time, beatsPerMinute: wire.beatsPerMinute) }
+        return .init(time: time, beatsPerMinute: wire.beatsPerMinute, recordID: try uuid(id, at: "\(path).recordId"))
+    }
+
+    static func entry(_ wire: StepEntry, at path: String) throws -> TerraSDK.StepEntry {
+        let interval = try Self.interval(start: wire.start, end: wire.end, at: path)
+        guard let id = wire.recordId else { return .init(interval: interval, steps: wire.steps) }
+        return .init(interval: interval, steps: wire.steps, recordID: try uuid(id, at: "\(path).recordId"))
+    }
+
+    static func entry(_ wire: SleepEntry, at path: String) throws -> TerraSDK.SleepEntry {
+        let interval = try Self.interval(start: wire.start, end: wire.end, at: path)
+        let stage = sleepStage(wire.stage)
+        guard let id = wire.recordId else { return .init(interval: interval, stage: stage) }
+        return .init(interval: interval, stage: stage, recordID: try uuid(id, at: "\(path).recordId"))
+    }
+
+    static func entry(_ wire: WorkoutEntry, at path: String) throws -> TerraSDK.WorkoutEntry {
+        let interval = try Self.interval(start: wire.start, end: wire.end, at: path)
+        let activity = Self.activity(wire.activity)
+        guard let id = wire.recordId else {
+            return .init(
+                interval: interval, activity: activity,
+                totalEnergyKilocalories: wire.totalEnergyKilocalories,
+                totalDistanceMeters: wire.totalDistanceMeters)
+        }
+        return .init(
+            interval: interval, activity: activity,
+            totalEnergyKilocalories: wire.totalEnergyKilocalories,
+            totalDistanceMeters: wire.totalDistanceMeters,
+            recordID: try uuid(id, at: "\(path).recordId"))
+    }
+
+    static func entry(_ wire: BodyEntry, at path: String) throws -> TerraSDK.BodyEntry {
+        let time = try instant(wire.time, at: "\(path).time")
+        var entry = try wire.recordId.map { TerraSDK.BodyEntry(time: time, recordID: try uuid($0, at: "\(path).recordId")) }
+            ?? TerraSDK.BodyEntry(time: time)
+        entry.bodyMassKilograms = wire.bodyMassKilograms
+        entry.bodyFatPercent = wire.bodyFatPercent
+        entry.bodyMassIndex = wire.bodyMassIndex
+        entry.heightMeters = wire.heightMeters
+        entry.leanBodyMassKilograms = wire.leanBodyMassKilograms
+        entry.bodyTemperatureCelsius = wire.bodyTemperatureCelsius
+        entry.oxygenSaturationPercent = wire.oxygenSaturationPercent
+        entry.bloodGlucoseMilligramsPerDeciliter = wire.bloodGlucoseMilligramsPerDeciliter
+        entry.bloodPressureSystolicMillimetersOfMercury = wire.bloodPressureSystolicMillimetersOfMercury
+        entry.bloodPressureDiastolicMillimetersOfMercury = wire.bloodPressureDiastolicMillimetersOfMercury
+        return entry
+    }
+
+    static func entry(_ wire: NutritionEntry, at path: String) throws -> TerraSDK.NutritionEntry {
+        let interval = try Self.interval(start: wire.start, end: wire.end, at: path)
+        let nutrients = Self.nutrients(wire.nutrients)
+        guard let id = wire.recordId else {
+            return .init(interval: interval, name: wire.name, nutrients: nutrients)
+        }
+        return .init(
+            interval: interval, name: wire.name, nutrients: nutrients, recordID: try uuid(id, at: "\(path).recordId"))
+    }
+
+    /// All thirty-nine, by name. The unit is in every name on both sides, so a mismatched pair
+    /// does not compile.
+    private static func nutrients(_ wire: Nutrients) -> TerraSDK.NutritionEntry.Nutrients {
+        var out = TerraSDK.NutritionEntry.Nutrients()
+        out.energyKilocalories = wire.energyKilocalories
+        out.proteinGrams = wire.proteinGrams
+        out.carbohydratesGrams = wire.carbohydratesGrams
+        out.fiberGrams = wire.fiberGrams
+        out.sugarGrams = wire.sugarGrams
+        out.fatTotalGrams = wire.fatTotalGrams
+        out.fatSaturatedGrams = wire.fatSaturatedGrams
+        out.fatMonounsaturatedGrams = wire.fatMonounsaturatedGrams
+        out.fatPolyunsaturatedGrams = wire.fatPolyunsaturatedGrams
+        out.cholesterolMilligrams = wire.cholesterolMilligrams
+        out.sodiumMilligrams = wire.sodiumMilligrams
+        out.potassiumMilligrams = wire.potassiumMilligrams
+        out.calciumMilligrams = wire.calciumMilligrams
+        out.ironMilligrams = wire.ironMilligrams
+        out.magnesiumMilligrams = wire.magnesiumMilligrams
+        out.zincMilligrams = wire.zincMilligrams
+        out.waterLiters = wire.waterLiters
+        out.caffeineMilligrams = wire.caffeineMilligrams
+        out.vitaminAMicrograms = wire.vitaminAMicrograms
+        out.vitaminCMilligrams = wire.vitaminCMilligrams
+        out.vitaminDMicrograms = wire.vitaminDMicrograms
+        out.vitaminEMilligrams = wire.vitaminEMilligrams
+        out.vitaminKMicrograms = wire.vitaminKMicrograms
+        out.vitaminB6Milligrams = wire.vitaminB6Milligrams
+        out.vitaminB12Micrograms = wire.vitaminB12Micrograms
+        out.folateMicrograms = wire.folateMicrograms
+        out.thiaminMilligrams = wire.thiaminMilligrams
+        out.riboflavinMilligrams = wire.riboflavinMilligrams
+        out.niacinMilligrams = wire.niacinMilligrams
+        out.biotinMicrograms = wire.biotinMicrograms
+        out.pantothenicAcidMilligrams = wire.pantothenicAcidMilligrams
+        out.phosphorusMilligrams = wire.phosphorusMilligrams
+        out.iodineMicrograms = wire.iodineMicrograms
+        out.chromiumMicrograms = wire.chromiumMicrograms
+        out.copperMilligrams = wire.copperMilligrams
+        out.manganeseMilligrams = wire.manganeseMilligrams
+        out.molybdenumMicrograms = wire.molybdenumMicrograms
+        out.seleniumMicrograms = wire.seleniumMicrograms
+        out.chlorideMilligrams = wire.chlorideMilligrams
+        return out
+    }
+}
+
+private extension WorkoutScope {
+    var sortKey: String { Conversions.sortKey(activity) }
+
+    var wireKey: String {
+        (try? BridgeDispatch.makeEncoder().encode(self)).map { String(decoding: $0, as: UTF8.self) } ?? ""
+    }
+}