@dashx/react-native 1.1.5 → 1.2.0

package/.claude/settings.local.json

@@ -8,7 +8,24 @@
       "Bash(swift build:*)",
       "Bash(xcodebuild -scheme DashX -destination 'generic/platform=iOS' build)",
       "Bash(./gradlew :dashx:compileDebugKotlin)",
-      "Bash(./gradlew :dashx:compileDebugKotlin --info)"
+      "Bash(./gradlew :dashx:compileDebugKotlin --info)",
+      "Bash(gh pr:*)",
+      "WebFetch(domain:github.com)",
+      "WebFetch(domain:patch-diff.githubusercontent.com)",
+      "WebFetch(domain:raw.githubusercontent.com)",
+      "Bash(ls -la /Users/gulshan/Work/dashx-react-native/ios/DashXRCTAppDelegate*)",
+      "Bash(npx jest *)",
+      "Bash(ls *)",
+      "Bash(grep *)",
+      "Read(//private/tmp/**)",
+      "Bash(javap -p com/dashx/android/DashX.class)",
+      "Bash(javap -p 'com/dashx/android/DashX$Companion.class')",
+      "Bash(jar xf *)",
+      "Bash(javap 'com/dashx/android/DashX$Companion.class')",
+      "Bash(javap 'com/dashx/android/data/Asset.class')",
+      "Bash(javap 'com/dashx/android/data/AssetData.class')",
+      "Read(//Users/gulshan/Work/dashx-ios/**)",
+      "WebSearch"
     ]
   }
 }

package/.gitignore

@@ -42,5 +42,5 @@ buck-out/
 \.buckd/
 *.keystore
 
-# Cursor plans
+# Cursor
 .cursor

package/DashXReactNative.podspec

@@ -1,7 +1,6 @@
 require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
-folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
 
 Pod::Spec.new do |s|
   s.name         = "DashXReactNative"
@@ -17,30 +16,10 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m,mm,swift}"
   s.requires_arc = true
 
-  # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
-  # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
-  if respond_to?(:install_modules_dependencies, true)
-    install_modules_dependencies(s)
-  else
-    s.dependency "React-Core"
+  # React Native >= 0.71 provides install_modules_dependencies.
+  # Since our minimum supported RN version is 0.74, we can call it directly.
+  install_modules_dependencies(s)
 
-    # Don't install the dependencies when we run `pod install` in the old architecture.
-    if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
-      s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
-      s.pod_target_xcconfig    = {
-          "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
-          "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
-          "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
-      }
-      s.dependency "React-Codegen"
-      s.dependency "RCT-Folly"
-      s.dependency "RCTRequired"
-      s.dependency "RCTTypeSafety"
-      s.dependency "ReactCommon/turbomodule/core"
-    end
-  end
-
-  s.dependency "React-RCTAppDelegate"
   # DashX iOS SDK — consumers must provide the source in their Podfile:
   #   pod 'DashX', :git => 'https://github.com/dashxhq/dashx-ios.git', :tag => '1.1.9'
   # For local development:

package/README.md

@@ -26,7 +26,9 @@ _DashX SDK for React Native_
 
 ## Install
 
