@apex-inc/capacitor-plugin 0.1.0

package/android/src/main/java/inc/apex/capacitor/InstallReferrerParser.kt

@@ -0,0 +1,123 @@
+package inc.apex.capacitor
+
+/**
+ * Parses Play Install Referrer strings into a map of click-ID claims.
+ *
+ * Android's Play Install Referrer API returns a URL-encoded key=value&... string
+ * that carries the ad-network click IDs used for attribution. We extract the
+ * fields the server expects (gclid, fbclid, ttclid, msclkid, li_fat_id, wbraid,
+ * gbraid, and utm_* parameters) and surface them as a typed Kotlin map.
+ *
+ * This is the single most important piece of Android attribution — without it,
+ * all paid installs appear as organic and ROAS is meaningless.
+ *
+ * Pure-logic Kotlin: no Android runtime imports so it runs under plain JUnit.
+ */
+object InstallReferrerParser {
+
+    /** Known click-ID keys we always surface at the top level of the result. */
+    private val KNOWN_CLICK_IDS = setOf(
+        "gclid",
+        "fbclid",
+        "ttclid",       // TikTok
+        "msclkid",      // Microsoft / Bing Ads
+        "li_fat_id",    // LinkedIn
+        "wbraid",       // Google App Campaigns web-to-app
+        "gbraid",       // Google App Campaigns app-to-app
+        "epik",         // Pinterest
+        "rdt_cid",      // Reddit
+        "twclid"        // Twitter / X
+    )
+
+    private val KNOWN_UTM_KEYS = setOf(
+        "utm_source",
+        "utm_medium",
+        "utm_campaign",
+        "utm_term",
+        "utm_content"
+    )
+
+    /** Parsed referrer claims — populated fields + any extras the ad network sent. */
+    data class Claims(
+        val raw: String,
+        val clickIds: Map<String, String>,
+        val utm: Map<String, String>,
+        val other: Map<String, String>
+    ) {
+        /** Convenience for the most common access pattern. */
+        fun hasAnyClickId(): Boolean = clickIds.isNotEmpty()
+        fun hasAnyAttribution(): Boolean = clickIds.isNotEmpty() || utm.isNotEmpty()
+    }
+
+    /**
+     * Parse a raw referrer string into structured claims. An empty or null
+     * input returns an empty Claims object — the install is treated as organic.
+     */
+    fun parse(raw: String?): Claims {
+        val safeRaw = raw?.trim().orEmpty()
+        if (safeRaw.isEmpty()) {
+            return Claims(raw = "", clickIds = emptyMap(), utm = emptyMap(), other = emptyMap())
+        }
+
+        val clicks = mutableMapOf<String, String>()
+        val utm = mutableMapOf<String, String>()
+        val other = mutableMapOf<String, String>()
+
+        for (pair in splitPairs(safeRaw)) {
+            val key = pair.first.lowercase()
+            val value = pair.second
+            if (value.isEmpty()) continue
+
+            when {
+                KNOWN_CLICK_IDS.contains(key) -> clicks[key] = value
+                KNOWN_UTM_KEYS.contains(key) -> utm[key] = value
+                else -> other[key] = value
+            }
+        }
+
+        return Claims(raw = safeRaw, clickIds = clicks, utm = utm, other = other)
+    }
+
+    private fun splitPairs(raw: String): List<Pair<String, String>> {
+        val decoded = urlDecode(raw)
+        return decoded.split("&")
+            .mapNotNull { segment ->
+                val idx = segment.indexOf('=')
+                if (idx <= 0) return@mapNotNull null
+                val k = segment.substring(0, idx)
+                val v = segment.substring(idx + 1)
+                if (k.isBlank()) return@mapNotNull null
+                urlDecode(k) to urlDecode(v)
+            }
+    }
+
+    /**
+     * Decode percent-encoded strings and `+` as space. We implement this
+     * manually rather than using `URLDecoder` to keep the class dependency-free
+     * for JUnit tests.
+     */
+    internal fun urlDecode(value: String): String {
+        if (value.isEmpty()) return value
+        val sb = StringBuilder(value.length)
+        var i = 0
+        while (i < value.length) {
+            val c = value[i]
+            when {
+                c == '+' -> sb.append(' ')
+                c == '%' && i + 2 < value.length -> {
+                    val hex = value.substring(i + 1, i + 3)
+                    val byte = hex.toIntOrNull(16)
+                    if (byte != null) {
+                        sb.append(byte.toChar())
+                        i += 2
+                    } else {
+                        sb.append(c)
+                    }
+                }
+                else -> sb.append(c)
+            }
+            i++
+        }
+        return sb.toString()
+    }
+}

