react-native-oauth-essentials 1.0.2

package/ios/AppleIdRetriever.swift

@@ -0,0 +1,61 @@
+import AuthenticationServices
+import React
+
+public class AppleIdRetriever: RCTPromiseSettler,
+  ASAuthorizationControllerDelegate,
+  ASAuthorizationControllerPresentationContextProviding  {
+
+  override init(
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock,
+    emitEvent: ((String, NSDictionary) -> Void)?
+  ) {
+    super.init(resolve: resolve, reject: reject, emitEvent: emitEvent)
+
+    let controller = ASAuthorizationController(authorizationRequests: [
+      ASAuthorizationAppleIDProvider().createRequest(),
+    ])
+
+    controller.delegate = self
+    controller.presentationContextProvider = self
+
+    if #available(iOS 16.0, *) {
+      controller.performRequests(options: .preferImmediatelyAvailableCredentials)
+    } else {
+      controller.performRequests()
+    }
+  }
+
+  public func presentationAnchor(for controller: ASAuthorizationController) -> ASPresentationAnchor {
+    return UIWindow()
+  }
+
+  public func authorizationController(
+    controller: ASAuthorizationController,
+    didCompleteWithAuthorization authorization: ASAuthorization
+  ) {
+    if let appleIdCredential = authorization.credential as? ASAuthorizationAppleIDCredential {
+      let result = CredentialFactory.fromAppleId(appleIdCredential: appleIdCredential)
+      self.resolve?(result)
+      self.emitEvent?("onCredentialSuccess", result as NSDictionary)
+      cleanup()
+    }
+  }
+
+  public func authorizationController(controller: ASAuthorizationController, didCompleteWithError error: Error) {
+    let nsError = error as NSError
+    if nsError.domain == ASAuthorizationError.errorDomain,
+       nsError.code == ASAuthorizationError.canceled.rawValue {
+      
+      let result = CredentialFactory.fromCancelled()
+      self.resolve?(result)
+      self.emitEvent?("onCredentialSuccess", result as NSDictionary)
+    } else {
+      self.emitEvent?("onCredentialFailure", [
+        "code": CredentialError.invalidResult.rawValue,
+        "message": error.localizedDescription
+      ])
+    }
+    cleanup()
+  }
+}

package/ios/CredentialError.swift

@@ -0,0 +1,6 @@
+public enum CredentialError: String {
+  case noSignInAvailable = "NO_SIGN_IN_AVAILABLE"
+  case invalidResult = "INVALID_RESULT_ERROR"
+  case simultaneousCallError = "SIMULTANEOUS_CALL_ERROR"
+  case notSupportedError = "NOT_SUPPORTED_ERROR"
+}

package/ios/CredentialFactory.swift

