react-native-authsignal 1.8.1 → 2.0.0-alpha2

package/android/build.gradle

@@ -77,5 +77,5 @@ dependencies {
 
   implementation "androidx.browser:browser:1.2.0"
 
-  implementation("com.authsignal:authsignal-android:2.6.0")
+  implementation("com.authsignal:authsignal-android:3.0.0-alpha")
 }

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

@@ -0,0 +1,135 @@
+package com.authsignal.react
+
+import android.util.Log
+import com.authsignal.inapp.AuthsignalInApp
+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 kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+class AuthsignalInAppModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(
+    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!!)
+
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun getCredential(promise: Promise) {
+    launch(promise) {
+      val response = it.getCredential()
+
+      if (response.error != null) {
+        val errorCode = response.errorCode ?: defaultError
+
+        promise.reject(errorCode, response.error)
+      } else if (response.data != null) {
+        val credential = response.data
+        val map = Arguments.createMap()
+        map.putString("credentialId", credential!!.credentialId)
+        map.putString("createdAt", credential.createdAt)
+        map.putString("userId", credential.userId)
+        map.putString("lastAuthenticatedAt", credential.lastAuthenticatedAt)
+        promise.resolve(map)
+      } else {
+        promise.resolve(null)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun addCredential(
+    token: String?,
+    promise: Promise
+  ) {
+    launch(promise) {
+      val response = it.addCredential(token, null)
+
+      if (response.error != null) {
+        val errorCode = response.errorCode ?: defaultError
+
+        promise.reject(errorCode, response.error)
+      } else {
+        val credential = response.data
+        val map = Arguments.createMap()
+        map.putString("credentialId", credential!!.credentialId)
+        map.putString("createdAt", credential.createdAt)
+        map.putString("userId", credential.userId)
+        map.putString("lastAuthenticatedAt", credential.lastAuthenticatedAt)
+        promise.resolve(map)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun removeCredential(promise: Promise) {
+    launch(promise) {
+      val response = it.removeCredential()
+
+      if (response.error != null) {
+        val errorCode = response.errorCode ?: defaultError
+
+        promise.reject(errorCode, response.error)
+      } else {
+        promise.resolve(response.data)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun verify(promise: Promise) {
+    launch(promise) {
+      val response = it.verify()
+
+      if (response.error != null) {
+        val errorCode = response.errorCode ?: defaultError
+
+        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)
+      }
+    }
+  }
+
+  private fun launch(promise: Promise, fn: suspend (client: AuthsignalDevice) -> Unit) {
+    coroutineScope.launch {
+      authsignal?.let {
+        fn(it)
+      }  ?: run {
+        Log.w("init_error", "AuthsignalInAppModule is not initialized.")
+
+        promise.resolve(null)
+      }
+    }
+  }
+}

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

@@ -12,7 +12,8 @@ class AuthsignalPackage : ReactPackage {
       AuthsignalEmailModule(reactContext),
       AuthsignalPasskeyModule(reactContext),
       AuthsignalPushModule(reactContext),
-      AuthsignalDeviceModule(reactContext),
+      AuthsignalInAppModule(reactContext),
+      AuthsignalQRCodeModule(reactContext),
       AuthsignalSMSModule(reactContext),
       AuthsignalTOTPModule(reactContext),
       AuthsignalWhatsappModule(reactContext)

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

@@ -51,6 +51,7 @@ class AuthsignalPushModule(private val reactContext: ReactApplicationContext) :
         val map = Arguments.createMap()
         map.putString("credentialId", credential!!.credentialId)
         map.putString("createdAt", credential.createdAt)
+        map.putString("userId", credential.userId)
         map.putString("lastAuthenticatedAt", credential.lastAuthenticatedAt)
         promise.resolve(map)
       }
@@ -70,7 +71,13 @@ class AuthsignalPushModule(private val reactContext: ReactApplicationContext) :
 
         promise.reject(errorCode, response.error)
       } else {
-        promise.resolve(response.data)
+        val credential = response.data
+        val map = Arguments.createMap()
+        map.putString("credentialId", credential!!.credentialId)
+        map.putString("createdAt", credential.createdAt)
+        map.putString("userId", credential.userId)
+        map.putString("lastAuthenticatedAt", credential.lastAuthenticatedAt)
+        promise.resolve(map)
       }
     }
   }

package/android/src/main/java/com/authsignal/react/{AuthsignalDeviceModule.kt → AuthsignalQRCodeModule.kt}

@@ -1,7 +1,7 @@
 package com.authsignal.react
 
 import android.util.Log
-import com.authsignal.device.AuthsignalDevice
+import com.authsignal.qr.AuthsignalQRCode
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
@@ -12,12 +12,12 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
 
-class AuthsignalDeviceModule(private val reactContext: ReactApplicationContext) :
+class AuthsignalQRCodeModule(private val reactContext: ReactApplicationContext) :
   ReactContextBaseJavaModule(
     reactContext
   ) {
   private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
-  private var authsignal: AuthsignalDevice? = null
+  private var authsignal: AuthsignalQRCode? = null
   private var defaultError = "unexpected_error"
 
   override fun getConstants(): Map<String, Any>? {
@@ -27,12 +27,12 @@ class AuthsignalDeviceModule(private val reactContext: ReactApplicationContext)
   }
 
   override fun getName(): String {
-    return "AuthsignalDeviceModule"
+    return "AuthsignalQRCodeModule"
   }
 
   @ReactMethod
   fun initialize(tenantID: String?, baseURL: String?, promise: Promise) {
-    Log.d("AuthsignalDeviceModule", "initialize: $tenantID, $baseURL")
+    Log.d("AuthsignalQRCodeModule", "initialize: $tenantID, $baseURL")
     authsignal = AuthsignalDevice(tenantID!!, baseURL!!)
 
     promise.resolve(null)
@@ -100,34 +100,6 @@ class AuthsignalDeviceModule(private val reactContext: ReactApplicationContext)
     }
   }
 
-  @ReactMethod
-  fun getChallenge(promise: Promise) {
-    launch(promise) {
-      val response = it.getChallenge()
-
-      if (response.error != null) {
-        val errorCode = response.errorCode ?: defaultError
-
-        promise.reject(errorCode, response.error)
-      } else {
-        val challenge = response.data
-
-        if (challenge == null) {
-          promise.resolve(null)
-        } else {
-          val map = Arguments.createMap()
-          map.putString("challengeId", challenge.challengeId)
-          map.putString("actionCode", challenge.actionCode)
-          map.putString("idempotencyKey", challenge.idempotencyKey)
-          map.putString("ipAddress", challenge.ipAddress)
-          map.putString("deviceId", challenge.deviceId)
-          map.putString("userAgent", challenge.userAgent)
-          promise.resolve(map)
-        }
-      }
-    }
-  }
-
   @ReactMethod
   fun claimChallenge(
     challengeId: String,
@@ -175,33 +147,12 @@ class AuthsignalDeviceModule(private val reactContext: ReactApplicationContext)
     }
   }
 
-  @ReactMethod
-  fun verify(promise: Promise) {
-    launch(promise) {
-      val response = it.verify()
-
-      if (response.error != null) {
-        val errorCode = response.errorCode ?: defaultError
-
-        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)
-      }
-    }
-  }
-
   private fun launch(promise: Promise, fn: suspend (client: AuthsignalDevice) -> Unit) {
     coroutineScope.launch {
       authsignal?.let {
         fn(it)
       }  ?: run {
-        Log.w("init_error", "AuthsignalDeviceModule is not initialized.")
+        Log.w("init_error", "AuthsignalQRCodeModule is not initialized.")
 
         promise.resolve(null)
       }

package/ios/AuthsignalInAppModule.m

@@ -0,0 +1,26 @@
+#import <React/RCTBridgeModule.h>
+#import <Foundation/Foundation.h>
+
+@interface RCT_EXTERN_MODULE(AuthsignalInAppModule, NSObject)
+
+RCT_EXTERN_METHOD(initialize:(NSString)tenantID
+                  withBaseURL:(NSString)baseURL
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getCredential:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(addCredential:(NSString)token
+                  withRequireUserAuthentication:(BOOL)requireUserAuthentication
+                  withKeychainAccess:(NSString)keychainAccess
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(removeCredential:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(verify:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/AuthsignalInAppModule.swift

@@ -0,0 +1,163 @@
+import Security
+import Foundation
+import Authsignal
+
+@objc(AuthsignalInAppModule)
+class AuthsignalInAppModule: NSObject {
+  var authsignal: AuthsignalInApp?
+  
+  @objc static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+  
+  @objc func initialize(
+    _ tenantID: NSString,
+    withBaseURL baseURL: NSString,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) -> Void {
+    self.authsignal = AuthsignalInApp(tenantID: tenantID as String, baseURL: baseURL as String)
+    
+    resolve(nil)
+  }
+
+  @objc func getCredential(
+    _ resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) -> Void {
+    guard let authsignal = authsignal else {
+      resolve(nil)
+      return
+    }
+    
+    Task.init {
+      let response = await authsignal.getCredential()
+      
+      if let error = response.error {
+        reject(response.errorCode ?? "unexpected_error", error, nil)
+      } else if let data = response.data {
+        let credential: [String: String?] = [
+          "credentialId": data.credentialId,
+          "createdAt": data.createdAt,
+          "userId": data.userId,
+          "lastAuthenticatedAt": data.lastAuthenticatedAt,
+        ]
+        
+        resolve(credential)
+      } else {
+        resolve(nil)
+      }
+    }
+  }
+
+  @objc func addCredential(
+    _ token: NSString?,
+    withRequireUserAuthentication requireUserAuthentication: Bool,
+    withKeychainAccess keychainAccess: NSString,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) -> Void {
+    guard let authsignal = authsignal else {
+      resolve(nil)
+      return
+    }
+    
+    let tokenStr = token as String?
+    let userPresenceRequired = requireUserAuthentication as Bool
+    let keychainAccess = getKeychainAccess(value: keychainAccess as String?)
+    
+    Task.init {
+      let response = await authsignal.addCredential(
+        token: tokenStr,
+        keychainAccess: keychainAccess,
+        userPresenceRequired: userPresenceRequired
+      )
+      
+      if let error = response.error {
+        reject(response.errorCode ?? "unexpected_error", error, nil)
+      } else if let data = response.data {
+        let credential: [String: String?] = [
+          "credentialId": data.credentialId,
+          "createdAt": data.createdAt,
+          "userId": data.userId,
+          "lastAuthenticatedAt": data.lastAuthenticatedAt,
+        ]
+        
+        resolve(credential)
+      } else {
+        resolve(nil)
+      }
+    }
+  }
+  
+  @objc func removeCredential(
+    _ resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) -> Void {
+    guard let authsignal = authsignal else {
+      resolve(nil)
+      return
+    }
+    
+    Task.init {
+      let response = await authsignal.removeCredential()
+      
+      if let error = response.error {
+        reject(response.errorCode ?? "unexpected_error", error, nil)
+      } else {
+        resolve(response.data)
+      }
+    }
+  }
+
+  @objc func verify(
+    _ resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) -> Void {
+    guard let authsignal = authsignal else {
+      resolve(nil)
+      return
+    }
+    
+    Task.init {
+      let response = await authsignal.verify()
+      
+      if let error = response.error {
+        reject(response.errorCode ?? "unexpected_error", error, nil)
+      } else if let data = response.data {
+        let result: [String: String?] = [
+          "token": data.token,
+          "userId": data.userId,
+          "userAuthenticatorId": data.userAuthenticatorId,
+          "username": data.username,
+        ]
+        
+        resolve(result)
+      } else {
+        resolve(nil)
+      }
+    }
+  }
+
+  func getKeychainAccess(value: String?) -> KeychainAccess {
+    switch value {
+    case "afterFirstUnlock":
+      return .afterFirstUnlock
+      
+    case "afterFirstUnlockThisDeviceOnly":
+      return .afterFirstUnlockThisDeviceOnly
+        
+    case "whenUnlocked":
+      return .whenUnlocked
+        
+    case "whenUnlockedThisDeviceOnly":
+      return .whenUnlockedThisDeviceOnly
+        
+    case "whenPasscodeSetThisDeviceOnly":
+      return .whenPasscodeSetThisDeviceOnly
+      
+    default:
+      return .whenUnlockedThisDeviceOnly
+    }
+  }
+}

package/ios/AuthsignalPushModule.swift

@@ -39,6 +39,7 @@ class AuthsignalPushModule: NSObject {
         let credential: [String: String?] = [
           "credentialId": data.credentialId,
           "createdAt": data.createdAt,
+          "userId": data.userId,
           "lastAuthenticatedAt": data.lastAuthenticatedAt,
         ]
         
@@ -75,7 +76,14 @@ class AuthsignalPushModule: NSObject {
       if let error = response.error {
         reject(response.errorCode ?? "unexpected_error", error, nil)
       } else {
-        resolve(response.data)
+         let credential: [String: String?] = [
+          "credentialId": response.data!.credentialId,
+          "createdAt": response.data!.createdAt,
+          "userId": response.data!.userId,
+          "lastAuthenticatedAt": response.data!.lastAuthenticatedAt,
+        ]
+        
+        resolve(credential)
       }
     }
   }

package/ios/{AuthsignalDeviceModule.m → AuthsignalQRModule.m}

@@ -1,7 +1,7 @@
 #import <React/RCTBridgeModule.h>
 #import <Foundation/Foundation.h>
 
-@interface RCT_EXTERN_MODULE(AuthsignalDeviceModule, NSObject)
+@interface RCT_EXTERN_MODULE(AuthsignalQRCodeModule, NSObject)
 
 RCT_EXTERN_METHOD(initialize:(NSString)tenantID
                   withBaseURL:(NSString)baseURL
@@ -20,9 +20,6 @@ RCT_EXTERN_METHOD(addCredential:(NSString)token
 RCT_EXTERN_METHOD(removeCredential:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(getChallenge:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
 RCT_EXTERN_METHOD(claimChallenge:(NSString)challengeId
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
@@ -33,7 +30,4 @@ RCT_EXTERN_METHOD(updateChallenge:(NSString)challengeId
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(verify:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
 @end

package/ios/{AuthsignalDeviceModule.swift → AuthsignalQRModule.swift}

@@ -2,9 +2,9 @@ import Security
 import Foundation
 import Authsignal
 
-@objc(AuthsignalDeviceModule)
-class AuthsignalDeviceModule: NSObject {
-  var authsignal: AuthsignalDevice?
+@objc(AuthsignalQRCodeModule)
+class AuthsignalQRCodeModule: NSObject {
+  var authsignal: AuthsignalQRCode?
   
   @objc static func requiresMainQueueSetup() -> Bool {
     return true
@@ -16,7 +16,7 @@ class AuthsignalDeviceModule: NSObject {
     resolver resolve: @escaping RCTPromiseResolveBlock,
     rejecter reject: @escaping RCTPromiseRejectBlock
   ) -> Void {
-    self.authsignal = AuthsignalDevice(tenantID: tenantID as String, baseURL: baseURL as String)
+    self.authsignal = AuthsignalQRCode(tenantID: tenantID as String, baseURL: baseURL as String)
     
     resolve(nil)
   }
@@ -110,37 +110,6 @@ class AuthsignalDeviceModule: NSObject {
     }
   }
 
-  @objc func getChallenge(
-    _ resolve: @escaping RCTPromiseResolveBlock,
-    rejecter reject: @escaping RCTPromiseRejectBlock
-  ) -> Void {
-    guard let authsignal = authsignal else {
-      resolve(nil)
-      return
-    }
-    
-    Task.init {
-      let response = await authsignal.getChallenge()
-      
-      if let error = response.error {
-        reject(response.errorCode ?? "unexpected_error", error, nil)
-      } else if let data = response.data as? DeviceChallenge {
-        let challenge: [String: String?] = [
-          "challengeId": data.challengeId,
-          "actionCode": data.actionCode,
-          "idempotencyKey": data.idempotencyKey,
-          "userAgent": data.userAgent,
-          "deviceId": data.deviceId,
-          "ipAddress": data.ipAddress,
-        ]
-        
-        resolve(challenge)
-      } else {
-        resolve(nil)
-      }
-    }
-  }
-
   @objc func claimChallenge(
     _ challengeId: NSString,
     resolver resolve: @escaping RCTPromiseResolveBlock,
@@ -203,35 +172,6 @@ class AuthsignalDeviceModule: NSObject {
     }
   }
 
-  @objc func verify(
-    _ resolve: @escaping RCTPromiseResolveBlock,
-    rejecter reject: @escaping RCTPromiseRejectBlock
-  ) -> Void {
-    guard let authsignal = authsignal else {
-      resolve(nil)
-      return
-    }
-    
-    Task.init {
-      let response = await authsignal.verify()
-      
-      if let error = response.error {
-        reject(response.errorCode ?? "unexpected_error", error, nil)
-      } else if let data = response.data {
-        let result: [String: String?] = [
-          "token": data.token,
-          "userId": data.userId,
-          "userAuthenticatorId": data.userAuthenticatorId,
-          "username": data.username,
-        ]
-        
-        resolve(result)
-      } else {
-        resolve(nil)
-      }
-    }
-  }
-
   func getKeychainAccess(value: String?) -> KeychainAccess {
     switch value {
     case "afterFirstUnlock":