Persistance de l'état d'authentification

Vous pouvez spécifier comment l'état d'authentification persiste lorsque vous utilisez le SDK JavaScript Firebase. Cela inclut la possibilité de spécifier si un utilisateur connecté doit être conservé indéfiniment jusqu'à une déconnexion explicite, effacé lorsque la fenêtre est fermée ou effacé lors de l'actualisation de la page.

Pour une application Web, le comportement par défaut consiste à conserver la session d'un utilisateur même après qu'il a fermé le navigateur. C'est pratique, car l'utilisateur doivent se connecter en permanence chaque fois qu'une page Web est consultée appareil. L'utilisateur peut alors être amené à saisir de nouveau son mot de passe, à envoyer un SMS de validation, etc., ce qui peut ajouter beaucoup de friction à l'expérience utilisateur.

Toutefois, dans certains cas, ce comportement n'est pas idéal:

• Les applications contenant des données sensibles peuvent souhaiter effacer l'état lorsque la fenêtre ou que l'onglet est fermé. Cette étape est importante au cas où l'utilisateur oublie de se déconnecter.
• Applications utilisées sur un appareil partagé par plusieurs utilisateurs. Une approche exemple ici est une application exécutée dans un ordinateur de bibliothèque.
• Application installée sur un appareil partagé et à laquelle plusieurs utilisateurs peuvent accéder. Le développeur ne peut pas déterminer comment cette application est accessible et peut souhaiter permettre à un utilisateur de choisir de conserver ou non sa session. Pour ce faire, vous pouvez ajouter une option "Se souvenir de moi" lors de la connexion.
• Dans certains cas, un développeur peut souhaiter ne pas conserver un utilisateur anonyme tant qu'il n'est pas mis à niveau vers un compte non anonyme téléphone, etc.).
• Un développeur peut souhaiter autoriser différents utilisateurs à se connecter à une application dans différents onglets. Par défaut, l'état est conservé dans tous les onglets. pour la même origine.

Comme indiqué ci-dessus, il existe plusieurs situations dans lesquelles la persistance permanente par défaut peut devoir être remplacée.

Types de persistance de l'état d'authentification acceptés

Vous pouvez choisir l'un des trois types de persistance de l'état d'authentification sur une instance Firebase Auth spécifiée en fonction des exigences de votre application ou de l'utilisateur.

Modifier la persistance de l'état d'authentification

Vous pouvez spécifier ou modifier le type de persistance existant en appelant la méthode Méthode firebase.auth().setPersistence:

import { getAuth, setPersistence, signInWithEmailAndPassword, browserSessionPersistence } from "firebase/auth";

const auth = getAuth();
setPersistence(auth, browserSessionPersistence)
  .then(() => {
    // Existing and future Auth states are now persisted in the current
    // session only. Closing the window would clear any existing state even
    // if a user forgets to sign out.
    // ...
    // New sign-in will be persisted with session persistence.
    return signInWithEmailAndPassword(auth, email, password);
  })
  .catch((error) => {
    // Handle Errors here.
    const errorCode = error.code;
    const errorMessage = error.message;
  });
auth_set_persistence_session.js

firebase.auth().setPersistence(firebase.auth.Auth.Persistence.SESSION)
  .then(() => {
    // Existing and future Auth states are now persisted in the current
    // session only. Closing the window would clear any existing state even
    // if a user forgets to sign out.
    // ...
    // New sign-in will be persisted with session persistence.
    return firebase.auth().signInWithEmailAndPassword(email, password);
  })
  .catch((error) => {
    // Handle Errors here.
    var errorCode = error.code;
    var errorMessage = error.message;
  });
auth-state-persistence.js

Cela modifiera le type de persistance sur l'instance Auth spécifiée pour la session d'authentification actuellement enregistrée et appliquer ce type de persistance les demandes de connexion futures, y compris la connexion avec les demandes de redirection. Cela permettra renvoyer une promesse qui sera résolue une fois que l'état aura été copié à partir d'un type de stockage à l'autre. Appeler une méthode de connexion après avoir modifié la persistance attend que ce changement de persistance soit terminé avant de l'appliquer au nouvel état d'authentification.