@@ -0,0 +1,133 @@
+import AuthenticationServices
+import GoogleSignIn
+
+class CredentialFactory {
+  
+    public static func fromCancelled() -> [String: Any] {
+        return [
+            "type": CredentialsType.cancelled.rawValue,
+            "data": NSNull()
+        ]
+    }
+    
+    public static func fromAppleId(appleIdCredential: ASAuthorizationAppleIDCredential) -> [String: Any]  {
+        let idToken: Any =
+        appleIdCredential.identityToken
+        .flatMap { String(data: $0, encoding: .utf8) } ?? NSNull()
+
+        let authorizationCode: Any =
+        appleIdCredential.authorizationCode
+        .flatMap { String(data: $0, encoding: .utf8) } ?? NSNull()
+
+        let fullName =
+        appleIdCredential.fullName
+        .flatMap { PersonNameComponentsFormatter().string(from: $0) } ?? ""
+
+        let data: [String: Any] = [
+          "idToken": idToken,
+          "authorizationCode": authorizationCode,
+          "user": appleIdCredential.user,
+          "email": appleIdCredential.email ?? "",
+          "fullName": fullName,
+          "likelyReal": appleIdCredential.realUserStatus == .likelyReal
+        ]
+
+        let result: [String: Any] = [
+          "type": CredentialsType.appleId.rawValue,
+          "data": data
+        ]
+        
+        return result
+    }
+    
+    public static func fromPassword(credential: ASPasswordCredential) -> [String: Any] {
+        let data: [String: Any] = [
+            "username": credential.user, "password": credential.password
+        ]
+        let result: [String: Any] = [
+          "type": CredentialsType.password.rawValue,
+          "data": data
+        ]
+        return result
+    }
+    
+    @available(iOS 16.0, *)
+    public static func fromPasskeyRegistration(credential: ASAuthorizationPlatformPublicKeyCredentialRegistration) -> [String: Any] {
+        let responseJson: [String: Any] = [
+          "id": base64URLEncode(credential.credentialID),
+          "rawId": base64URLEncode(credential.credentialID),
+          "type": "public-key",
+          "response": [
+            "clientDataJSON": base64URLEncode(credential.rawClientDataJSON),
+            "attestationObject": base64URLEncode(credential.rawAttestationObject ?? Data())
+          ]
+        ]
+
+        guard let jsonData = try? JSONSerialization.data(withJSONObject: responseJson),
+              let jsonString = String(data: jsonData, encoding: .utf8) else {
+          return [
+            "type": CredentialsType.passkey.rawValue,
+            "data": "{}"
+          ]
+        }
+
+        return [
+          "type": CredentialsType.passkey.rawValue,
+          "data": jsonString
+        ]
+    }
+
+    @available(iOS 16.0, *)
+    public static func fromPasskeyAssertion(credential: ASAuthorizationPlatformPublicKeyCredentialAssertion) -> [String: Any] {
+        let responseJson: [String: Any] = [
+          "id": base64URLEncode(credential.credentialID),
+          "rawId": base64URLEncode(credential.credentialID),
+          "type": "public-key",
+          "response": [
+            "clientDataJSON": base64URLEncode(credential.rawClientDataJSON),
+            "authenticatorData": base64URLEncode(credential.rawAuthenticatorData),
+            "signature": base64URLEncode(credential.signature),
+            "userHandle": base64URLEncode(credential.userID)
+          ]
+        ]
+
+        guard let jsonData = try? JSONSerialization.data(withJSONObject: responseJson),
+              let jsonString = String(data: jsonData, encoding: .utf8) else {
+          return [
+            "type": CredentialsType.passkey.rawValue,
+            "data": "{}"
+          ]
+        }
+
+        return [
+          "type": CredentialsType.passkey.rawValue,
+          "data": jsonString
+        ]
+    }
+
+    private static func base64URLEncode(_ data: Data) -> String {
+        return data.base64EncodedString()
+            .replacingOccurrences(of: "+", with: "-")
+            .replacingOccurrences(of: "/", with: "_")
+            .replacingOccurrences(of: "=", with: "")
+    }
+
+    public static func fromGoogleId(user: GIDGoogleUser) -> [String: Any] {
+        let profile = user.profile
+        let data: [String: Any] = [
+          "idToken": user.idToken?.tokenString ?? "",
+          "id": user.userID ?? "",
+          "displayName": profile?.name ?? "",
+          "givenName": profile?.givenName ?? "",
+          "familyName": profile?.familyName ?? "",
+          "profilePictureUri": profile?.imageURL(withDimension: 200)?.absoluteString ?? "",
+          "email": profile?.email ?? ""
+        ]
+
+        let result: [String: Any] = [
+          "type": CredentialsType.googleId.rawValue,
+          "data": data
+        ]
+        return result
+    }
+}

package/ios/CredentialsType.swift

@@ -0,0 +1,7 @@
+public enum CredentialsType: String {
+  case googleId = "GOOGLE_ID"
+  case password = "PASSWORD"
+  case appleId = "APPLE_ID"
+  case cancelled = "CANCELLED"
+  case passkey = "PASSKEY"
+}

package/ios/GoogleIdRetriever.swift

