feat: init SwiftUI library for FirebaseAuthSwiftUI

.gitignore

@@ -16,7 +16,7 @@ DerivedData
 *.hmap
 *.ipa
 *.xcuserstate
-
+.build/
 # Third Party
 /sdk
 

.swiftformat

@@ -0,0 +1,5 @@
+# Formatting Options
+--indent 2
+--maxwidth 100
+--wrapparameters afterfirst
+--disable wrapMultilineStatementBraces

FirebaseSwiftUI/FirebaseAuthSwiftUI/.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+/.build
+/Packages
+xcuserdata/
+DerivedData/
+.swiftpm/configuration/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
+.netrc

FirebaseSwiftUI/FirebaseAuthSwiftUI/Sources/Services/AuthConfiguration.swift

@@ -0,0 +1,24 @@
+import Foundation
+
+public final class AuthConfiguration {
+  let shouldHideCancelButton: Bool
+  let interactiveDismissEnabled: Bool
+  let shouldAutoUpgradeAnonymousUsers: Bool
+  let customStringsBundle: Bundle?
+  let tosUrl: URL
+  let privacyPolicyUrl: URL
+
+  public init(shouldHideCancelButton: Bool = false,
+              interactiveDismissEnabled: Bool = true,
+              shouldAutoUpgradeAnonymousUsers: Bool = false,
+              customStringsBundle: Bundle? = nil,
+              tosUrl: URL = URL(string: "https://example.com/tos")!,
+              privacyPolicyUrl: URL = URL(string: "https://example.com/privacy")!) {
+    self.shouldHideCancelButton = shouldHideCancelButton
+    self.interactiveDismissEnabled = interactiveDismissEnabled
+    self.shouldAutoUpgradeAnonymousUsers = shouldAutoUpgradeAnonymousUsers
+    self.customStringsBundle = customStringsBundle
+    self.tosUrl = tosUrl
+    self.privacyPolicyUrl = privacyPolicyUrl
+  }
+}

FirebaseSwiftUI/FirebaseAuthSwiftUI/Sources/Services/AuthService.swift

