@wayq/beekon-rn 0.0.7 → 0.0.9

package/ios/BeekonRn.swift

@@ -24,6 +24,7 @@ import BeekonKit
   private let onSyncStatusCb: (NSDictionary) -> Void
   private let onAuthTokensCb: (NSDictionary) -> Void
   private let onLicenseStatusCb: (NSDictionary) -> Void
+  private let onLogCb: (NSDictionary) -> Void
 
   private var stateTask: Task<Void, Never>?
   private var locationsTask: Task<Void, Never>?
@@ -31,11 +32,12 @@ import BeekonKit
   private var syncStatusTask: Task<Void, Never>?
   private var authTokensTask: Task<Void, Never>?
   private var licenseStatusTask: Task<Void, Never>?
+  private var logsTask: Task<Void, Never>?
 
   // Reported to the native verifier via setWrapperInfo (diagnostics only — the
   // verifier consumes only the product). Keep in sync with package.json
   // "version" on release.
-  private static let wrapperVersion = "0.0.7"
+  private static let wrapperVersion = "0.0.9"
 
   @objc public init(
     onState: @escaping (NSDictionary) -> Void,
@@ -43,7 +45,8 @@ import BeekonKit
     onGeofenceEvent: @escaping (NSDictionary) -> Void,
     onSyncStatus: @escaping (NSDictionary) -> Void,
     onAuthTokens: @escaping (NSDictionary) -> Void,
-    onLicenseStatus: @escaping (NSDictionary) -> Void
+    onLicenseStatus: @escaping (NSDictionary) -> Void,
+    onLog: @escaping (NSDictionary) -> Void
   ) {
     // Identify this wrapper to the native verifier (license-format-v1 §11) before
     // any configure() can run — a direct native call (nonisolated static),
@@ -55,6 +58,7 @@ import BeekonKit
     self.onSyncStatusCb = onSyncStatus
     self.onAuthTokensCb = onAuthTokens
     self.onLicenseStatusCb = onLicenseStatus
+    self.onLogCb = onLog
     super.init()
     self.stateTask = Task { [weak self] in
       guard let self = self else { return }
@@ -92,6 +96,12 @@ import BeekonKit
         self.onLicenseStatusCb(self.licenseStatusToWire(status))
       }
     }
+    self.logsTask = Task { [weak self] in
+      guard let self = self else { return }
+      for await entry in await Beekon.shared.logs {
+        self.onLogCb(self.logEntryToWire(entry))
+      }
+    }
   }
 
   @objc public func invalidate() {
@@ -101,12 +111,14 @@ import BeekonKit
     syncStatusTask?.cancel()
     authTokensTask?.cancel()
     licenseStatusTask?.cancel()
+    logsTask?.cancel()
     stateTask = nil
     locationsTask = nil
     geofenceEventsTask = nil
     syncStatusTask = nil
     authTokensTask = nil
     licenseStatusTask = nil
+    logsTask = nil
   }
 
   /// Register Beekon's background-refresh task and install cold-launch hooks.
@@ -123,11 +135,22 @@ import BeekonKit
   @objc public func configure(
     _ config: NSDictionary,
     resolver resolve: @escaping @Sendable (Any?) -> Void,
-    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+    rejecter reject: @escaping @Sendable (String?, String?, Error?) -> Void
   ) {
+    // GATED on beekon native 0.0.9 (sealed BeekonConfig) — does not compile
+    // against the pinned 0.0.8 dep. `wireToConfig` now throws: the cloud arm
+    // (`try BeekonConfig.cloud(...)`) raises BeekonError.invalidConfiguration on
+    // an empty/invalid projectKey, which we surface via the existing reject path.
+    //
     // Convert the non-Sendable NSDictionary to a Sendable BeekonConfig before
     // crossing into the Task closure.
-    let cfg = wireToConfig(config)
+    let cfg: BeekonConfig
+    do {
+      cfg = try wireToConfig(config)
+    } catch {
+      reject(errorCode(error), error.localizedDescription, error)
+      return
+    }
     Task {
       await Beekon.shared.configure(cfg)
       resolve(nil)
@@ -322,9 +345,96 @@ import BeekonKit
     }
   }
 
+  // MARK: - Diagnostic logs (spec diagnostics/log-format-v1)
+
+  @objc public func getLogFromMs(
+    _ fromMs: Double,
+    toMs: Double,
+    resolver resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter reject: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    Task { [weak self] in
+      guard let self = self else { return }
+      do {
+        let from = Date(timeIntervalSince1970: fromMs / 1000.0)
+        let to = Date(timeIntervalSince1970: toMs / 1000.0)
+        let entries = try await Beekon.shared.getLog(from: from, to: to)
+        resolve(entries.map { self.logEntryToWire($0) })
+      } catch {
+        reject(self.errorCode(error), error.localizedDescription, error)
+      }
+    }
+  }
+
+  @objc public func exportLogWithResolver(
+    _ resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter reject: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    Task { [weak self] in
+      guard let self = self else { return }
+      do {
+        resolve(try await Beekon.shared.exportLog())
+      } catch {
+        reject(self.errorCode(error), error.localizedDescription, error)
+      }
+    }
+  }
+
+  @objc public func clearLogWithResolver(
+    _ resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter reject: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    Task { [weak self] in
+      guard let self = self else { return }
+      do {
+        try await Beekon.shared.clearLog()
+        resolve(nil)
+      } catch {
+        reject(self.errorCode(error), error.localizedDescription, error)
+      }
+    }
+  }
+
+  @objc public func setLogLevel(
+    _ level: String,
+    resolver resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    // setLogLevel is nonisolated on the actor — callable synchronously.
+    Beekon.shared.setLogLevel(logLevelFromWire(level))
+    resolve(nil)
+  }
+
+  @objc public func logWithLevel(
+    _ level: String,
+    message: String,
+    resolver resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    Beekon.shared.log(logLevelFromWire(level), message)
+    resolve(nil)
+  }
+
   // MARK: - Mappers: wire (NSDictionary/NSArray) → Beekon
 
