Persistance de l’état d’authentification

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

Pour une application Web, le comportement par défaut consiste à conserver la session d'un utilisateur même après que celui-ci ferme le navigateur. Ceci est pratique car l’utilisateur n’est pas obligé de se connecter en permanence à chaque fois que la page Web est visitée sur le même appareil. Cela pourrait obliger l'utilisateur à devoir ressaisir son mot de passe, envoyer une vérification par SMS, etc., ce qui pourrait ajouter beaucoup de friction à l'expérience utilisateur.

Cependant, il existe des cas où 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é. Ceci est important au cas où l’utilisateur oublie de se déconnecter.
  • Applications utilisées sur un appareil partagé par plusieurs utilisateurs. Un exemple courant ici est une application exécutée sur un ordinateur de bibliothèque.
  • Une application sur un appareil partagé auquel plusieurs utilisateurs peuvent accéder. Le développeur n'est pas en mesure de déterminer comment l'on accède à cette application et peut souhaiter fournir à un utilisateur la possibilité de choisir de conserver ou non sa session. Cela pourrait être fait en ajoutant une option « Se souvenir de moi » lors de la connexion.
  • Dans certaines situations, un développeur peut souhaiter ne pas conserver un utilisateur anonyme jusqu'à ce que cet utilisateur soit mis à niveau vers 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 sur différents onglets. Le comportement par défaut consiste à conserver l'état dans les onglets pour la même origine.

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

Types de persistance de l'état d'authentification pris en charge

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.

Énumération Valeur Description
firebase.auth.Auth.Persistence.LOCAL 'locale' 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 seront conservées pour un seul domaine uniquement.
firebase.auth.Auth.Persistence.SESSION 'session' Indique que l'état ne persistera que dans la session ou l'onglet en cours et sera effacé lorsque l'onglet ou la fenêtre dans laquelle l'utilisateur s'est authentifié sera fermé. S'applique uniquement aux applications Web.
firebase.auth.Auth.Persistence.NONE 'aucun' Indique que l'état sera uniquement stocké en mémoire et sera effacé lors de l'actualisation de la fenêtre ou de l'activité.

Modification de 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 modular API

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;
  });

Web namespaced API

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;
  });

Cela modifiera le type de persistance sur l'instance d'authentification spécifiée pour la session d'authentification actuellement enregistrée et appliquera ce type de persistance pour les futures demandes de connexion, y compris la connexion avec les demandes de redirection. Cela renverra une promesse qui sera résolue une fois que l’État aura fini de copier d’un type de stockage à l’autre. L’appel d’une méthode de connexion après avoir modifié la persistance attendra la fin de cette modification de persistance 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 n'en 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 de la persistance.

  • Initialement, le SDK vérifiera si un utilisateur authentifié existe. À moins que setPersistence ne soit appelé, le type de persistance actuel de cet utilisateur sera appliqué pour les futures tentatives de connexion. Ainsi, si cet utilisateur a été conservé en session sur une page Web précédente et qu'une nouvelle page a été visitée, se reconnecter 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 sera 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 future utilisera ce type de persistance.
  • Si l'utilisateur est connecté et que le type de persistance est modifié, cet utilisateur connecté existant remplacera la persistance 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 remplacera la persistance de l'état d'authentification conservée de la page précédente qui a démarré le flux de redirection.

    Web modular API

    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;
      });

    Web namespaced API

    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;
      });

Comportement attendu dans les onglets du navigateur

Le comportement attendu suivant s'appliquera lorsque différents types de persistance sont utilisés dans différents onglets. L'exigence est qu'à aucun moment, il ne devrait jamais y avoir plusieurs types d'états enregistrés en même temps (par exemple, état d'authentification enregistré dans session et types de stockage local ) :

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