package/android/src/main/java/inc/apex/capacitor/OfflineQueue.kt

@@ -0,0 +1,150 @@
+package inc.apex.capacitor
+
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * Durable event queue backed by a plain JSON file inside the app's internal
+ * storage directory. File-based storage is pragmatic for our event scale
+ * (a few hundred to low thousands of events max) — Room's migration machinery
+ * is overkill.
+ *
+ * Thread-safe via an intrinsic lock. The JS-side queue is the source of truth;
+ * this native queue exists so events survive the app being killed while the
+ * JS runtime is frozen.
+ *
+ * Pure-Kotlin-plus-org.json — runs under JUnit with a FileStorage abstraction
+ * that tests can swap for in-memory without any Android runtime.
+ */
+data class NativeQueuedEvent(
+    val id: String,
+    val payload: Map<String, Any?>,
+    val attempts: Int,
+    val enqueuedAtMs: Long,
+)
+
+interface QueueStorage {
+    fun readAll(): String?
+    fun writeAll(contents: String)
+}
+
+class NativeOfflineQueue(
+    private val storage: QueueStorage,
+    private val maxSize: Int = 1000,
+) {
+    init {
+        require(maxSize >= 1) { "maxSize must be >= 1, got $maxSize" }
+    }
+
+    private val lock = Any()
+
+    fun enqueue(event: NativeQueuedEvent) {
+        require(event.id.isNotEmpty()) { "event.id is required" }
+        synchronized(lock) {
+            val events = readLocked().toMutableList()
+            events.add(event)
+            if (events.size > maxSize) {
+                val overflow = events.size - maxSize
+                events.subList(0, overflow).clear()
+            }
+            writeLocked(events)
+        }
+    }
+
+    fun peek(batchSize: Int): List<NativeQueuedEvent> {
+        if (batchSize < 1) return emptyList()
+        return synchronized(lock) {
+            readLocked().take(batchSize)
+        }
+    }
+
+    fun markSent(ids: List<String>) {
+        if (ids.isEmpty()) return
+        synchronized(lock) {
+            val idSet = ids.toSet()
+            val kept = readLocked().filterNot { idSet.contains(it.id) }
+            writeLocked(kept)
+        }
+    }
+
+    fun markFailed(ids: List<String>) {
+        if (ids.isEmpty()) return
+        synchronized(lock) {
+            val idSet = ids.toSet()
+            val next = readLocked().map {
+                if (idSet.contains(it.id)) it.copy(attempts = it.attempts + 1) else it
+            }
+            writeLocked(next)
+        }
+    }
+
+    fun size(): Int = synchronized(lock) { readLocked().size }
+
+    fun oldestEventAtMs(): Long? = synchronized(lock) {
+        readLocked().firstOrNull()?.enqueuedAtMs
+    }
+
+    fun clear() = synchronized(lock) { writeLocked(emptyList()) }
+
+    // ── Serialization ──────────────────────────────────────────────
+
+    private fun readLocked(): List<NativeQueuedEvent> {
+        val raw = storage.readAll() ?: return emptyList()
+        if (raw.isBlank()) return emptyList()
+        return try {
+            val array = JSONArray(raw)
+            val result = mutableListOf<NativeQueuedEvent>()
+            for (i in 0 until array.length()) {
+                val obj = array.getJSONObject(i)
+                val payloadObj = obj.optJSONObject("payload")
+                val payload = payloadObj?.let { jsonObjectToMap(it) } ?: emptyMap()
+                result.add(
+                    NativeQueuedEvent(
+                        id = obj.getString("id"),
+                        payload = payload,
+                        attempts = obj.optInt("attempts", 0),
+                        enqueuedAtMs = obj.optLong("enqueuedAtMs", 0L),
+                    )
+                )
+            }
+            result
+        } catch (_: Exception) {
+            emptyList()
+        }
+    }
+
+    private fun writeLocked(events: List<NativeQueuedEvent>) {
+        val array = JSONArray()
+        for (ev in events) {
+            val obj = JSONObject()
+            obj.put("id", ev.id)
+            obj.put("attempts", ev.attempts)
+            obj.put("enqueuedAtMs", ev.enqueuedAtMs)
+            obj.put("payload", JSONObject(ev.payload))
+            array.put(obj)
+        }
+        storage.writeAll(array.toString())
+    }
+
+    private fun jsonObjectToMap(obj: JSONObject): Map<String, Any?> {
+        val result = mutableMapOf<String, Any?>()
+        val keys = obj.keys()
+        while (keys.hasNext()) {
+            val key = keys.next()
+            result[key] = obj.opt(key)
+        }
+        return result
+    }
+}
+
+/**
+ * In-memory storage backend for tests.
+ */
+class InMemoryQueueStorage : QueueStorage {
+    private var contents: String? = null
+
+    override fun readAll(): String? = contents
+    override fun writeAll(contents: String) {
+        this.contents = contents
+    }
+}

