Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

Vincula varios proveedores de autenticación con una cuenta mediante JavaScript

Para permitir que los usuarios accedan a la app con varios proveedores de autenticación, puedes vincular las credenciales de estos proveedores con una cuenta de usuario existente. Los usuarios se pueden identificar con el mismo ID de usuario de Firebase, sin importar el proveedor de autenticación que hayan usado para acceder. Por ejemplo, un usuario que accedió con una contraseña puede vincular una Cuenta de Google y después usar cualquiera de los dos métodos para acceder. Por otra parte, un usuario anónimo puede vincular una cuenta de Facebook y luego acceder con Facebook para continuar usando la app.

Antes de comenzar

Agrega a tu app compatibilidad para dos o más proveedores de autenticación (posiblemente con la inclusión de la autenticación anónima).

Para vincular credenciales de un proveedor de autenticación como Google o Facebook con una cuenta de usuario existente, haz lo siguiente:

  1. Permite que el usuario acceda mediante cualquier proveedor o método de autenticación.
  2. Obtén el objeto AuthProvider que corresponde al proveedor que deseas vincular con la cuenta del usuario. Ejemplos:

    Versión web 9

    import { GoogleAuthProvider, FacebookAuthProvider, TwitterAuthProvider, GithubAuthProvider } from "firebase/auth";
    
    const googleProvider = new GoogleAuthProvider();
    const facebookProvider = new FacebookAuthProvider();
    const twitterProvider = new TwitterAuthProvider();
    const githubProvider = new GithubAuthProvider();

    Versión web 8

    var googleProvider = new firebase.auth.GoogleAuthProvider();
    var facebookProvider = new firebase.auth.FacebookAuthProvider();
    var twitterProvider = new firebase.auth.TwitterAuthProvider();
    var githubProvider = new firebase.auth.GithubAuthProvider();
  3. Pídele al usuario que acceda con el proveedor que deseas vincular. Para pedir a tus usuarios que accedan, puedes mostrar una ventana emergente o redireccionarlos a la página de acceso del proveedor. En dispositivos móviles, se prefiere el método de redireccionamiento.
    • Para acceder con una ventana emergente, llama a linkWithPopup:

      Versión web 9

      import { getAuth, linkWithPopup, GoogleAuthProvider } from "firebase/auth";
      const provider = new GoogleAuthProvider();
      
      const auth = getAuth();
      linkWithPopup(auth.currentUser, provider).then((result) => {
        // Accounts successfully linked.
        const credential = GoogleAuthProvider.credentialFromResult(result);
        const user = result.user;
        // ...
      }).catch((error) => {
        // Handle Errors here.
        // ...
      });

      Versión web 8

      auth.currentUser.linkWithPopup(provider).then((result) => {
        // Accounts successfully linked.
        var credential = result.credential;
        var user = result.user;
        // ...
      }).catch((error) => {
        // Handle Errors here.
        // ...
      });
    • Para acceder mediante el redireccionamiento a la página de acceso del proveedor, llama a linkWithRedirect:

      Versión web 9

      import { getAuth, linkWithRedirect, GoogleAuthProvider } from "firebase/auth";
      const provider = new GoogleAuthProvider();
      
      const auth = getAuth();
      linkWithRedirect(auth.currentUser, provider)
        .then(/* ... */)
        .catch(/* ... */);

      Versión web 8

      auth.currentUser.linkWithRedirect(provider)
        .then(/* ... */)
        .catch(/* ... */);
      Después de que el usuario accede, se lo redirecciona de vuelta a tu página. Luego, para recuperar el resultado del acceso, puedes llamar a getRedirectResult cuando tu página cargue:

      Versión web 9

      import { getRedirectResult } from "firebase/auth";
      getRedirectResult(auth).then((result) => {
        const credential = GoogleAuthProvider.credentialFromResult(result);
        if (credential) {
          // Accounts successfully linked.
          const user = result.user;
          // ...
        }
      }).catch((error) => {
        // Handle Errors here.
        // ...
      });

      Versión web 8

      auth.getRedirectResult().then((result) => {
        if (result.credential) {
          // Accounts successfully linked.
          var credential = result.credential;
          var user = result.user;
          // ...
        }
      }).catch((error) => {
        // Handle Errors here.
        // ...
      });
    Si el usuario accede correctamente, la cuenta de usuario correspondiente al proveedor se vincula con la cuenta del usuario en el proyecto de Firebase.

    La vinculación de cuentas fallará si ya se vincularon las credenciales con otra cuenta de usuario. En esta situación, debes administrar la fusión de las cuentas y los datos asociados según corresponda para la app:

    Versión web 9

    import { getAuth, signInWithCredential, linkWithCredential, OAuthProvider } from "firebase/auth";
    
    // The implementation of how you store your user data depends on your application
    const repo = new MyUserDataRepo();
    
    // Get reference to the currently signed-in user
    const auth = getAuth();
    const prevUser = auth.currentUser;
    
    // Get the data which you will want to merge. This should be done now
    // while the app is still signed in as this user.
    const prevUserData = repo.get(prevUser);
    
    // Delete the user's data now, we will restore it if the merge fails
    repo.delete(prevUser);
    
    // Sign in user with the account you want to link to
    signInWithCredential(auth, newCredential).then((result) => {
      console.log("Sign In Success", result);
      const currentUser = result.user;
      const currentUserData = repo.get(currentUser);
    
      // Merge prevUser and currentUser data stored in Firebase.
      // Note: How you handle this is specific to your application
      const mergedData = repo.merge(prevUserData, currentUserData);
    
      const credential = OAuthProvider.credentialFromResult(result);
      return linkWithCredential(prevUser, credential)
        .then((linkResult) => {
          // Sign in with the newly linked credential
          const linkCredential = OAuthProvider.credentialFromResult(linkResult);
          return signInWithCredential(auth, linkCredential);
        })
        .then((signInResult) => {
          // Save the merged data to the new user
          repo.set(signInResult.user, mergedData);
        });
    }).catch((error) => {
      // If there are errors we want to undo the data merge/deletion
      console.log("Sign In Error", error);
      repo.set(prevUser, prevUserData);
    });

    Versión web 8

    // The implementation of how you store your user data depends on your application
    var repo = new MyUserDataRepo();
    
    // Get reference to the currently signed-in user
    var prevUser = auth.currentUser;
    
    // Get the data which you will want to merge. This should be done now
    // while the app is still signed in as this user.
    var prevUserData = repo.get(prevUser);
    
    // Delete the user's data now, we will restore it if the merge fails
    repo.delete(prevUser);
    
    // Sign in user with the account you want to link to
    auth.signInWithCredential(newCredential).then((result) => {
      console.log("Sign In Success", result);
      var currentUser = result.user;
      var currentUserData = repo.get(currentUser);
    
      // Merge prevUser and currentUser data stored in Firebase.
      // Note: How you handle this is specific to your application
      var mergedData = repo.merge(prevUserData, currentUserData);
    
      return prevUser.linkWithCredential(result.credential)
        .then((linkResult) => {
          // Sign in with the newly linked credential
          return auth.signInWithCredential(linkResult.credential);
        })
        .then((signInResult) => {
          // Save the merged data to the new user
          repo.set(signInResult.user, mergedData);
        });
    }).catch((error) => {
      // If there are errors we want to undo the data merge/deletion
      console.log("Sign In Error", error);
      repo.set(prevUser, prevUserData);
    });

