react-native-authsignal 1.0.13 → 1.1.2

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

@@ -0,0 +1,152 @@
+package com.authsignal.react
+
+import android.util.Log
+import com.authsignal.push.AuthsignalPush
+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 AuthsignalPushModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(
+    reactContext
+  ) {
+  private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+  private var authsignal: AuthsignalPush? = 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 "AuthsignalPushModule"
+  }
+
+  @ReactMethod
+  fun initialize(tenantID: String?, baseURL: String?, promise: Promise) {
+    authsignal = AuthsignalPush(tenantID!!, baseURL!!)
+
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun getCredential(promise: Promise) {
+    launch(promise) {
+      val response = it.getCredential()
+
+      if (response.error != null) {
+        val errorCode = response.errorType ?: 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("lastAuthenticatedAt", credential.lastAuthenticatedAt)
+        promise.resolve(map)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun addCredential(
+    token: String?,
+    promise: Promise
+  ) {
+    launch(promise) {
+      val response = it.addCredential(token, null)
+
+      if (response.error != null) {
+        val errorCode = response.errorType ?: defaultError
+
+        promise.reject(errorCode, response.error)
+      } else {
+        promise.resolve(response.data)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun removeCredential(promise: Promise) {
+    launch(promise) {
+      val response = it.removeCredential()
+
+      if (response.error != null) {
+        val errorCode = response.errorType ?: defaultError
+
+        promise.reject(errorCode, response.error)
+      } else {
+        promise.resolve(response.data)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun getChallenge(promise: Promise) {
+    launch(promise) {
+      val response = it.getChallenge()
+
+      if (response.error != null) {
+        val errorCode = response.errorType ?: 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 updateChallenge(
+    challengeId: String,
+    approved: Boolean,
+    verificationCode: String?,
+    promise: Promise
+  ) {
+    launch(promise) {
+      val response = it.updateChallenge(challengeId, approved, verificationCode)
+
+      if (response.error != null) {
+        val errorCode = response.errorType ?: defaultError
+
+        promise.reject(errorCode, response.error)
+      } else {
+        promise.resolve(response.data)
+      }
+    }
+  }
+
+  private fun launch(promise: Promise, fn: suspend (client: AuthsignalPush) -> Unit) {
+    coroutineScope.launch {
+      authsignal?.let {
+        fn(it)
+      }  ?: run {
+        Log.w("init_error", "AuthsignalPushModule is not initialized.")
+
+        promise.resolve(null)
+      }
+    }
+  }
+}

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

@@ -0,0 +1,117 @@
+package com.authsignal.react
+
+import android.util.Log
+import com.authsignal.models.AuthsignalResponse
+import com.authsignal.models.ChallengeResponse
+import com.authsignal.models.EnrollResponse
+import com.authsignal.models.VerifyResponse
+import com.authsignal.sms.AuthsignalSMS
+import com.authsignal.totp.AuthsignalTOTP
+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
+import java.util.function.Consumer
+
+class AuthsignalSMSModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(
+    reactContext
+  ) {
+  private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+  private var authsignal: AuthsignalSMS? = null
+  private val 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 "AuthsignalSMSModule"
+  }
+
+  @ReactMethod
+  fun initialize(tenantID: String, baseURL: String, promise: Promise) {
+    val currentActivity = reactContext.currentActivity
+
+    if (currentActivity != null) {
+      authsignal = AuthsignalSMS(tenantID, baseURL)
+    }
+
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun enroll(phoneNumber: String, promise: Promise) {
+    launch(promise) {
+      val response = it.enroll(phoneNumber)
+
+      if (response.error != null) {
+        val errorCode = response.errorType ?: defaultError
+
+        promise.reject(errorCode, response.error)
+      } else {
+        val enrollResponse = response.data
+        val map = Arguments.createMap()
+        map.putString("userAuthenticatorId", enrollResponse!!.userAuthenticatorId)
+        promise.resolve(map)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun challenge(promise: Promise) {
+    launch(promise) {
+      val response = it.challenge()
+
+      if (response.error != null) {
+        val errorCode = response.errorType ?: defaultError
+
+        promise.reject(errorCode, response.error)
+      } else {
+        val challengeResponse = response.data
+        val map = Arguments.createMap()
+        map.putString("challengeId", challengeResponse!!.challengeId)
+        promise.resolve(map)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun verify(code: String, promise: Promise) {
+    launch(promise) {
+      val response = it.verify(code)
+
+      if (response.error != null) {
+        val errorCode = response.errorType ?: defaultError
+
+        promise.reject(errorCode, response.error)
+      } else {
+        val verifyResponse = response.data
+        val map = Arguments.createMap()
+        map.putBoolean("isVerified", verifyResponse!!.isVerified)
+        map.putString("token", verifyResponse.token)
+        map.putString("failureReason", verifyResponse.failureReason)
+        promise.resolve(map)
+      }
+    }
+  }
+
+  private fun launch(promise: Promise, fn: suspend (client: AuthsignalSMS) -> Unit) {
+    coroutineScope.launch {
+      authsignal?.let {
+        fn(it)
+      }  ?: run {
+        Log.w("init_error", "AuthsignalSMSModule is not initialized.")
+
+        promise.resolve(null)
+      }
+    }
+  }
+}

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

@@ -0,0 +1,95 @@
+package com.authsignal.react
+
+import android.util.Log
+import com.authsignal.totp.AuthsignalTOTP
+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 AuthsignalTOTPModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(
+    reactContext
+  ) {
+  private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+  private var authsignal: AuthsignalTOTP? = null
+  private val 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 "AuthsignalTOTPModule"
+  }
+
+  @ReactMethod
+  fun initialize(tenantID: String, baseURL: String, promise: Promise) {
+    val currentActivity = reactContext.currentActivity
+
+    if (currentActivity != null) {
+      authsignal = AuthsignalTOTP(tenantID, baseURL)
+    }
+
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun enroll(promise: Promise) {
+    launch(promise) {
+      val response = it.enroll()
+
+      if (response.error != null) {
+        val errorCode = response.errorType ?: defaultError
+
+        promise.reject(errorCode, response.error)
+      } else {
+        val enrollResponse = response.data
+        val map = Arguments.createMap()
+        map.putString("userAuthenticatorId", enrollResponse!!.userAuthenticatorId)
+        map.putString("uri", enrollResponse.uri)
+        map.putString("secret", enrollResponse.secret)
+        promise.resolve(map)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun verify(code: String, promise: Promise) {
+    launch(promise) {
+      val response = it.verify(code)
+
+      if (response.error != null) {
+        val errorCode = response.errorType ?: "verify_error"
+
+        promise.reject(errorCode, response.error)
+      } else {
+        val verifyResponse = response.data
+        val map = Arguments.createMap()
+        map.putBoolean("isVerified", verifyResponse!!.isVerified)
+        map.putString("token", verifyResponse.token)
+        map.putString("failureReason", verifyResponse.failureReason)
+        promise.resolve(map)
+      }
+    }
+  }
+
+  private fun launch(promise: Promise, fn: suspend (client: AuthsignalTOTP) -> Unit) {
+    coroutineScope.launch {
+      authsignal?.let {
+        fn(it)
+      }  ?: run {
+        Log.w("init_error", "AuthsignalTOTPModule is not initialized.")
+
+        promise.resolve(null)
+      }
+    }
+  }
+}

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

@@ -0,0 +1,17 @@
+package com.authsignal.react
+
+import android.app.Activity
+import android.content.Intent
+import android.os.Bundle
+import com.authsignal.react.AuthenticationActivity
+
+class RedirectActivity : Activity() {
+  public override fun onCreate(savedInstanceBundle: Bundle?) {
+    super.onCreate(savedInstanceBundle)
+    val intent = Intent(this, AuthenticationActivity::class.java)
+    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+    if (getIntent() != null) intent.setData(getIntent().data)
+    startActivity(intent)
+    finish()
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-authsignal",
-  "version": "1.0.13",
+  "version": "1.1.2",
   "description": "The official Authsignal React Native library.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/android/src/main/java/com/authsignal/react/AuthenticationActivity.java

@@ -1,73 +0,0 @@
-package com.authsignal.react;
-
-import android.app.Activity;
-import android.content.Intent;
-import android.net.Uri;
-import android.os.Bundle;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import androidx.browser.customtabs.CustomTabsIntent;
-
-public class AuthenticationActivity extends Activity {
-    static final int AUTHENTICATION_REQUEST = 1000;
-    static final String EXTRA_AUTHORIZE_URI = "com.authsignal.react.EXTRA_AUTHORIZE_URI";
-    private static final String EXTRA_INTENT_LAUNCHED = "com.authsignal.react.EXTRA_INTENT_LAUNCHED";
-
-    private boolean intentLaunched;
-
-    static void authenticateUsingBrowser(@NonNull Activity activity, @NonNull Uri authorizeUri) {
-        Intent intent = new Intent(activity, AuthenticationActivity.class);
-        intent.putExtra(AuthenticationActivity.EXTRA_AUTHORIZE_URI, authorizeUri);
-        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
-        activity.startActivityForResult(intent, AUTHENTICATION_REQUEST);
-    }
-
-    @Override
-    protected void onCreate(@Nullable Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        if (savedInstanceState != null) {
-            intentLaunched = savedInstanceState.getBoolean(EXTRA_INTENT_LAUNCHED, false);
-        }
-    }
-
-    @Override
-    protected void onResume() {
-        super.onResume();
-        final Intent authenticationIntent = getIntent();
-
-        if (!intentLaunched && authenticationIntent.getExtras() == null) {
-            finish();
-            return;
-        } else if (!intentLaunched) {
-            intentLaunched = true;
-            launchAuthenticationIntent();
-            return;
-        }
-
-        boolean resultMissing = authenticationIntent.getData() == null;
-        if (resultMissing) setResult(RESULT_CANCELED);
-        else setResult(RESULT_OK, authenticationIntent);
-        finish();
-    }
-
-    @Override
-    protected void onSaveInstanceState(@NonNull Bundle outState) {
-        super.onSaveInstanceState(outState);
-        outState.putBoolean(EXTRA_INTENT_LAUNCHED, intentLaunched);
-    }
-
-    @Override
-    protected void onNewIntent(@Nullable Intent intent) {
-        super.onNewIntent(intent);
-        setIntent(intent);
-    }
-
-    private void launchAuthenticationIntent() {
-        Bundle extras = getIntent().getExtras();
-        Uri authorizeUri = extras.getParcelable(EXTRA_AUTHORIZE_URI);
-        CustomTabsIntent.Builder builder = new CustomTabsIntent.Builder();
-        CustomTabsIntent customTabsIntent = builder.build();
-        customTabsIntent.launchUrl(this, authorizeUri);
-    }
-}

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

@@ -1,139 +0,0 @@
-package com.authsignal.react;
-
-import android.app.Activity;
-import android.util.Log;
-
-import androidx.annotation.NonNull;
-
-import com.authsignal.email.AuthsignalEmail;
-import com.authsignal.models.*;
-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.WritableMap;
-
-import java.util.HashMap;
-import java.util.Map;
-
-public class AuthsignalEmailModule extends ReactContextBaseJavaModule {
-  private final ReactApplicationContext reactContext;
-
-  private AuthsignalEmail authsignalEmail;
-
-  private final String TAG = "AuthsignalEmailModule";
-  private final String INIT_WARNING = "AuthsignalEmailModule is not initialized.";
-
-  public AuthsignalEmailModule(ReactApplicationContext reactContext) {
-    super(reactContext);
-    this.reactContext = reactContext;
-  }
-
-  @Override
-  public Map<String, Object> getConstants() {
-    final Map<String, Object> constants = new HashMap<>();
-    constants.put("bundleIdentifier", reactContext.getApplicationInfo().packageName);
-    return constants;
-  }
-
-  @NonNull
-  @Override
-  public String getName() {
-    return "AuthsignalEmailModule";
-  }
-
-  @ReactMethod
-  public void initialize(String tenantID, String baseURL, Promise promise) {
-    Activity currentActivity = reactContext.getCurrentActivity();
-
-    if (currentActivity != null) {
-      authsignalEmail = new AuthsignalEmail(
-        tenantID,
-        baseURL
-      );
-    }
-
-    promise.resolve(null);
-  }
-
-  @ReactMethod
-  public void enroll(String email, Promise promise) {
-    if (authsignalEmail != null) {
-      authsignalEmail
-        .enrollAsync(email)
-        .thenAcceptAsync(response -> {
-          if (response.getError() != null) {
-            String errorCode = response.getErrorType() != null ?
-              response.getErrorType() :
-              "enroll_error";
-
-            promise.reject(errorCode, response.getError());
-          } else {
-            EnrollResponse enrollResponse = response.getData();
-            WritableMap map = Arguments.createMap();
-            map.putString("userAuthenticatorId", enrollResponse.getUserAuthenticatorId());
-            promise.resolve(map);
-          }
-        });
-    } else {
-      Log.w(TAG, INIT_WARNING);
-
-      promise.resolve(null);
-    }
-  }
-
-  @ReactMethod
-  public void challenge(Promise promise) {
-    if (authsignalEmail != null) {
-      authsignalEmail
-        .challengeAsync()
-        .thenAcceptAsync(response -> {
-          if (response.getError() != null) {
-            String errorCode = response.getErrorType() != null ?
-              response.getErrorType() :
-              "challenge_error";
-
-            promise.reject(errorCode, response.getError());
-          } else {
-            ChallengeResponse challengeResponse = response.getData();
-            WritableMap map = Arguments.createMap();
-            map.putString("challengeId", challengeResponse.getChallengeId());
-            promise.resolve(map);
-          }
-        });
-    } else {
-      Log.w(TAG, INIT_WARNING);
-
-      promise.resolve(null);
-    }
-  }
-
-  @ReactMethod
-  public void verify(String code, Promise promise) {
-    if (authsignalEmail != null) {
-      authsignalEmail
-        .verifyAsync(code)
-        .thenAcceptAsync(response -> {
-          if (response.getError() != null) {
-            String errorCode = response.getErrorType() != null ?
-              response.getErrorType() :
-              "verify_error";
-
-            promise.reject(errorCode, response.getError());
-          } else {
-            VerifyResponse verifyResponse = response.getData();
-            WritableMap map = Arguments.createMap();
-            map.putBoolean("isVerified", verifyResponse.isVerified());
-            map.putString("token", verifyResponse.getToken());
-            map.putString("failureReason", verifyResponse.getFailureReason());
-            promise.resolve(map);
-          }
-        });
-    } else {
-      Log.w(TAG, INIT_WARNING);
-
-      promise.resolve(null);
-    }
-  }
-}