package/android/src/main/java/inc/apex/capacitor/SessionManager.kt

@@ -0,0 +1,108 @@
+package inc.apex.capacitor
+
+import java.util.UUID
+import java.util.concurrent.TimeUnit
+
+/**
+ * Native Android session manager. Mirrors the TS and Swift session managers —
+ * a session starts on the first activity and ends after `timeoutMinutes` of
+ * inactivity (default 30). The JS bridge also runs a session manager; this
+ * native copy catches background-state transitions that JS timers can't
+ * observe after Doze / App Standby kicks in.
+ *
+ * Pure Kotlin — injectable clock + scheduler keep unit tests deterministic.
+ */
+data class SessionSnapshot(
+    val sessionId: String,
+    val startedAtMs: Long,
+    var lastActivityMs: Long,
+    var eventCount: Int,
+    var endedAtMs: Long? = null,
+    var durationSeconds: Long? = null,
+)
+
+fun interface Scheduler {
+    /** Schedule a one-shot callback after `delayMs`, returns a cancel token. */
+    fun schedule(delayMs: Long, callback: () -> Unit): Any
+
+    companion object {
+        /** Default implementation — no-op scheduler used as a fallback in tests. */
+        val Noop: Scheduler = Scheduler { _, _ -> Any() }
+    }
+}
+
+fun interface ScheduleCanceller {
+    fun cancel(token: Any)
+
+    companion object {
+        val Noop: ScheduleCanceller = ScheduleCanceller { _ -> }
+    }
+}
+
+class NativeSessionManager(
+    private val timeoutMinutes: Int = 30,
+    private val now: () -> Long = { System.currentTimeMillis() },
+    private val scheduler: Scheduler = Scheduler.Noop,
+    private val canceller: ScheduleCanceller = ScheduleCanceller.Noop,
+    private val onStart: ((SessionSnapshot) -> Unit)? = null,
+    private val onEnd: ((SessionSnapshot) -> Unit)? = null,
+) {
+    private val timeoutMs: Long = TimeUnit.MINUTES.toMillis(timeoutMinutes.toLong())
+    private var current: SessionSnapshot? = null
+    private var cancelToken: Any? = null
+    private val lock = Any()
+
+    fun recordActivity(): SessionSnapshot {
+        synchronized(lock) {
+            val nowMs = now()
+            if (current == null) {
+                val snapshot = SessionSnapshot(
+                    sessionId = UUID.randomUUID().toString().lowercase(),
+                    startedAtMs = nowMs,
+                    lastActivityMs = nowMs,
+                    eventCount = 1,
+                )
+                current = snapshot
+                onStart?.invoke(snapshot.copy())
+            } else {
+                current!!.lastActivityMs = nowMs
+                current!!.eventCount++
+            }
+            rescheduleTimeoutLocked()
+            return current!!.copy()
+        }
+    }
+
+    fun endSession() {
+        synchronized(lock) {
+            endLocked()
+        }
+    }
+
+    fun forceStart(): SessionSnapshot {
+        synchronized(lock) { endLocked() }
+        return recordActivity()
+    }
+
+    fun getCurrent(): SessionSnapshot? = synchronized(lock) { current?.copy() }
+
+    private fun rescheduleTimeoutLocked() {
+        cancelToken?.let { canceller.cancel(it) }
+        cancelToken = scheduler.schedule(timeoutMs) {
+            synchronized(lock) { endLocked() }
+        }
+    }
+
+    private fun endLocked() {
+        val snapshot = current ?: return
+        cancelToken?.let { canceller.cancel(it) }
+        cancelToken = null
+
+        val nowMs = now()
+        snapshot.endedAtMs = nowMs
+        snapshot.durationSeconds = maxOf(0L, (nowMs - snapshot.startedAtMs) / 1000L)
+
+        onEnd?.invoke(snapshot.copy())
+        current = null
+    }
+}