-Requires **React Native 0.71+**, **iOS 13.0+**, **Android SDK 26+**, and **Node.js 16+**.
+Requires **React Native 0.74+**, **iOS 13.0+**, **Android SDK 26+**, and **Node.js 16+**.
+
+Supports both the **Old Architecture** (bridge) and **New Architecture** (TurboModule) from a single install.
 
 > **Note:** This SDK uses native modules and is **not compatible with Expo Go**. Use a [development build](https://docs.expo.dev/develop/development-builds/introduction/) if you are using Expo.
 

package/__tests__/fallback.test.js

@@ -0,0 +1,72 @@
+const mockNativeModule = {
+  configure: jest.fn(),
+  identify: jest.fn(),
+  setIdentity: jest.fn(),
+  reset: jest.fn(),
+  track: jest.fn(),
+  screen: jest.fn(),
+  fetchRecord: jest.fn(),
+  searchRecords: jest.fn(),
+  fetchStoredPreferences: jest.fn(),
+  saveStoredPreferences: jest.fn(),
+  subscribe: jest.fn(),
+  unsubscribe: jest.fn(),
+  setLogLevel: jest.fn(),
+  uploadAsset: jest.fn(),
+  fetchAsset: jest.fn(),
+  enableLifecycleTracking: jest.fn(),
+  enableAdTracking: jest.fn(),
+  processURL: jest.fn(),
+  trackNotificationNavigation: jest.fn(),
+  requestNotificationPermission: jest.fn(),
+  getNotificationPermissionStatus: jest.fn(),
+  addListener: jest.fn(),
+  removeListeners: jest.fn(),
+};
+
+jest.mock('react-native', () => ({
+  NativeModules: {
+    DashXReactNative: mockNativeModule,
+  },
+  NativeEventEmitter: jest.fn().mockImplementation(() => ({
+    addListener: jest.fn(() => ({ remove: jest.fn() })),
+  })),
+  Platform: {
+    OS: 'ios',
+    select: jest.fn((obj) => obj.default || ''),
+  },
+  TurboModuleRegistry: {
+    get: jest.fn(() => null),
+    getEnforcing: jest.fn(() => {
+      throw new Error('not available');
+    }),
+  },
+}));
+
+// TurboModule returns null -> should fall back to NativeModules
+jest.mock('../src/NativeDashXReactNative', () => ({
+  __esModule: true,
+  default: null,
+}));
+
+const DashX = require('../index').default;
+
+describe('NativeModules fallback', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('falls back to NativeModules.DashXReactNative when TurboModule is null', () => {
+    DashX.configure({ publicKey: 'pk_test' });
+    expect(mockNativeModule.configure).toHaveBeenCalledWith({
+      publicKey: 'pk_test',
+    });
+  });
+
+  it('calls track on the fallback module', () => {
+    DashX.track('event_name', { key: 'value' });
+    expect(mockNativeModule.track).toHaveBeenCalledWith('event_name', {
+      key: 'value',
+    });
+  });
+});

package/__tests__/index.test.js

@@ -37,6 +37,15 @@ jest.mock('react-native', () => ({
     OS: 'ios',
     select: jest.fn((obj) => obj.default || ''),
   },
+  TurboModuleRegistry: {
+    get: jest.fn(() => mockNativeModule),
+    getEnforcing: jest.fn(() => mockNativeModule),
+  },
+}));
+
+jest.mock('../src/NativeDashXReactNative', () => ({
+  __esModule: true,
+  default: mockNativeModule,
 }));
 
 const DashX = require('../index').default;
@@ -101,10 +110,14 @@ describe('setIdentity', () => {
     expect(() => DashX.setIdentity(null, 'token')).toThrow('uid is required');
   });
 
-  it('throws if token is missing', () => {
-    expect(() => DashX.setIdentity('uid', null)).toThrow(
-      'token is required'
-    );
+  it('passes null token through to native', () => {
+    DashX.setIdentity('uid', null);
+    expect(mockNativeModule.setIdentity).toHaveBeenCalledWith('uid', null);
+  });
+
+  it('passes undefined token as null to native', () => {
+    DashX.setIdentity('uid');
+    expect(mockNativeModule.setIdentity).toHaveBeenCalledWith('uid', null);
   });
 });
 

package/android/build.gradle

