@apex-inc/capacitor-plugin 0.3.6 → 0.3.8

package/ios/Sources/ApexCapacitorPlugin/BatchSender.swift

@@ -67,6 +67,12 @@ public final class NativeBatchSender {
     /// Drains the queue, one batch at a time, with exponential backoff
     /// on retryable failures. Safe to call concurrently — only one
     /// flush actually runs at a time; concurrent callers no-op.
+    ///
+    /// Accumulator is passed by value through the recursion (no inout).
+    /// The previous inout-based design tripped Swift's exclusivity
+    /// runtime check at line 85 because the same `totalFlushed` local
+    /// was both captured by the `done` closure and passed inout — a
+    /// classic simultaneous-access violation that traps in debug builds.
     public func flush(queue: NativeOfflineQueue, completion: @escaping (Int, Int) -> Void) {
         serial.async { [weak self] in
             guard let self = self else { completion(0, 0); return }
@@ -77,54 +83,56 @@ public final class NativeBatchSender {
                 return
             }
             self.inFlight = true
-
-            var totalFlushed = 0
-            self.drainLoop(queue: queue, flushed: &totalFlushed) { [weak self] in
-                self?.inFlight = false
-                let remaining = (try? queue.size()) ?? 0
-                completion(totalFlushed, remaining)
+            self.drainLoop(queue: queue, accumulated: 0) { [weak self] flushed in
+                self?.serial.async {
+                    self?.inFlight = false
+                    let remaining = (try? queue.size()) ?? 0
+                    completion(flushed, remaining)
+                }
             }
         }
     }
 
+    /// Recursive drain. `accumulated` is the running total of successfully
+    /// flushed events; `done` is invoked exactly once with the final count.
     private func drainLoop(
         queue: NativeOfflineQueue,
-        flushed: inout Int,
-        done: @escaping () -> Void
+        accumulated: Int,
+        done: @escaping (Int) -> Void
     ) {
         let batch: [NativeQueuedEvent]
         do {
             batch = try queue.peek(batchSize: batchSize)
         } catch {
             if debug { print("[apex-capacitor] peek failed: \(error)") }
-            done()
+            done(accumulated)
             return
         }
         if batch.isEmpty {
-            done()
+            done(accumulated)
             return
         }
 
-        let localFlushed = flushed
         sendBatchWithRetry(batch, attempt: 0) { [weak self] outcome in
-            guard let self = self else { done(); return }
+            guard let self = self else { done(accumulated); return }
             self.serial.async {
                 let ids = batch.map { $0.id }
                 switch outcome {
                 case .success:
                     try? queue.markSent(ids: ids)
                     if self.debug { print("[apex-capacitor] flushed batch of \(batch.count)") }
-                    var nextFlushed = localFlushed + batch.count
-                    self.drainLoop(queue: queue, flushed: &nextFlushed, done: done)
-                    // After the recursive call returns the outer flushed
-                    // is no longer relevant — drain handles its own.
+                    self.drainLoop(
+                        queue: queue,
+                        accumulated: accumulated + batch.count,
+                        done: done
+                    )
                 case .nonRetryable(let status):
                     if self.debug { print("[apex-capacitor] non-retryable HTTP \(status); leaving events queued") }
-                    done()
+                    done(accumulated)
                 case .retryableExhausted(let err):
                     try? queue.markFailed(ids: ids)
                     if self.debug { print("[apex-capacitor] retries exhausted: \(err)") }
-                    done()
+                    done(accumulated)
                 }
             }
         }

package/ios/Sources/ApexCapacitorPluginBridge/ApexCapacitorPlugin.swift

@@ -76,6 +76,11 @@ public class ApexCapacitorPlugin: CAPPlugin, CAPBridgedPlugin, UNUserNotificatio
     // reached the server. See friction-log F6.
     private var batchSender: NativeBatchSender?
     private var flushTimer: Timer?
+    // MMP-207 — debounced flush. Without this, every `track()` call
+    // kicked a POST, so 8 quick taps = 8 separate single-event HTTP
+    // requests. With debounce, rapid-fire events coalesce into one
+    // batch on the next tick.
+    private var flushDebounceWork: DispatchWorkItem?
 
     public override func load() {
         let defaults = UserDefaults.standard
@@ -220,16 +225,29 @@ public class ApexCapacitorPlugin: CAPPlugin, CAPBridgedPlugin, UNUserNotificatio
         }
     }
 
-    /// Fire-and-forget flush. Safe to call freely; the sender's serial
-    /// queue ensures only one drain runs at a time.
+    /// Fire-and-forget flush. Track-triggered calls are debounced
+    /// 250ms so rapid tap sessions coalesce into a single batch POST.
+    /// Timer + foreground + initialize callers bypass the debounce
+    /// since they're already paced.
     private func kickFlush(reason: String) {
         guard let queue = offlineQueue, let sender = batchSender else { return }
-        if debug { print("[apex-capacitor] flush kicked (\(reason))") }
-        sender.flush(queue: queue) { [weak self] flushed, remaining in
-            if self?.debug == true && (flushed > 0 || remaining > 0) {
-                print("[apex-capacitor] flush done — sent \(flushed), remaining \(remaining)")
+        let runFlush: () -> Void = { [weak self] in
+            guard let self = self else { return }
+            if self.debug { print("[apex-capacitor] flush kicked (\(reason))") }
+            sender.flush(queue: queue) { [weak self] flushed, remaining in
+                if self?.debug == true && (flushed > 0 || remaining > 0) {
+                    print("[apex-capacitor] flush done — sent \(flushed), remaining \(remaining)")
+                }
             }
         }
+        if reason == "track" {
+            flushDebounceWork?.cancel()
+            let work = DispatchWorkItem(block: runFlush)
+            flushDebounceWork = work
+            DispatchQueue.global().asyncAfter(deadline: .now() + .milliseconds(250), execute: work)
+        } else {
+            runFlush()
+        }
     }
 
     // MARK: - ATT
@@ -424,6 +442,14 @@ public class ApexCapacitorPlugin: CAPPlugin, CAPBridgedPlugin, UNUserNotificatio
         }
         codablePayload["platform"] = AnyCodable("ios")
         codablePayload["timestamp"] = AnyCodable(ISO8601DateFormatter().string(from: Date()))
+        // MMP-207 — stamp visitorId. Without this, /api/events accepts
+        // the event into the SDK firehose store but its second pass
+        // bails at `if (!visitorId) continue;` so the event never
+        // reaches the TESTEVT# / EVT# stores the debug dashboard reads.
+        // Net result before this fix: events arrived but the dashboard
+        // showed nothing. The visitor id is the stable per-install id
+        // we mint in load() and persist to UserDefaults.
+        codablePayload["visitorId"] = AnyCodable(visitorId)
         let event = NativeQueuedEvent(
             id: id,
             payload: codablePayload,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apex-inc/capacitor-plugin",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Apex Capacitor plugin — iOS/Android attribution, events, deep linking, SKAN, and offline-tolerant tracking for Capacitor apps.",
   "main": "dist/index.js",
   "module": "dist/esm/index.js",