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. Cela est pratique, car l'utilisateur n'a pas besoin de se connecter en permanence chaque fois qu'il accède à la page Web sur le même appareil. L'utilisateur peut alors être amené à saisir à 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 peut ne pas être idéal:

• Les applications contenant des données sensibles peuvent vouloir effacer l'état lorsque la fenêtre ou l'onglet est fermé. Cela est important au cas où l'utilisateur oublierait de se déconnecter.
• Applications utilisées sur un appareil partagé par plusieurs utilisateurs. Un exemple courant est une application exécutée sur un ordinateur de bibliothèque.
• Application sur un appareil partagé pouvant être consultée par plusieurs utilisateurs. 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, ajoutez une option "Se souvenir de moi" lors de la connexion.
• Dans certains cas, un développeur peut choisir de ne pas conserver un utilisateur anonyme tant qu'il n'est pas passé à un compte non anonyme (fédéré, mot de passe, 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é entre 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.

Remarque :Ne confondez pas la persistance de l'état Auth avec la persistance des données hors connexion de Firestore. La persistance de l'état d'authentification spécifie comment une session utilisateur est conservée sur un appareil. En revanche, Firestore enablePersistence active la mise en cache des données Cloud Firestore lorsque l'appareil est hors connexion.

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.

Enum	Valeur	Description
firebase.auth.Auth.Persistence.LOCAL	"local"	Indique que l'état sera conservé même lorsque la fenêtre du navigateur est fermée ou que l'activité est détruite dans React Native. Une déconnexion explicite est nécessaire pour effacer cet état. Notez que les sessions Web Firebase Auth sont d'origine hôte unique et ne sont conservées que pour un seul domaine.
firebase.auth.Auth.Persistence.SESSION	"session"	Indique que l'état ne persistera que dans la session ou l'onglet en cours, et qu'il sera effacé lorsque l'onglet ou la fenêtre dans laquelle l'utilisateur s'est authentifié sera fermé. Ne s'applique qu'aux applications Web.
firebase.auth.Auth.Persistence.NONE	"none"	Indique que l'état ne sera stocké qu'en mémoire et sera effacé lorsque la fenêtre ou l'activité sera actualisée.

Modifier la persistance de l'état d'authentification

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

Web

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

Web

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 modifie le type de persistance sur l'instance Auth spécifiée pour la session Auth actuellement enregistrée et applique ce type de persistance aux futures requêtes de connexion, y compris la connexion avec des requêtes de redirection. Cela renvoie une promesse qui sera résolue une fois que l'état aura terminé la copie d'un type de stockage à un 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), alors qu'il est none pour les applications backend Node.js.

Présentation du comportement de persistance

Les critères suivants sont appliqués pour déterminer l'état actuel de 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 tentatives de connexion utiliseront 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 explicitement spécifiée sur cette page, elle remplace la persistance de l'état d'authentification conservée de la page précédente ayant lancé 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. L'exigence est qu'à aucun moment, il ne doit pas y avoir 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 sur 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é.