[Auth] Use result type to wrap completion handlers internally (#13563)

ncooke3 · web-flow · commit 454f3999ce8f · 2024-12-03T17:58:52.000-05:00
diff --git a/FirebaseAuth/Sources/Swift/Auth/Auth.swift b/FirebaseAuth/Sources/Swift/Auth/Auth.swift
@@ -300,9 +300,9 @@ extension Auth: AuthInterop {
       Task {
         do {
           let response = try await self.backend.call(with: request)
-          Auth.wrapMainAsync(callback: completion, withParam: response.signinMethods, error: nil)
+          Auth.wrapMainAsync(callback: completion, with: .success(response.signinMethods))
         } catch {
-          Auth.wrapMainAsync(callback: completion, withParam: nil, error: error)
+          Auth.wrapMainAsync(callback: completion, with: .failure(error))
         }
       }
     }
@@ -365,9 +365,9 @@ extension Auth: AuthInterop {
             withEmail: email,
             password: password
           )
-          decoratedCallback(authData, nil)
+          decoratedCallback(.success(authData))
         } catch {
-          decoratedCallback(nil, error)
+          decoratedCallback(.failure(error))
         }
       }
     }
@@ -463,9 +463,9 @@ extension Auth: AuthInterop {
         do {
           let authData = try await self.internalSignInAndRetrieveData(withCredential: credential,
                                                                       isReauthentication: false)
-          decoratedCallback(authData, nil)
+          decoratedCallback(.success(authData))
         } catch {
-          decoratedCallback(nil, error)
+          decoratedCallback(.failure(error))
         }
       }
     }
@@ -544,9 +544,9 @@ extension Auth: AuthInterop {
               withCredential: credential,
               isReauthentication: false
             )
-            decoratedCallback(authData, nil)
+            decoratedCallback(.success(authData))
           } catch {
-            decoratedCallback(nil, error)
+            decoratedCallback(.failure(error))
           }
         }
       }
@@ -642,9 +642,9 @@ extension Auth: AuthInterop {
         do {
           let authData = try await self.internalSignInAndRetrieveData(withCredential: credential,
                                                                       isReauthentication: false)
-          decoratedCallback(authData, nil)
+          decoratedCallback(.success(authData))
         } catch {
-          decoratedCallback(nil, error)
+          decoratedCallback(.failure(error))
         }
       }
     }
@@ -710,7 +710,7 @@ extension Auth: AuthInterop {
       let decoratedCallback = self.signInFlowAuthDataResultCallback(byDecorating: completion)
       if let currentUser = self._currentUser, currentUser.isAnonymous {
         let result = AuthDataResult(withUser: currentUser, additionalUserInfo: nil)
-        decoratedCallback(result, nil)
+        decoratedCallback(.success(result))
         return
       }
       let request = SignUpNewUserRequest(requestConfiguration: self.requestConfiguration)
@@ -728,10 +728,11 @@ extension Auth: AuthInterop {
                                                       profile: nil,
                                                       username: nil,
                                                       isNewUser: true)
-          decoratedCallback(AuthDataResult(withUser: user, additionalUserInfo: additionalUserInfo),
-                            nil)
+          decoratedCallback(
+            .success(AuthDataResult(withUser: user, additionalUserInfo: additionalUserInfo))
+          )
         } catch {
-          decoratedCallback(nil, error)
+          decoratedCallback(.failure(error))
         }
       }
     }
@@ -790,10 +791,11 @@ extension Auth: AuthInterop {
                                                       profile: nil,
                                                       username: nil,
                                                       isNewUser: response.isNewUser)
-          decoratedCallback(AuthDataResult(withUser: user, additionalUserInfo: additionalUserInfo),
-                            nil)
+          decoratedCallback(
+            .success(AuthDataResult(withUser: user, additionalUserInfo: additionalUserInfo))
+          )
         } catch {
-          decoratedCallback(nil, error)
+          decoratedCallback(.failure(error))
         }
       }
     }
