react-native-authsignal 2.6.1 → 2.8.0-alpha.2

package/android/build.gradle

@@ -1,19 +1,6 @@
-buildscript {
-  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["Authsignal_kotlinVersion"]
-
-  repositories {
-      google()
-      mavenCentral()
-  }
-
-  dependencies {
-    classpath 'com.android.tools.build:gradle:8.1.4'
-    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-  }
-}
-
 apply plugin: 'com.android.library'
 apply plugin: 'org.jetbrains.kotlin.android'
+apply plugin: 'com.facebook.react'
 
 def getExtOrDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['Authsignal_' + name]
@@ -45,7 +32,7 @@ android {
     }
   }
 
-  lintOptions {
+  lint {
     disable 'GradleCompatible'
   }
 
@@ -68,14 +55,11 @@ repositories {
   google()
 }
 
-def kotlin_version = getExtOrDefault("kotlinVersion")
-
 dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
-  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
   implementation "androidx.browser:browser:1.2.0"
 
-  implementation("com.authsignal:authsignal-android:3.4.0")
+  implementation("com.authsignal:authsignal-android:3.4.1-alpha.2")
 }

package/android/gradle.properties

@@ -1,4 +1,4 @@
-Authsignal_kotlinVersion=1.9.24
+Authsignal_kotlinVersion=2.1.0
 Authsignal_minSdkVersion=24
 Authsignal_targetSdkVersion=34
 Authsignal_compileSdkVersion=34

package/android/src/main/java/com/authsignal/react/AuthsignalEmailModule.kt

@@ -5,35 +5,24 @@ import com.authsignal.email.AuthsignalEmail
 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.module.annotations.ReactModule
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
 
