Persistência do Estado de Autenticação

Você pode especificar como o estado de autenticação persiste ao usar o Firebase JS SDK. Isso inclui a capacidade de especificar se um usuário conectado deve persistir indefinidamente até o logout explícito, ser limpo quando a janela for fechada ou limpo no recarregamento da página.

Para uma aplicação web, o comportamento padrão é persistir a sessão de um usuário mesmo depois que o usuário fecha o navegador. Isso é conveniente porque o usuário não precisa fazer login continuamente sempre que a página da web é visitada no mesmo dispositivo. Isso pode exigir que o usuário digite novamente sua senha, envie uma verificação por SMS, etc., o que pode adicionar muito atrito à experiência do usuário.

Porém, há casos em que esse comportamento pode não ser o ideal:

• Os aplicativos com dados confidenciais podem querer limpar o estado quando a janela ou guia for fechada. Isso é importante caso o usuário esqueça de sair.
• Aplicativos usados ​​em um dispositivo compartilhado por vários usuários. Um exemplo comum aqui é um aplicativo executado em um computador de biblioteca.
• Um aplicativo em um dispositivo compartilhado que pode ser acessado por vários usuários. O desenvolvedor não consegue dizer como esse aplicativo é acessado e pode querer fornecer ao usuário a capacidade de escolher se deseja persistir sua sessão ou não. Isso pode ser feito adicionando uma opção "Lembrar-me" durante o login.
• Em algumas situações, um desenvolvedor pode querer não persistir um usuário anônimo até que esse usuário seja atualizado para uma conta não anônima (federada, senha, telefone, etc.).
• Um desenvolvedor pode querer permitir que diferentes usuários façam login em um aplicativo em guias diferentes. O comportamento padrão é persistir o estado nas guias da mesma origem.

Conforme declarado acima, há diversas situações em que a persistência permanente padrão pode precisar ser substituída.

Tipos suportados de persistência de estado de autenticação

Você pode escolher um dos três tipos de persistência de estado do Auth em uma instância específica do Firebase Auth com base no seu aplicativo ou nos requisitos do usuário.

Modificando a persistência do estado Auth

Você pode especificar ou modificar o tipo de persistência existente chamando o método 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

Isto alterará o tipo de persistência na instância Auth especificada para a sessão Auth atualmente salva e aplicará esse tipo de persistência para solicitações de entrada futuras, incluindo entrada com solicitações de redirecionamento. Isso retornará uma promessa que será resolvida assim que o estado terminar de copiar de um tipo de armazenamento para outro. Chamar um método de login após alterar a persistência aguardará a conclusão dessa alteração de persistência antes de aplicá-la no novo estado Auth.

O padrão para navegadores da web e aplicativos React Native é local (desde que o navegador suporte esse mecanismo de armazenamento, por exemplo, cookies/dados de terceiros estejam habilitados), enquanto não é none para aplicativos de backend Node.js.

Visão geral do comportamento de persistência

Os seguintes critérios serão aplicados ao determinar o estado atual de persistência.

• Inicialmente, o SDK verificará se existe um usuário autenticado. A menos que setPersistence seja chamado, o tipo de persistência atual desse usuário será aplicado para futuras tentativas de login. Portanto, se esse usuário persistiu na session de uma página da Web anterior e uma nova página foi visitada, fazer login novamente com um usuário diferente resultará no salvamento do estado desse usuário com a persistência session .
• Se nenhum usuário estiver conectado e nenhuma persistência for especificada, a configuração padrão será aplicada ( local em um aplicativo de navegador).
• Se nenhum usuário estiver conectado e um novo tipo de persistência for definido, qualquer tentativa futura de login usará esse tipo de persistência.
• Se o usuário estiver conectado e o tipo de persistência for modificado, o usuário conectado existente alterará a persistência para a nova. Todas as futuras tentativas de login usarão essa nova persistência.

• Quando signInWithRedirect é chamado, o tipo de persistência atual é retido e aplicado no final do fluxo OAuth ao usuário recém-conectado, mesmo que a persistência seja none . Se a persistência for explicitamente especificada nessa página, ela substituirá a persistência do estado de autenticação retido da página anterior que iniciou o fluxo de redirecionamento.

  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;
    });
  auth_set_persistence_none.js

  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;
    });
  auth-state-persistence.js

Comportamento esperado nas guias do navegador

O comportamento esperado a seguir será aplicado quando diferentes tipos de persistência forem usados ​​em guias diferentes. O requisito é que, em qualquer ponto, nunca haja vários tipos de estados salvos ao mesmo tempo (por exemplo, estado de autenticação salvo em session e tipos local de armazenamento):

• Os usuários podem fazer login usando session ou none persistência com diferentes usuários em várias guias. Cada guia não pode ver o estado da outra guia.
• Qualquer tentativa de login usando persistência local será detectada e sincronizada em todas as guias. Se o usuário tiver feito login anteriormente em uma guia específica usando session ou none persistência, esse estado será limpo.
• Se o usuário tiver feito login anteriormente usando persistência local com várias guias abertas e depois alternar para none ou persistência session em uma guia, o estado dessa guia será modificado com o usuário persistido na session ou none e em todas as outras guias, o usuário será desconectado.