Rebase and through getIDToken...

paulb777 · paulb777 · commit c497d1a56b51 · 2024-07-19T16:30:42.000-07:00
diff --git a/FirebaseAuth/Sources/Swift/Auth/AuthWorker.swift b/FirebaseAuth/Sources/Swift/Auth/AuthWorker.swift
@@ -317,6 +317,8 @@ actor AuthWorker {
     #endif
   }
 
+  // MARK: User.swift implementations
+
   func updateEmail(user: User,
                    email: String?,
                    password: String?) async throws {
@@ -373,6 +375,59 @@ actor AuthWorker {
     }
   }
 
+  #if os(iOS)
+    /// Updates the phone number for the user. On success, the cached user profile data is updated.
+    ///
+    /// Invoked asynchronously on the global work queue in the future.
+    /// - Parameter credential: The new phone number credential corresponding to the phone
+    /// number to be added to the Firebase account. If a phone number is already linked to the
+    /// account, this new phone number will replace it.
+    /// - Parameter isLinkOperation: Boolean value indicating whether or not this is a link
+    /// operation.
+    /// - Parameter completion: Optionally; the block invoked when the user profile change has
+    /// finished.
+    func updateOrLinkPhoneNumber(user: User, credential: PhoneAuthCredential,
+                                 isLinkOperation: Bool) async throws {
+      let accessToken = try await user.internalGetTokenAsync()
+
+      guard let configuration = user.auth?.requestConfiguration else {
+        fatalError("Auth Internal Error: nil value for VerifyPhoneNumberRequest initializer")
+      }
+      switch credential.credentialKind {
+      case .phoneNumber: fatalError("Internal Error: Missing verificationCode")
+      case let .verification(verificationID, code):
+        let operation = isLinkOperation ? AuthOperationType.link : AuthOperationType.update
+        let request = VerifyPhoneNumberRequest(verificationID: verificationID,
+                                               verificationCode: code,
+                                               operation: operation,
+                                               requestConfiguration: configuration)
+        request.accessToken = accessToken
+        do {
+          let verifyResponse = try await AuthBackend.call(with: request)
+          guard let idToken = verifyResponse.idToken,
+                let refreshToken = verifyResponse.refreshToken else {
+            fatalError("Internal Auth Error: missing token in internalUpdateOrLinkPhoneNumber")
+          }
+          user.tokenService = SecureTokenService(
+            withRequestConfiguration: configuration,
+            accessToken: idToken,
+            accessTokenExpirationDate: verifyResponse.approximateExpirationDate,
+            refreshToken: refreshToken
+          )
+          // Get account info to update cached user info.
+          let userAccount = try await getAccountInfoRefreshingCache(user)
+          user.isAnonymous = false
+          if let error = user.updateKeychain() {
+            throw error
+          }
+        } catch {
+          user.signOutIfTokenIsInvalid(withError: error)
+          throw error
+        }
+      }
+    }
+  #endif
+
   /// Performs a setAccountInfo request by mutating the results of a getAccountInfo response,
   /// atomically in regards to other calls to this method.
   /// - Parameter changeBlock: A block responsible for mutating a template `SetAccountInfoRequest`