@@ -0,0 +1,205 @@
+@preconcurrency import FirebaseAuth
+import SwiftUI
+
+public protocol GoogleProviderProtocol {
+  func handleUrl(_ url: URL) -> Bool
+  @MainActor func signInWithGoogle(clientID: String) async throws -> AuthCredential
+}
+
+public protocol FacebookProviderProtocol {}
+
+public enum AuthenticationProvider {
+  case email
+  case google
+}
+
+public enum AuthenticationOperationType: String {
+  case signIn
+  case signUp
+  case deleteAccount
+}
+
+public enum AuthenticationState {
+  case unauthenticated
+  case authenticating
+  case authenticated
+}
+
+public enum AuthenticationFlow {
+  case login
+  case signUp
+}
+
+@MainActor
+final class AuthListenerManager {
+  private var authStateHandle: AuthStateDidChangeListenerHandle?
+  private let auth: Auth
+  private weak var authEnvironment: AuthService?
+
+  init(auth: Auth, authEnvironment: AuthService) {
+    self.auth = auth
+    self.authEnvironment = authEnvironment
+    setupAuthenticationListener()
+  }
+
+  deinit {
+    if let handle = authStateHandle {
+      auth.removeStateDidChangeListener(handle)
+    }
+  }
+
+  private func setupAuthenticationListener() {
+    authStateHandle = auth.addStateDidChangeListener { [weak self] _, user in
+      self?.authEnvironment?.currentUser = user
+      self?.authEnvironment?.updateAuthenticationState()
+    }
+  }
+}
+
+@MainActor
+@Observable
+public final class AuthService {
+  public let configuration: AuthConfiguration
+  public let auth: Auth
+  private var listenerManager: AuthListenerManager?
+  private let googleProvider: GoogleProviderProtocol?
+  private let facebookProvider: FacebookProviderProtocol?
+  public let string: StringUtils
+
+  public init(configuration: AuthConfiguration = AuthConfiguration(), auth: Auth = Auth.auth(),
+              googleProvider: GoogleProviderProtocol? = nil,
+              facebookProvider: FacebookProviderProtocol? = nil) {
+    self.auth = auth
+    self.configuration = configuration
+    self.googleProvider = googleProvider
+    self.facebookProvider = facebookProvider
+    string = StringUtils(bundle: configuration.customStringsBundle ?? Bundle.module)
+    listenerManager = AuthListenerManager(auth: auth, authEnvironment: self)
+  }
+
+  public var currentUser: User?
+  public var authenticationState: AuthenticationState = .unauthenticated
+  public var authenticationFlow: AuthenticationFlow = .login
+
+  private var safeGoogleProvider: GoogleProviderProtocol {
+    get throws {
+      guard let provider = googleProvider else {
+        throw NSError(
+          domain: "AuthEnvironmentErrorDomain",
+          code: 1,
+          userInfo: [
+            NSLocalizedDescriptionKey: "`GoogleProviderSwift` has not been configured",
+          ]
+        )
+      }
+      return provider
+    }
+  }
+
+  private var safeFacebookProvider: FacebookProviderProtocol {
+    get throws {
+      guard let provider = facebookProvider else {
+        throw NSError(
+          domain: "AuthEnvironmentErrorDomain",
+          code: 1,
+          userInfo: [
+            NSLocalizedDescriptionKey: "`FacebookProviderSwift` has not been configured",
+          ]
+        )
+      }
+      return provider
+    }
+  }
+
+  func updateAuthenticationState() {
+    authenticationState =
+      (currentUser == nil || currentUser?.isAnonymous == true)
+        ? .unauthenticated
+        : .authenticated
+  }
+
+  public func signOut() async throws {
+    try await auth.signOut()
+    updateAuthenticationState()
+  }
+
+  public func signInWithGoogle() async throws {
+    authenticationState = .authenticating
+    do {
+      guard let clientID = auth.app?.options.clientID else { throw NSError(
+        domain: "AuthServiceErrorDomain",
+        code: 2,
+        userInfo: [
+          NSLocalizedDescriptionKey: "OAuth client ID not found. Please make sure Google Sign-In is enabled in the Firebase console. You may have to download a new GoogleService-Info.plist file after enabling Google Sign-In.",
+        ]
+      ) }
+      let credential = try await safeGoogleProvider.signInWithGoogle(clientID: clientID)
+
+      try await signIn(with: credential)
+      updateAuthenticationState()
+    } catch {
+      authenticationState = .unauthenticated
+      throw error
+    }
+  }
+
+  func signIn(with credentials: AuthCredential) async throws {
+    authenticationState = .authenticating
+    do {
+      try await auth.signIn(with: credentials)
+      updateAuthenticationState()
+    } catch {
+      authenticationState = .unauthenticated
+      throw error
+    }
+  }
+
+  func sendEmailVerification() async throws {
+    if currentUser != nil {
+      do {
+        // TODO: - can use set user action code settings?
+        try await currentUser!.sendEmailVerification()
+      } catch {
+        throw error
+      }
+    }
+  }
+
+  func signIn(withEmail email: String, password: String) async throws {
+    let credential = EmailAuthProvider.credential(withEmail: email, password: password)
+    try await auth.signIn(with: credential)
+  }
+
+  func createUser(withEmail email: String, password: String) async throws {
+    authenticationState = .authenticating
+    do {
+      try await auth.createUser(withEmail: email, password: password)
+      updateAuthenticationState()
+    } catch {
+      authenticationState = .unauthenticated
+      throw error
+    }
+  }
+
+  func sendPasswordRecoveryEmail(to email: String) async throws {
+    do {
+      try await auth.sendPasswordReset(withEmail: email)
+    } catch {
+      throw error
+    }
+  }
+
+  func sendEmailSignInLink(to email: String) async throws {
+    do {
+      // TODO: - how does user set action code settings? Needs configuring
+      let actionCodeSettings = ActionCodeSettings()
+      actionCodeSettings.handleCodeInApp = true
+      try await auth.sendSignInLink(
+        toEmail: email,
+        actionCodeSettings: actionCodeSettings
+      )
+    } catch {
+      throw error
+    }
+  }
+}

FirebaseSwiftUI/FirebaseAuthSwiftUI/Sources/Strings/en.lproj/Localizable.strings

@@ -0,0 +1,23 @@
+/* Error message displayed when there's no account matching the email address. Use short/abbreviated translation for 'email' which is less than 15 chars. */
+"UserNotFoundError" = "That email address doesn’t match an existing account.";
+
+/* Error message displayed when the email address is already in use. Use short/abbreviated translation for 'email' which is less than 15 chars. */
+"EmailAlreadyInUseError" = "The email address is already in use by another account.";
+
+/* Error message displayed when user enters an invalid email address. Use short/abbreviated translation for 'email' which is less than 15 chars. */
+"InvalidEmailError" = "That email address isn't correct.";
+
+/* Error message displayed when the password is too weak. */
+"WeakPasswordError" = "Password must be at least 6 characters long.";
+
+/* Error message displayed when many accounts have been created from same IP address. */
+"SignUpTooManyTimesError" = "Too many account requests are coming from your IP address. Try again in a few minutes.";
+
+/* Error message displayed when the email and password don't match. Use short/abbreviated translation for 'email' which is less than 15 chars. */
+"WrongPasswordError" = "The email and password you entered don't match.";
+
+/* Error message displayed when the account is disabled. Use short/abbreviated translation for 'email' which is less than 15 chars. */
+"AccountDisabledError" = "That email address is for an account that has been disabled.";
+
+/* Error message displayed when after re-authorization current user's email and re-authorized user's email doesn't match. Use short/abbreviated translation for 'email' which is less than 15 chars. */
+"EmailsDoNotMatchError" = "Emails don't match";

