@dashx/react-native 1.2.0 → 1.3.1

package/android/src/test/java/com/dashx/rn/sdk/util/UtilsTest.kt

@@ -0,0 +1,305 @@
+package com.dashx.rn.sdk.util
+
+import com.facebook.react.bridge.JavaOnlyArray
+import com.facebook.react.bridge.JavaOnlyMap
+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 kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.add
+import kotlinx.serialization.json.boolean
+import kotlinx.serialization.json.buildJsonArray
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.double
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.put
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+/**
+ * Pure-JVM unit tests for the conversion helpers in [Utils.kt]. Swaps
+ * [WritableFactory] over to `JavaOnlyMap` / `JavaOnlyArray` in [setUp] so
+ * the JNI-backed `WritableNative*` constructors don't execute — those need
+ * the Android runtime and would crash a plain JUnit run.
+ *
+ * `JavaOnlyMap` / `JavaOnlyArray` are pure-Java RN-provided stand-ins that
+ * implement the full `WritableMap` / `WritableArray` contracts, so their
+ * `.get*` accessors let the assertions inspect everything the helpers wrote.
+ */
+class UtilsTest {
+
+    @Before
+    fun setUp() {
+        WritableFactory.createMap = { JavaOnlyMap() }
+        WritableFactory.createArray = { JavaOnlyArray() }
+    }
+
+    @After
+    fun tearDown() {
+        // Not strictly necessary (tests don't share state with prod) but keeps
+        // the invariant clear: the object factory is production-pointed at
+        // rest, test-pointed only inside a test method.
+        WritableFactory.createMap = { error("WritableNativeMap not available in JVM tests") }
+        WritableFactory.createArray = { error("WritableNativeArray not available in JVM tests") }
+    }
+
+    // ---------------------------------------------------------------------
+    // convertMapToJson: ReadableMap → kotlinx JsonObject
+    // ---------------------------------------------------------------------
+
+    @Test
+    fun convertMapToJson_returnsNullForNullInput() {
+        assertNull(convertMapToJson(null))
+    }
+
+    @Test
+    fun convertMapToJson_emptyMapProducesEmptyJsonObject() {
+        val json = convertMapToJson(JavaOnlyMap())
+        assertEquals(0, json!!.size)
+    }
+
+    @Test
+    fun convertMapToJson_primitives() {
+        val input = JavaOnlyMap().apply {
+            putBoolean("flag", true)
+            putDouble("n", 3.14)
+            putString("s", "hello")
+            putNull("nothing")
+        }
+
+        val json = convertMapToJson(input)!!
+
+        assertEquals(true, json["flag"]!!.jsonPrimitive.boolean)
+        assertEquals(3.14, json["n"]!!.jsonPrimitive.double, 0.0)
+        assertEquals("hello", json["s"]!!.jsonPrimitive.content)
+        assertTrue(
+            "null RN value should land as JsonNull",
+            json["nothing"] is JsonNull
+        )
+    }
+
+    @Test
+    fun convertMapToJson_nestedMap() {
+        val inner = JavaOnlyMap().apply { putString("k", "v") }
+        val input = JavaOnlyMap().apply { putMap("child", inner) }
+
+        val json = convertMapToJson(input)!!
+        val childJson = json["child"]!!.jsonObject
+
+        assertEquals("v", childJson["k"]!!.jsonPrimitive.content)
+    }
+
+    @Test
+    fun convertMapToJson_nestedArray() {
+        val inner = JavaOnlyArray().apply {
+            pushString("a")
+            pushDouble(1.0)
+        }
+        val input = JavaOnlyMap().apply { putArray("xs", inner) }
+
+        val json = convertMapToJson(input)!!
+        val arr = json["xs"]!!.jsonArray
+
+        assertEquals(2, arr.size)
+        assertEquals("a", arr[0].jsonPrimitive.content)
+        assertEquals(1.0, arr[1].jsonPrimitive.double, 0.0)
+    }
+
+    // ---------------------------------------------------------------------
+    // convertArrayToJson: ReadableArray → kotlinx JsonArray
+    // ---------------------------------------------------------------------
+
+    @Test
+    fun convertArrayToJson_returnsNullForNullInput() {
+        assertNull(convertArrayToJson(null))
+    }
+
+    @Test
+    fun convertArrayToJson_mixedPrimitives() {
+        val input = JavaOnlyArray().apply {
+            pushBoolean(false)
+            pushDouble(42.0)
+            pushString("foo")
+            pushNull()
+        }
+
+        val arr = convertArrayToJson(input)!!
+
+        assertEquals(4, arr.size)
+        assertFalse(arr[0].jsonPrimitive.boolean)
+        assertEquals(42.0, arr[1].jsonPrimitive.double, 0.0)
+        assertEquals("foo", arr[2].jsonPrimitive.content)
+        assertTrue(arr[3] is JsonNull)
+    }
+
+    // ---------------------------------------------------------------------
+    // convertReadableArrayToKJsonList: ReadableArray[ReadableMap] → List<JsonObject>
+    // ---------------------------------------------------------------------
+
+    @Test
+    fun convertReadableArrayToKJsonList_filtersNonMapEntries() {
+        val input = JavaOnlyArray().apply {
+            pushMap(JavaOnlyMap().apply { putString("a", "1") })
+            pushString("not-a-map")
+            pushMap(JavaOnlyMap().apply { putString("b", "2") })
+        }
+
+        val list = convertReadableArrayToKJsonList(input)!!
+
+        assertEquals(2, list.size)
+        assertEquals("1", list[0]["a"]!!.jsonPrimitive.content)
+        assertEquals("2", list[1]["b"]!!.jsonPrimitive.content)
+    }
+
+    @Test
+    fun convertReadableArrayToKJsonList_returnsNullForEmpty() {
+        assertNull(convertReadableArrayToKJsonList(null))
+        assertNull(convertReadableArrayToKJsonList(JavaOnlyArray()))
+    }
+
+    // ---------------------------------------------------------------------
+    // convertJsonToMap: kotlinx JsonObject → WritableMap
+    // ---------------------------------------------------------------------
+
+    @Test
+    fun convertJsonToMap_returnsNullForNullInput() {
+        assertNull(convertJsonToMap(null))
+    }
+
+    @Test
+    fun convertJsonToMap_primitives() {
+        val input = buildJsonObject {
+            put("flag", true)
+            put("n", 3.14)
+            put("s", "hello")
+            put("nothing", JsonNull)
+        }
+
+        val map = convertJsonToMap(input) as JavaOnlyMap
+
+        assertEquals(true, map.getBoolean("flag"))
+        assertEquals(3.14, map.getDouble("n"), 0.0)
+        assertEquals("hello", map.getString("s"))
+        assertTrue(
+            "JsonNull should land as RN null",
+            map.isNull("nothing")
+        )
+    }
+
+    @Test
+    fun convertJsonToMap_nestedObject() {
+        val input = buildJsonObject {
+            put("outer", buildJsonObject {
+                put("inner", "deep")
+            })
+        }
+
+        val map = convertJsonToMap(input) as JavaOnlyMap
+        val inner = map.getMap("outer") as JavaOnlyMap
+
+        assertEquals("deep", inner.getString("inner"))
+    }
+
+    @Test
+    fun convertJsonToMap_nestedArray() {
+        val input = buildJsonObject {
+            put("xs", buildJsonArray {
+                add("a")
+                add(1.0)
+                add(JsonNull)
+            })
+        }
+
+        val map = convertJsonToMap(input) as JavaOnlyMap
+        val arr = map.getArray("xs") as JavaOnlyArray
+
+        assertEquals(3, arr.size())
+        assertEquals("a", arr.getString(0))
+        assertEquals(1.0, arr.getDouble(1), 0.0)
+        assertTrue(arr.isNull(2))
+    }
+
+    // ---------------------------------------------------------------------
+    // Round-trip: ReadableMap → JsonObject → WritableMap
+    // ---------------------------------------------------------------------
+
+    @Test
+    fun roundTrip_preservesEverything() {
+        val input = JavaOnlyMap().apply {
+            putString("str", "hello")
+            putDouble("num", 12.5)
+            putBoolean("bool", true)
+            putNull("nil")
+            putMap(
+                "nested",
+                JavaOnlyMap().apply { putString("k", "v") }
+            )
+            putArray(
+                "arr",
+                JavaOnlyArray().apply {
+                    pushString("a")
+                    pushDouble(1.0)
+                }
+            )
+        }
+
+        val json = convertMapToJson(input)!!
+        val roundTripped = convertJsonToMap(json) as JavaOnlyMap
+
+        assertEquals("hello", roundTripped.getString("str"))
+        assertEquals(12.5, roundTripped.getDouble("num"), 0.0)
+        assertEquals(true, roundTripped.getBoolean("bool"))
+        assertTrue(roundTripped.isNull("nil"))
+        assertEquals("v", (roundTripped.getMap("nested") as JavaOnlyMap).getString("k"))
+        val arr = roundTripped.getArray("arr") as JavaOnlyArray
+        assertEquals("a", arr.getString(0))
+        assertEquals(1.0, arr.getDouble(1), 0.0)
+    }
+
+    // ---------------------------------------------------------------------
+    // Regression: pre-migration crashes
+    // ---------------------------------------------------------------------
+
+    /**
+     * The Gson-based `convertJsonToMap` crashed on JSON nulls because
+     * `value.asJsonPrimitive.isBoolean` throws when `value is JsonNull`.
+     * The kotlinx rewrite explicitly branches `is JsonNull` → `putNull(key)`.
+     */
+    @Test
+    fun convertJsonToMap_doesNotCrashOnNestedJsonNull() {
+        val input = buildJsonObject {
+            put("outer", buildJsonObject {
+                put("inner", JsonNull)
+            })
+        }
+
+        val map = convertJsonToMap(input) as JavaOnlyMap
+        val nested = map.getMap("outer") as JavaOnlyMap
+        assertTrue(nested.isNull("inner"))
+    }
+
+    /**
+     * Pre-migration `saveStoredPreferences` NPE'd on a null preferenceData
+     * because `MapUtil.toJSONElement(null).toString()` dereferenced null.
+     * The new path is `convertMapToJson(null) ?: buildJsonObject {}` which
+     * can't NPE — null input returns a null `JsonObject?`, caller
+     * substitutes an empty object.
+     */
+    @Test
+    fun convertMapToJson_nullInputIsSafe() {
+        val fallback: JsonObject = convertMapToJson(null) ?: buildJsonObject { }
+        assertEquals(0, fallback.size)
+    }
+}

