feat: implement Haptika PPG and Watch V1

2026-07-31 16:19:42 +02:00
parent 6b7d4e0728
commit b9930b7378
249 changed files with 46475 additions and 122 deletions
@@ -0,0 +1,169 @@
+import Foundation
+
+public enum WatchSyncKind: String, Codable, Sendable {
+  case liveHeartRate
+  case measurementUpsert
+  case regulationSessionUpsert
+  case feelingUpsert
+  case tombstone
+  case preferences
+  case acknowledgement = "ack"
+}
+
+/// The payload is encoded JSON data. Keeping the transport wrapper non-generic lets the
+/// offline outbox contain measurements, sessions and tombstones in a single queue.
+public struct WatchSyncEnvelopeV1: Codable, Equatable, Sendable, Identifiable {
+  public static let schemaVersion = 1
+
+  public var id: UUID { eventID }
+  public let eventID: UUID
+  public let deviceID: String
+  public let sequence: UInt64
+  public let sentAt: Date
+  public let kind: WatchSyncKind
+  public let payload: Data
+
+  public init(
+    eventID: UUID = UUID(),
+    deviceID: String,
+    sequence: UInt64,
+    sentAt: Date = Date(),
+    kind: WatchSyncKind,
+    payload: Data
+  ) {
+    self.eventID = eventID
+    self.deviceID = deviceID
+    self.sequence = sequence
+    self.sentAt = sentAt
+    self.kind = kind
+    self.payload = payload
+  }
+
+  public init<Payload: Encodable>(
+    eventID: UUID = UUID(),
+    deviceID: String,
+    sequence: UInt64,
+    sentAt: Date = Date(),
+    kind: WatchSyncKind,
+    payload: Payload,
+    encoder: JSONEncoder = WatchCoding.encoder
+  ) throws {
+    self.init(
+      eventID: eventID,
+      deviceID: deviceID,
+      sequence: sequence,
+      sentAt: sentAt,
+      kind: kind,
+      payload: try encoder.encode(payload)
+    )
+  }
+
+  public func decodePayload<Payload: Decodable>(
+    _ type: Payload.Type,
+    decoder: JSONDecoder = WatchCoding.decoder
+  ) throws -> Payload {
+    try decoder.decode(type, from: payload)
+  }
+
+  private enum CodingKeys: String, CodingKey {
+    case schemaVersion, eventID = "eventId", deviceID = "deviceId", sequence, sentAt, kind, payload
+  }
+
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(Self.schemaVersion, forKey: .schemaVersion)
+    try container.encode(eventID, forKey: .eventID)
+    try container.encode(deviceID, forKey: .deviceID)
+    try container.encode(sequence, forKey: .sequence)
+    try container.encode(sentAt, forKey: .sentAt)
+    try container.encode(kind, forKey: .kind)
+    try container.encode(try WatchJSONValue(data: payload), forKey: .payload)
+  }
+
+  public init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
+    guard try container.decode(Int.self, forKey: .schemaVersion) == Self.schemaVersion else {
+      throw DecodingError.dataCorruptedError(forKey: .schemaVersion, in: container, debugDescription: "Unsupported Watch envelope schema")
+    }
+    eventID = try container.decode(UUID.self, forKey: .eventID)
+    deviceID = try container.decode(String.self, forKey: .deviceID)
+    sequence = try container.decode(UInt64.self, forKey: .sequence)
+    sentAt = try container.decode(Date.self, forKey: .sentAt)
+    kind = try container.decode(WatchSyncKind.self, forKey: .kind)
+    payload = try container.decode(WatchJSONValue.self, forKey: .payload).data()
+  }
+}
+
+private enum WatchJSONValue: Codable, Equatable {
+  case object([String: WatchJSONValue])
+  case array([WatchJSONValue])
+  case string(String)
+  case number(Double)
+  case bool(Bool)
+  case null
+
+  init(data: Data) throws {
+    self = try WatchCoding.decoder.decode(Self.self, from: data)
+  }
+
+  func data() throws -> Data { try WatchCoding.encoder.encode(self) }
+
+  init(from decoder: Decoder) throws {
+    let container = try decoder.singleValueContainer()
+    if container.decodeNil() { self = .null }
+    else if let value = try? container.decode(Bool.self) { self = .bool(value) }
+    else if let value = try? container.decode(Double.self) { self = .number(value) }
+    else if let value = try? container.decode(String.self) { self = .string(value) }
+    else if let value = try? container.decode([WatchJSONValue].self) { self = .array(value) }
+    else { self = .object(try container.decode([String: WatchJSONValue].self)) }
+  }
+
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    switch self {
+    case let .object(value): try container.encode(value)
+    case let .array(value): try container.encode(value)
+    case let .string(value): try container.encode(value)
+    case let .number(value): try container.encode(value)
+    case let .bool(value): try container.encode(value)
+    case .null: try container.encodeNil()
+    }
+  }
+}
+
+public struct WatchAcknowledgementV1: Codable, Equatable, Sendable {
+  public let eventIDs: [UUID]
+  public let receivedAt: Date
+
+  public init(eventIDs: [UUID], receivedAt: Date = Date()) {
+    self.eventIDs = eventIDs
+    self.receivedAt = receivedAt
+  }
+}
+
+public struct WatchLiveHeartRateV1: Codable, Equatable, Sendable {
+  public let bpm: Double
+  public let sampledAt: Date
+  public let measurementID: UUID?
+
+  public init(bpm: Double, sampledAt: Date, measurementID: UUID? = nil) {
+    self.bpm = bpm
+    self.sampledAt = sampledAt
+    self.measurementID = measurementID
+  }
+}
+
+public enum WatchCoding {
+  public static var encoder: JSONEncoder {
+    let encoder = JSONEncoder()
+    encoder.dateEncodingStrategy = .iso8601
+    encoder.outputFormatting = [.sortedKeys]
+    return encoder
+  }
+
+  public static var decoder: JSONDecoder {
+    let decoder = JSONDecoder()
+    decoder.dateDecodingStrategy = .iso8601
+    return decoder
+  }
+}