-  private func wireToConfig(_ d: NSDictionary) -> BeekonConfig {
+  // GATED on beekon native 0.0.9 (sealed BeekonConfig) — does not compile against
+  // the pinned 0.0.8 dep (the flat BeekonConfig(...) init). Switches on the wire
+  // `mode` (cloud-mode-v1 §2) to build the matching sealed arm. The cloud factory
+  // is throwing (`try BeekonConfig.cloud(...)`): an empty/invalid projectKey
+  // raises BeekonError.invalidConfiguration, propagated to configure()'s reject.
+  // iOS has NO `notification`, so the cloud arm omits it.
+  private func wireToConfig(_ d: NSDictionary) throws -> BeekonConfig {
+    if d["mode"] as? String == "cloud" {
+      let projectKey = (d["projectKey"] as? String) ?? ""
+      // Omitted endpoint → the baked-in Beekon Cloud default.
+      let endpoint = (d["endpoint"] as? String) ?? "https://api.getbeekon.com"
+      return try BeekonConfig.cloud(
+        projectKey: projectKey,
+        endpoint: endpoint,
+        logLevel: logLevelFromWire(d["logLevel"] as? String)
+      )
+    }
+
     let minTime =
       (d["minTimeBetweenLocationsSeconds"] as? NSNumber)?.doubleValue ?? 30
     let minDist =
@@ -343,6 +453,7 @@ import BeekonKit
           headers: entriesToDict((s["headers"] as? NSArray) ?? []),
           intervalSeconds: (s["intervalSeconds"] as? NSNumber)?.doubleValue ?? 300,
           batchSize: (s["batchSize"] as? NSNumber)?.intValue ?? 100,
+          syncThreshold: (s["syncThreshold"] as? NSNumber)?.intValue ?? 0,
           auth: auth
         )
       } else {
@@ -352,8 +463,9 @@ import BeekonKit
       }
     }
 
-    // `notification` is Android-only — iOS ignores it.
-    return BeekonConfig(
+    // `notification` is Android-only — iOS ignores it (the selfManaged factory
+    // takes no notification parameter on iOS).
+    return BeekonConfig.selfManaged(
       minTimeBetweenLocationsSeconds: minTime,
       minDistanceBetweenLocationsMeters: minDist,
       accuracyMode: accuracyModeFromWire(d["accuracyMode"] as? String),
@@ -363,7 +475,8 @@ import BeekonKit
       sync: sync,
       // Passed through verbatim; nil/blank means unset — the SDK falls through to
       // the Info.plist value, then evaluation (license-format-v1 §9).
-      licenseKey: d["licenseKey"] as? String
+      licenseKey: d["licenseKey"] as? String,
+      logLevel: logLevelFromWire(d["logLevel"] as? String)
     )
   }
 
@@ -471,6 +584,16 @@ import BeekonKit
     ]
   }
 
+  private func logEntryToWire(_ e: LogEntry) -> NSDictionary {
+    return [
+      "id": e.id,
+      "timestampMs": e.timestamp.timeIntervalSince1970 * 1000.0,
+      "level": e.level.rawValue,
+      "category": e.category,
+      "message": e.message,
+    ]
+  }
+
   private func stateToWire(_ s: BeekonState) -> NSDictionary {
     switch s {
     case .idle:
@@ -590,12 +713,21 @@ import BeekonKit
     }
   }
 
+  // Wire token (LogLevel.rawValue, lowercase) -> LogLevel; unknown defaults to .info.
+  private func logLevelFromWire(_ s: String?) -> LogLevel {
+    LogLevel(rawValue: s ?? "") ?? .info
+  }
+
+  // GATED on beekon native 0.0.9 (StopReason.cloudModeUnavailable) — the new case
+  // does not exist on the pinned 0.0.8 dep. (Non-frozen enum, so the existing
+  // `@unknown default` already keeps this compiling either way.)
   private func stopReasonToWire(_ r: StopReason) -> String {
     switch r {
     case .user: return "user"
     case .permissionDenied: return "permissionDenied"
     case .locationServicesDisabled: return "locationServicesDisabled"
     case .locationUnavailable: return "locationUnavailable"
+    case .cloudModeUnavailable: return "cloudModeUnavailable"
     case .system: return "system"
     @unknown default: return "system"
     }