package/dist/batch-sender.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Batch sender with exponential-backoff retries.
+ *
+ * Drains the offline queue by sending events in batches to `/api/events`.
+ * Retries on 5xx and network errors with exponential backoff (1s, 2s, 4s).
+ * Gives up after 3 attempts per batch — events remain in the queue for a
+ * future flush attempt but are marked with incremented `attempts` so old
+ * failing events don't block new ones indefinitely.
+ *
+ * The fetch function is injectable for testing and to allow future runtimes
+ * to swap in native HTTP clients (e.g. on restricted networks).
+ */
+import type { OfflineQueue } from "./offline-queue";
+export interface BatchSenderOptions {
+    /** API base URL. Default `https://api.apex.inc`. */
+    apiUrl?: string;
+    /** Project key attached to each request. Required. */
+    projectKey: string;
+    /** Max events sent per batch. Default 50. */
+    batchSize?: number;
+    /** Max retry attempts before giving up on a batch. Default 3. */
+    maxRetries?: number;
+    /** Base backoff delay in milliseconds. Default 1000. */
+    baseBackoffMs?: number;
+    /** Injectable fetch (Node, test mocks, custom runtimes). */
+    fetchFn?: typeof fetch;
+    /** Injectable sleep for testing (must return a Promise that resolves). */
+    sleepFn?: (ms: number) => Promise<void>;
+    /** Platform header to include (`ios` / `android`). */
+    platformHeader?: "ios" | "android" | "web";
+    /** Enable verbose logs. */
+    debug?: boolean;
+}
+export interface FlushResult {
+    flushed: number;
+    remaining: number;
+    attemptedBatches: number;
+    lastError?: string;
+}
+export declare class BatchSender {
+    private readonly apiUrl;
+    private readonly projectKey;
+    private readonly batchSize;
+    private readonly maxRetries;
+    private readonly baseBackoffMs;
+    private readonly fetchFn;
+    private readonly sleepFn;
+    private readonly platformHeader?;
+    private readonly debug;
+    constructor(options: BatchSenderOptions);
+    /**
+     * Flushes as many events from the queue as possible, one batch at a time,
+     * with exponential backoff on retryable failures. Stops early on
+     * non-retryable errors (400/401/403) and leaves remaining events queued.
+     */
+    flush(queue: OfflineQueue): Promise<FlushResult>;
+    private sendBatchWithRetry;
+    private postBatch;
+}
+//# sourceMappingURL=batch-sender.d.ts.map

package/dist/batch-sender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-sender.d.ts","sourceRoot":"","sources":["../src/batch-sender.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,iBAAiB,CAAC;AAEjE,MAAM,WAAW,kBAAkB;IACjC,oDAAoD;IACpD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sDAAsD;IACtD,UAAU,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wDAAwD;IACxD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;IACvB,0EAA0E;IAC1E,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,sDAAsD;IACtD,cAAc,CAAC,EAAE,KAAK,GAAG,SAAS,GAAG,KAAK,CAAC;IAC3C,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgC;IACxD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAA4B;IAC5D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAU;gBAEpB,OAAO,EAAE,kBAAkB;IAiBvC;;;;OAIG;IACG,KAAK,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;YAgCxC,kBAAkB;YAyClB,SAAS;CAoBxB"}

