@dashx/react-native 1.1.0 → 1.1.2

package/android/src/main/java/com/dashx/rn/sdk/DashXReactNativeFirebaseMessagingService.kt

@@ -0,0 +1,72 @@
+package com.dashx.rn.sdk
+
+import com.dashx.android.DashXFirebaseMessagingService
+import com.dashx.android.DashXLog
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.firebase.messaging.RemoteMessage
+
+/**
+ * Extends dashx-android's FCM service to also emit "messageReceived" to the React Native JS layer
+ * so that DashX.onMessageReceived() callbacks receive push notifications.
+ */
+class DashXReactNativeFirebaseMessagingService : DashXFirebaseMessagingService() {
+
+    private val tag = DashXReactNativeFirebaseMessagingService::class.java.simpleName
+
+    override fun onMessageReceived(remoteMessage: RemoteMessage) {
+        // Preserve dashx-android behavior (notification display + tracking)
+        super.onMessageReceived(remoteMessage)
+
+        val context = MessageReceivedEventHolder.reactContext ?: run {
+            DashXLog.d(tag, "React context not available, skipping JS emit")
+            return
+        }
+
+        if (!context.hasActiveReactInstance()) {
+            DashXLog.d(tag, "No active React instance, skipping JS emit")
+            return
+        }
+
+        val payload = remoteMessageToWritableMap(remoteMessage)
+        context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("messageReceived", payload)
+    }
+
+    private fun remoteMessageToWritableMap(remoteMessage: RemoteMessage): WritableMap {
+        val map = Arguments.createMap()
+
+        // Data payload (always present as Map<String, String>)
+        remoteMessage.data.let { data ->
+            if (!data.isNullOrEmpty()) {
+                val dataMap = Arguments.createMap()
+                for ((key, value) in data) {
+                    dataMap.putString(key, value)
+                }
+                map.putMap("data", dataMap)
+            }
+        }
+
+        // Notification payload (if present)
+        remoteMessage.notification?.let { notification ->
+            val notifMap = Arguments.createMap()
+            notification.title?.let { notifMap.putString("title", it) }
+            notification.body?.let { notifMap.putString("body", it) }
+            notification.bodyLocalizationKey?.let { notifMap.putString("bodyLocalizationKey", it) }
+            notification.titleLocalizationKey?.let { notifMap.putString("titleLocalizationKey", it) }
+            notification.channelId?.let { notifMap.putString("channelId", it) }
+            notification.clickAction?.let { notifMap.putString("clickAction", it) }
+            notification.tag?.let { notifMap.putString("tag", it) }
+            notification.imageUrl?.toString()?.let { notifMap.putString("imageUrl", it) }
+            map.putMap("notification", notifMap)
+        }
+
+        remoteMessage.messageId?.let { map.putString("messageId", it) }
+        remoteMessage.senderId?.let { map.putString("senderId", it) }
+        remoteMessage.from?.let { map.putString("from", it) }
+
+        return map
+    }
+}

package/android/src/main/java/com/dashx/rn/sdk/DashXReactNativeModule.kt

@@ -1,6 +1,5 @@
 package com.dashx.rn.sdk
 
-import android.net.Uri
 import com.dashx.rn.sdk.util.*
 import com.dashx.android.DashX
 import com.dashx.android.DashXLog
