react-native-authsignal 0.4.5 → 1.0.1

package/ios/AuthsignalEmailModule.swift

@@ -0,0 +1,109 @@
+import Security
+import Foundation
+import Authsignal
+
+@objc(AuthsignalEmailModule)
+class AuthsignalEmailModule: NSObject {
+  var authsignal: AuthsignalEmail?
+  
+  @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 = AuthsignalEmail(tenantID: tenantID as String, baseURL: baseURL as String)
+    
+    resolve(nil)
+  }
+  
+  @objc func enroll(
+    _ email: NSString,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) -> Void {
+    if (authsignal == nil) {
+      resolve(nil)
+      return
+    }
+    
+    let emailStr = email as String
+    
+    Task.init {
+      let response = await authsignal!.enroll(email: emailStr)
+      
+      if (response.errorCode == "TOKEN_NOT_SET") {
+        reject("tokenNotSetError", "TOKEN_NOT_SET", nil)
+      } else if (response.error != nil) {
+        reject("enrollError", response.error, nil)
+      } else {
+        let enrollResponse: [String: String?] = [
+          "userAuthenticatorId": response.data!.userAuthenticatorId,
+        ]
+
+        resolve(enrollResponse)
+      }
+    }
+  }
+
+  @objc func challenge(
+    _ resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) -> Void {
+    if (authsignal == nil) {
+      resolve(nil)
+      return
+    }
+    
+    Task.init {
+      let response = await authsignal!.challenge()
+      
+      if (response.errorCode == "TOKEN_NOT_SET") {
+        reject("tokenNotSetError", "TOKEN_NOT_SET", nil)
+      } else if (response.error != nil) {
+        reject("challengeError", response.error, nil)
+      } else {
+        let challengeResponse: [String: String?] = [
+          "challengeId": response.data!.challengeId,
+        ]
+
+        resolve(challengeResponse)
+      }
+    }
+  }
+
+  @objc func verify(
+    _ code: NSString,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) -> Void {
+    if (authsignal == nil) {
+      resolve(nil)
+      return
+    }
+    
+    let codeStr = code as String
+    
+    Task.init {
+      let response = await authsignal!.verify(code: codeStr)
+      
+      if (response.errorCode == "TOKEN_NOT_SET") {
+        reject("tokenNotSetError", "TOKEN_NOT_SET", nil)
+      } else if (response.error != nil) {
+        reject("verifyError", response.error, nil)
+      } else {
+        let verifyResponse: [String: Any?] = [
+          "isVerified": response.data!.isVerified,
+          "token": response.data!.token,
+          "failureReason": response.data!.failureReason,
+        ]
+
+        resolve(verifyResponse)
+      }
+    }
+  }
+}

package/ios/AuthsignalModule.m

@@ -1,68 +1,14 @@
-#import "AuthsignalModule.h"
-#import <React/RCTConvert.h>
+#import <React/RCTBridgeModule.h>
+#import <Foundation/Foundation.h>
 
-@interface AuthsignalModule ()
-@property (strong, nonatomic) NSObject *session;
-@end
-
-@implementation AuthsignalModule
-
-RCT_EXPORT_MODULE();
+@interface RCT_EXTERN_MODULE(AuthsignalModule, NSObject)
 