@@ -866,7 +868,7 @@ extension Auth: AuthInterop {
                                  action: AuthRecaptchaAction.signUpPassword) { response, error in
           if let error {
             DispatchQueue.main.async {
-              decoratedCallback(nil, error)
+              decoratedCallback(.failure(error))
             }
             return
           }
@@ -881,7 +883,8 @@ extension Auth: AuthInterop {
 
   func internalCreateUserWithEmail(request: SignUpNewUserRequest,
                                    inResponse: SignUpNewUserResponse? = nil,
-                                   decoratedCallback: @escaping (AuthDataResult?, Error?) -> Void) {
+                                   decoratedCallback: @escaping (Result<AuthDataResult, Error>)
+                                     -> Void) {
     Task {
       do {
         var response: SignUpNewUserResponse
@@ -900,11 +903,11 @@ extension Auth: AuthInterop {
                                                     profile: nil,
                                                     username: nil,
                                                     isNewUser: true)
-        decoratedCallback(AuthDataResult(withUser: user,
-                                         additionalUserInfo: additionalUserInfo),
-                          nil)
+        decoratedCallback(
+          .success(AuthDataResult(withUser: user, additionalUserInfo: additionalUserInfo))
+        )
       } catch {
-        decoratedCallback(nil, error)
+        decoratedCallback(.failure(error))
       }
     }
   }
@@ -1009,9 +1012,9 @@ extension Auth: AuthInterop {
           let actionCodeInfo = ActionCodeInfo(withOperation: operation,
                                               email: email,
                                               newEmail: response.verifiedEmail)
-          Auth.wrapMainAsync(callback: completion, withParam: actionCodeInfo, error: nil)
+          Auth.wrapMainAsync(callback: completion, with: .success(actionCodeInfo))
         } catch {
-          Auth.wrapMainAsync(callback: completion, withParam: nil, error: error)
+          Auth.wrapMainAsync(callback: completion, with: .failure(error))
         }
       }
     }