package/index.d.ts

@@ -74,6 +74,12 @@ export type NavigationAction =
   | { type: 'richLanding'; url: string }
   | { type: 'clickAction'; action: string };
 
+export interface NotificationClickedEvent {
+  notification: NotificationMessage;
+  action: NavigationAction | null;
+  actionIdentifier: string;
+}
+
 export interface ProcessURLOptions {
   source?: string;
   forwardToLinkHandler?: boolean;
@@ -92,9 +98,11 @@ export interface DashXInstance {
   identify(options: IdentifyOptions): void;
 
   /**
-   * Set user identity using a UID and authentication token.
+   * Set user identity using a UID and authentication token. Both are
+   * nullable — passing `null` clears that field on the native SDK. Empty
+   * strings are forwarded as-is (no coercion to `null`).
    */
-  setIdentity(uid: string, token?: string | null): void;
+  setIdentity(uid: string | null, token?: string | null): void;
 
   /**
    * Clear the current user identity and reset SDK state.
@@ -224,6 +232,18 @@ export interface DashXInstance {
    * Returns a subscription that can be removed via `.remove()`.
    */
   onLinkReceived(callback: (url: string) => void): EmitterSubscription;
+
+  /**
+   * Register a listener for notification tap events. Fired when the user taps
+   * a DashX notification or one of its action buttons. The callback receives
+   * the full notification payload, the resolved `NavigationAction` (parsed
+   * from the payload; `null` if no navigation intent could be resolved), and
+   * the raw `actionIdentifier` from `UNNotificationResponse`.
+   * Returns a subscription that can be removed via `.remove()`.
+   */
+  onNotificationClicked(
+    callback: (event: NotificationClickedEvent) => void
+  ): EmitterSubscription;
 }
 
 declare const DashX: DashXInstance;

package/index.js

@@ -58,12 +58,16 @@ const DashX = {
   },
 
   setIdentity(uid, token) {
-    if (!uid || typeof uid !== 'string') {
-      throw new Error(
-        'DashX.setIdentity: uid is required and must be a string'
-      );
+    // Both uid and token are nullable passthroughs to the native SDK. Only
+    // validate TYPE here — the native side decides semantics. `undefined` is
+    // normalized to `null` because the RN bridge can't carry undefined.
+    if (uid !== null && uid !== undefined && typeof uid !== 'string') {
+      throw new Error('DashX.setIdentity: uid must be a string or null');
+    }
+    if (token !== null && token !== undefined && typeof token !== 'string') {
+      throw new Error('DashX.setIdentity: token must be a string or null');
     }
-    return getNativeDashX().setIdentity(uid, token || null);
+    return getNativeDashX().setIdentity(uid ?? null, token ?? null);
   },
 
   reset() {
@@ -214,6 +218,15 @@ const DashX = {
     }
     return getEventEmitter().addListener('linkReceived', callback);
   },
+
+  onNotificationClicked(callback) {
+    if (typeof callback !== 'function') {
+      throw new Error(
+        'DashX.onNotificationClicked: callback must be a function'
+      );
+    }
+    return getEventEmitter().addListener('notificationClicked', callback);
+  },
 };
 
 export default DashX;

package/ios/DashXNotificationHandler.swift

@@ -2,9 +2,7 @@ import Foundation
 import UIKit
 import UserNotifications
 import DashX
-#if canImport(FirebaseMessaging)
 import FirebaseMessaging
-#endif
 
 /// The result of handling a notification response.
 /// Consumers can use `url` to navigate and `actionIdentifier` for custom action handling.
@@ -14,11 +12,15 @@ public final class DashXNotificationResponseResult: NSObject {
     @objc public let actionIdentifier: String
     /// The DashX notification URL, if present in the payload.
     @objc public let url: URL?
+    /// The resolved navigation intent for the tap / action button.
+    /// Non-@objc (the enum isn't representable in Obj-C); read via Swift.
+    public let navigationAction: NavigationAction?
 
-    init(userInfo: [AnyHashable: Any], actionIdentifier: String, url: URL?) {
+    init(userInfo: [AnyHashable: Any], actionIdentifier: String, url: URL?, navigationAction: NavigationAction?) {
         self.userInfo = userInfo
         self.actionIdentifier = actionIdentifier
         self.url = url
+        self.navigationAction = navigationAction
     }
 }
 
@@ -30,9 +32,7 @@ public final class DashXNotificationHandler: NSObject {
         userInfo: [AnyHashable: Any],
         completionHandler: @escaping (UIBackgroundFetchResult) -> Void
     ) {
-        #if canImport(FirebaseMessaging)
         Messaging.messaging().appDidReceiveMessage(userInfo)
-        #endif
 
         DashXEventEmitter.instance.dispatch(
             name: "messageReceived",
@@ -88,9 +88,7 @@ public final class DashXNotificationHandler: NSObject {
     public static func handleNotificationResponse(_ response: UNNotificationResponse) -> DashXNotificationResponseResult {
         let userInfo = response.notification.request.content.userInfo
 
-        #if canImport(FirebaseMessaging)
         Messaging.messaging().appDidReceiveMessage(userInfo)
-        #endif
 
         DashXEventEmitter.instance.dispatch(
             name: "messageReceived",
@@ -104,11 +102,25 @@ public final class DashXNotificationHandler: NSObject {
         }
 
         let notificationUrl = userInfo.dashxNotificationUrl()
+        let dashxData = userInfo.dashxNotificationData()
+        let navigationAction = dashxData?.navigationAction(forActionIdentifier: response.actionIdentifier)
+
+        if response.actionIdentifier != UNNotificationDismissActionIdentifier {
+            DashXEventEmitter.instance.dispatch(
+                name: "notificationClicked",
+                body: [
+                    "notification": bridgeSafePayload(from: userInfo),
+                    "action": jsonDictionary(from: navigationAction) ?? NSNull(),
+                    "actionIdentifier": response.actionIdentifier,
+                ]
+            )
+        }
 
         return DashXNotificationResponseResult(
             userInfo: userInfo,
             actionIdentifier: response.actionIdentifier,
-            url: notificationUrl
+            url: notificationUrl,
+            navigationAction: navigationAction
         )
     }
 
@@ -119,14 +131,21 @@ public final class DashXNotificationHandler: NSObject {
     /// `application(_:didRegisterForRemoteNotificationsWithDeviceToken:)`.
     @objc
     public static func handleDeviceToken(_ deviceToken: Data) {
-        #if canImport(FirebaseMessaging)
-        Messaging.messaging().setAPNSToken(deviceToken, type: .unknown)
+        // Force the APNs environment explicitly rather than using `.unknown`
+        // (auto-detect). Firebase's auto-detection reads the token's aps
+        // entitlement from the signed binary and sometimes mis-tags dev
+        // builds as production, producing an FCM token whose pushes silently
+        // fail at APNs with 410 Unregistered.
+        #if DEBUG
+        Messaging.messaging().setAPNSToken(deviceToken, type: .sandbox)
+        #else
+        Messaging.messaging().setAPNSToken(deviceToken, type: .prod)
+        #endif
         Messaging.messaging().token { token, error in
             if let token = token {
                 DashX.setFCMToken(to: token)
             }
         }
-        #endif
     }
 
     // MARK: - Foreground Notification
@@ -142,9 +161,7 @@ public final class DashXNotificationHandler: NSObject {
     ) {
         let userInfo = notification.request.content.userInfo
 
-        #if canImport(FirebaseMessaging)
         Messaging.messaging().appDidReceiveMessage(userInfo)
-        #endif
 
         DashX.trackMessage(message: userInfo, event: .delivered)
 
@@ -197,6 +214,24 @@ public final class DashXNotificationHandler: NSObject {
         task.resume()
     }
 
+    /// Serializes a ``NavigationAction`` into the JS-bridge shape mirrored by
+    /// `NavigationAction` in `index.d.ts`. Returns `nil` for `nil` input.
+    private static func jsonDictionary(from action: NavigationAction?) -> [String: Any]? {
+        guard let action else { return nil }
+        switch action {
+        case .deepLink(let url):
+            return ["type": "deepLink", "url": url.absoluteString]
+        case .screen(let name, let data):
+            var dict: [String: Any] = ["type": "screen", "name": name]
+            if let data { dict["data"] = data }
+            return dict
+        case .richLanding(let url):
+            return ["type": "richLanding", "url": url.absoluteString]
+        case .clickAction(let actionString):
+            return ["type": "clickAction", "action": actionString]
+        }
+    }
+
     private static func bridgeSafePayload(from userInfo: [AnyHashable: Any]) -> [String: Any] {
         userInfo.reduce(into: [String: Any]()) { result, pair in
             let key = String(describing: pair.key)

package/ios/DashXReactNative.swift

@@ -16,7 +16,7 @@ class DashXReactNative: RCTEventEmitter {
     }
 
     override func supportedEvents() -> [String] {
-        return ["messageReceived", "linkReceived"]
+        return ["messageReceived", "linkReceived", "notificationClicked"]
     }
 
     @objc(configure:)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dashx/react-native",
   "title": "DashX React Native",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "DashX SDK for React Native",
   "main": "index.js",
   "types": "index.d.ts",

package/android/build/.transforms/4be36c77bb64b99c240b0e4ea43b1314/results.bin

@@ -1 +0,0 @@
-o/bundleLibRuntimeToDirRelease

package/android/build/.transforms/cbfb6e2ce23b1b241042f41368f14b56/results.bin

@@ -1 +0,0 @@
-o/bundleLibRuntimeToDirRelease

package/android/build/.transforms/f3c6049e7ab4bb564c79f3a246b8575e/results.bin

@@ -1 +0,0 @@
-o/classes

package/android/build/.transforms/febf729dca33feaeadd8434490b5ecc4/results.bin

@@ -1 +0,0 @@
-o/classes