@@ -3,6 +3,14 @@ import groovy.json.JsonSlurper
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 
+def isNewArchitectureEnabled() {
+    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+if (isNewArchitectureEnabled()) {
+    apply plugin: 'com.facebook.react'
+}
+
 def getVersionFromNpm() {
     def inputFile = new File("../package.json")
     def packageJson = new JsonSlurper().parseText(inputFile.text)
@@ -30,6 +38,16 @@ android {
         abortOnError false
     }
 
+    sourceSets {
+        main {
+            if (isNewArchitectureEnabled()) {
+                java.srcDirs += ['src/newarch/java']
+            } else {
+                java.srcDirs += ['src/oldarch/java']
+            }
+        }
+    }
+
     packaging {
         pickFirst 'lib/arm64-v8a/libc++_shared.so'
         pickFirst 'lib/arm64-v8a/libfbjni.so'
@@ -42,6 +60,14 @@ android {
    }
 }
 
+if (isNewArchitectureEnabled()) {
+    react {
+        jsRootDir = file("../src/")
+        libraryName = "RNDashXReactNativeSpec"
+        codegenJavaPackageName = "com.dashx.rn.sdk"
+    }
+}
+
 repositories {
     mavenCentral()
     google()
@@ -55,5 +81,5 @@ dependencies {
     // Ensure Firebase Messaging types are available for FCM service subclass
     implementation 'com.google.firebase:firebase-messaging-ktx:23.1.2'
 
-    implementation "com.dashx:dashx-android:1.2.4"
+    implementation "com.dashx:dashx-android:1.2.5"
 }

package/android/src/main/AndroidManifest.xml

@@ -1,5 +1,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
+
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
     <application>
         <!-- Replace dashx-android's FCM service with our subclass that also emits to JS. -->
         <service

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

@@ -0,0 +1,384 @@
+package com.dashx.rn.sdk
+
+import android.Manifest
+import android.app.Activity
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+import com.dashx.rn.sdk.util.*
+import com.dashx.android.DashX
+import com.dashx.android.DashXLog
+import com.dashx.android.DashXLog.LogLevel
+import com.dashx.android.data.Asset
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+
+class DashXReactNativeModuleImpl(private val reactContext: ReactApplicationContext) {
+    private val tag = DashXReactNativeModuleImpl::class.java.simpleName
+
+    fun initialize() {
+        MessageReceivedEventHolder.reactContext = reactContext
+    }
+
+    fun invalidate() {
+        MessageReceivedEventHolder.reactContext = null
+    }
+
+    fun setLogLevel(level: Double) {
+        // JS contract: 0 = off, 1 = errors, 2 = debug
+        // Native SDK:  OFF = -1, ERROR = 0, INFO = 1, DEBUG = 2
+        val logLevel = when (level.toInt()) {
+            0 -> LogLevel.OFF
+            1 -> LogLevel.ERROR
+            2 -> LogLevel.DEBUG
+            else -> LogLevel.OFF
+        }
+        DashXLog.setLogLevel(logLevel)
+    }
+
+    fun configure(options: ReadableMap) {
+        createDefaultNotificationChannel()
+        DashX.configure(
+            reactContext,
+            options.getString("publicKey")!!,
+            options.getStringIfPresent("baseURI"),
+            options.getStringIfPresent("targetEnvironment")
+        )
+    }
+
+    private fun createDefaultNotificationChannel() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        val notificationManager = reactContext.getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager ?: return
+
+        val existing = notificationManager.getNotificationChannel(DEFAULT_CHANNEL_ID)
+        if (existing != null) return
+
+        val channel = NotificationChannel(
+            DEFAULT_CHANNEL_ID,
+            DEFAULT_CHANNEL_NAME,
+            NotificationManager.IMPORTANCE_HIGH
+        ).apply {
+            enableVibration(true)
+            setShowBadge(true)
+            lockscreenVisibility = android.app.Notification.VISIBILITY_PUBLIC
+        }
+        notificationManager.createNotificationChannel(channel)
+    }
+
+    fun identify(options: ReadableMap?) {
+        val optionsHashMap = options?.toHashMap()
+            ?.filterValues { it != null }
+            ?.mapValues { it.value.toString() }
+        DashX.identify(optionsHashMap?.let { HashMap(it) })
+    }
+
+    fun setIdentity(uid: String?, token: String?) {
+        DashX.setIdentity(uid, token)
+    }
+
+    fun reset() {
+        DashX.reset()
+    }
+
+    fun track(event: String, data: ReadableMap?) {
+        val jsonData = try {
+            data?.toHashMap()
+                ?.filterValues { it != null }
+                ?.mapValues { it.value.toString() }
+                ?.let { HashMap(it) }
+        } catch (e: Exception) {
+            DashXLog.d(tag, "Failed to convert track data, sending event without data: ${e.message}")
+            null
+        }
+
+        DashX.track(event, jsonData)
+    }
+
+    fun screen(screenName: String, data: ReadableMap?) {
+        val screenData = data?.toHashMap()
+            ?.filterValues { it != null }
+            ?.mapValues { it.value.toString() }
+            ?.let { HashMap(it) }
+            ?: HashMap()
+        DashX.screen(screenName, screenData)
+    }
+
+    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(E_UNSPECIFIED, "Error parsing fields: ${e.message}")
+            return
+        }
+        val include = try {
+            convertReadableArrayToKJsonList(options?.getArray("include"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing include: ${e.message}")
+            return
+        }
+        val exclude = try {
+            convertReadableArrayToKJsonList(options?.getArray("exclude"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing exclude: ${e.message}")
+            return
+        }
+
+        DashX.fetchRecord(
+            urn = urn,
+            preview = preview,
+            language = language,
+            fields = fields,
+            include = include,
+            exclude = exclude,
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            },
+            onSuccess = {
+                promise.resolve(convertJsonToMap(convertKJsonToJson(it)))
+            }
+        )
+    }
+
+    fun searchRecords(resource: String, options: ReadableMap?, promise: Promise) {
+        val jsonFilter = try {
+            convertMapToJson(options?.getMap("filter"))?.let { convertJsonToKJson(it) }
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing filter: ${e.message}")
+            return
+        }
+        val order = try {
+            convertReadableArrayToKJsonList(options?.getArray("order"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "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(E_UNSPECIFIED, "Error parsing fields: ${e.message}")
+            return
+        }
+        val include = try {
+            convertReadableArrayToKJsonList(options?.getArray("include"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing include: ${e.message}")
+            return
+        }
+        val exclude = try {
+            convertReadableArrayToKJsonList(options?.getArray("exclude"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing exclude: ${e.message}")
+            return
+        }
+
+        DashX.searchRecords(
+            resource = resource,
+            filter = jsonFilter,
+            order = order,
+            limit = limit,
+            preview = preview,
+            language = language,
+            fields = fields,
+            include = include,
+            exclude = exclude,
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            },
+            onSuccess = { records ->
+                val readableArray = Arguments.createArray()
+                records.forEach {
+                    readableArray.pushMap(convertJsonToMap(convertKJsonToJson(it)))
+                }
+                promise.resolve(readableArray)
+            }
+        )
+    }
+
+    fun fetchStoredPreferences(promise: Promise) {
+        DashX.fetchStoredPreferences(
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            },
+            onSuccess = { content ->
+                promise.resolve(convertJsonToMap(convertKJsonToJson(Json.decodeFromString<JsonObject>(Json.encodeToString(content)))))
+            }
+        )
+    }
+
+    fun saveStoredPreferences(preferenceData: ReadableMap?, promise: Promise) {
+        val preferencesString = MapUtil.toJSONElement(preferenceData).toString()
+
+        DashX.saveStoredPreferences(
+            Json.decodeFromString<JsonObject>(preferencesString),
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            },
+            onSuccess = { content ->
+                promise.resolve(convertJsonToMap(convertKJsonToJson(Json.decodeFromString<JsonObject>(Json.encodeToString(content)))))
+            }
+        )
+    }
+
+    fun subscribe() {
+        DashX.subscribe()
+    }
+
+    fun unsubscribe() {
+        DashX.unsubscribe()
+    }
+
+    // --- iOS-only methods: no-op stubs on Android (JS guards prevent these from being called) ---
+
+    fun enableLifecycleTracking() {
+        // iOS-only; no-op on Android
+    }
+
+    fun enableAdTracking() {
+        // iOS-only; no-op on Android
+    }
+
+    fun processURL(url: String, source: String?, forwardToLinkHandler: Boolean) {
+        // iOS-only; no-op on Android
+    }
+
+    fun trackNotificationNavigation(action: ReadableMap?, notificationId: String?) {
+        // iOS-only; no-op on Android
+    }
+
+    fun uploadAsset(filePath: String, resource: String, attribute: String, promise: Promise) {
+        val file = java.io.File(filePath)
+        DashX.uploadAsset(
+            file = file,
+            resource = resource,
+            attribute = attribute,
+            onSuccess = { asset ->
+                try {
+                    val jsonString = Json.encodeToString(asset)
+                    val jsonObject = org.json.JSONObject(jsonString)
+                    promise.resolve(convertJsonToMap(jsonObject))
+                } catch (e: Exception) {
+                    promise.resolve(null)
+                }
+            },
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            }
+        )
+    }
+
+    fun fetchAsset(assetId: String, promise: Promise) {
+        DashX.fetchAsset(
+            assetId = assetId,
+            onSuccess = { asset ->
+                try {
+                    val jsonString = Json.encodeToString(asset)
+                    val jsonObject = org.json.JSONObject(jsonString)
+                    promise.resolve(convertJsonToMap(jsonObject))
+                } catch (e: Exception) {
+                    promise.resolve(null)
+                }
+            },
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            }
+        )
+    }
+
+    fun requestNotificationPermission(promise: Promise) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            promise.resolve(PERMISSION_AUTHORIZED)
+            return
+        }
+
+        val alreadyGranted = ContextCompat.checkSelfPermission(
+            reactContext,
+            Manifest.permission.POST_NOTIFICATIONS
+        ) == PackageManager.PERMISSION_GRANTED
+        if (alreadyGranted) {
+            promise.resolve(PERMISSION_AUTHORIZED)
+            return
+        }
+
+        val activity = reactContext.currentActivity as? PermissionAwareActivity
+        if (activity == null) {
+            promise.reject(E_UNSPECIFIED, "No current activity to request permission from")
+            return
+        }
+
+        reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            .edit()
+            .putBoolean(KEY_PERMISSION_REQUESTED, true)
+            .apply()
+
+        val listener = PermissionListener { requestCode, _, grantResults ->
+            if (requestCode != NOTIFICATION_PERMISSION_REQUEST_CODE) return@PermissionListener false
+            val granted = grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED
+            promise.resolve(if (granted) PERMISSION_AUTHORIZED else PERMISSION_DENIED)
+            true
+        }
+
+        activity.requestPermissions(
+            arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+            NOTIFICATION_PERMISSION_REQUEST_CODE,
+            listener
+        )
+    }
+
+    fun getNotificationPermissionStatus(promise: Promise) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            promise.resolve(PERMISSION_AUTHORIZED)
+            return
+        }
+        val granted = ContextCompat.checkSelfPermission(
+            reactContext,
+            Manifest.permission.POST_NOTIFICATIONS
+        ) == PackageManager.PERMISSION_GRANTED
+        if (granted) {
+            promise.resolve(PERMISSION_AUTHORIZED)
+        } else {
+            val wasRequested = reactContext
+                .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+                .getBoolean(KEY_PERMISSION_REQUESTED, false)
+            promise.resolve(if (wasRequested) PERMISSION_DENIED else PERMISSION_NOT_DETERMINED)
+        }
+    }
+
+    companion object {
+        const val NAME = "DashXReactNative"
+        private const val E_UNSPECIFIED = "EUNSPECIFIED"
+        private const val DEFAULT_CHANNEL_ID = "default_dashx_notification_channel"
+        private const val DEFAULT_CHANNEL_NAME = "Notifications"
+
+        private const val NOTIFICATION_PERMISSION_REQUEST_CODE = 3571
+
+        private const val PREFS_NAME = "dashx_rn_prefs"
+        private const val KEY_PERMISSION_REQUESTED = "notification_permission_requested"
+
+        // Mirrors iOS UNAuthorizationStatus values used by the JS layer.
+        private const val PERMISSION_NOT_DETERMINED = 0
+        private const val PERMISSION_DENIED = 1
+        private const val PERMISSION_AUTHORIZED = 2
+    }
+}