@billdog.io/react-native 1.0.0-beta.2

package/android/src/main/kotlin/io/billdog/reactnative/BillDogVirtualCurrencyModule.kt

@@ -0,0 +1,407 @@
+package io.billdog.reactnative
+
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.BufferedReader
+import java.io.InputStreamReader
+import java.net.HttpURLConnection
+import java.net.URL
+import java.net.URLEncoder
+
+/**
+ * BillDogVirtualCurrency — React Native native module for Android
+ * (`NativeModules.BillDogVirtualCurrency`).
+ *
+ * Standalone HTTP bridge that mirrors the iOS `BillDogVirtualCurrencyBridge.swift`
+ * 1:1 — same endpoints, same request bodies, same `X-BillDog-API-Key` header, and
+ * the same `onBalanceChanged` / `onTransaction` events. This is deliberately a
+ * self-contained bridge (not a delegation to `io.billdog:billdog-virtual-currency`)
+ * so the RN Virtual Currency surface behaves identically on iOS and Android and
+ * does not depend on the core module registry being wired with the VC satellite.
+ *
+ * The authoritative JS contract is `src/modules/VirtualCurrency.ts`; each
+ * `BillDogVirtualCurrency.<method>(...)` there maps to the identically-named
+ * `@ReactMethod` below.
+ *
+ * ⚠️ VERIFICATION: this file needs a Gradle/Android build
+ * (`./gradlew :billdog_react-native:compileDebugKotlin` or the example app build)
+ * to type-check — there is no Android toolchain in the authoring environment.
+ */
+class BillDogVirtualCurrencyModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    private val TAG = "BillDogVirtualCurrency"
+
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
+    private var baseUrl: String? = null
+    private var apiKey: String? = null
+    private var customerId: String? = null
+    private var enableLogging: Boolean = false
+
+    override fun getName(): String = "BillDogVirtualCurrency"
+
+    // ── Lifecycle ────────────────────────────────────────────────────────────
+
+    override fun invalidate() {
+        scope.cancel()
+        super.invalidate()
+    }
+
+    @Deprecated("Deprecated in RN; kept for older RN versions that call it instead of invalidate()")
+    override fun onCatalystInstanceDestroy() {
+        scope.cancel()
+        @Suppress("DEPRECATION")
+        super.onCatalystInstanceDestroy()
+    }
+
+    // NativeEventEmitter on the JS side requires these to exist on the module.
+    @ReactMethod
+    fun addListener(@Suppress("UNUSED_PARAMETER") eventName: String) { /* RCTEventEmitter — no-op. */ }
+
+    @ReactMethod
+    fun removeListeners(@Suppress("UNUSED_PARAMETER") count: Double) { /* RCTEventEmitter — no-op. */ }
+
+    // ── Initialization ───────────────────────────────────────────────────────
+
+    /**
+     * BillDogVirtualCurrency.initialize(config) — stores baseUrl / apiKey /
+     * customerId / enableLogging. Mirrors the iOS bridge's `initialize`.
+     */
+    @ReactMethod
+    fun initialize(config: ReadableMap, promise: Promise) {
+        val baseUrl = if (config.hasKey("baseUrl")) config.getString("baseUrl") else null
+        val apiKey = if (config.hasKey("apiKey")) config.getString("apiKey") else null
+        val customerId = if (config.hasKey("customerId")) config.getString("customerId") else null
+        if (baseUrl.isNullOrEmpty() || apiKey.isNullOrEmpty() || customerId.isNullOrEmpty()) {
+            promise.reject("INVALID_CONFIG", "Missing required configuration parameters")
+            return
+        }
+        this.baseUrl = baseUrl.trimEnd('/')
+        this.apiKey = apiKey
+        this.customerId = customerId
+        this.enableLogging = config.hasKey("enableLogging") && config.getBoolean("enableLogging")
+        if (enableLogging) Log.d(TAG, "Virtual Currency initialized for customer: $customerId")
+        promise.resolve(null)
+    }
+
+    // ── Balance operations ─────────────────────────────────────────────────────
+
+    @ReactMethod
+    fun getBalance(currencyId: String, promise: Promise) {
+        val customerId = this.customerId ?: return promise.reject(
+            "NOT_INITIALIZED", "Virtual Currency module not initialized"
+        )
+        run(promise) {
+            val q = "currency_id=${enc(currencyId)}&customer_id=${enc(customerId)}"
+            val json = httpGet("/virtual-currency/balances?$q")
+            json.getDouble("balance")
+        }
+    }
+
+    @ReactMethod
+    fun addCurrency(
+        currencyId: String,
+        amount: Double,
+        reason: String?,
+        metadata: ReadableMap?,
+        promise: Promise,
+    ) {
+        transaction(currencyId, amount, "earn", reason, metadata, "ADD_CURRENCY_ERROR", promise)
+    }
+
+    @ReactMethod
+    fun deductCurrency(
+        currencyId: String,
+        amount: Double,
+        reason: String?,
+        metadata: ReadableMap?,
+        promise: Promise,
+    ) {
+        // Deduct posts a negative amount, mirroring the iOS bridge.
+        transaction(currencyId, -amount, "spend", reason, metadata, "DEDUCT_CURRENCY_ERROR", promise)
+    }
+
+    @ReactMethod
+    fun grantCurrency(
+        currencyId: String,
+        amount: Double,
+        reason: String?,
+        promise: Promise,
+    ) {
+        transaction(currencyId, amount, "grant", reason, null, "GRANT_CURRENCY_ERROR", promise)
+    }
+
+    private fun transaction(
+        currencyId: String,
+        amount: Double,
+        type: String,
+        reason: String?,
+        metadata: ReadableMap?,
+        errorCode: String,
+        promise: Promise,
+    ) {
+        val customerId = this.customerId ?: return promise.reject(
+            "NOT_INITIALIZED", "Virtual Currency module not initialized"
+        )
+        scope.launch {
+            try {
+                val body = JSONObject().apply {
+                    put("currency_id", currencyId)
+                    put("customer_id", customerId)
+                    put("amount", amount)
+                    put("type", type)
+                    if (reason != null) put("reason", reason)
+                    if (metadata != null) put("metadata", readableMapToJson(metadata))
+                }
+                val json = withContext(Dispatchers.IO) { httpPost("/virtual-currency/transactions", body) }
+                val newBalance = json.getDouble("new_balance")
+                emit("onBalanceChanged", Arguments.createMap().apply {
+                    putString("currencyId", currencyId)
+                    putDouble("newBalance", newBalance)
+                })
+                emit("onTransaction", Arguments.createMap().apply {
+                    putString("id", json.optString("id", ""))
+                    putString("currencyId", currencyId)
+                    putDouble("amount", amount)
+                    putString("type", type)
+                    if (reason != null) putString("reason", reason)
+                    putDouble("newBalance", newBalance)
+                })
+                promise.resolve(newBalance)
+            } catch (e: Throwable) {
+                promise.reject(errorCode, e.message, e)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun getTransactionHistory(currencyId: String?, limit: Double, promise: Promise) {
+        val customerId = this.customerId ?: return promise.reject(
+            "NOT_INITIALIZED", "Virtual Currency module not initialized"
+        )
+        run(promise) {
+            var path = "/virtual-currency/transactions/history?customer_id=${enc(customerId)}&limit=${limit.toInt()}"
+            if (!currencyId.isNullOrEmpty()) path += "&currency_id=${enc(currencyId)}"
+            val json = httpGet(path)
+            jsonArrayToWritable(json.optJSONArray("transactions") ?: JSONArray())
+        }
+    }
+
+    @ReactMethod
+    fun exchangeCurrency(
+        fromCurrencyId: String,
+        toCurrencyId: String,
+        fromAmount: Double,
+        promise: Promise,
+    ) {
+        val customerId = this.customerId ?: return promise.reject(
+            "NOT_INITIALIZED", "Virtual Currency module not initialized"
+        )
+        scope.launch {
+            try {
+                val body = JSONObject().apply {
+                    put("from_currency_id", fromCurrencyId)
+                    put("to_currency_id", toCurrencyId)
+                    put("from_amount", fromAmount)
+                    put("customer_id", customerId)
+                }
+                val json = withContext(Dispatchers.IO) { httpPost("/virtual-currency/exchange", body) }
+                // Build the camelCase ExchangeResult the JS `ExchangeResult` type expects.
+                val newFrom = json.optDouble("new_from_balance", 0.0)
+                val newTo = json.optDouble("new_to_balance", 0.0)
+                val result: WritableMap = Arguments.createMap().apply {
+                    putBoolean("success", true)
+                    putString("fromCurrencyId", fromCurrencyId)
+                    putString("toCurrencyId", toCurrencyId)
+                    putDouble("fromAmount", fromAmount)
+                    putDouble("toAmount", json.optDouble("to_amount", 0.0))
+                    putDouble("exchangeRate", json.optDouble("exchange_rate", 0.0))
+                    putDouble("newFromBalance", newFrom)
+                    putDouble("newToBalance", newTo)
+                }
+                emit("onBalanceChanged", Arguments.createMap().apply {
+                    putString("currencyId", fromCurrencyId)
+                    putDouble("newBalance", newFrom)
+                })
+                emit("onBalanceChanged", Arguments.createMap().apply {
+                    putString("currencyId", toCurrencyId)
+                    putDouble("newBalance", newTo)
+                })
+                promise.resolve(result)
+            } catch (e: Throwable) {
+                promise.reject("EXCHANGE_ERROR", e.message, e)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun getAllCurrencies(promise: Promise) {
+        val customerId = this.customerId ?: return promise.reject(
+            "NOT_INITIALIZED", "Virtual Currency module not initialized"
+        )
+        run(promise) {
+            // All-balances route returns `data.balances = [{currency:{…}, balance}]`
+            // (NOT `currencies`); the JS layer normalizes the nested shape.
+            val json = httpGet("/virtual-currency/balances?customer_id=${enc(customerId)}")
+            jsonArrayToWritable(json.optJSONArray("balances") ?: JSONArray())
+        }
+    }
+
+    // ── Helpers ────────────────────────────────────────────────────────────────
+
+    /** Run [block] on the IO dispatcher; resolve/reject the promise. */
+    private fun run(promise: Promise, block: () -> Any?) {
+        scope.launch {
+            try {
+                val value = withContext(Dispatchers.IO) { block() }
+                promise.resolve(value)
+            } catch (e: Throwable) {
+                promise.reject("BILLDOG_VC_ERROR", e.message, e)
+            }
+        }
+    }
+
+    private fun emit(name: String, body: WritableMap) {
+        try {
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit(name, body)
+        } catch (_: Throwable) { /* no active JS context — drop the event */ }
+    }
+
+    private fun enc(s: String): String = URLEncoder.encode(s, "UTF-8")
+
+    private fun openConnection(path: String, method: String): HttpURLConnection {
+        val base = baseUrl ?: throw IllegalStateException("Configuration missing")
+        val key = apiKey ?: throw IllegalStateException("Configuration missing")
+        val conn = URL(base + path).openConnection() as HttpURLConnection
+        conn.requestMethod = method
+        conn.setRequestProperty("X-BillDog-API-Key", key)
+        conn.setRequestProperty("Content-Type", "application/json")
+        conn.setRequestProperty("Accept", "application/json")
+        conn.connectTimeout = 15000
+        conn.readTimeout = 15000
+        return conn
+    }
+
+    private fun httpGet(path: String): JSONObject {
+        val conn = openConnection(path, "GET")
+        return readJson(conn)
+    }
+
+    private fun httpPost(path: String, body: JSONObject): JSONObject {
+        val conn = openConnection(path, "POST")
+        conn.doOutput = true
+        conn.outputStream.use { it.write(body.toString().toByteArray(Charsets.UTF_8)) }
+        return readJson(conn)
+    }
+
+    private fun readJson(conn: HttpURLConnection): JSONObject {
+        try {
+            val code = conn.responseCode
+            val stream = if (code in 200..299) conn.inputStream else conn.errorStream
+            val text = stream?.let {
+                BufferedReader(InputStreamReader(it, Charsets.UTF_8)).use { r -> r.readText() }
+            } ?: ""
+            if (code !in 200..299) {
+                throw RuntimeException(if (text.isNotEmpty()) text else "HTTP $code")
+            }
+            val root = JSONObject(text)
+            // BillDog edge functions wrap payloads in { success, data, meta }
+            // (supabase/functions/_shared/response.ts). Descend into `data` so
+            // callers read `balance`/`transactions`/`new_balance` at the top.
+            return root.optJSONObject("data") ?: root
+        } finally {
+            conn.disconnect()
+        }
+    }
+
+    private fun readableMapToJson(map: ReadableMap): JSONObject {
+        val json = JSONObject()
+        val it = map.keySetIterator()
+        while (it.hasNextKey()) {
+            val key = it.nextKey()
+            when (map.getType(key)) {
+                ReadableType.Null -> json.put(key, JSONObject.NULL)
+                ReadableType.Boolean -> json.put(key, map.getBoolean(key))
+                ReadableType.Number -> json.put(key, map.getDouble(key))
+                ReadableType.String -> json.put(key, map.getString(key))
+                ReadableType.Map -> json.put(key, readableMapToJson(map.getMap(key)!!))
+                ReadableType.Array -> json.put(key, readableArrayToJson(map.getArray(key)!!))
+            }
+        }
+        return json
+    }
+
+    private fun readableArrayToJson(array: ReadableArray): JSONArray {
+        val json = JSONArray()
+        for (i in 0 until array.size()) {
+            when (array.getType(i)) {
+                ReadableType.Null -> json.put(JSONObject.NULL)
+                ReadableType.Boolean -> json.put(array.getBoolean(i))
+                ReadableType.Number -> json.put(array.getDouble(i))
+                ReadableType.String -> json.put(array.getString(i))
+                ReadableType.Map -> json.put(readableMapToJson(array.getMap(i)))
+                ReadableType.Array -> json.put(readableArrayToJson(array.getArray(i)))
+            }
+        }
+        return json
+    }
+
+    private fun jsonToWritable(json: JSONObject): WritableMap {
+        val map = Arguments.createMap()
+        val keys = json.keys()
+        while (keys.hasNext()) {
+            val key = keys.next()
+            when (val v = json.get(key)) {
+                JSONObject.NULL -> map.putNull(key)
+                is Boolean -> map.putBoolean(key, v)
+                is Int -> map.putInt(key, v)
+                is Long -> map.putDouble(key, v.toDouble())
+                is Double -> map.putDouble(key, v)
+                is String -> map.putString(key, v)
+                is JSONObject -> map.putMap(key, jsonToWritable(v))
+                is JSONArray -> map.putArray(key, jsonArrayToWritable(v))
+                else -> map.putString(key, v.toString())
+            }
+        }
+        return map
+    }
+
+    private fun jsonArrayToWritable(array: JSONArray): WritableArray {
+        val out = Arguments.createArray()
+        for (i in 0 until array.length()) {
+            when (val v = array.get(i)) {
+                JSONObject.NULL -> out.pushNull()
+                is Boolean -> out.pushBoolean(v)
+                is Int -> out.pushInt(v)
+                is Long -> out.pushDouble(v.toDouble())
+                is Double -> out.pushDouble(v)
+                is String -> out.pushString(v)
+                is JSONObject -> out.pushMap(jsonToWritable(v))
+                is JSONArray -> out.pushArray(jsonArrayToWritable(v))
+                else -> out.pushString(v.toString())
+            }
+        }
+        return out
+    }
+}

package/android/src/main/kotlin/io/billdog/virtualcurrency/BillDogVirtualCurrencyPackage.kt

@@ -0,0 +1,44 @@
+package io.billdog.virtualcurrency
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import io.billdog.reactnative.BillDogModule
+import io.billdog.reactnative.BillDogAnalyticsModule
+import io.billdog.reactnative.BillDogABTestModule
+import io.billdog.reactnative.BillDogSurveyModule
+import io.billdog.reactnative.BillDogVirtualCurrencyModule
+import io.billdog.reactnative.BillDogPaywallViewManager
+
+/**
+ * ReactPackage for @billdog.io/react-native (Android).
+ *
+ * Thin-bridge architecture: the modules and view managers registered here delegate to
+ * the native BillDog Android SDK (io.billdog:billdog-core / billdog-compose) rather than
+ * reimplementing logic in JS.
+ *
+ * Phase 0 (this commit): module skeleton so autolinking resolves and the package compiles.
+ * Phase 2 registers the real native modules and the paywall view manager below.
+ */
+class BillDogVirtualCurrencyPackage : ReactPackage {
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        // Thin-bridge native modules — each delegates to the native BillDog Android SDK,
+        // except BillDogVirtualCurrency which is a self-contained HTTP bridge mirroring
+        // the iOS BillDogVirtualCurrencyBridge.swift 1:1 (iOS/Android RN parity).
+        return listOf(
+            BillDogModule(reactContext),                 // NativeModules.BillDog (core, 41 methods)
+            BillDogAnalyticsModule(reactContext),        // NativeModules.BillDogAnalytics
+            BillDogABTestModule(reactContext),           // NativeModules.BillDogABTest
+            BillDogSurveyModule(reactContext),           // NativeModules.BillDogSurvey
+            BillDogVirtualCurrencyModule(reactContext),  // NativeModules.BillDogVirtualCurrency
+        )
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        // BDPaywallView — SimpleViewManager<FrameLayout> hosting a ComposeView +
+        // PaywallScreen(config) for inline (embedded) native paywalls.
+        return listOf(BillDogPaywallViewManager())
+    }
+}

package/dist/AdvancedPaywallCache.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Phase 4: Advanced Caching Features for React Native
+ * - Cache compression (reduce storage by 60%)
+ * - Multi-level caching (memory + disk)
+ * - Intelligent prefetching
+ * - Analytics tracking
+ */
+export interface AdvancedCacheConfig {
+    enabled: boolean;
+    maxCacheAge: number;
+    compressionEnabled: boolean;
+    memoryCache: boolean;
+    maxMemoryEntries: number;
+    intelligentPrefetch: boolean;
+    analyticsEnabled: boolean;
+}
+export declare const DEFAULT_ADVANCED_CONFIG: AdvancedCacheConfig;
+interface CacheAnalytics {
+    hits: number;
+    misses: number;
+    memoryHits: number;
+    diskHits: number;
+    compressionSavings: number;
+    averageRetrievalTime: number;
+    prefetchSuccessRate: number;
+}
+interface CachedPaywall {
+    paywall: any;
+    version: number;
+    cachedAt: number;
+    expiresAt: number;
+    etag?: string;
+}
+export declare class AdvancedPaywallCache {
+    private config;
+    private cacheDir;
+    private memoryCache;
+    private accessPatterns;
+    private analytics;
+    constructor(config?: Partial<AdvancedCacheConfig>);
+    private compressData;
+    private decompressData;
+    get(identifier: string): Promise<CachedPaywall | null>;
+    private getDiskCached;
+    set(identifier: string, paywall: CachedPaywall): Promise<void>;
+    private addToMemoryCache;
+    private findLeastRecentlyUsed;
+    private trackAccess;
+    private schedulePrefetch;
+    learnRelationship(fromId: string, toId: string): void;
+    private updateAverageRetrievalTime;
+    private saveAnalytics;
+    private loadAnalytics;
+    getAnalytics(): CacheAnalytics & {
+        hitRate: number;
+        memoryHitRate: number;
+        memorySize: number;
+    };
+    resetAnalytics(): void;
+    private saveAccessPatterns;
+    private loadAccessPatterns;
+    delete(identifier: string): Promise<void>;
+    clearAll(): Promise<void>;
+    getStats(): Promise<{
+        paywallCount: number;
+        memoryCount: number;
+        compressionSavings: number;
+    }>;
+}
+export {};