@@ -410,7 +465,7 @@ actor AuthWorker {
   /// Gets the users' account data from the server, updating our local values.
   /// - Parameter callback: Invoked when the request to getAccountInfo has completed, or when an
   /// error has been detected. Invoked asynchronously on the auth global work queue in the future.
-  private func getAccountInfoRefreshingCache(_ user: User) async throws
+  func getAccountInfoRefreshingCache(_ user: User) async throws
     -> GetAccountInfoResponseUser {
     let token = try await user.internalGetTokenAsync()
     let request = GetAccountInfoRequest(accessToken: token,
@@ -438,8 +493,7 @@ actor AuthWorker {
       guard user.uid == requestConfiguration.auth?.getUserID() else {
         throw AuthErrorUtils.userMismatchError()
       }
-      // TODO: set tokenService migration
-
+      try await user.setTokenService(tokenService: user.tokenService)
       return authResult
     } catch {
       if (error as NSError).code == AuthErrorCode.userNotFound.rawValue {
@@ -449,6 +503,24 @@ actor AuthWorker {
     }
   }
 
+  #if os(iOS)
+    func reauthenticate(with provider: FederatedAuthProvider,
+                        uiDelegate: AuthUIDelegate?) async throws -> AuthDataResult {
+      let credential = try await provider.credential(with: uiDelegate)
+      return try await reauthenticate(with: credential)
+    }
+  #endif
+
+  func getIDTokenResult(user: User,
+                        forcingRefresh forceRefresh: Bool) async throws -> AuthTokenResult {
+    let token = try await user.internalGetTokenAsync(forceRefresh: forceRefresh)
+    let tokenResult = try AuthTokenResult.tokenResult(token: token)
+    AuthLog.logDebug(code: "I-AUT000017", message: "Actual token expiration date: " +
+      "\(String(describing: tokenResult.expirationDate))," +
+      "current date: \(Date())")
+    return tokenResult
+  }
+
   /// Update the current user; initializing the user's internal properties correctly, and
   /// optionally saving the user to disk.
   ///
diff --git a/FirebaseAuth/Sources/Swift/User/User.swift b/FirebaseAuth/Sources/Swift/User/User.swift
@@ -227,10 +227,16 @@ extension User: NSSecureCoding {}
     @objc(updatePhoneNumberCredential:completion:)
     open func updatePhoneNumber(_ credential: PhoneAuthCredential,
                                 completion: ((Error?) -> Void)? = nil) {
-      kAuthGlobalWorkQueue.async {
-        self.internalUpdateOrLinkPhoneNumber(credential: credential,
-                                             isLinkOperation: false) { error in
-          User.callInMainThreadWithError(callback: completion, error: error)
+      Task {
+        do {
+          try await self.updatePhoneNumber(credential)
+          await MainActor.run {
+            completion?(nil)
+          }
+        } catch {
+          await MainActor.run {
+            completion?(error)
+          }
         }
       }
     }
@@ -251,15 +257,9 @@ extension User: NSSecureCoding {}
     /// account this new phone number will replace it.
     @available(iOS 13, tvOS 13, macOS 10.15, macCatalyst 13, watchOS 7, *)
     open func updatePhoneNumber(_ credential: PhoneAuthCredential) async throws {
-      return try await withCheckedThrowingContinuation { continuation in
-        self.updatePhoneNumber(credential) { error in
-          if let error {
-            continuation.resume(throwing: error)
-          } else {
-            continuation.resume()
-          }
-        }
-      }
+      try await auth.authWorker.updateOrLinkPhoneNumber(user: self,
+                                                        credential: credential,
+                                                        isLinkOperation: false)
     }
   #endif
 
@@ -296,9 +296,16 @@ extension User: NSSecureCoding {}
   /// - Parameter completion: Optionally; the block invoked when the reload has finished. Invoked
   ///   asynchronously on the main thread in the future.
   @objc open func reload(completion: ((Error?) -> Void)? = nil) {
-    kAuthGlobalWorkQueue.async {
-      self.getAccountInfoRefreshingCache { user, error in
-        User.callInMainThreadWithError(callback: completion, error: error)
+    Task {
+      do {
+        try await self.reload()
+        await MainActor.run {
+          completion?(nil)
+        }
+      } catch {
+        await MainActor.run {
+          completion?(error)
+        }
       }
     }
   }
@@ -310,15 +317,7 @@ extension User: NSSecureCoding {}
   /// `updateEmail(to:)`.
   @available(iOS 13, tvOS 13, macOS 10.15, macCatalyst 13, watchOS 7, *)
   open func reload() async throws {
-    return try await withCheckedThrowingContinuation { continuation in
-      self.reload { error in
-        if let error {
-          continuation.resume(throwing: error)
-        } else {
-          continuation.resume()
-        }
-      }
-    }
+    let _ = try await auth.authWorker.getAccountInfoRefreshingCache(self)
   }
 
   /// Renews the user's authentication tokens by validating a fresh set of credentials supplied
@@ -418,15 +417,15 @@ extension User: NSSecureCoding {}
     open func reauthenticate(with provider: FederatedAuthProvider,
                              uiDelegate: AuthUIDelegate?,
                              completion: ((AuthDataResult?, Error?) -> Void)? = nil) {
-      kAuthGlobalWorkQueue.async {
-        Task {
-          do {
-            let credential = try await provider.credential(with: uiDelegate)
-            self.reauthenticate(with: credential, completion: completion)
-          } catch {
-            if let completion {
-              completion(nil, error)
-            }
+      Task {
+        do {
+          let result = try await reauthenticate(with: provider, uiDelegate: uiDelegate)
+          await MainActor.run {
+            completion?(result, nil)
+          }
+        } catch {
+          await MainActor.run {
+            completion?(nil, error)
           }
         }
       }
@@ -445,15 +444,7 @@ extension User: NSSecureCoding {}
     @discardableResult
     open func reauthenticate(with provider: FederatedAuthProvider,
                              uiDelegate: AuthUIDelegate?) async throws -> AuthDataResult {
-      return try await withCheckedThrowingContinuation { continuation in
-        self.reauthenticate(with: provider, uiDelegate: uiDelegate) { result, error in
-          if let result {
-            continuation.resume(returning: result)
-          } else if let error {
-            continuation.resume(throwing: error)
-          }
-        }
-      }
+      return try await auth.authWorker.reauthenticate(with: provider, uiDelegate: uiDelegate)
     }
   #endif
 
@@ -478,10 +469,15 @@ extension User: NSSecureCoding {}
   @objc(getIDTokenForcingRefresh:completion:)
   open func getIDTokenForcingRefresh(_ forceRefresh: Bool,
                                      completion: ((String?, Error?) -> Void)?) {
-    getIDTokenResult(forcingRefresh: forceRefresh) { tokenResult, error in
-      if let completion {
-        DispatchQueue.main.async {
-          completion(tokenResult?.token, error)
+    Task {
+      do {
+        let tokenResult = try await getIDTokenResult(forcingRefresh: forceRefresh)
+        await MainActor.run {
+          completion?(tokenResult.token, nil)
+        }
+      } catch {
+        await MainActor.run {
+          completion?(nil, error)
         }
       }
     }
@@ -496,15 +492,7 @@ extension User: NSSecureCoding {}
   /// - Returns: The Firebase authentication token.
   @available(iOS 13, tvOS 13, macOS 10.15, macCatalyst 13, watchOS 7, *)
   open func getIDToken(forcingRefresh forceRefresh: Bool = false) async throws -> String {
-    return try await withCheckedThrowingContinuation { continuation in
-      self.getIDTokenForcingRefresh(forceRefresh) { tokenResult, error in
-        if let tokenResult {
-          continuation.resume(returning: tokenResult)
-        } else if let error {
-          continuation.resume(throwing: error)
-        }
-      }
-    }
+    return try await getIDTokenResult(forcingRefresh: forceRefresh).token
   }
 
   /// API included for compatibility with a mis-named Firebase 10 API.
@@ -518,13 +506,7 @@ extension User: NSSecureCoding {}
   ///    asynchronously on the main thread in the future.
   @objc(getIDTokenResultWithCompletion:)
   open func getIDTokenResult(completion: ((AuthTokenResult?, Error?) -> Void)?) {
-    getIDTokenResult(forcingRefresh: false) { tokenResult, error in
-      if let completion {
-        DispatchQueue.main.async {
-          completion(tokenResult, error)
-        }
-      }
-    }
+    getIDTokenResult(forcingRefresh: false, completion: completion)
   }
 
   /// Retrieves the Firebase authentication token, possibly refreshing it if it has expired.
@@ -539,34 +521,15 @@ extension User: NSSecureCoding {}
   @objc(getIDTokenResultForcingRefresh:completion:)
   open func getIDTokenResult(forcingRefresh: Bool,
                              completion: ((AuthTokenResult?, Error?) -> Void)?) {
-    kAuthGlobalWorkQueue.async {
-      self.internalGetToken(forceRefresh: forcingRefresh) { token, error in
-        var tokenResult: AuthTokenResult?
-        if let token {
-          do {
-            tokenResult = try AuthTokenResult.tokenResult(token: token)
-            AuthLog.logDebug(code: "I-AUT000017", message: "Actual token expiration date: " +
-              "\(String(describing: tokenResult?.expirationDate))," +
-              "current date: \(Date())")
-            if let completion {
-              DispatchQueue.main.async {
-                completion(tokenResult, error)
-              }
-            }
-            return
-          } catch {
-            if let completion {
-              DispatchQueue.main.async {
-                completion(tokenResult, error)
-              }
-            }
-            return
-          }
+    Task {
+      do {
+        let tokenResult = try await getIDTokenResult(forcingRefresh: forcingRefresh)
+        await MainActor.run {
+          completion?(tokenResult, nil)
         }
-        if let completion {
-          DispatchQueue.main.async {
-            completion(nil, error)
-          }
+      } catch {
+        await MainActor.run {
+          completion?(nil, error)
         }
       }
     }
@@ -582,15 +545,7 @@ extension User: NSSecureCoding {}
   @available(iOS 13, tvOS 13, macOS 10.15, macCatalyst 13, watchOS 7, *)
   open func getIDTokenResult(forcingRefresh forceRefresh: Bool = false) async throws
     -> AuthTokenResult {
-    return try await withCheckedThrowingContinuation { continuation in
-      self.getIDTokenResult(forcingRefresh: forceRefresh) { tokenResult, error in
-        if let tokenResult {
-          continuation.resume(returning: tokenResult)
-        } else if let error {
-          continuation.resume(throwing: error)
-        }
-      }
-    }
+    try await auth.authWorker.getIDTokenResult(user: self, forcingRefresh: forceRefresh)
   }
 
   /// Associates a user account from a third-party identity provider with this user and
diff --git a/FirebaseAuth/Tests/Unit/UserTests.swift b/FirebaseAuth/Tests/Unit/UserTests.swift