@@ -0,0 +1,83 @@
+import GoogleSignIn
+import React
+
+public class GoogleIdRetriever: RCTPromiseSettler {
+
+  init(
+    clientId: String,
+    options: NSDictionary,
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock,
+    emitEvent: ((String, NSDictionary) -> Void)?
+  ) {
+    super.init(resolve: resolve, reject: reject, emitEvent: emitEvent)
+    performGoogleSignIn(clientId:clientId, options: options)
+  }
+
+  private func performGoogleSignIn(clientId: String, options: NSDictionary) {
+    var rootVC: UIViewController?
+    DispatchQueue.main.sync {
+        if #available(iOS 13.0, *) {
+            rootVC = UIApplication.shared.connectedScenes
+                .compactMap { $0 as? UIWindowScene }
+                .flatMap { $0.windows }
+                .first { $0.isKeyWindow }?
+                .rootViewController
+        } else {
+            rootVC = UIApplication.shared.keyWindow?.rootViewController
+        }
+    }
+
+    guard let rootVC = rootVC else {
+      self.reject?(
+        CredentialError.noSignInAvailable.rawValue,
+        "No root view controller available",
+        nil
+      )
+      self.emitEvent?("onCredentialFailure", [
+        "code": CredentialError.noSignInAvailable.rawValue,
+        "message": "No root view controller available"
+      ])
+
+      self.cleanup()
+      return
+    }
+
+    GIDSignIn.sharedInstance.configuration = GIDConfiguration(clientID: clientId)
+    GIDSignIn.sharedInstance.signIn(withPresenting: rootVC) { result, error in
+      
+      if let error = error {
+        let nsError = error as NSError
+        if nsError.code == GIDSignInError.canceled.rawValue {
+          let result = CredentialFactory.fromCancelled()
+          self.resolve?(result)
+          self.emitEvent?("onCredentialSuccess", result as NSDictionary)
+        } else {
+          self.reject?(CredentialError.invalidResult.rawValue, error.localizedDescription, error)
+          self.emitEvent?("onCredentialFailure", [
+            "code": CredentialError.invalidResult.rawValue,
+            "message": error.localizedDescription
+          ])
+        }
+        self.cleanup()
+        return
+      }
+      
+      guard let user = result?.user else {
+          self.reject?(CredentialError.invalidResult.rawValue, "No user returned", nil)
+          self.emitEvent?("onCredentialFailure", [
+            "code": CredentialError.invalidResult.rawValue,
+            "message": "No user returned"
+          ])
+          
+          self.cleanup()
+          return
+      }
+
+      let result = CredentialFactory.fromGoogleId(user: user)
+      self.resolve?(result)
+      self.emitEvent?("onCredentialSuccess", result as NSDictionary)
+      self.cleanup()
+    }
+  }
+}

package/ios/HybridRetriever.swift

@@ -0,0 +1,64 @@
+import AuthenticationServices
+import React
+
+public class HybridRetriever: RCTPromiseSettler,
+ASAuthorizationControllerDelegate,
+ASAuthorizationControllerPresentationContextProviding  {
+
+  init(
+    clientId: String,
+    options: NSDictionary,
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock,
+    emitEvent: ((String, NSDictionary) -> Void)?
+  ) {
+    super.init(resolve: resolve, reject: reject, emitEvent: emitEvent)
+
+    let controller = ASAuthorizationController(authorizationRequests: [
+      ASAuthorizationAppleIDProvider().createRequest(),
+      ASAuthorizationPasswordProvider().createRequest()
+    ])
+
+    controller.delegate = self
+    controller.presentationContextProvider = self
+
+    if #available(iOS 16.0, *) {
+      controller.performRequests(options: .preferImmediatelyAvailableCredentials)
+    } else {
+      controller.performRequests()
+    }
+  }
+
+  public func presentationAnchor(for controller: ASAuthorizationController) -> ASPresentationAnchor {
+    return UIWindow()
+  }
+
+  public func authorizationController(
+    controller: ASAuthorizationController,
+    didCompleteWithAuthorization authorization: ASAuthorization
+  ) {
+    if let appleIdCredential = authorization.credential as? ASAuthorizationAppleIDCredential {
+      let result = CredentialFactory.fromAppleId(appleIdCredential: appleIdCredential)
+      self.resolve?(result)
+      self.emitEvent?("onCredentialSuccess", result as NSDictionary)
+    }
+    else if let credential = authorization.credential as? ASPasswordCredential {
+      let result = CredentialFactory.fromPassword(credential: credential)
+      self.resolve?(result)
+      self.emitEvent?("onCredentialSuccess", result as NSDictionary)
+    }
+    cleanup()
+  }
+
+  public func authorizationController(controller: ASAuthorizationController, didCompleteWithError error: Error) {
+    self.reject?(
+      CredentialError.invalidResult.rawValue,
+      error.localizedDescription,
+      error
+    )
+    self.emitEvent?("onCredentialFailure", [
+      "code": CredentialError.invalidResult.rawValue,
+      "message": error.localizedDescription
+    ])
+  }
+}

package/ios/OauthEssentials.h

@@ -0,0 +1,8 @@
+#import <OauthEssentialsSpec/OauthEssentialsSpec.h>
+
+@interface OauthEssentials : NativeOauthEssentialsSpecBase <NativeOauthEssentialsSpec>
+
+- (void)emitOnCredentialSuccess:(NSDictionary *)value;
+- (void)emitOnCredentialFailure:(NSDictionary *)value;
+
+@end

package/ios/OauthEssentials.mm