@@ -2238,23 +2241,19 @@ extension Auth: AuthInterop {
   /// Invoked asynchronously on the main thread in the future.
   /// - Returns: Returns a block that updates the current user.
   func signInFlowAuthDataResultCallback(byDecorating callback:
-    ((AuthDataResult?, Error?) -> Void)?) -> (AuthDataResult?, Error?) -> Void {
-    let authDataCallback: (((AuthDataResult?, Error?) -> Void)?, AuthDataResult?, Error?) -> Void =
-      { callback, result, error in
-        Auth.wrapMainAsync(callback: callback, withParam: result, error: error)
-      }
-    return { authResult, error in
-      if let error {
-        authDataCallback(callback, nil, error)
-        return
-      }
-      do {
-        try self.updateCurrentUser(authResult?.user, byForce: false, savingToDisk: true)
-      } catch {
-        authDataCallback(callback, nil, error)
-        return
+    ((AuthDataResult?, Error?) -> Void)?) -> (Result<AuthDataResult, Error>) -> Void {
+    return { result in
+      switch result {
+      case let .success(authResult):
+        do {
+          try self.updateCurrentUser(authResult.user, byForce: false, savingToDisk: true)
+          Auth.wrapMainAsync(callback: callback, with: .success(authResult))
+        } catch {
+          Auth.wrapMainAsync(callback: callback, with: .failure(error))
+        }
+      case let .failure(error):
+        Auth.wrapMainAsync(callback: callback, with: .failure(error))
       }
-      authDataCallback(callback, authResult, nil)
     }
   }
 
@@ -2278,11 +2277,12 @@ extension Auth: AuthInterop {
   }
 
   class func wrapMainAsync<T: Any>(callback: ((T?, Error?) -> Void)?,
-                                   withParam param: T?,
-                                   error: Error?) -> Void {
-    if let callback {
-      DispatchQueue.main.async {
-        callback(param, error)
+                                   with result: Result<T, Error>) -> Void {
+    guard let callback else { return }
+    DispatchQueue.main.async {
+      switch result {
+      case let .success(success): callback(success, nil)
+      case let .failure(error): callback(nil, error)
       }
     }
   }
diff --git a/FirebaseAuth/Sources/Swift/AuthProvider/PhoneAuthProvider.swift b/FirebaseAuth/Sources/Swift/AuthProvider/PhoneAuthProvider.swift
@@ -265,10 +265,10 @@ import Foundation
     /// - Parameter phoneNumber: The phone number to be verified.
     /// - Parameter callback: The callback to be invoked on the global work queue when the flow is
     /// finished.
-    func verifyClAndSendVerificationCode(toPhoneNumber phoneNumber: String,
-                                         retryOnInvalidAppCredential: Bool,
-                                         uiDelegate: AuthUIDelegate?,
-                                         auditFallback: Bool = false) async throws
+    private func verifyClAndSendVerificationCode(toPhoneNumber phoneNumber: String,
+                                                 retryOnInvalidAppCredential: Bool,
+                                                 uiDelegate: AuthUIDelegate?,
+                                                 auditFallback: Bool = false) async throws
       -> String? {
       let codeIdentity = try await verifyClient(withUIDelegate: uiDelegate)
       let request = SendVerificationCodeRequest(phoneNumber: phoneNumber,
@@ -350,7 +350,7 @@ import Foundation
             action: .mfaSmsSignIn
           )
           let response = try await auth.backend.call(with: request)
-          return response.responseInfo?.sessionInfo
+          return response.responseInfo.sessionInfo
         }
       } catch {
         // For Audit fallback only after rCE check failed
@@ -419,9 +419,8 @@ import Foundation
                                               MFAEnrollmentID: session.multiFactorInfo?.uid,
                                               signInInfo: startMFARequestInfo,
                                               requestConfiguration: auth.requestConfiguration)
-
           let response = try await auth.backend.call(with: request)
-          return response.responseInfo?.sessionInfo
+          return response.responseInfo.sessionInfo
         }
       } catch {
         return try await handleVerifyErrorWithRetry(
diff --git a/FirebaseAuth/Sources/Swift/Backend/RPC/MultiFactor/SignIn/StartMFASignInResponse.swift b/FirebaseAuth/Sources/Swift/Backend/RPC/MultiFactor/SignIn/StartMFASignInResponse.swift
@@ -16,7 +16,7 @@ import Foundation
 
 @available(iOS 13, tvOS 13, macOS 10.15, macCatalyst 13, watchOS 7, *)
 struct StartMFASignInResponse: AuthRPCResponse {
-  var responseInfo: AuthProtoStartMFAPhoneResponseInfo?
+  let responseInfo: AuthProtoStartMFAPhoneResponseInfo
 
   init(dictionary: [String: AnyHashable]) throws {
     if let data = dictionary["phoneResponseInfo"] as? [String: AnyHashable] {
diff --git a/FirebaseAuth/Sources/Swift/Backend/RPC/SendVerificationTokenResponse.swift b/FirebaseAuth/Sources/Swift/Backend/RPC/SendVerificationTokenResponse.swift
@@ -15,7 +15,7 @@
 import Foundation
 
 struct SendVerificationCodeResponse: AuthRPCResponse {
-  var verificationID: String?
+  let verificationID: String?
 
   init(dictionary: [String: AnyHashable]) throws {
     verificationID = dictionary["sessionInfo"] as? String
diff --git a/FirebaseAuth/Sources/Swift/MultiFactor/MultiFactorResolver.swift b/FirebaseAuth/Sources/Swift/MultiFactor/MultiFactorResolver.swift
@@ -80,7 +80,7 @@ import Foundation
           let result = AuthDataResult(withUser: user, additionalUserInfo: nil)
           let decoratedCallback = self.auth
             .signInFlowAuthDataResultCallback(byDecorating: completion)
-          decoratedCallback(result, nil)
+          decoratedCallback(.success(result))
         } catch {
           if let completion {
             completion(nil, error)

Original file line number	Diff line number	Diff line change
`@@ -300,9 +300,9 @@ extension Auth: AuthInterop {`
`300`	`300`	`Task {`
`301`	`301`	`do {`
`302`	`302`	`let response = try await self.backend.call(with: request)`
`303`		`- Auth.wrapMainAsync(callback: completion, withParam: response.signinMethods, error: nil)`
	`303`	`+ Auth.wrapMainAsync(callback: completion, with: .success(response.signinMethods))`
`304`	`304`	`} catch {`
`305`		`- Auth.wrapMainAsync(callback: completion, withParam: nil, error: error)`
	`305`	`+ Auth.wrapMainAsync(callback: completion, with: .failure(error))`
`306`	`306`	`}`
`307`	`307`	`}`
`308`	`308`	`}`
`@@ -365,9 +365,9 @@ extension Auth: AuthInterop {`
`365`	`365`	`withEmail: email,`
`366`	`366`	`password: password`
`367`	`367`	`)`
`368`		`- decoratedCallback(authData, nil)`
	`368`	`+ decoratedCallback(.success(authData))`
`369`	`369`	`} catch {`
`370`		`- decoratedCallback(nil, error)`
	`370`	`+ decoratedCallback(.failure(error))`
`371`	`371`	`}`
`372`	`372`	`}`
`373`	`373`	`}`
`@@ -463,9 +463,9 @@ extension Auth: AuthInterop {`
`463`	`463`	`do {`
`464`	`464`	`let authData = try await self.internalSignInAndRetrieveData(withCredential: credential,`
`465`	`465`	`isReauthentication: false)`
`466`		`- decoratedCallback(authData, nil)`
	`466`	`+ decoratedCallback(.success(authData))`
`467`	`467`	`} catch {`
`468`		`- decoratedCallback(nil, error)`
	`468`	`+ decoratedCallback(.failure(error))`
`469`	`469`	`}`
`470`	`470`	`}`
`471`	`471`	`}`
`@@ -544,9 +544,9 @@ extension Auth: AuthInterop {`
`544`	`544`	`withCredential: credential,`
`545`	`545`	`isReauthentication: false`
`546`	`546`	`)`
`547`		`- decoratedCallback(authData, nil)`
	`547`	`+ decoratedCallback(.success(authData))`
`548`	`548`	`} catch {`
`549`		`- decoratedCallback(nil, error)`
	`549`	`+ decoratedCallback(.failure(error))`
`550`	`550`	`}`
`551`	`551`	`}`
`552`	`552`	`}`
`@@ -642,9 +642,9 @@ extension Auth: AuthInterop {`
`642`	`642`	`do {`
`643`	`643`	`let authData = try await self.internalSignInAndRetrieveData(withCredential: credential,`
`644`	`644`	`isReauthentication: false)`
`645`		`- decoratedCallback(authData, nil)`
	`645`	`+ decoratedCallback(.success(authData))`
`646`	`646`	`} catch {`
`647`		`- decoratedCallback(nil, error)`
	`647`	`+ decoratedCallback(.failure(error))`
`648`	`648`	`}`
`649`	`649`	`}`
`650`	`650`	`}`
`@@ -710,7 +710,7 @@ extension Auth: AuthInterop {`
`710`	`710`	`let decoratedCallback = self.signInFlowAuthDataResultCallback(byDecorating: completion)`
`711`	`711`	`if let currentUser = self._currentUser, currentUser.isAnonymous {`
`712`	`712`	`let result = AuthDataResult(withUser: currentUser, additionalUserInfo: nil)`
`713`		`- decoratedCallback(result, nil)`
	`713`	`+ decoratedCallback(.success(result))`
`714`	`714`	`return`
`715`	`715`	`}`
`716`	`716`	`let request = SignUpNewUserRequest(requestConfiguration: self.requestConfiguration)`
`@@ -728,10 +728,11 @@ extension Auth: AuthInterop {`
`728`	`728`	`profile: nil,`
`729`	`729`	`username: nil,`
`730`	`730`	`isNewUser: true)`
`731`		`- decoratedCallback(AuthDataResult(withUser: user, additionalUserInfo: additionalUserInfo),`
`732`		`- nil)`
	`731`	`+ decoratedCallback(`
	`732`	`+ .success(AuthDataResult(withUser: user, additionalUserInfo: additionalUserInfo))`
	`733`	`+ )`
`733`	`734`	`} catch {`
`734`		`- decoratedCallback(nil, error)`
	`735`	`+ decoratedCallback(.failure(error))`
`735`	`736`	`}`
`736`	`737`	`}`
`737`	`738`	`}`
`@@ -790,10 +791,11 @@ extension Auth: AuthInterop {`
`790`	`791`	`profile: nil,`
`791`	`792`	`username: nil,`
`792`	`793`	`isNewUser: response.isNewUser)`
`793`		`- decoratedCallback(AuthDataResult(withUser: user, additionalUserInfo: additionalUserInfo),`
`794`		`- nil)`
	`794`	`+ decoratedCallback(`
	`795`	`+ .success(AuthDataResult(withUser: user, additionalUserInfo: additionalUserInfo))`
	`796`	`+ )`
`795`	`797`	`} catch {`
`796`		`- decoratedCallback(nil, error)`
	`798`	`+ decoratedCallback(.failure(error))`
`797`	`799`	`}`
`798`	`800`	`}`
`799`	`801`	`}`
`@@ -866,7 +868,7 @@ extension Auth: AuthInterop {`
`866`	`868`	`action: AuthRecaptchaAction.signUpPassword) { response, error in`
`867`	`869`	`if let error {`
`868`	`870`	`DispatchQueue.main.async {`
`869`		`- decoratedCallback(nil, error)`
	`871`	`+ decoratedCallback(.failure(error))`
`870`	`872`	`}`
`871`	`873`	`return`
`872`	`874`	`}`
`@@ -881,7 +883,8 @@ extension Auth: AuthInterop {`
`881`	`883`
`882`	`884`	`func internalCreateUserWithEmail(request: SignUpNewUserRequest,`
`883`	`885`	`inResponse: SignUpNewUserResponse? = nil,`
`884`		`- decoratedCallback: @escaping (AuthDataResult?, Error?) -> Void) {`
	`886`	`+ decoratedCallback: @escaping (Result<AuthDataResult, Error>)`
	`887`	`+ -> Void) {`
`885`	`888`	`Task {`
`886`	`889`	`do {`
`887`	`890`	`var response: SignUpNewUserResponse`
`@@ -900,11 +903,11 @@ extension Auth: AuthInterop {`
`900`	`903`	`profile: nil,`
`901`	`904`	`username: nil,`
`902`	`905`	`isNewUser: true)`
`903`		`- decoratedCallback(AuthDataResult(withUser: user,`
`904`		`- additionalUserInfo: additionalUserInfo),`
`905`		`- nil)`
	`906`	`+ decoratedCallback(`
	`907`	`+ .success(AuthDataResult(withUser: user, additionalUserInfo: additionalUserInfo))`
	`908`	`+ )`
`906`	`909`	`} catch {`
`907`		`- decoratedCallback(nil, error)`
	`910`	`+ decoratedCallback(.failure(error))`
`908`	`911`	`}`
`909`	`912`	`}`
`910`	`913`	`}`
`@@ -1009,9 +1012,9 @@ extension Auth: AuthInterop {`
`1009`	`1012`	`let actionCodeInfo = ActionCodeInfo(withOperation: operation,`
`1010`	`1013`	`email: email,`
`1011`	`1014`	`newEmail: response.verifiedEmail)`
`1012`		`- Auth.wrapMainAsync(callback: completion, withParam: actionCodeInfo, error: nil)`
	`1015`	`+ Auth.wrapMainAsync(callback: completion, with: .success(actionCodeInfo))`
`1013`	`1016`	`} catch {`
`1014`		`- Auth.wrapMainAsync(callback: completion, withParam: nil, error: error)`
	`1017`	`+ Auth.wrapMainAsync(callback: completion, with: .failure(error))`
`1015`	`1018`	`}`
`1016`	`1019`	`}`
`1017`	`1020`	`}`
`@@ -2238,23 +2241,19 @@ extension Auth: AuthInterop {`
`2238`	`2241`	`/// Invoked asynchronously on the main thread in the future.`
`2239`	`2242`	`/// - Returns: Returns a block that updates the current user.`
`2240`	`2243`	`func signInFlowAuthDataResultCallback(byDecorating callback:`
`2241`		`- ((AuthDataResult?, Error?) -> Void)?) -> (AuthDataResult?, Error?) -> Void {`
`2242`		`- let authDataCallback: (((AuthDataResult?, Error?) -> Void)?, AuthDataResult?, Error?) -> Void =`
`2243`		`- { callback, result, error in`
`2244`		`- Auth.wrapMainAsync(callback: callback, withParam: result, error: error)`
`2245`		`- }`
`2246`		`- return { authResult, error in`
`2247`		`- if let error {`
`2248`		`- authDataCallback(callback, nil, error)`
`2249`		`- return`
`2250`		`- }`
`2251`		`- do {`
`2252`		`- try self.updateCurrentUser(authResult?.user, byForce: false, savingToDisk: true)`
`2253`		`- } catch {`
`2254`		`- authDataCallback(callback, nil, error)`
`2255`		`- return`
	`2244`	`+ ((AuthDataResult?, Error?) -> Void)?) -> (Result<AuthDataResult, Error>) -> Void {`
	`2245`	`+ return { result in`
	`2246`	`+ switch result {`
	`2247`	`+ case let .success(authResult):`
	`2248`	`+ do {`
	`2249`	`+ try self.updateCurrentUser(authResult.user, byForce: false, savingToDisk: true)`
	`2250`	`+ Auth.wrapMainAsync(callback: callback, with: .success(authResult))`
	`2251`	`+ } catch {`
	`2252`	`+ Auth.wrapMainAsync(callback: callback, with: .failure(error))`
	`2253`	`+ }`
	`2254`	`+ case let .failure(error):`
	`2255`	`+ Auth.wrapMainAsync(callback: callback, with: .failure(error))`
`2256`	`2256`	`}`
`2257`		`- authDataCallback(callback, authResult, nil)`
`2258`	`2257`	`}`
`2259`	`2258`	`}`
`2260`	`2259`
`@@ -2278,11 +2277,12 @@ extension Auth: AuthInterop {`
`2278`	`2277`	`}`
`2279`	`2278`
`2280`	`2279`	`class func wrapMainAsync<T: Any>(callback: ((T?, Error?) -> Void)?,`
`2281`		`- withParam param: T?,`
`2282`		`- error: Error?) -> Void {`
`2283`		`- if let callback {`
`2284`		`- DispatchQueue.main.async {`
`2285`		`- callback(param, error)`
	`2280`	`+ with result: Result<T, Error>) -> Void {`
	`2281`	`+ guard let callback else { return }`
	`2282`	`+ DispatchQueue.main.async {`
	`2283`	`+ switch result {`
	`2284`	`+ case let .success(success): callback(success, nil)`
	`2285`	`+ case let .failure(error): callback(nil, error)`
`2286`	`2286`	`}`
`2287`	`2287`	`}`
`2288`	`2288`	`}`