package/dist/batch-sender.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * Batch sender with exponential-backoff retries.
+ *
+ * Drains the offline queue by sending events in batches to `/api/events`.
+ * Retries on 5xx and network errors with exponential backoff (1s, 2s, 4s).
+ * Gives up after 3 attempts per batch — events remain in the queue for a
+ * future flush attempt but are marked with incremented `attempts` so old
+ * failing events don't block new ones indefinitely.
+ *
+ * The fetch function is injectable for testing and to allow future runtimes
+ * to swap in native HTTP clients (e.g. on restricted networks).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchSender = void 0;
+class BatchSender {
+    constructor(options) {
+        this.apiUrl = (options.apiUrl ?? "https://api.apex.inc").replace(/\/+$/, "");
+        this.projectKey = options.projectKey;
+        this.batchSize = options.batchSize ?? 50;
+        this.maxRetries = options.maxRetries ?? 3;
+        this.baseBackoffMs = options.baseBackoffMs ?? 1000;
+        this.fetchFn = options.fetchFn ?? globalThis.fetch?.bind(globalThis);
+        this.sleepFn =
+            options.sleepFn ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+        this.platformHeader = options.platformHeader;
+        this.debug = options.debug ?? false;
+        if (!this.fetchFn) {
+            throw new Error("BatchSender: fetch is not available. Provide options.fetchFn.");
+        }
+    }
+    /**
+     * Flushes as many events from the queue as possible, one batch at a time,
+     * with exponential backoff on retryable failures. Stops early on
+     * non-retryable errors (400/401/403) and leaves remaining events queued.
+     */
+    async flush(queue) {
+        let flushed = 0;
+        let attemptedBatches = 0;
+        let lastError;
+        while (true) {
+            const batch = await queue.peek(this.batchSize);
+            if (batch.length === 0)
+                break;
+            attemptedBatches += 1;
+            const outcome = await this.sendBatchWithRetry(batch);
+            if (outcome.status === "success") {
+                const eventIds = batch.map((q) => q.event.id).filter((id) => !!id);
+                await queue.markSent(eventIds);
+                flushed += batch.length;
+            }
+            else if (outcome.status === "retryable_exhausted") {
+                const eventIds = batch.map((q) => q.event.id).filter((id) => !!id);
+                await queue.markFailed(eventIds);
+                lastError = outcome.error;
+                break; // leave for next flush cycle
+            }
+            else {
+                // Non-retryable: leave events in place but stop flushing.
+                lastError = outcome.error;
+                break;
+            }
+        }
+        const remaining = await queue.size();
+        return { flushed, remaining, attemptedBatches, lastError };
+    }
+    async sendBatchWithRetry(batch) {
+        let lastError = "unknown";
+        for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+            try {
+                const response = await this.postBatch(batch);
+                if (response.ok) {
+                    return { status: "success" };
+                }
+                // Non-retryable client errors — leave events, surface to caller.
+                if (response.status >= 400 && response.status < 500) {
+                    return { status: "non_retryable", error: `HTTP ${response.status}` };
+                }
+                // Retryable: 5xx or unknown. Fall through to backoff.
+                lastError = `HTTP ${response.status}`;
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err.message : String(err);
+            }
+            if (attempt < this.maxRetries - 1) {
+                const backoff = this.baseBackoffMs * 2 ** attempt;
+                if (this.debug) {
+                    console.log(`[apex-capacitor] batch-sender retry ${attempt + 1}/${this.maxRetries - 1} in ${backoff}ms (${lastError})`);
+                }
+                await this.sleepFn(backoff);
+            }
+        }
+        return { status: "retryable_exhausted", error: lastError };
+    }
+    async postBatch(batch) {
+        const body = {
+            projectKey: this.projectKey,
+            events: batch.map((q) => q.event),
+        };
+        const headers = {
+            "Content-Type": "application/json",
+            "X-Apex-Project-Key": this.projectKey,
+        };
+        if (this.platformHeader) {
+            headers["X-Apex-Platform"] = this.platformHeader;
+        }
+        return this.fetchFn(`${this.apiUrl}/api/events`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+        });
+    }
+}
+exports.BatchSender = BatchSender;
+//# sourceMappingURL=batch-sender.js.map

package/dist/batch-sender.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-sender.js","sourceRoot":"","sources":["../src/batch-sender.ts"],"names":[],"mappings":"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"}