Para agregar credenciales de dirección de correo electrónico y contraseña a una cuenta de usuario existente, haz lo siguiente:

  1. Permite que el usuario acceda mediante cualquier proveedor o método de autenticación.
  2. Pide al usuario que ingrese una dirección de correo electrónico y una nueva contraseña.
  3. Crea un objeto AuthCredential con la dirección de correo electrónico y la contraseña:

    Versión web 9

    import { EmailAuthProvider } from "firebase/auth";
    
    const credential = EmailAuthProvider.credential(email, password);

    Versión web 8

    var credential = firebase.auth.EmailAuthProvider.credential(email, password);
  4. Pasa el objeto AuthCredential al método linkWithCredential del usuario que accedió:

    Versión web 9

    import { getAuth, linkWithCredential } from "firebase/auth";
    
    const auth = getAuth();
    linkWithCredential(auth.currentUser, credential)
      .then((usercred) => {
        const user = usercred.user;
        console.log("Account linking success", user);
      }).catch((error) => {
        console.log("Account linking error", error);
      });

    Versión web 8

    auth.currentUser.linkWithCredential(credential)
      .then((usercred) => {
        var user = usercred.user;
        console.log("Account linking success", user);
      }).catch((error) => {
        console.log("Account linking error", error);
      });

    La llamada a linkWithCredential fallará si ya se vincularon las credenciales con la cuenta de otro usuario. En esta situación, debes administrar la fusión de las cuentas y los datos asociados según corresponda para la app (consulta los ejemplos anteriores).

Puedes desvincular un proveedor de autenticación de una cuenta para que el usuario ya no pueda acceder con ese proveedor.

Para desvincular un proveedor de autenticación de una cuenta de usuario, pasa el ID del proveedor al método unlink. Puedes obtener los ID de los proveedores de autenticación vinculados con un usuario desde la propiedad providerData.

Versión web 9

import { getAuth, unlink } from "firebase/auth";

const auth = getAuth();
unlink(auth.currentUser, providerId).then(() => {
  // Auth provider unlinked from account
  // ...
}).catch((error) => {
  // An error happened
  // ...
});

Versión web 8

user.unlink(providerId).then(() => {
  // Auth provider unlinked from account
  // ...
}).catch((error) => {
  // An error happened
  // ...
});