-- (dispatch_queue_t)methodQueue
-{
-  return dispatch_get_main_queue();
-}
+RCT_EXTERN_METHOD(launch:(NSString)url
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXPORT_METHOD(launch:(NSString *)url resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-  NSURL *authUrl = [RCTConvert NSURL:url];
-  NSString *scheme = @"authsignal";
-  
-  ASWebAuthenticationSession* authenticationSession = [[ASWebAuthenticationSession alloc] initWithURL:authUrl
-                                                                                    callbackURLScheme:scheme
-                                                                                    completionHandler:^(NSURL * _Nullable callbackURL,
-                                                                                                        NSError * _Nullable error) {
-    if (callbackURL) {
-      NSURLComponents *components = [[NSURLComponents alloc] initWithString:callbackURL.absoluteString];
-      NSString *token;
-      
-      for (NSURLQueryItem *item in components.queryItems) {
-        if ([item.name isEqualToString:@"token"]) {
-          token = item.value;
-        }
-      }
-      
-      resolve(token);
-    } else if (error) {
-      if ([[error domain] isEqualToString:ASWebAuthenticationSessionErrorDomain] &&
-          [error code] == ASWebAuthenticationSessionErrorCodeCanceledLogin) {
-        resolve(nil);
-      } else {
-        reject(@"AS_ERROR", error.description, nil);
-      }
-    }
-    
-    self.session = nil;
-  }];
-
-  #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 130000
-  if (@available(iOS 13, *)) {
-    authenticationSession.presentationContextProvider = self;
-    authenticationSession.prefersEphemeralWebBrowserSession = NO;
-  }
-  #endif
-  
-  self.session = authenticationSession;
-  
-  [(ASWebAuthenticationSession*) self.session start];
-}
-
-#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 130000
-- (ASPresentationAnchor)presentationAnchorForWebAuthenticationSession:(ASWebAuthenticationSession *)session  API_AVAILABLE(ios(13.0)){
-   return UIApplication.sharedApplication.keyWindow;
-}
-#endif
+RCT_EXTERN_METHOD(setToken:(NSString)token
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
 
 @end
-

package/ios/AuthsignalModule.swift

@@ -0,0 +1,87 @@
+import AuthenticationServices
+import Authsignal
+import Foundation
+import React
+import Security
+
+@objc(AuthsignalModule)
+class AuthsignalModule: NSObject, ASWebAuthenticationPresentationContextProviding {
+  var session: ASWebAuthenticationSession?
+  
+  @objc static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+  
+  @objc func methodQueue() -> DispatchQueue {
+      return DispatchQueue.main
+  }
+  
+  @objc func launch(
+    _ url: NSString,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) -> Void {
+    let scheme = "authsignal"
+    let urlStr = url as String?
+    
+    guard let authUrl = URL(string: urlStr!) else {
+      reject("AS_ERROR", "Invalid URL", nil)
+      
+      return
+    }
+    
+    let authenticationSession = ASWebAuthenticationSession(url: authUrl, callbackURLScheme: scheme) { callbackURL, error in
+      if let error {
+        if self.isCanceledLoginError(error) {
+          resolve(nil)
+        } else {
+          reject("AS_ERROR", error.localizedDescription, nil)
+        }
+      } else if let callbackURL = callbackURL {
+        let components = URLComponents(string: callbackURL.absoluteString)
+        var token: String?
+
+        for item in components?.queryItems ?? [] {
+          if item.name == "token" {
+            token = item.value
+
+            TokenCache.shared.token = item.value
+          }
+        }
+
+        resolve(token)
+      }
+
+      self.session = nil
+    }
+
+    #if os(iOS) && swift(>=5.1)
+    if #available(iOS 13, *) {
+        authenticationSession.presentationContextProvider = self
+        authenticationSession.prefersEphemeralWebBrowserSession = false
+    }
+    #endif
+
+    self.session = authenticationSession
+
+    self.session?.start()
+  }
+  
+  @objc func setToken(
+    _ token: NSString,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) -> Void {
+    TokenCache.shared.token = token as String
+
+    resolve("token_set")
+  }
+  
+  private func isCanceledLoginError(_ error: Error) -> Bool {
+    (error as NSError).code == ASWebAuthenticationSessionError.canceledLogin.rawValue
+  }
+  
+  func presentationAnchor(for session: ASWebAuthenticationSession) -> ASPresentationAnchor {
+    return UIApplication.shared.keyWindow!
+  }
+}

package/ios/AuthsignalPasskeyModule.m

@@ -9,7 +9,7 @@ RCT_EXTERN_METHOD(initialize:(NSString)tenantID
                   rejecter:(RCTPromiseRejectBlock)reject)
 
 RCT_EXTERN_METHOD(signUp:(NSString)token
-                  withUserName:(NSString)userName
+                  withUsername:(NSString)username
                   withDisplayName:(NSString)displayName
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)

package/ios/AuthsignalPasskeyModule.swift

@@ -22,8 +22,8 @@ class AuthsignalPasskeyModule: NSObject {
   }
   
   @objc func signUp(
-    _ token: NSString,
-    withUserName userName: NSString?,
+    _ token: NSString?,
+    withUsername username: NSString?,
     withDisplayName displayName: NSString?,
     resolver resolve: @escaping RCTPromiseResolveBlock,
     rejecter reject: @escaping RCTPromiseRejectBlock
@@ -33,14 +33,16 @@ class AuthsignalPasskeyModule: NSObject {
       return
     }
     
-    let tokenStr = token as String
-    let userNameStr = userName as String?
+    let tokenStr = token as String?
+    let usernameStr = username as String?
     let displayNameStr = displayName as String?
     
     Task.init {
-      let response = await authsignal!.signUp(token: tokenStr, userName: userNameStr, displayName: displayNameStr)
+      let response = await authsignal!.signUp(token: tokenStr, username: usernameStr, displayName: displayNameStr)
       
-      if (response.error != nil) {
+      if (response.errorCode == "TOKEN_NOT_SET") {
+        reject("tokenNotSetError", "TOKEN_NOT_SET", nil)
+      } else if (response.error != nil) {
         reject("signUpError", response.error, nil)
       } else {
         let signUpResponse: [String: String?] = [
@@ -76,7 +78,7 @@ class AuthsignalPasskeyModule: NSObject {
         preferImmediatelyAvailableCredentials: preferImmediatelyAvailableCredentials
       )
       
-      if (response.errorCode == .canceled) {
+      if (response.errorCode == "SIGN_IN_CANCELED") {
         reject("signInCanceled", "SIGN_IN_CANCELED", nil)
       } else if (response.error != nil) {
         reject("signInError", response.error, nil)
@@ -86,8 +88,8 @@ class AuthsignalPasskeyModule: NSObject {
           "token": response.data!.token,
           "userId": response.data!.userId,
           "userAuthenticatorId": response.data!.userAuthenticatorId,
-          "userName": response.data!.userName,
-          "userDisplayName": response.data!.userDisplayName,
+          "username": response.data!.username,
+          "displayName": response.data!.displayName,
         ]
 
         resolve(signInResponse)

package/ios/AuthsignalPushModule.m

@@ -21,7 +21,7 @@ RCT_EXTERN_METHOD(removeCredential:(RCTPromiseResolveBlock)resolve
 RCT_EXTERN_METHOD(getChallenge:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(updateChallenge:(NSString)challengeID
+RCT_EXTERN_METHOD(updateChallenge:(NSString)challengeId
                   withApproval:(BOOL)approved
                   withVerificationCode:(NSString)verificationCode
                   resolver:(RCTPromiseResolveBlock)resolve

package/ios/AuthsignalPushModule.swift

@@ -37,7 +37,7 @@ class AuthsignalPushModule: NSObject {
         reject("getCredential error", error, nil)
       } else if let data = response.data {
         let credential: [String: String?] = [
-          "credentialID": response.data!.credentialID,
+          "credentialId": response.data!.credentialId,
           "createdAt": response.data!.createdAt,
           "lastAuthenticatedAt": response.data!.lastAuthenticatedAt,
         ]
@@ -50,7 +50,7 @@ class AuthsignalPushModule: NSObject {
   }
 
   @objc func addCredential(
-    _ token: NSString,
+    _ token: NSString?,
     resolver resolve: @escaping RCTPromiseResolveBlock,
     rejecter reject: @escaping RCTPromiseRejectBlock
   ) -> Void {
@@ -59,12 +59,14 @@ class AuthsignalPushModule: NSObject {
       return
     }
     
-    let tokenStr = token as String
+    let tokenStr = token as String?
     
     Task.init {
       let response = await authsignal.addCredential(token: tokenStr)
       
-      if let error = response.error {
+      if (response.errorCode == "TOKEN_NOT_SET") {
+        reject("tokenNotSetError", "TOKEN_NOT_SET", nil)
+      } else if let error = response.error {
         reject("addCredential error", error, nil)
       } else {
         resolve(response.data)
@@ -113,7 +115,7 @@ class AuthsignalPushModule: NSObject {
   }
 
   @objc func updateChallenge(
-    _ challengeID: NSString,
+    _ challengeId: NSString,
     withApproval approved: Bool,
     withVerificationCode verificationCode: NSString,
     resolver resolve: @escaping RCTPromiseResolveBlock,
@@ -124,13 +126,13 @@ class AuthsignalPushModule: NSObject {
       return
     }
     
-    let challenge = challengeID as String
+    let challenge = challengeId as String
     let approval = approved as Bool
     let code = verificationCode as String?
     
     Task.init {
       let response = await authsignal.updateChallenge(
-        challengeID: challenge,
+        challengeId: challenge,
         approved: approval,
         verificationCode: code
       )

package/ios/AuthsignalSMSModule.m

@@ -0,0 +1,22 @@
+#import <React/RCTBridgeModule.h>
+#import <Foundation/Foundation.h>
+
+@interface RCT_EXTERN_MODULE(AuthsignalSMSModule, NSObject)
+
+RCT_EXTERN_METHOD(initialize:(NSString)tenantID
+                  withBaseURL:(NSString)baseURL
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(enroll:(NSString)phoneNumber
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(challenge:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(verify:(NSString)code
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)             
+
+@end

package/ios/AuthsignalSMSModule.swift

@@ -0,0 +1,109 @@
+import Security
+import Foundation
+import Authsignal
+
+@objc(AuthsignalSMSModule)
+class AuthsignalSMSModule: NSObject {
+  var authsignal: AuthsignalSMS?
+  
+  @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 = AuthsignalSMS(tenantID: tenantID as String, baseURL: baseURL as String)
+    
+    resolve(nil)
+  }
+  
+  @objc func enroll(
+    _ phoneNumber: NSString,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) -> Void {
+    if (authsignal == nil) {
+      resolve(nil)
+      return
+    }
+    
+    let phoneNumberStr = phoneNumber as String
+    
+    Task.init {
+      let response = await authsignal!.enroll(phoneNumber: phoneNumberStr)
+      
+      if (response.errorCode == "TOKEN_NOT_SET") {
+        reject("tokenNotSetError", "TOKEN_NOT_SET", nil)
+      } else if (response.error != nil) {
+        reject("enrollError", response.error, nil)
+      } else {
+        let enrollResponse: [String: String?] = [
+          "userAuthenticatorId": response.data!.userAuthenticatorId,
+        ]
+
+        resolve(enrollResponse)
+      }
+    }
+  }
+
+  @objc func challenge(
+    _ resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) -> Void {
+    if (authsignal == nil) {
+      resolve(nil)
+      return
+    }
+    
+    Task.init {
+      let response = await authsignal!.challenge()
+      
+      if (response.errorCode == "TOKEN_NOT_SET") {
+        reject("tokenNotSetError", "TOKEN_NOT_SET", nil)
+      } else if (response.error != nil) {
+        reject("challengeError", response.error, nil)
+      } else {
+        let challengeResponse: [String: String?] = [
+          "challengeId": response.data!.challengeId,
+        ]
+
+        resolve(challengeResponse)
+      }
+    }
+  }
+
+  @objc func verify(
+    _ code: NSString,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) -> Void {
+    if (authsignal == nil) {
+      resolve(nil)
+      return
+    }
+    
+    let codeStr = code as String
+    
+    Task.init {
+      let response = await authsignal!.verify(code: codeStr)
+      
+      if (response.errorCode == "TOKEN_NOT_SET") {
+        reject("tokenNotSetError", "TOKEN_NOT_SET", nil)
+      } else if (response.error != nil) {
+        reject("verifyError", response.error, nil)
+      } else {
+        let verifyResponse: [String: Any?] = [
+          "isVerified": response.data!.isVerified,
+          "token": response.data!.token,
+          "failureReason": response.data!.failureReason,
+        ]
+
+        resolve(verifyResponse)
+      }
+    }
+  }
+}

package/ios/AuthsignalTOTPModule.m

@@ -0,0 +1,18 @@
+#import <React/RCTBridgeModule.h>
+#import <Foundation/Foundation.h>
+
+@interface RCT_EXTERN_MODULE(AuthsignalTOTPModule, NSObject)
+
+RCT_EXTERN_METHOD(initialize:(NSString)tenantID
+                  withBaseURL:(NSString)baseURL
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(enroll:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(verify:(NSString)code
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)             
+
+@end

package/ios/AuthsignalTOTPModule.swift

@@ -0,0 +1,82 @@
+import Security
+import Foundation
+import Authsignal
+
+@objc(AuthsignalTOTPModule)
+class AuthsignalTOTPModule: NSObject {
+  var authsignal: AuthsignalTOTP?
+  
+  @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 = AuthsignalTOTP(tenantID: tenantID as String, baseURL: baseURL as String)
+    
+    resolve(nil)
+  }
+  
+  @objc func enroll(
+    _ resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) -> Void {
+    if (authsignal == nil) {
+      resolve(nil)
+      return
+    }
+    
+    Task.init {
+      let response = await authsignal!.enroll()
+      
+      if (response.errorCode == "TOKEN_NOT_SET") {
+        reject("tokenNotSetError", "TOKEN_NOT_SET", nil)
+      } else if (response.error != nil) {
+        reject("enrollError", response.error, nil)
+      } else {
+        let enrollResponse: [String: String?] = [
+          "userAuthenticatorId": response.data!.userAuthenticatorId,
+          "uri": response.data!.uri,
+          "secret": response.data!.secret,
+        ]
+
+        resolve(enrollResponse)
+      }
+    }
+  }
+
+  @objc func verify(
+    _ code: NSString,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) -> Void {
+    if (authsignal == nil) {
+      resolve(nil)
+      return
+    }
+    
+    let codeStr = code as String
+    
+    Task.init {
+      let response = await authsignal!.verify(code: codeStr)
+      
+      if (response.errorCode == "TOKEN_NOT_SET") {
+        reject("tokenNotSetError", "TOKEN_NOT_SET", nil)
+      } else if (response.error != nil) {
+        reject("verifyError", response.error, nil)
+      } else {
+        let verifyResponse: [String: Any?] = [
+          "isVerified": response.data!.isVerified,
+          "token": response.data!.token,
+          "failureReason": response.data!.failureReason,
+        ]
+
+        resolve(verifyResponse)
+      }
+    }
+  }
+}