@@ -14,6 +13,16 @@ import kotlinx.serialization.json.JsonObject
 class DashXReactNativeModule(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
     private val tag = DashXReactNativeModule::class.java.simpleName
 
+    override fun initialize() {
+        super.initialize()
+        MessageReceivedEventHolder.reactContext = reactContext
+    }
+
+    override fun invalidate() {
+        MessageReceivedEventHolder.reactContext = null
+        super.invalidate()
+    }
+
     override fun getName(): String {
         return "DashXReactNative"
     }
@@ -37,7 +46,9 @@ class DashXReactNativeModule(private val reactContext: ReactApplicationContext)
     @ReactMethod
     fun identify(options: ReadableMap?) {
         val optionsHashMap = options?.toHashMap()
-        DashX.identify(optionsHashMap as HashMap<String, String>?)
+            ?.filterValues { it != null }
+            ?.mapValues { it.value.toString() }
+        DashX.identify(optionsHashMap?.let { HashMap(it) })
     }
 
     @ReactMethod
@@ -53,7 +64,10 @@ class DashXReactNativeModule(private val reactContext: ReactApplicationContext)
     @ReactMethod
     fun track(event: String, data: ReadableMap?) {
         val jsonData = try {
-            data?.toHashMap() as HashMap<String, String>?
+            data?.toHashMap()
+                ?.filterValues { it != null }
+                ?.mapValues { it.value.toString() }
+                ?.let { HashMap(it) }
         } catch (e: Exception) {
             DashXLog.d(tag, e.message)
             return
@@ -64,15 +78,47 @@ class DashXReactNativeModule(private val reactContext: ReactApplicationContext)
 
     @ReactMethod
     fun screen(screenName: String, data: ReadableMap?) {
-        DashX.screen(screenName, data?.toHashMap() as HashMap<String, String>)
+        val screenData = data?.toHashMap()
+            ?.filterValues { it != null }
+            ?.mapValues { it.value.toString() }
+            ?.let { HashMap(it) }
+            ?: HashMap()
+        DashX.screen(screenName, screenData)
     }
 
     @ReactMethod
-    fun fetchContent(urn: String, options: ReadableMap?, promise: Promise) {
+    fun fetchRecord(urn: String, options: ReadableMap?, promise: Promise) {
+        val preview = options?.getBooleanIfPresent("preview")
+        val language = options?.getStringIfPresent("language")
+        val fields = try {
+            convertReadableArrayToKJsonList(options?.getArray("fields"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject("EUNSPECIFIED", "Error parsing fields: ${e.message}")
+            return
+        }
+        val include = try {
+            convertReadableArrayToKJsonList(options?.getArray("include"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject("EUNSPECIFIED", "Error parsing include: ${e.message}")
+            return
+        }
+        val exclude = try {
+            convertReadableArrayToKJsonList(options?.getArray("exclude"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject("EUNSPECIFIED", "Error parsing exclude: ${e.message}")
+            return
+        }
+
         DashX.fetchRecord(
-            urn,
-            options?.getBooleanIfPresent("preview"),
-            options?.getStringIfPresent("language"),
+            urn = urn,
+            preview = preview,
+            language = language,
+            fields = fields,
+            include = include,
+            exclude = exclude,
             onError = {
                 promise.reject("EUNSPECIFIED", it.message)
             },
@@ -83,30 +129,62 @@ class DashXReactNativeModule(private val reactContext: ReactApplicationContext)
     }
 
     @ReactMethod
-    fun searchContent(contentType: String, options: ReadableMap?, promise: Promise) {
+    fun searchRecords(resource: String, options: ReadableMap?, promise: Promise) {
         val jsonFilter = try {
-            convertMapToJson(options?.getMap("filter"))
+            convertMapToJson(options?.getMap("filter"))?.let { convertJsonToKJson(it) }
         } catch (e: Exception) {
             DashXLog.d(tag, e.message)
-            throw Exception("Encountered an error while parsing filter")
+            promise.reject("EUNSPECIFIED", "Error parsing filter: ${e.message}")
+            return
         }
-
-        val jsonOrder = try {
-            convertMapToJson(options?.getMap("order"))
+        val order = try {
+            convertReadableArrayToKJsonList(options?.getArray("order"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject("EUNSPECIFIED", "Error parsing order: ${e.message}")
+            return
+        }
+        val limit = options?.getIntIfPresent("limit")
+        val preview = options?.getBooleanIfPresent("preview")
+        val language = options?.getStringIfPresent("language")
+        val fields = try {
+            convertReadableArrayToKJsonList(options?.getArray("fields"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject("EUNSPECIFIED", "Error parsing fields: ${e.message}")
+            return
+        }
+        val include = try {
+            convertReadableArrayToKJsonList(options?.getArray("include"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject("EUNSPECIFIED", "Error parsing include: ${e.message}")
+            return
+        }
+        val exclude = try {
+            convertReadableArrayToKJsonList(options?.getArray("exclude"))
         } catch (e: Exception) {
             DashXLog.d(tag, e.message)
-            throw Exception("Encountered an error while parsing order")
+            promise.reject("EUNSPECIFIED", "Error parsing exclude: ${e.message}")
+            return
         }
 
         DashX.searchRecords(
-            contentType,
-            convertJsonToKJson(jsonFilter),
+            resource = resource,
+            filter = jsonFilter,
+            order = order,
+            limit = limit,
+            preview = preview,
+            language = language,
+            fields = fields,
+            include = include,
+            exclude = exclude,
             onError = {
                 promise.reject("EUNSPECIFIED", it.message)
             },
-            onSuccess = { content ->
+            onSuccess = { records ->
                 val readableArray = Arguments.createArray()
-                content.forEach {
+                records.forEach {
                     readableArray.pushMap(convertJsonToMap(convertKJsonToJson(it)))
                 }
                 promise.resolve(readableArray)

package/android/src/main/java/com/dashx/rn/sdk/MessageReceivedEventHolder.kt

@@ -0,0 +1,14 @@
+package com.dashx.rn.sdk
+
+import com.facebook.react.bridge.ReactApplicationContext
+
+/**
+ * Holds a reference to the React context so that [DashXReactNativeFirebaseMessagingService]
+ * can emit "messageReceived" events to JS when FCM messages arrive.
+ * Set by [DashXReactNativeModule], cleared when the module is invalidated.
+ */
+object MessageReceivedEventHolder {
+    @Volatile
+    var reactContext: ReactApplicationContext? = null
+        internal set
+}

package/android/src/main/java/com/dashx/rn/sdk/ReactNativeLibraryInfoProvider.kt

@@ -0,0 +1,8 @@
+package com.dashx.rn.sdk
+
+import com.dashx.android.DashXLibraryInfoProvider
+
+class ReactNativeLibraryInfoProvider : DashXLibraryInfoProvider {
+    override val name = "@dashx/react-native"
+    override val version: String = BuildConfig.VERSION_NAME
+}

package/android/src/main/java/com/dashx/rn/sdk/util/Utils.kt

@@ -26,6 +26,20 @@ fun convertJsonToKJson(jsonObject: JsonObject?): KJsonObject? {
     return Json.decodeFromString(jsonString)
 }
 
+/**
+ * Converts a ReadableArray of maps to a list of kotlinx JsonObjects for DashX.searchRecords options (order, fields, include, exclude).
+ */
+@Throws(JSONException::class)
+fun convertReadableArrayToKJsonList(readableArray: ReadableArray?): List<KJsonObject>? {
+    if (readableArray == null || readableArray.size() == 0) return null
+    return (0 until readableArray.size()).mapNotNull { i ->
+        when (readableArray.getType(i)) {
+            ReadableType.Map -> readableArray.getMap(i)?.let { convertMapToJson(it)?.let { gson -> convertJsonToKJson(gson) } }
+            else -> null
+        }
+    }.ifEmpty { null }
+}
+
 @Throws(JSONException::class)
 fun convertMapToJson(readableMap: ReadableMap?): JsonObject? {
     val iterator = readableMap?.keySetIterator() ?: return null

package/android/src/main/resources/META-INF/services/com.dashx.android.DashXLibraryInfoProvider

@@ -0,0 +1 @@
+com.dashx.rn.sdk.ReactNativeLibraryInfoProvider

package/index.d.ts

@@ -0,0 +1,129 @@
+import { EmitterSubscription } from 'react-native';
+
+export interface ConfigureOptions {
+  publicKey: string;
+  baseURI?: string;
+  targetEnvironment?: string;
+}
+
+export interface IdentifyOptions {
+  firstName?: string;
+  lastName?: string;
+  email?: string;
+  phone?: string;
+  [key: string]: string | undefined;
+}
+
+export type LogLevel = 0 | 1 | 2;
+
+export interface FetchRecordOptions {
+  preview?: boolean;
+  language?: string;
+  fields?: Record<string, unknown>[];
+  include?: Record<string, unknown>[];
+  exclude?: Record<string, unknown>[];
+}
+
+export interface SearchRecordsOptions {
+  filter?: Record<string, unknown>;
+  order?: Record<string, unknown>[];
+  limit?: number;
+  preview?: boolean;
+  language?: string;
+  fields?: Record<string, unknown>[];
+  include?: Record<string, unknown>[];
+  exclude?: Record<string, unknown>[];
+}
+
+export interface NotificationMessage {
+  [key: string]: unknown;
+}
+
+export interface DashXInstance {
+  /**
+   * Initialize the SDK with your public key and optional configuration.
+   * Call this as early as possible, e.g. in your root component.
+   */
+  configure(options: ConfigureOptions): void;
+
+  /**
+   * Identify the current user with traits such as name and email.
+   */
+  identify(options: IdentifyOptions): void;
+
+  /**
+   * Set user identity using a UID and authentication token.
+   */
+  setIdentity(uid: string, token: string): void;
+
+  /**
+   * Clear the current user identity and reset SDK state.
+   */
+  reset(): void;
+
+  /**
+   * Track a named event with optional metadata.
+   */
+  track(event: string, data?: Record<string, unknown>): void;
+
+  /**
+   * Track a screen view with optional metadata.
+   */
+  screen(screenName: string, data?: Record<string, unknown>): void;
+
+  /**
+   * Fetch a single record by URN (e.g. "article/123") with optional preview, language, fields, include, exclude.
+   * Returns a promise resolving to the record object.
+   */
+  fetchRecord(
+    urn: string,
+    options?: FetchRecordOptions
+  ): Promise<Record<string, unknown>>;
+
+  /**
+   * Search records by resource with optional filter, order, limit, preview, language, fields, include, exclude.
+   * Returns a promise resolving to an array of record objects.
+   */
+  searchRecords(
+    resource: string,
+    options?: SearchRecordsOptions
+  ): Promise<Record<string, unknown>[]>;
+
+  /**
+   * Subscribe the current device to push notifications.
+   */
+  subscribe(): void;
+
+  /**
+   * Unsubscribe the current device from push notifications.
+   */
+  unsubscribe(): void;
+
+  /**
+   * Fetch stored notification preferences for the current user.
+   */
+  fetchStoredPreferences(): Promise<Record<string, unknown>>;
+
+  /**
+   * Save notification preferences for the current user.
+   */
+  saveStoredPreferences(
+    data: Record<string, unknown>
+  ): Promise<Record<string, unknown>>;
+
+  /**
+   * Set SDK log verbosity. 0 = off, 1 = errors, 2 = debug.
+   */
+  setLogLevel(level: LogLevel): void;
+
+  /**
+   * Register a listener for incoming push notification messages.
+   * Returns a subscription that can be removed via `.remove()`.
+   */
+  onMessageReceived(
+    callback: (message: NotificationMessage) => void
+  ): EmitterSubscription;
+}
+
+declare const DashX: DashXInstance;
+export default DashX;

package/index.js

@@ -1,78 +1,139 @@
-import { NativeModules, Platform } from 'react-native';
-
-const LINKING_ERROR =
-  `The package 'dashx-react-native' doesn't seem to be linked. Make sure: \n\n` +
-  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
-  '- You rebuilt the app after installing the package\n' +
-  '- You are not using Expo Go\n';
-
-const DashX = NativeModules.DashXReactNative
-  ? NativeModules.DashXReactNative
-  : new Proxy(
-    {},
-    {
-      get() {
-        throw new Error(LINKING_ERROR);
-      },
-    }
+import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
+
+function getLinkingError() {
+  return (
+    `The package 'dashx-react-native' doesn't seem to be linked. Make sure: \n\n` +
+    Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+    '- You rebuilt the app after installing the package\n' +
+    '- You are not using Expo Go\n'
   );
+}
 
-const {
-  configure,
-  identify,
-  setIdentity,
-  reset,
-  track,
-  screen,
-  fetchStoredPreferences,
-  saveStoredPreferences,
-  subscribe,
-  unsubscribe,
-  setLogLevel,
-} = DashX;
-
-DashX.configure = (options) => {
-  return configure(options);
+let _nativeDashX = null;
+function getNativeDashX() {
+  if (!_nativeDashX) {
+    _nativeDashX = NativeModules.DashXReactNative
+      ? NativeModules.DashXReactNative
+      : new Proxy(
+          {},
+          {
+            get() {
+              throw new Error(getLinkingError());
+            },
+          }
+        );
+  }
+  return _nativeDashX;
 }
 
-DashX.identify = (options) => {
-  return identify(options);
-};
+let _eventEmitter = null;
+function getEventEmitter() {
+  if (!_eventEmitter) {
+    _eventEmitter = new NativeEventEmitter(getNativeDashX());
+  }
+  return _eventEmitter;
+}
 
-DashX.setIdentity = (uid, token) => {
-  return setIdentity(uid, token);
-};
+const DashX = {
+  configure(options) {
+    if (!options || typeof options !== 'object') {
+      throw new Error('DashX.configure: options must be an object');
+    }
+    if (!options.publicKey || typeof options.publicKey !== 'string') {
+      throw new Error('DashX.configure: publicKey is required and must be a string');
+    }
+    return getNativeDashX().configure(options);
+  },
 
-DashX.reset = () => {
-  return reset();
-}
+  identify(options) {
+    if (!options || typeof options !== 'object') {
+      throw new Error('DashX.identify: options must be an object');
+    }
+    return getNativeDashX().identify(options);
+  },
 
-DashX.track = (event, data) => {
-  return track(event, data || null);
-}
+  setIdentity(uid, token) {
+    if (!uid || typeof uid !== 'string') {
+      throw new Error('DashX.setIdentity: uid is required and must be a string');
+    }
+    if (!token || typeof token !== 'string') {
+      throw new Error('DashX.setIdentity: token is required and must be a string');
+    }
+    return getNativeDashX().setIdentity(uid, token);
+  },
 
-DashX.screen = (screenName, data) => {
-  return screen(screenName, data || null)
-}
+  reset() {
+    return getNativeDashX().reset();
+  },
 
-DashX.fetchStoredPreferences = () => {
-  return fetchStoredPreferences();
-};
+  track(event, data) {
+    if (!event || typeof event !== 'string') {
+      throw new Error('DashX.track: event is required and must be a string');
+    }
+    return getNativeDashX().track(event, data || null);
+  },
 
-DashX.saveStoredPreferences = (preferenceData) => {
-  return saveStoredPreferences(preferenceData);
-};
+  screen(screenName, data) {
+    if (!screenName || typeof screenName !== 'string') {
+      throw new Error('DashX.screen: screenName is required and must be a string');
+    }
+    return getNativeDashX().screen(screenName, data || null);
+  },
 
-DashX.subscribe = () => {
-  return subscribe();
-}
+  fetchRecord(urn, options = {}) {
+    if (!urn || typeof urn !== 'string') {
+      throw new Error('DashX.fetchRecord: urn is required and must be a string (e.g. "article/123")');
+    }
+    if (options !== null && typeof options !== 'object') {
+      throw new Error('DashX.fetchRecord: options must be an object');
+    }
+    return getNativeDashX().fetchRecord(urn, options || null);
+  },
 
-DashX.unsubscribe = () => {
-  return unsubscribe();
-}
+  searchRecords(resource, options = {}) {
+    if (!resource || typeof resource !== 'string') {
+      throw new Error('DashX.searchRecords: resource is required and must be a string');
+    }
+    if (options !== null && typeof options !== 'object') {
+      throw new Error('DashX.searchRecords: options must be an object');
+    }
+    return getNativeDashX().searchRecords(resource, options || null);
+  },
 
-DashX.setLogLevel = (level) => {
-  return setLogLevel(level);
-}
+  fetchStoredPreferences() {
+    return getNativeDashX().fetchStoredPreferences();
+  },
+
+  saveStoredPreferences(preferenceData) {
+    if (!preferenceData || typeof preferenceData !== 'object') {
+      throw new Error(
+        'DashX.saveStoredPreferences: preferenceData is required and must be an object'
+      );
+    }
+    return getNativeDashX().saveStoredPreferences(preferenceData);
+  },
+
+  subscribe() {
+    return getNativeDashX().subscribe();
+  },
+
+  unsubscribe() {
+    return getNativeDashX().unsubscribe();
+  },
+
+  setLogLevel(level) {
+    if (typeof level !== 'number') {
+      throw new Error('DashX.setLogLevel: level must be a number');
+    }
+    return getNativeDashX().setLogLevel(level);
+  },
+
+  onMessageReceived(callback) {
+    if (typeof callback !== 'function') {
+      throw new Error('DashX.onMessageReceived: callback must be a function');
+    }
+    return getEventEmitter().addListener('messageReceived', callback);
+  },
+};
 
 export default DashX;

package/ios/DashXEventEmitter.swift

@@ -1,6 +1,6 @@
 class DashXEventEmitter {
     static let instance = DashXEventEmitter()
-    private static var eventEmitter: DashXReactNative!
+    private static var eventEmitter: DashXReactNative?
 
     private init() {}
 
@@ -9,6 +9,7 @@ class DashXEventEmitter {
     }
 
     func dispatch(name: String, body: Any?) {
-        DashXEventEmitter.eventEmitter.sendEvent(withName: name, body: body)
+        guard let emitter = DashXEventEmitter.eventEmitter else { return }
+        emitter.sendEvent(withName: name, body: body)
     }
 }