FirebaseSwiftUI/FirebaseAuthSwiftUI/Sources/Utils/EmailUtils.swift

@@ -0,0 +1,10 @@
+import Foundation
+
+class EmailUtils {
+  static let emailRegex = ".+@([a-zA-Z0-9\\-]+\\.)+[a-zA-Z0-9]{2,63}"
+
+  static func isValidEmail(_ email: String) -> Bool {
+    let emailPredicate = NSPredicate(format: "SELF MATCHES %@", emailRegex)
+    return emailPredicate.evaluate(with: email)
+  }
+}

FirebaseSwiftUI/FirebaseAuthSwiftUI/Sources/Utils/StringUtils.swift

@@ -0,0 +1,58 @@
+import FirebaseAuth
+import SwiftUI
+
+let kKeyNotFound = "Key not found"
+
+let kUsersNotFoundError = "UserNotFoundError"
+let kEmailAlreadyInUseError = "EmailAlreadyInUseError"
+let kInvalidEmailError = "InvalidEmailError"
+let kWeakPasswordError = "WeakPasswordError"
+let kSignUpTooManyTimesError = "SignUpTooManyTimesError"
+let kWrongPasswordError = "WrongPasswordError"
+let kAccountDisabledError = "AccountDisabledError"
+let kEmailsDoNotMatchError = "EmailsDoNotMatchError"
+let kUnknownError = "UnknownError"
+
+public class StringUtils {
+  let bundle: Bundle
+  init(bundle: Bundle) {
+    self.bundle = bundle
+  }
+
+  public func localizedString(forKey key: String) -> String {
+    return bundle.localizedString(forKey: key, value: nil, table: nil)
+  }
+
+  public func localizedErrorMessage(for error: Error) -> String {
+    let authError = error as NSError
+    let errorCode = AuthErrorCode(rawValue: authError.code)
+    switch errorCode {
+    case .emailAlreadyInUse:
+      return localizedString(
+        forKey: kEmailAlreadyInUseError
+      )
+    case .invalidEmail:
+      return localizedString(forKey: kInvalidEmailError)
+    case .weakPassword:
+      return localizedString(forKey: kWeakPasswordError)
+    case .tooManyRequests:
+      return localizedString(
+        forKey: kSignUpTooManyTimesError
+      )
+    case .wrongPassword:
+      return localizedString(
+        forKey: kWrongPasswordError
+      )
+    case .userNotFound:
+      return localizedString(
+        forKey: kUsersNotFoundError
+      )
+    case .userDisabled:
+      return localizedString(
+        forKey: kAccountDisabledError
+      )
+    default:
+      return error.localizedDescription
+    }
+  }
+}

FirebaseSwiftUI/FirebaseAuthSwiftUI/Sources/Views/AuthPickerView.swift

@@ -0,0 +1,46 @@
+import SwiftUI
+
+@MainActor
+public struct AuthPickerView<Content: View> {
+  @Environment(AuthService.self) private var authService
+  let providerButtons: () -> Content
+
+  public init(@ViewBuilder providerButtons: @escaping () -> Content) {
+    self.providerButtons = providerButtons
+  }
+
+  private func switchFlow() {
+    authService.authenticationFlow = authService
+      .authenticationFlow == .login ? .signUp : .login
+  }
+}
+
+extension AuthPickerView: View {
+  public var body: some View {
+    VStack {
+      if authService.authenticationState == .authenticated {
+        SignedInView()
+      } else {
+        Text(authService.authenticationFlow == .login ? "Login" : "Sign up")
+        VStack { Divider() }
+        EmailAuthView()
+        providerButtons()
+        VStack { Divider() }
+        HStack {
+          Text(authService
+            .authenticationFlow == .login ? "Don't have an account yet?" :
+            "Already have an account?")
+          Button(action: {
+            withAnimation {
+              switchFlow()
+            }
+          }) {
+            Text(authService.authenticationFlow == .signUp ? "Log in" : "Sign up")
+              .fontWeight(.semibold)
+              .foregroundColor(.blue)
+          }
+        }
+      }
+    }
+  }
+}