@react-native-firebase/auth 24.1.0 → 25.0.0

package/lib/{User.js → User.ts}

@@ -21,30 +21,42 @@ import {
   isUndefined,
   isBoolean,
 } from '@react-native-firebase/app/dist/module/common';
+import type { IdTokenResult, UserInfo, UserMetadata } from './types/auth';
+import type { FirebaseAuthTypes } from './types/namespaced';
+import type { AuthInternal, NativeUserInternal } from './types/internal';
+
+type AuthProviderWithObject = FirebaseAuthTypes.AuthProvider & {
+  toObject(): Record<string, unknown>;
+};
 
 export default class User {
-  constructor(auth, user) {
+  /** @internal */
+  readonly _auth: AuthInternal;
+  /** @internal */
+  readonly _user: NativeUserInternal;
+
+  constructor(auth: AuthInternal, user: NativeUserInternal) {
     this._auth = auth;
     this._user = user;
   }
 
-  get displayName() {
+  get displayName(): string | null {
     return this._user.displayName || null;
   }
 
-  get email() {
+  get email(): string | null {
     return this._user.email || null;
   }
 
-  get emailVerified() {
+  get emailVerified(): boolean {
     return this._user.emailVerified || false;
   }
 
-  get isAnonymous() {
+  get isAnonymous(): boolean {
     return this._user.isAnonymous || false;
   }
 
-  get metadata() {
+  get metadata(): UserMetadata {
     const { metadata } = this._user;
 
     return {
@@ -53,148 +65,173 @@ export default class User {
     };
   }
 
-  get multiFactor() {
+  get multiFactor(): FirebaseAuthTypes.MultiFactor | null {
     return this._user.multiFactor || null;
   }
 
-  get phoneNumber() {
+  get phoneNumber(): string | null {
     return this._user.phoneNumber || null;
   }
 
-  get tenantId() {
+  get tenantId(): string | null {
     return this._user.tenantId || null;
   }
 
-  get photoURL() {
+  get photoURL(): string | null {
     return this._user.photoURL || null;
   }
 
-  get providerData() {
-    return this._user.providerData;
+  get providerData(): UserInfo[] {
+    return this._user.providerData.map(provider => ({
+      displayName: provider.displayName ?? null,
+      email: provider.email ?? null,
+      phoneNumber: provider.phoneNumber ?? null,
+      photoURL: provider.photoURL ?? null,
+      providerId: provider.providerId,
+      uid: provider.uid,
+    }));
   }
 
-  get providerId() {
+  get providerId(): string {
     return this._user.providerId;
   }
 
-  get uid() {
+  get uid(): string {
     return this._user.uid;
   }
 
-  delete() {
+  delete(): Promise<void> {
     return this._auth.native.delete().then(() => {
-      this._auth._setUser();
+      this._auth._setUser(null);
     });
   }
 
-  getIdToken(forceRefresh = false) {
+  getIdToken(forceRefresh = false): Promise<string> {
     return this._auth.native.getIdToken(forceRefresh);
   }
 
-  getIdTokenResult(forceRefresh = false) {
-    return this._auth.native.getIdTokenResult(forceRefresh);
+  getIdTokenResult(forceRefresh = false): Promise<IdTokenResult> {
+    return this._auth.native.getIdTokenResult(forceRefresh) as Promise<IdTokenResult>;
   }
 
-  linkWithCredential(credential) {
+  linkWithCredential(
+    credential: FirebaseAuthTypes.AuthCredential,
+  ): Promise<FirebaseAuthTypes.UserCredential> {
     return this._auth.native
       .linkWithCredential(credential.providerId, credential.token, credential.secret)
-      .then(userCredential => this._auth._setUserCredential(userCredential));
+      .then(
+        userCredential =>
+          this._auth._setUserCredential(userCredential) as FirebaseAuthTypes.UserCredential,
+      );
   }
 
-  linkWithPopup(provider) {
+  linkWithPopup(provider: AuthProviderWithObject): Promise<FirebaseAuthTypes.UserCredential> {
     // call through to linkWithRedirect for shared implementation
     return this.linkWithRedirect(provider);
   }
 
-  linkWithRedirect(provider) {
+  linkWithRedirect(provider: AuthProviderWithObject): Promise<FirebaseAuthTypes.UserCredential> {
     return this._auth.native
       .linkWithProvider(provider.toObject())
-      .then(userCredential => this._auth._setUserCredential(userCredential));
+      .then(
+        userCredential =>
+          this._auth._setUserCredential(userCredential) as FirebaseAuthTypes.UserCredential,
+      );
   }
 
-  reauthenticateWithCredential(credential) {
+  reauthenticateWithCredential(
+    credential: FirebaseAuthTypes.AuthCredential,
+  ): Promise<FirebaseAuthTypes.UserCredential> {
     return this._auth.native
       .reauthenticateWithCredential(credential.providerId, credential.token, credential.secret)
-      .then(userCredential => this._auth._setUserCredential(userCredential));
+      .then(
+        userCredential =>
+          this._auth._setUserCredential(userCredential) as FirebaseAuthTypes.UserCredential,
+      );
   }
 
-  reauthenticateWithPopup(provider) {
+  reauthenticateWithPopup(
+    provider: AuthProviderWithObject,
+  ): Promise<FirebaseAuthTypes.UserCredential> {
     // call through to reauthenticateWithRedirect for shared implementation
-    return this.reauthenticateWithRedirect(provider);
+    return this._auth.native
+      .reauthenticateWithProvider(provider.toObject())
+      .then(
+        userCredential =>
+          this._auth._setUserCredential(userCredential) as FirebaseAuthTypes.UserCredential,
+      );
   }
 
-  reauthenticateWithRedirect(provider) {
+  reauthenticateWithRedirect(provider: AuthProviderWithObject): Promise<void> {
     return this._auth.native
       .reauthenticateWithProvider(provider.toObject())
-      .then(userCredential => this._auth._setUserCredential(userCredential));
+      .then(userCredential => {
+        this._auth._setUserCredential(userCredential);
+      });
   }
 
-  reload() {
+  reload(): Promise<void> {
     return this._auth.native.reload().then(user => {
       this._auth._setUser(user);
     });
   }
 
-  sendEmailVerification(actionCodeSettings) {
+  sendEmailVerification(actionCodeSettings?: FirebaseAuthTypes.ActionCodeSettings): Promise<void> {
     if (isObject(actionCodeSettings)) {
-      if (!isString(actionCodeSettings.url)) {
+      const settings = actionCodeSettings as FirebaseAuthTypes.ActionCodeSettings;
+
+      if (!isString(settings.url)) {
         throw new Error(
           "firebase.auth.User.sendEmailVerification(*) 'actionCodeSettings.url' expected a string value.",
         );
       }
 
-      if (!isUndefined(actionCodeSettings.linkDomain) && !isString(actionCodeSettings.linkDomain)) {
+      if (!isUndefined(settings.linkDomain) && !isString(settings.linkDomain)) {
         throw new Error(
           "firebase.auth.User.sendEmailVerification(*) 'actionCodeSettings.linkDomain' expected a string value.",
         );
       }
 
-      if (
-        !isUndefined(actionCodeSettings.handleCodeInApp) &&
-        !isBoolean(actionCodeSettings.handleCodeInApp)
-      ) {
+      if (!isUndefined(settings.handleCodeInApp) && !isBoolean(settings.handleCodeInApp)) {
         throw new Error(
           "firebase.auth.User.sendEmailVerification(*) 'actionCodeSettings.handleCodeInApp' expected a boolean value.",
         );
       }
 
-      if (!isUndefined(actionCodeSettings.iOS)) {
-        if (!isObject(actionCodeSettings.iOS)) {
+      if (!isUndefined(settings.iOS)) {
+        if (!isObject(settings.iOS)) {
           throw new Error(
             "firebase.auth.User.sendEmailVerification(*) 'actionCodeSettings.iOS' expected an object value.",
           );
         }
-        if (!isString(actionCodeSettings.iOS.bundleId)) {
+        if (!isString(settings.iOS.bundleId)) {
           throw new Error(
             "firebase.auth.User.sendEmailVerification(*) 'actionCodeSettings.iOS.bundleId' expected a string value.",
           );
         }
       }
 
-      if (!isUndefined(actionCodeSettings.android)) {
-        if (!isObject(actionCodeSettings.android)) {
+      if (!isUndefined(settings.android)) {
+        if (!isObject(settings.android)) {
           throw new Error(
             "firebase.auth.User.sendEmailVerification(*) 'actionCodeSettings.android' expected an object value.",
           );
         }
-        if (!isString(actionCodeSettings.android.packageName)) {
+        if (!isString(settings.android.packageName)) {
           throw new Error(
             "firebase.auth.User.sendEmailVerification(*) 'actionCodeSettings.android.packageName' expected a string value.",
           );
         }
 
-        if (
-          !isUndefined(actionCodeSettings.android.installApp) &&
-          !isBoolean(actionCodeSettings.android.installApp)
-        ) {
+        if (!isUndefined(settings.android.installApp) && !isBoolean(settings.android.installApp)) {
           throw new Error(
             "firebase.auth.User.sendEmailVerification(*) 'actionCodeSettings.android.installApp' expected a boolean value.",
           );
         }
 
         if (
-          !isUndefined(actionCodeSettings.android.minimumVersion) &&
-          !isString(actionCodeSettings.android.minimumVersion)
+          !isUndefined(settings.android.minimumVersion) &&
+          !isString(settings.android.minimumVersion)
         ) {
           throw new Error(
             "firebase.auth.User.sendEmailVerification(*) 'actionCodeSettings.android.minimumVersion' expected a string value.",
@@ -204,31 +241,39 @@ export default class User {
     }
 
     return this._auth.native.sendEmailVerification(actionCodeSettings).then(user => {
-      this._auth._setUser(user);
-    });
+        this._auth._setUser(user);
+      });
   }
 
-  toJSON() {
+  toJSON(): object {
     return Object.assign({}, this._user);
   }
 
-  unlink(providerId) {
-    return this._auth.native.unlink(providerId).then(user => this._auth._setUser(user));
+  unlink(providerId: string): Promise<FirebaseAuthTypes.User> {
+    return this._auth.native
+      .unlink(providerId)
+      .then(user => {
+        const updatedUser = this._auth._setUser(user);
+        if (!updatedUser) {
+          throw new Error('firebase.auth.User.unlink() returned no user after unlinking provider.');
+        }
+        return updatedUser;
+      });
   }
 
-  updateEmail(email) {
+  updateEmail(email: string): Promise<void> {
     return this._auth.native.updateEmail(email).then(user => {
       this._auth._setUser(user);
     });
   }
 
-  updatePassword(password) {
+  updatePassword(password: string): Promise<void> {
     return this._auth.native.updatePassword(password).then(user => {
       this._auth._setUser(user);
     });
   }
 
-  updatePhoneNumber(credential) {
+  updatePhoneNumber(credential: FirebaseAuthTypes.AuthCredential): Promise<void> {
     return this._auth.native
       .updatePhoneNumber(credential.providerId, credential.token, credential.secret)
       .then(user => {
@@ -236,13 +281,16 @@ export default class User {
       });
   }
 
-  updateProfile(updates) {
+  updateProfile(updates: FirebaseAuthTypes.UpdateProfile): Promise<void> {
     return this._auth.native.updateProfile(updates).then(user => {
       this._auth._setUser(user);
     });
   }
 
-  verifyBeforeUpdateEmail(newEmail, actionCodeSettings) {
+  verifyBeforeUpdateEmail(
+    newEmail: string,
+    actionCodeSettings?: FirebaseAuthTypes.ActionCodeSettings,
+  ): Promise<void> {
     if (!isString(newEmail)) {
       throw new Error(
         "firebase.auth.User.verifyBeforeUpdateEmail(*) 'newEmail' expected a string value.",
@@ -250,64 +298,60 @@ export default class User {
     }
 
     if (isObject(actionCodeSettings)) {
-      if (!isString(actionCodeSettings.url)) {
+      const settings = actionCodeSettings as FirebaseAuthTypes.ActionCodeSettings;
+
+      if (!isString(settings.url)) {
         throw new Error(
           "firebase.auth.User.verifyBeforeUpdateEmail(_, *) 'actionCodeSettings.url' expected a string value.",
         );
       }
 
-      if (!isUndefined(actionCodeSettings.linkDomain) && !isString(actionCodeSettings.linkDomain)) {
+      if (!isUndefined(settings.linkDomain) && !isString(settings.linkDomain)) {
         throw new Error(
           "firebase.auth.User.verifyBeforeUpdateEmail(_, *) 'actionCodeSettings.linkDomain' expected a string value.",
         );
       }
 
-      if (
-        !isUndefined(actionCodeSettings.handleCodeInApp) &&
-        !isBoolean(actionCodeSettings.handleCodeInApp)
-      ) {
+      if (!isUndefined(settings.handleCodeInApp) && !isBoolean(settings.handleCodeInApp)) {
         throw new Error(
           "firebase.auth.User.verifyBeforeUpdateEmail(_, *) 'actionCodeSettings.handleCodeInApp' expected a boolean value.",
         );
       }
 
-      if (!isUndefined(actionCodeSettings.iOS)) {
-        if (!isObject(actionCodeSettings.iOS)) {
+      if (!isUndefined(settings.iOS)) {
+        if (!isObject(settings.iOS)) {
           throw new Error(
             "firebase.auth.User.verifyBeforeUpdateEmail(_, *) 'actionCodeSettings.iOS' expected an object value.",
           );
         }
-        if (!isString(actionCodeSettings.iOS.bundleId)) {
+        if (!isString(settings.iOS.bundleId)) {
           throw new Error(
             "firebase.auth.User.verifyBeforeUpdateEmail(_, *) 'actionCodeSettings.iOS.bundleId' expected a string value.",
           );
         }
       }
 
-      if (!isUndefined(actionCodeSettings.android)) {
-        if (!isObject(actionCodeSettings.android)) {
+      if (!isUndefined(settings.android)) {
+        if (!isObject(settings.android)) {
           throw new Error(
             "firebase.auth.User.verifyBeforeUpdateEmail(_, *) 'actionCodeSettings.android' expected an object value.",
           );
         }
-        if (!isString(actionCodeSettings.android.packageName)) {
+        if (!isString(settings.android.packageName)) {
           throw new Error(
             "firebase.auth.User.verifyBeforeUpdateEmail(_, *) 'actionCodeSettings.android.packageName' expected a string value.",
           );
         }
 
-        if (
-          !isUndefined(actionCodeSettings.android.installApp) &&
-          !isBoolean(actionCodeSettings.android.installApp)
-        ) {
+        if (!isUndefined(settings.android.installApp) && !isBoolean(settings.android.installApp)) {
           throw new Error(
             "firebase.auth.User.verifyBeforeUpdateEmail(_, *) 'actionCodeSettings.android.installApp' expected a boolean value.",
           );
         }
 
         if (
-          !isUndefined(actionCodeSettings.android.minimumVersion) &&
-          !isString(actionCodeSettings.android.minimumVersion)
+          !isUndefined(settings.android.minimumVersion) &&
+          !isString(settings.android.minimumVersion)
         ) {
           throw new Error(
             "firebase.auth.User.verifyBeforeUpdateEmail(_, *) 'actionCodeSettings.android.minimumVersion' expected a string value.",
@@ -317,27 +361,27 @@ export default class User {
     }
 
     return this._auth.native.verifyBeforeUpdateEmail(newEmail, actionCodeSettings).then(user => {
-      this._auth._setUser(user);
-    });
+        this._auth._setUser(user);
+      });
   }
 
   /**
    * KNOWN UNSUPPORTED METHODS
    */
 
-  linkWithPhoneNumber() {
+  linkWithPhoneNumber(): never {
     throw new Error(
       'firebase.auth.User.linkWithPhoneNumber() is unsupported by the native Firebase SDKs.',
     );
   }
 
-  reauthenticateWithPhoneNumber() {
+  reauthenticateWithPhoneNumber(): never {
     throw new Error(
       'firebase.auth.User.reauthenticateWithPhoneNumber() is unsupported by the native Firebase SDKs.',
     );
   }
 
-  get refreshToken() {
+  get refreshToken(): never {
     throw new Error('firebase.auth.User.refreshToken is unsupported by the native Firebase SDKs.');
   }
 }

package/lib/constants.ts

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+export const ActionCodeOperation = {
+  EMAIL_SIGNIN: 'EMAIL_SIGNIN',
+  PASSWORD_RESET: 'PASSWORD_RESET',
+  RECOVER_EMAIL: 'RECOVER_EMAIL',
+  REVERT_SECOND_FACTOR_ADDITION: 'REVERT_SECOND_FACTOR_ADDITION',
+  VERIFY_AND_CHANGE_EMAIL: 'VERIFY_AND_CHANGE_EMAIL',
+  VERIFY_EMAIL: 'VERIFY_EMAIL',
+} as const;
+
+export const FactorId = {
+  PHONE: 'phone',
+  TOTP: 'totp',
+} as const;
+
+export const OperationType = {
+  LINK: 'link',
+  REAUTHENTICATE: 'reauthenticate',
+  SIGN_IN: 'signIn',
+} as const;
+
+export const ProviderId = {
+  FACEBOOK: 'facebook.com',
+  GITHUB: 'github.com',
+  GOOGLE: 'google.com',
+  PASSWORD: 'password',
+  PHONE: 'phone',
+  TWITTER: 'twitter.com',
+} as const;
+
+export const SignInMethod = {
+  EMAIL_LINK: 'emailLink',
+  EMAIL_PASSWORD: 'password',
+  FACEBOOK: 'facebook.com',
+  GITHUB: 'github.com',
+  GOOGLE: 'google.com',
+  PHONE: 'phone',
+  TWITTER: 'twitter.com',
+} as const;

package/lib/credentials/AuthCredential.ts

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+export function parseCredentialJSON(json: object | string): object | null {
+  if (typeof json === 'string') {
+    try {
+      return JSON.parse(json) as object;
+    } catch {
+      return null;
+    }
+  }
+
+  if (json === null || Array.isArray(json)) {
+    return null;
+  }
+
+  return json;
+}
+
+export class AuthCredential {
+  readonly providerId: string;
+  readonly signInMethod: string;
+  /** @internal RNFB native bridge token slot. */
+  readonly token: string;
+  /** @internal RNFB native bridge secret slot. */
+  readonly secret: string;
+
+  constructor(providerId: string, signInMethod: string, token: string, secret: string) {
+    this.providerId = providerId;
+    this.signInMethod = signInMethod;
+    this.token = token;
+    this.secret = secret;
+  }
+
+  toJSON(): object {
+    return {
+      providerId: this.providerId,
+      signInMethod: this.signInMethod,
+    };
+  }
+}

package/lib/credentials/EmailAuthCredential.ts

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import { AuthCredential, parseCredentialJSON } from './AuthCredential';
+
+type EmailCredentialJSON = {
+  email?: string;
+  password?: string;
+  signInMethod?: string;
+  tenantId?: string | null;
+};
+
+export class EmailAuthCredential extends AuthCredential {
+  constructor(
+    signInMethod: 'password' | 'emailLink',
+    email: string,
+    password: string,
+  ) {
+    super(signInMethod, signInMethod, email, password);
+  }
+
+  toJSON(): object {
+    return {
+      email: this.token,
+      password: this.secret,
+      signInMethod: this.signInMethod,
+      tenantId: null,
+    };
+  }
+
+  static fromJSON(json: object | string): EmailAuthCredential | null {
+    const parsed = parseCredentialJSON(json) as EmailCredentialJSON | null;
+    if (!parsed) {
+      return null;
+    }
+
+    const signInMethod = parsed.signInMethod;
+    if (signInMethod !== 'password' && signInMethod !== 'emailLink') {
+      return null;
+    }
+
+    if (typeof parsed.email !== 'string' || typeof parsed.password !== 'string') {
+      return null;
+    }
+
+    return new EmailAuthCredential(signInMethod, parsed.email, parsed.password);
+  }
+}
+
+export function createEmailAuthCredential(
+  email: string,
+  password: string,
+  signInMethod: 'password' | 'emailLink',
+): EmailAuthCredential {
+  return new EmailAuthCredential(signInMethod, email, password);
+}