@@ -0,0 +1,104 @@
+#import "OauthEssentials.h"
+#import <AuthenticationServices/AuthenticationServices.h>
+#import "OauthEssentials-Swift.h"
+
+
+@implementation OauthEssentials {
+  OauthEssentialsModule *_sModule;
+}
+
+- (instancetype)init
+{
+  self = [super init];
+  if (self) {
+    __weak OauthEssentials *weakSelf = self;
+
+    _sModule = [[OauthEssentialsModule alloc]
+                initOnCredentialSuccess:^(NSDictionary * _Nonnull value) {
+      [weakSelf emitOnCredentialSuccess:value];
+    } onCredentialFailure:^(NSDictionary * _Nonnull value) {
+      [weakSelf emitOnCredentialSuccess:value];
+    }];
+  }
+  return self;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeOauthEssentialsSpecJSI>(params);
+}
+
++ (NSString *)moduleName
+{
+  return @"OauthEssentials";
+}
+
+// Constants
+- (NSDictionary *)getConstants
+{
+  return [_sModule getConstants];
+}
+
+// Methods
+- (void)googleSignIn:(NSString *)clientId
+             options:(NSDictionary *)options
+             resolve:(RCTPromiseResolveBlock)resolve
+              reject:(RCTPromiseRejectBlock)reject
+{
+  [_sModule googleSignIn:clientId
+                  options:options
+                 resolver:resolve
+                 rejecter:reject];
+}
+
+- (void)passwordSignIn:(NSString *)username
+              password:(NSString *)password
+               resolve:(RCTPromiseResolveBlock)resolve
+                reject:(RCTPromiseRejectBlock)reject
+{
+  [_sModule passwordSignIn:username
+                  password:password
+                   resolver:resolve
+                   rejecter:reject];
+}
+
+- (void)getPassword:(RCTPromiseResolveBlock)resolve
+             reject:(RCTPromiseRejectBlock)reject
+{
+  [_sModule getPassword:resolve
+                            rejecter:reject];
+}
+
+
+- (void)hybridSignIn:(NSString *)clientId
+             options:(NSDictionary *)options
+             resolve:(RCTPromiseResolveBlock)resolve
+             reject:(RCTPromiseRejectBlock)reject
+{
+  [_sModule hybridSignIn:clientId options:options resolver:resolve rejecter:reject];
+}
+
+- (void)appleSignIn:(NSString *)webAndroidUrl
+            resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject {
+    [_sModule appleSignIn:webAndroidUrl resolver:resolve rejecter:reject];
+}
+
+- (void)createPassKey:(NSDictionary *)options
+              resolve:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject {
+    [_sModule createPassKey:options resolver:resolve rejecter:reject];
+}
+
+- (void)getPassKey:(NSDictionary *)options
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject {
+    [_sModule getPassKey:options resolver:resolve rejecter:reject];
+}
+
+- (facebook::react::ModuleConstants<JS::NativeOauthEssentials::Constants>) constantsToExport {
+  return (facebook::react::ModuleConstants<JS::NativeOauthEssentials::Constants>)[_sModule getConstants];
+}
+
+@end

package/ios/OauthEssentialsModule.swift