La valeur par défaut pour le navigateur Web et les applications React Native est local (à condition que le navigateur prenne en charge ce mécanisme de stockage, par exemple. Les cookies/données tiers sont activés), tandis que la valeur est none pour les applications backend Node.js.

Présentation du comportement de persistance

Les critères suivants seront appliqués pour déterminer l'état actuel la persistance.

• Au départ, le SDK vérifie si un utilisateur authentifié existe. Sauf si setPersistence est appelé, le type de persistance actuel de cet utilisateur sera appliqué pour les futures tentatives de connexion. Par conséquent, si cet utilisateur a été conservé dans session sur une page Web précédente et qu'une nouvelle page a été consultée, la connexion à nouveau avec un autre utilisateur entraînera également l'enregistrement de l'état de cet utilisateur avec la persistance session.
• Si aucun utilisateur n'est connecté et qu'aucune persistance n'est spécifiée, le paramètre par défaut est appliqué (local dans une application de navigateur).
• Si aucun utilisateur n'est connecté et qu'un nouveau type de persistance est défini, toute tentative de connexion ultérieure utilisera ce type de persistance.
• Si l'utilisateur est connecté et que le type de persistance est modifié, la persistance de cet utilisateur connecté existant est remplacée par la nouvelle. Toutes les futures connexions essaie d'utiliser cette nouvelle persistance.

• Lorsque signInWithRedirect est appelé, le type de persistance actuel est conservé et appliqué à la fin du flux OAuth à l'utilisateur nouvellement connecté, même si la persistance était none. Si la persistance est spécifiée explicitement sur cette page, elle remplace la a conservé la persistance de l'état d'authentification à partir de la page précédente, qui a déclenché le flux de redirection.

  Web

  import { getAuth, setPersistence, signInWithRedirect, inMemoryPersistence, GoogleAuthProvider } from "firebase/auth";
  
  const auth = getAuth();
  setPersistence(auth, inMemoryPersistence)
    .then(() => {
      const provider = new GoogleAuthProvider();
      // In memory persistence will be applied to the signed in Google user
      // even though the persistence was set to 'none' and a page redirect
      // occurred.
      return signInWithRedirect(auth, provider);
    })
    .catch((error) => {
      // Handle Errors here.
      const errorCode = error.code;
      const errorMessage = error.message;
    });
  auth_set_persistence_none.js

  Web

  firebase.auth().setPersistence(firebase.auth.Auth.Persistence.NONE)
    .then(() => {
      var provider = new firebase.auth.GoogleAuthProvider();
      // In memory persistence will be applied to the signed in Google user
      // even though the persistence was set to 'none' and a page redirect
      // occurred.
      return firebase.auth().signInWithRedirect(provider);
    })
    .catch((error) => {
      // Handle Errors here.
      var errorCode = error.code;
      var errorMessage = error.message;
    });
  auth-state-persistence.js

Comportement attendu dans les onglets du navigateur

Le comportement attendu suivant s'applique lorsque différents types de persistance sont utilisés dans différents onglets. La condition est qu'à tout moment, plusieurs types d'états enregistrés en même temps (par exemple, l'état d'authentification enregistré dans les types de stockage session et local):

• Les utilisateurs peuvent se connecter à l'aide de la persistance session ou none avec différents utilisateurs dans plusieurs onglets. Chaque onglet ne peut pas voir l'état de l'autre.
• Toute tentative de connexion à l'aide de la persistance local sera détectée et synchronisée dans tous les onglets. Si l'utilisateur était déjà connecté à un onglet spécifique à l'aide de la persistance session ou none, cet état sera effacé.
• Si l'utilisateur était précédemment connecté à l'aide de la persistance local avec plusieurs onglets ouverts, puis qu'il passe à la persistance none ou session dans un onglet, l'état de cet onglet sera modifié avec l'utilisateur persistant dans session ou none, et dans tous les autres onglets, l'utilisateur sera déconnecté.