+@ReactModule(name = AuthsignalEmailModule.NAME)
 class AuthsignalEmailModule(private val reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(
-    reactContext
-  ) {
+  NativeAuthsignalEmailModuleSpec(reactContext) {
   private var authsignal: AuthsignalEmail? = null
 
   private val defaultError = "unexpected_error"
 
   private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
 
-  override fun getConstants(): Map<String, Any>? {
-    val constants: MutableMap<String, Any> = HashMap()
-    constants["bundleIdentifier"] = reactContext.applicationInfo.packageName
-    return constants
-  }
-
-  override fun getName(): String {
-    return "AuthsignalEmailModule"
-  }
-
   @ReactMethod
-  fun initialize(tenantID: String, baseURL: String, promise: Promise) {
+  override fun initialize(tenantID: String, baseURL: String, promise: Promise) {
     val currentActivity = reactContext.currentActivity
 
     if (currentActivity != null) {
@@ -44,7 +33,7 @@ class AuthsignalEmailModule(private val reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun enroll(email: String, promise: Promise) {
+  override fun enroll(email: String, promise: Promise) {
     launch(promise) {
       val response = it.enroll(email)
 
@@ -62,7 +51,7 @@ class AuthsignalEmailModule(private val reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun challenge(promise: Promise) {
+  override fun challenge(promise: Promise) {
     launch(promise) {
       val response = it.challenge()
 
@@ -80,7 +69,7 @@ class AuthsignalEmailModule(private val reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun verify(code: String, promise: Promise) {
+  override fun verify(code: String, promise: Promise) {
     launch(promise) {
       val response = it.verify(code)
 
@@ -110,4 +99,8 @@ class AuthsignalEmailModule(private val reactContext: ReactApplicationContext) :
       }
     }
   }
+
+  companion object {
+    const val NAME = "AuthsignalEmailModule"
+  }
 }

package/android/src/main/java/com/authsignal/react/AuthsignalInAppModule.kt

@@ -2,44 +2,34 @@ package com.authsignal.react
 
 import android.util.Log
 import com.authsignal.inapp.AuthsignalInApp
+import com.authsignal.models.api.AppAttestation
 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.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
 
+@ReactModule(name = AuthsignalInAppModule.NAME)
 class AuthsignalInAppModule(private val reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(
-    reactContext
-  ) {
+  NativeAuthsignalInAppModuleSpec(reactContext) {
   private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
   private var authsignal: AuthsignalInApp? = null
   private var defaultError = "unexpected_error"
 
-  override fun getConstants(): Map<String, Any>? {
-    val constants: MutableMap<String, Any> = HashMap()
-    constants["bundleIdentifier"] = reactContext.applicationInfo.packageName
-    return constants
-  }
-
-  override fun getName(): String {
-    return "AuthsignalInAppModule"
-  }
-
   @ReactMethod
-  fun initialize(tenantID: String?, baseURL: String?, promise: Promise) {
-    Log.d("AuthsignalInAppModule", "initialize: $tenantID, $baseURL")
-    authsignal = AuthsignalInApp(tenantID!!, baseURL!!, context = reactContext)
+  override fun initialize(tenantID: String, baseURL: String, promise: Promise) {
+    authsignal = AuthsignalInApp(tenantID, baseURL, context = reactContext)
 
     promise.resolve(null)
   }
 
   @ReactMethod
-  fun getCredential(username: String?, promise: Promise) {
+  override fun getCredential(username: String?, promise: Promise) {
     launch(promise) {
       val response = it.getCredential(username = username)
 
@@ -62,11 +52,20 @@ class AuthsignalInAppModule(private val reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun addCredential(
+  override fun addCredential(
     token: String?,
+    _requireUserAuthentication: Boolean,
+    _keychainAccess: String?,
     username: String?,
+    appAttestationMap: ReadableMap?,
     promise: Promise
   ) {
+    val appAttestation = appAttestationMap?.let { map ->
+      val attestationToken = map.getString("token") ?: return@let null
+      val keyId = if (map.hasKey("keyId")) map.getString("keyId") else null
+      AppAttestation(token = attestationToken, keyId = keyId)
+    }
+
     launch(promise) {
       val response = it.addCredential(
         token = token,
@@ -75,6 +74,7 @@ class AuthsignalInAppModule(private val reactContext: ReactApplicationContext) :
         timeout = 0,
         authorizationType = 0,
         username = username,
+        appAttestation = appAttestation,
       )
 
       if (response.error != null) {
@@ -94,7 +94,7 @@ class AuthsignalInAppModule(private val reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun removeCredential(username: String?, promise: Promise) {
+  override fun removeCredential(username: String?, promise: Promise) {
     launch(promise) {
       val response = it.removeCredential(username = username)
 
@@ -109,7 +109,7 @@ class AuthsignalInAppModule(private val reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun verify(
+  override fun verify(
     action: String?,
     username: String?,
     promise: Promise
@@ -122,19 +122,23 @@ class AuthsignalInAppModule(private val reactContext: ReactApplicationContext) :
 
         promise.reject(errorCode, response.error)
       } else {
-        val data = response.data!!
-        val map = Arguments.createMap()
-        map.putString("token", data.token)
-        map.putString("userId", data.userId)
-        map.putString("userAuthenticatorId", data.userAuthenticatorId)
-        map.putString("username", data.username)
-        promise.resolve(map)
+        val data = response.data
+        if (data != null) {
+          val map = Arguments.createMap()
+          map.putString("token", data.token)
+          map.putString("userId", data.userId)
+          map.putString("userAuthenticatorId", data.userAuthenticatorId)
+          map.putString("username", data.username)
+          promise.resolve(map)
+        } else {
+          promise.reject(defaultError, "No data returned")
+        }
       }
     }
   }
 
   @ReactMethod
-  fun createPin(pin: String, username: String, token: String?, promise: Promise) {
+  override fun createPin(pin: String, username: String, token: String?, promise: Promise) {
     launch(promise) {
       val response = it.createPin(
         pin = pin,
@@ -147,19 +151,23 @@ class AuthsignalInAppModule(private val reactContext: ReactApplicationContext) :
 
         promise.reject(errorCode, response.error)
       } else {
-        val data = response.data!!
-        val map = Arguments.createMap()
-        map.putString("credentialId", data.credentialId)
-        map.putString("createdAt", data.createdAt)
-        map.putString("userId", data.userId)
-        map.putString("lastAuthenticatedAt", data.lastAuthenticatedAt)
-        promise.resolve(map)
+        val data = response.data
+        if (data != null) {
+          val map = Arguments.createMap()
+          map.putString("credentialId", data.credentialId)
+          map.putString("createdAt", data.createdAt)
+          map.putString("userId", data.userId)
+          map.putString("lastAuthenticatedAt", data.lastAuthenticatedAt)
+          promise.resolve(map)
+        } else {
+          promise.reject(defaultError, "No data returned")
+        }
       }
     }
   }
 
   @ReactMethod
-  fun verifyPin(pin: String, username: String, action: String?, promise: Promise) {
+  override fun verifyPin(pin: String, username: String, action: String?, promise: Promise) {
     launch(promise) {
       val response = it.verifyPin(
         pin = pin,
@@ -172,18 +180,22 @@ class AuthsignalInAppModule(private val reactContext: ReactApplicationContext) :
 
         promise.reject(errorCode, response.error)
       } else {
-        val data = response.data!!
-        val map = Arguments.createMap()
-        map.putBoolean("isVerified", data.isVerified)
-        map.putString("token", data.token)
-        map.putString("userId", data.userId)
-        promise.resolve(map)
+        val data = response.data
+        if (data != null) {
+          val map = Arguments.createMap()
+          map.putBoolean("isVerified", data.isVerified)
+          map.putString("token", data.token)
+          map.putString("userId", data.userId)
+          promise.resolve(map)
+        } else {
+          promise.reject(defaultError, "No data returned")
+        }
       }
     }
   }
 
   @ReactMethod
-  fun deletePin(username: String, promise: Promise) {
+  override fun deletePin(username: String, promise: Promise) {
     launch(promise) {
       val response = it.deletePin(username = username)
 
@@ -198,7 +210,7 @@ class AuthsignalInAppModule(private val reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun getAllPinUsernames(promise: Promise) {
+  override fun getAllPinUsernames(promise: Promise) {
     launch(promise) {
       val response = it.getAllPinUsernames()
 
@@ -225,4 +237,8 @@ class AuthsignalInAppModule(private val reactContext: ReactApplicationContext) :
       }
     }
   }
+
+  companion object {
+    const val NAME = "AuthsignalInAppModule"
+  }
 }

package/android/src/main/java/com/authsignal/react/AuthsignalModule.kt

@@ -7,61 +7,49 @@ import android.net.Uri
 import com.authsignal.TokenCache.Companion.shared
 import com.authsignal.react.AuthenticationActivity.Companion.authenticateUsingBrowser
 import com.facebook.react.bridge.ActivityEventListener
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.Callback
 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.module.annotations.ReactModule
 import java.net.URLDecoder
 
+@ReactModule(name = AuthsignalModule.NAME)
 class AuthsignalModule(private val reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(
-    reactContext
-  ), ActivityEventListener {
-  private var callback: Callback? = null
+  NativeAuthsignalModuleSpec(reactContext), ActivityEventListener {
+  private var launchPromise: Promise? = null
 
   init {
     reactContext.addActivityEventListener(this)
   }
 
-  override fun getConstants(): Map<String, Any>? {
-    val constants: MutableMap<String, Any> = HashMap()
-    constants["bundleIdentifier"] = reactContext.applicationInfo.packageName
-    return constants
-  }
-
-  override fun getName(): String {
-    return "AuthsignalModule"
-  }
-
   @ReactMethod
-  fun setToken(token: String?, promise: Promise) {
+  override fun setToken(token: String?, promise: Promise) {
     shared.token = token
 
     promise.resolve("token_set")
   }
 
   @ReactMethod
-  fun launch(url: String?, callback: Callback) {
+  override fun launch(url: String?, promise: Promise) {
+    if (url == null) {
+      promise.reject("invalid_url", "Launch URL must not be null.")
+      return
+    }
+
     val activity = reactContext.currentActivity
     val parsedUrl = Uri.parse(url)
-    this.callback = callback
+    this.launchPromise = promise
 
     try {
       if (activity != null) {
         authenticateUsingBrowser(activity, parsedUrl)
       } else {
-        val error = Arguments.createMap()
-        error.putString("error", "activity_not_available")
-        error.putString("error_description", "Android Activity is null.")
-        callback.invoke(error)
+        promise.reject("activity_not_available", "Android Activity is null.")
+        this.launchPromise = null
       }
     } catch (e: ActivityNotFoundException) {
-      val error = Arguments.createMap()
-      error.putString("error", "browser_not_available")
-      error.putString("error_description", "No browser app is installed")
-      callback.invoke(error)
+      promise.reject("browser_not_available", "No browser app is installed")
+      this.launchPromise = null
     }
   }
 
@@ -71,7 +59,7 @@ class AuthsignalModule(private val reactContext: ReactApplicationContext) :
     resultCode: Int,
     data: Intent?
   ) {
-    val cb = this@AuthsignalModule.callback ?: return
+    val pendingPromise = this@AuthsignalModule.launchPromise ?: return
 
     val hasResult =
       resultCode == Activity.RESULT_OK && requestCode == AuthenticationActivity.AUTHENTICATION_REQUEST && data!!.data != null
@@ -93,23 +81,21 @@ class AuthsignalModule(private val reactContext: ReactApplicationContext) :
             shared.token = value
           }
         }
-        cb.invoke(null, token)
+        pendingPromise.resolve(token)
       } catch (ex: Exception) {
-        val error = Arguments.createMap()
-        error.putString("error", "malformed_url")
-        error.putString("error_description", "Malformed redirect url")
-        cb.invoke(error)
+        pendingPromise.reject("malformed_url", "Malformed redirect url")
       }
     } else {
-      val error = Arguments.createMap()
-      error.putString("error", "user_cancelled")
-      error.putString("error_description", "User cancelled")
-      cb.invoke(error)
+      pendingPromise.resolve(null)
     }
 
-    this@AuthsignalModule.callback = null
+    this@AuthsignalModule.launchPromise = null
   }
 
   override fun onNewIntent(intent: Intent) {
   }
+
+  companion object {
+    const val NAME = "AuthsignalModule"
+  }
 }

package/android/src/main/java/com/authsignal/react/AuthsignalPackage.kt

@@ -1,26 +1,79 @@
 package com.authsignal.react
 
-import com.facebook.react.ReactPackage
+import com.facebook.react.TurboReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ViewManager
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
 
-class AuthsignalPackage : ReactPackage {
-  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    return listOf<NativeModule>(
-      AuthsignalModule(reactContext),
-      AuthsignalEmailModule(reactContext),
-      AuthsignalPasskeyModule(reactContext),
-      AuthsignalPushModule(reactContext),
-      AuthsignalInAppModule(reactContext),
-      AuthsignalQRCodeModule(reactContext),
-      AuthsignalSMSModule(reactContext),
-      AuthsignalTOTPModule(reactContext),
-      AuthsignalWhatsappModule(reactContext)
-    )
+class AuthsignalPackage : TurboReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return when (name) {
+      AuthsignalModule.NAME -> AuthsignalModule(reactContext)
+      AuthsignalEmailModule.NAME -> AuthsignalEmailModule(reactContext)
+      AuthsignalPasskeyModule.NAME -> AuthsignalPasskeyModule(reactContext)
+      AuthsignalPushModule.NAME -> AuthsignalPushModule(reactContext)
+      AuthsignalInAppModule.NAME -> AuthsignalInAppModule(reactContext)
+      AuthsignalQRCodeModule.NAME -> AuthsignalQRCodeModule(reactContext)
+      AuthsignalSMSModule.NAME -> AuthsignalSMSModule(reactContext)
+      AuthsignalTOTPModule.NAME -> AuthsignalTOTPModule(reactContext)
+      AuthsignalWhatsappModule.NAME -> AuthsignalWhatsappModule(reactContext)
+      else -> null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      mapOf(
+        AuthsignalModule.NAME to createModuleInfo(
+          AuthsignalModule.NAME,
+          AuthsignalModule::class.java.name
+        ),
+        AuthsignalEmailModule.NAME to createModuleInfo(
+          AuthsignalEmailModule.NAME,
+          AuthsignalEmailModule::class.java.name
+        ),
+        AuthsignalPasskeyModule.NAME to createModuleInfo(
+          AuthsignalPasskeyModule.NAME,
+          AuthsignalPasskeyModule::class.java.name
+        ),
+        AuthsignalPushModule.NAME to createModuleInfo(
+          AuthsignalPushModule.NAME,
+          AuthsignalPushModule::class.java.name
+        ),
+        AuthsignalInAppModule.NAME to createModuleInfo(
+          AuthsignalInAppModule.NAME,
+          AuthsignalInAppModule::class.java.name
+        ),
+        AuthsignalQRCodeModule.NAME to createModuleInfo(
+          AuthsignalQRCodeModule.NAME,
+          AuthsignalQRCodeModule::class.java.name
+        ),
+        AuthsignalSMSModule.NAME to createModuleInfo(
+          AuthsignalSMSModule.NAME,
+          AuthsignalSMSModule::class.java.name
+        ),
+        AuthsignalTOTPModule.NAME to createModuleInfo(
+          AuthsignalTOTPModule.NAME,
+          AuthsignalTOTPModule::class.java.name
+        ),
+        AuthsignalWhatsappModule.NAME to createModuleInfo(
+          AuthsignalWhatsappModule.NAME,
+          AuthsignalWhatsappModule::class.java.name
+        ),
+      )
+    }
   }
 
-  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-    return emptyList()
+  private fun createModuleInfo(name: String, className: String): ReactModuleInfo {
+    return ReactModuleInfo(
+      name,
+      className,
+      false,
+      false,
+      false,
+      false,
+      true,
+    )
   }
 }

package/android/src/main/java/com/authsignal/react/AuthsignalPasskeyModule.kt

@@ -5,31 +5,22 @@ import com.authsignal.passkey.AuthsignalPasskey
 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.module.annotations.ReactModule
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
 
+@ReactModule(name = AuthsignalPasskeyModule.NAME)
 class AuthsignalPasskeyModule(private val reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(reactContext) {
+  NativeAuthsignalPasskeyModuleSpec(reactContext) {
   private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
   private var authsignal: AuthsignalPasskey? = null
   private var defaultError = "unexpected_error"
 
-  override fun getConstants(): Map<String, Any>? {
-    val constants: MutableMap<String, Any> = HashMap()
-    constants["bundleIdentifier"] = reactContext.applicationInfo.packageName
-    return constants
-  }
-
-  override fun getName(): String {
-    return "AuthsignalPasskeyModule"
-  }
-
   @ReactMethod
-  fun initialize(tenantID: String, baseURL: String, deviceID: String?, promise: Promise) {
+  override fun initialize(tenantID: String, baseURL: String, deviceID: String?, promise: Promise) {
     val activity = reactContext.currentActivity
 
     if (activity != null) {
@@ -40,7 +31,7 @@ class AuthsignalPasskeyModule(private val reactContext: ReactApplicationContext)
   }
 
   @ReactMethod
-  fun signUp(token: String?, username: String?, displayName: String?, ignorePasskeyAlreadyExistsError: Boolean, promise: Promise) {
+  override fun signUp(token: String?, username: String?, displayName: String?, ignorePasskeyAlreadyExistsError: Boolean, promise: Promise) {
     launch(promise) {
       val response = it.signUp(token, username, displayName, false, ignorePasskeyAlreadyExistsError)
 
@@ -61,7 +52,13 @@ class AuthsignalPasskeyModule(private val reactContext: ReactApplicationContext)
   }
 
   @ReactMethod
-  fun signIn(action: String?, token: String?, preferImmediatelyAvailableCredentials: Boolean, promise: Promise) {
+  override fun signIn(
+    action: String?,
+    token: String?,
+    _autofill: Boolean,
+    preferImmediatelyAvailableCredentials: Boolean,
+    promise: Promise
+  ) {
     launch(promise) {
       val response = it.signIn(action, token, preferImmediatelyAvailableCredentials)
 
@@ -84,7 +81,12 @@ class AuthsignalPasskeyModule(private val reactContext: ReactApplicationContext)
   }
 
   @ReactMethod
-  fun shouldPromptToCreatePasskey(username: String?, promise: Promise) {
+  override fun cancel() {
+    // No-op on Android; cancel is only applicable for iOS autofill
+  }
+
+  @ReactMethod
+  override fun shouldPromptToCreatePasskey(username: String?, promise: Promise) {
     launch(promise) {
       val response = it.shouldPromptToCreatePasskey(username)
 
@@ -93,7 +95,7 @@ class AuthsignalPasskeyModule(private val reactContext: ReactApplicationContext)
   }
 
   @ReactMethod
-  fun isAvailableOnDevice(promise: Promise) {
+  override fun isAvailableOnDevice(promise: Promise) {
     launch(promise) {
       val response = it.isAvailableOnDevice()
 
@@ -112,4 +114,8 @@ class AuthsignalPasskeyModule(private val reactContext: ReactApplicationContext)
       }
     }
   }
+
+  companion object {
+    const val NAME = "AuthsignalPasskeyModule"
+  }
 }