@@ -0,0 +1,210 @@
+import Foundation
+import React
+import GoogleSignIn
+import AuthenticationServices
+import Security
+import UIKit
+
+public class OauthEssentialsModule: NSObject {
+
+  public var onCredentialSuccess: ((NSDictionary) -> Void)?
+  public var onCredentialFailure: ((NSDictionary) -> Void)?
+
+  private var _password_retriever: PasswordRetriever? = nil
+  private var _google_id_retriever: GoogleIdRetriever? = nil
+  private var _apple_id_retriever: AppleIdRetriever? = nil
+  private var _hybrid_retriever: HybridRetriever? = nil
+  private var _passkey_retriever: RCTPromiseSettler? = nil
+
+  @objc
+  public init(
+    onCredentialSuccess: @escaping ((NSDictionary) -> Void),
+    onCredentialFailure: @escaping ((NSDictionary) -> Void)
+  ) {
+    super.init()
+
+    self.onCredentialSuccess = onCredentialSuccess
+    self.onCredentialFailure = onCredentialFailure
+  }
+
+  private func ensurePreviousPromiseSettled(settler: RCTPromiseSettler?, reject: RCTPromiseRejectBlock) -> Bool {
+    if settler == nil || (settler != nil && ((settler?.settled()) != nil)) {
+      return true
+    }
+
+    reject(
+      CredentialError.simultaneousCallError.rawValue,
+      "Another operation is in progress",
+      nil
+    )
+    return false
+  }
+
+  @objc(requiresMainQueueSetup)
+  static func requiresMainQueueSetup() -> Bool { true }
+
+  @objc
+  public func getConstants() -> [String: Any] {
+    var googleIdSupported: Bool = false
+    var appleIdSupported: Bool  = false
+    var passwordSupported: Bool  = false
+    var passkeySupported = false
+    if #available(iOS 13.0, *) {
+      // Modern GoogleSignIn works on iOS 13+
+      googleIdSupported = true
+      appleIdSupported = true
+      passwordSupported = true
+    }
+    if #available(iOS 16.0, *) {
+      passkeySupported = true
+    }
+
+    return [
+      "GOOGLE_ID_SUPPORTED": googleIdSupported,
+      "PASSWORD_SUPPORTED": passwordSupported,
+      "GOOGLE_PLAY_SERVICES_SUPPORTED": false, // Not applicable on iOS, it does not have Google Play Services
+      "APPLE_ID_SUPPORTED": appleIdSupported,
+      "HYBRID_SUPPORTED": true,
+      "PASSKEY_SUPPORTED": passkeySupported
+    ]
+  }
+
+  @objc
+  public func googleSignIn(
+    _ clientId: String,
+    options: NSDictionary,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    if (ensurePreviousPromiseSettled(settler: self._google_id_retriever,reject: reject)) {
+      self._google_id_retriever = GoogleIdRetriever(clientId: clientId, options: options,resolve: resolve,reject: reject, emitEvent: emitEvent)
+    }
+  }
+
+  @objc
+  public func passwordSignIn(
+    _ username: String,
+    password: String,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    if (ensurePreviousPromiseSettled(settler: self._apple_id_retriever, reject: reject)) {
+      self._apple_id_retriever = AppleIdRetriever(resolve: resolve, reject: reject, emitEvent: self.emitEvent)
+    }
+  }
+
+  @objc
+  public func getPassword(
+    _ resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+      if (ensurePreviousPromiseSettled(settler: self._password_retriever,reject: reject)) {
+        self._password_retriever = PasswordRetriever(resolve: resolve,reject: reject, emitEvent: self.emitEvent)
+      }
+  }
+
+  @objc
+  public func hybridSignIn(
+    _ clientId: String,
+    options: NSDictionary,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock) {
+    if (ensurePreviousPromiseSettled(settler: self._hybrid_retriever,reject: reject)) {
+      self._hybrid_retriever = HybridRetriever(clientId: clientId, options: options, resolve: resolve, reject: reject, emitEvent: emitEvent)
+    }
+  }
+
+  @objc(createPassKey:resolver:rejecter:)
+  public func createPassKey(
+    _ options: NSDictionary,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    guard #available(iOS 16.0, *) else {
+      reject(
+        CredentialError.notSupportedError.rawValue,
+        "Passkeys require iOS 16.0 or later",
+        nil
+      )
+      return
+    }
+
+    if ensurePreviousPromiseSettled(settler: self._passkey_retriever, reject: reject) {
+      guard let requestJson = options["requestJson"] as? String else {
+        reject(
+          CredentialError.invalidResult.rawValue,
+          "\"requestJson\" field is required",
+          nil
+        )
+        return
+      }
+
+      self._passkey_retriever = PasskeyRetriever(
+        requestJson: requestJson,
+        mode: .registration,
+        resolve: resolve,
+        reject: reject,
+        emitEvent: emitEvent
+      )
+    }
+  }
+
+  @objc(getPassKey:resolver:rejecter:)
+  public func getPassKey(
+    _ options: NSDictionary,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    guard #available(iOS 16.0, *) else {
+      reject(
+        CredentialError.notSupportedError.rawValue,
+        "Passkeys require iOS 16.0 or later",
+        nil
+      )
+      return
+    }
+
+    if ensurePreviousPromiseSettled(settler: self._passkey_retriever, reject: reject) {
+      guard let requestJson = options["requestJson"] as? String else {
+        reject(
+          CredentialError.invalidResult.rawValue,
+          "\"requestJson\" field is required",
+          nil
+        )
+        return
+      }
+
+      self._passkey_retriever = PasskeyRetriever(
+        requestJson: requestJson,
+        mode: .assertion,
+        resolve: resolve,
+        reject: reject,
+        emitEvent: emitEvent
+      )
+    }
+  }
+
+  @objc(appleSignIn:resolver:rejecter:)
+  public func appleSignIn(
+    _ webAndroidUrl: String,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    if (ensurePreviousPromiseSettled(settler: self._apple_id_retriever,reject: reject)) {
+      self._apple_id_retriever = AppleIdRetriever(resolve: resolve,reject: reject,  emitEvent: emitEvent)
+    }
+  }
+
+  private func emitEvent(eventName: String, body: NSDictionary) {
+    switch eventName {
+      case "onCredentialSuccess":
+        onCredentialSuccess?(body)
+
+      case "onCredentialFailure":
+        onCredentialFailure?(body)
+
+      default:
+        print("Unhandled event found: \(eventName)")
+    }
+  }
+}