Tokens JWT com NodeJS

Tokens JWT com NodeJS

No mundo das autenticações online, muito se fala sobre os famosos Tokens JWT 🤓

Eles representam uma forma de autenticarmos nossos usuários de forma segura, por meio de tokens de expiração em JSON 🔐

Há um tempo atrás, a Micilini publicou um artigo que fala exclusivamente sobre o que são Tokens JWT e como realizar autenticações de forma segura.

Então se você não sabe o que são Tokens JWT e como eles funcionam, recomendo que você dê uma olhada no link acima 🙂

Nesta lição, vamos focar exclusivamente em como implementar autenticações usando tokens JWT em nossas aplicações feitas com NodeJS + Express.

Recapitulando tokens JWT

Tokens JWT (JSON Web Tokens) são uma forma compacta e segura de transmitir informações entre partes como um objeto JSON. Eles são amplamente utilizados para autenticação e autorização em aplicações web.

Durante a sua jornada como desenvolvedor, você verá muito a utilização desses tokens em conjunto com sistemas de login e cadastro 😉

Um Token JWT é composto por três partes distintas:

Header: contém informações sobre como o token é assinado, e como o algoritmo será utilizado (por exemplo, HMAC ou RSA).

Payload: contém as informações ou "claims" que podem incluir dados do usuário e permissões.

Signature: é uma assinatura que é gerada a partir do header e do payload, usando uma chave secreta ou um par de chaves públicas e privadas.

O funcionamento de um Token JWT se baseia nos seguintes passos abaixo:

Autenticação: após o login, o servidor gera um JWT e o envia ao cliente. O cliente armazena o token e o inclui nas requisições subsequentes para acessar recursos protegidos.

Autorização: o servidor pode verificar o token para garantir que o usuário tem permissão para acessar determinados recursos ou realizar ações específicas.

Troca de informações: como os tokens são assinados, é possível garantir a integridade dos dados, reforçando que eles não foram alterados durante a transmissão.

Abaixo, deixo um exemplo de um Token JWT:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Você pode verificar o conteúdo existente dentro desse token por meio da ferramenta jwt.io:

Basta colar o token no campo Encoded que automaticamente o resultado decodificado (Decoded) aparecerá nos blocos a direita.

Dito isso, vamos aprender a gerenciar tokens JWT em nossas aplicações feitas com NodeJS 😉

A biblioteca jsonwebtoken

Quando falamos de Tokens JWT em aplicações feitas com NodeJS, logo pensamos na biblioteca jsonwebtoken, que é a biblioteca mais utilizada para o gerenciamento de Tokens JWT no NodeJS.

Com ela, seremos capazes de gerar um token JWT com base em uma chave secreta ou com criptografia assimétrica (chaves públicas/privadas).

Além disso, contamos com um payload (dados) que são codificados no token, junto com uma assinatura que garante a integridade desses mesmos dados.

A instalação dessa biblioteca ocorre de forma bem simples, basta utilizar o comando abaixo, dentro do seu terminal (Promt de Comando), que está apontado para a pasta do seu projeto:

npm i jsonwebtoken

Feito isso, você já estará pronto para gerenciar seus Tokens JWT em seu projeto 🙃

Os 4 pilares de validação de Tokens JWT 

De acordo com as explicações discursadas durante o artigo Cookies VS LocalStorage: Dicas de como armazenar dados e tokens (JWT) com segurança.

Há de se imaginar que uma aplicação que trabalha com esses tipos tokens, deve implementar 4 fundamentos que atuam como pilares para uma boa implementação dos mesmos. Vejamos cada um deles:

📜 A aplicação deve ser capaz de gerar o AccessToken com uma data de expiração mínima (1 minuto?), de modo a mantê-lo salvo na memória (ou dentro de uma sessão).

📜 A aplicação deve ser capaz de gerar o RefreshToken, com uma data de expiração máxima (30 dias?), dentro de um cookie seguro.

📜 A aplicação deve conseguir validar o AccessToken que será informado pelo navegador do usuário.

📜 A aplicação deve conseguir validar o RefreshToken que está armazenado no cookie do navegador do usuário.

Vamos ver como isso pode ser representado em uma aplicação feita com Javascript 😉

1) Função para gerar o AccessToken:

const jwt = require('jsonwebtoken');

function generateAccessToken(userID, expiresIn) {
    const accessTokenPayload = {
        user_id: userID,
        exp: Math.floor(Date.now() / 1000) + expiresIn // Expiração em segundos
    };

    // Gera e retorna o AccessToken
    return jwt.sign(accessTokenPayload, 'CODIGO-SECRETO-PARA-CODIFICAR-O-ACCESS-TOKEN', { algorithm: 'HS256' });
}

A função é responsável por gerar o nosso Token JWT chamado de AccessToken,  ela está recebendo dois parâmetros principais:

userID: representa o identificador único do usuário (costuma representar um ID do banco de dados).

expiresIn: define o tempo de expiração do token, em segundos, indicando quanto tempo o token será válido após a sua geração.

Já a constante accessTokenPayload, é um objeto que contém duas informações:

user_id: que é o ID do usuário que foi passado como argumento para a função.

exp: que é a data de expiração do token. Ela é calculada pegando o tempo atual (em milissegundos) e convertendo para segundos (dividindo por 1000), e somando o valor de expiresIn para definir o tempo de vida do token.

Observação: você pode passar outros tipos de dados que deseja armazenar dentro do seu Token JWT, como é o caso das roles e outras informações adicionais.

Por fim, nós temos a função jwt.sign, que é responsável por gerar o Token JWT, ela por sua vez, recebe três parâmetros:

Payload (accessTokenPayload): contém as informações do usuário e o tempo de expiração (que foi definido anteriormente).

'CODIGO-SECRETO-PARA-CODIFICAR-O-ACCESS-TOKEN': é uma chave secreta usada para assinar o token e garantir sua integridade (geralmente armazenada de forma segura, como em variáveis de ambiente).

'HS256': apesar de ser um argumento opcional, ele define o algoritmo de assinatura HMAC usando SHA-256, que é um dos algoritmos mais comumente usados para garantir a segurança do token.

2) Função para gerar o RefreshToken:

const jwt = require('jsonwebtoken');

function generateRefreshToken(userID) {
    const expirationTime = Math.floor(Date.now() / 1000) + (30 * 24 * 60 * 60); // 30 dias

    const refreshTokenPayload = {
        user_id: userID,
        exp: expirationTime
    };

    // Gera e retorna o RefreshToken
    return jwt.sign(refreshTokenPayload, 'CODIGO-SECRETO-PARA-CODIFICAR-O-REFRESH-TOKEN', { algorithm: 'HS256' });
}

O funcionamento da função acima segue o mesmo padrão da função de AccessToken, a diferença é que nós estamos usando uma data de expiração maior (30 dias), junto com um código secreto diferente.

3) Função para verificar se o AccessToken é valido:

const jwt = require('jsonwebtoken');

function verifyAccessToken(accessToken) {
    try {
        return jwt.verify(accessToken, 'CODIGO-SECRETO-PARA-CODIFICAR-O-ACCESS-TOKEN', { algorithm: 'HS256' });
    } catch (error) {
        return null;
    }
}

Na função acima, nós estamos executando uma estrutura do tipo Try...Catch que faz o uso da função jwt.verify para validar o AccessToken que foi recebido.

Observação: tanto o segundo quanto o terceiro argumento, precisam ser os mesmos que você declarou durante a função de geração do AccessToken.

4) Função para verificar se o RefreshToken é válido:

const jwt = require('jsonwebtoken');

function verifyRefreshToken(refreshToken) {
    try {
        return jwt.verify(refreshToken, 'CODIGO-SECRETO-PARA-CODIFICAR-O-REFRESH-TOKEN', { algorithm: 'HS256' });
    } catch (error) {
        console.log('Token verification error:', error.message); // Adicione este log
        return null;
    }
}

Na função acima, nós estamos executando uma estrutura do tipo Try...Catch que faz o uso da função jwt.verify para validar o RefreshToken que foi recebido.

Observação: tanto o segundo quanto o terceiro argumento, precisam ser os mesmos que você declarou durante a função de geração do RefreshToken.

Com isso em mente, vamos ver na prática como implementar um sistema de login seguro usando Tokens JWT 😉

Criando seu projeto de testes

Agora nós iremos criar uma aplicação com NodeJS + Express, que fará o uso da autenticação de Tokens JWT 🥳

Essa aplicação contará com duas telas principais, a primeira é referente ao formulário de login, e a segunda é um dashboard de boas vindas que só poderá ser acessado caso o usuário estiver logado.

Além disso, foi criado uma terceira tela de boas vindas, que representa a página inicial da nossa aplicação.

Para isso, vamos começar criando uma nova pasta dedicada ao nosso projeto, no meu caso, eu criei uma pasta chamada de Tokens JWT dentro da minha área de trabalho (desktop):

Com o seu terminal (Prompt de Comando) aberto na pasta raiz que acabamos de criar, precisamos inicializar o nosso projeto por meio do NPM, sendo assim, execute o seguinte comando abaixo:

npm init -y

A flag -y, como você já deve saber, cria um novo projeto de forma enxuta, respondendo SIM para tudo 😅

Nós vamos precisar também da biblioteca do express, cookie-parser, express-session, e do jsonwebtokens, pois iremos criar um servidor que vai fazer o uso de autenticação de usuários:

npm install express jsonwebtoken cookie-parser express-session

Em seguida, vamos criar o nosso index.js que vai conter três rotas principais, a rota de home, a rota de login e a rota de dashboard:

const express = require('express');
const path = require('path');
const app = express();
const cookieParser = require('cookie-parser');
const session = require('express-session');

// Middleware para interpretar o body de requisições POST
app.use(express.urlencoded({ extended: true })); // Para dados de formulário (application/x-www-form-urlencoded)
app.use(express.json()); // Para dados em formato JSON

// Definindo o diretório de arquivos estáticos (HTML)
app.use(express.static(path.join(__dirname, 'views')));

// Configuração da sessão
app.use(session({
    secret: 'seu-segredo-aqui', // Deve ser uma string segura
    resave: false,              // Não salvar a sessão se nada foi modificado
    saveUninitialized: true,    // Salvar uma sessão nova, mesmo sem modificações
    cookie: {
        secure: false, // Apenas para HTTPS, se for true, não funcionará no localhost
        maxAge: 60000 // 1 minuto (60000 ms)
    }
}));

//Configuração do cookie-parser
app.use(cookieParser());

// Rota para a página home
app.get('/', (req, res) => {
    res.sendFile(path.join(__dirname, 'views', 'home.html'));
});

// Rota para a página de login
app.get('/login', (req, res) => {
    res.sendFile(path.join(__dirname, 'views', 'login.html'));
});

// Rota para a página de dashboard
app.get('/dashboard', (req, res) => {
    res.sendFile(path.join(__dirname, 'views', 'dashboard.html'));
});

// Servidor rodando na porta 3000
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Servidor rodando na porta ${PORT}`);
});

Por fim, precisamos criar uma pasta chamada views (dentro da pasta raiz da sua aplicação), junto com três arquivos HTML:

views > home.html:

<!DOCTYPE html>
<html lang="pt-br">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Home</title>
</head>
<body>
    <h1>Bem-vindo a nossa aplicação</h1>
    <p>Para acessar o dashboard, <a href="/login">clique aqui</a> para fazer o login.</p>
</body>
</html>

views > login.html:

<!DOCTYPE html>
<html lang="pt-br">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Tela de Login</title>
</head>
<body>
    <h1>Faça o Login para continuar:</h1>
    <form action="/dashboard" method="GET">
        <label for="email">E-mail:</label>
        <input type="email" name="email" id="email" required>
        <label for="password">Senha:</label>
        <input type="password" name="password" id="password" required>
        <button type="submit">Entrar</button>
    </form>
</body>
</html>

views > dashboard.html:

<!DOCTYPE html>
<html lang="pt-br">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Dashboard</title>
</head>
<body>
    <h1>Dashboard</h1>
    <p>Bem-vindo ao seu painel de controle.</p>
</body>
</html>

Ao rodar a sua aplicação (node ./index.js) e acessar o servidor local (http://localhost:3000), você já vai conseguir navegar entre as 3 rotas tranquilamente 😉

Criando nosso arquivo de validação

A primeira coisa que precisamos fazer, é criar o nosso arquivo de validação, e que será usado dentro do nosso index.js.

Este arquivo contém todas as quatro funções de gerenciamento de Tokens JWT que vimos no tópico anterior.

Sendo assim, dentro da pasta raiz do seu projeto, crie um novo arquivo chamado manageTokens.js com o seguinte conteúdo:

const jwt = require('jsonwebtoken');

// Definir segredos para assinar os tokens JWT
const ACCESS_SECRET = 'myaccesstok';
const REFRESH_SECRET = 'myrefreshtok';

// Função para gerar AccessToken
function generateAccessToken(userID, expiresIn) {
    const accessTokenPayload = {
        user_id: userID,
        exp: Math.floor(Date.now() / 1000) + expiresIn // Expiração em segundos
    };

    // Gera e retorna o AccessToken
    return jwt.sign(accessTokenPayload, ACCESS_SECRET, { algorithm: 'HS256' });
}

// Função para gerar RefreshToken
function generateRefreshToken(userID) {
    const expirationTime = Math.floor(Date.now() / 1000) + (30 * 24 * 60 * 60); // 30 dias

    const refreshTokenPayload = {
        user_id: userID,
        exp: expirationTime
    };

    // Gera e retorna o RefreshToken
    return jwt.sign(refreshTokenPayload, REFRESH_SECRET, { algorithm: 'HS256' });
}

//Função para verificar se o AccessToken é válido
function verifyAccessToken(accessToken) {
    try {
        return jwt.verify(accessToken, ACCESS_SECRET, { algorithm: 'HS256' });
    } catch (error) {
        return null;
    }
}

//Função para verificar se o RefreshToken é válido
function verifyRefreshToken(refreshToken) {
    try {
        return jwt.verify(refreshToken, REFRESH_SECRET, { algorithm: 'HS256' });
    } catch (error) {
        console.log('Token verification error:', error.message); // Adicione este log
        return null;
    }
}

module.exports = {
    generateAccessToken,
    generateRefreshToken,
    verifyAccessToken,
    verifyRefreshToken
};

Este arquivo representa um módulo que será chamado futuramente pelos arquivos que precisarem dele, ou seja, arquivos que vão trabalhar de forma direta com autenticação de usuário 😉

Criando a nossa rota de autenticação

Para que o sistema de login possa funcionar corretamente, vamos precisar adicionar mais uma nova rota dentro do index.js, chamada de /loginUser que será do método POST:

// Rota para realizar o login
app.post('/loginUser', (req, res) => {
    //Verifica de forma direta se o usuário e senha estão corretos
    if (req.body.email === 'admin@admin.com' && req.body.password === 'admin') {
        //Gera os tokens de acesso e refresh
        const accessToken = generateAccessToken(1, 60); // expira em 1 minuto
        const refreshToken = generateRefreshToken(1);// expira em 30 dias

        //Salva o accessToken na sessão do usuário
        req.session.accessToken = accessToken;

        //Salva o RefreshToken em um cookie
        res.cookie('refreshToken', refreshToken, {
            expires: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000), // expira em 30 dias
            path: '/',
            secure: true, // apenas HTTPS
            httpOnly: true, // acessível apenas via HTTP
            sameSite: 'None' // ajuste conforme necessário
        });

        //Se estiver tudo OK, devemos redirecionar o usuário para /dashboard
        res.redirect('/dashboard');
    } else {
        //Se estiver errado, devemos retornar um erro 401, com uma mensagem com um link para voltar para a tela de /login
        res.status(401).send('Usuário ou senha inválidos. <a href="/login">Voltar</a>');
    }
});

Além disso, não se esqueça de atualizar o arquivo login.html, para que o atributo action aponte para a rota /loginUser em vez de /dashboard:

<!DOCTYPE html>
<html lang="pt-br">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Tela de Login</title>
</head>
<body>
    <h1>Faça o Login para continuar:</h1>
    <form action="/loginUser" method="POST">
        <label for="email">E-mail:</label>
        <input type="email" name="email" id="email" required>
        <label for="password">Senha:</label>
        <input type="password" name="password" id="password" required>
        <button type="submit">Entrar</button>
    </form>
</body>
</html>

Se você observar, a rota /loginUser está recebendo os dados do formulário e fazendo uma "validação mocada", e se o email e senha fornecidos estiverem corretos, ele gera os AccessToken e RefreshToken, e os salva dentro de sessões e cookies.

Por fim, se tudo ocorrer bem, o usuário será direcionado a rota de /dashboard.

Além disso, não se esqueça de importar dentro do seu index.js, o arquivo manageTokens.js, pois iremos precisar de duas funções que existem dentro dele:

const { generateAccessToken, generateRefreshToken } = require('./manageTokens');

Garantindo que o seu usuário está logado, antes de acessar a rota de /dashboard

Atualmente se o usuário digitar /dashboard no navegador, ele vai conseguir acessar essa página tranquilamente, tipo de coisa que não deveria acontecer.

Para fazer com que nossos usuários só consigam acessar a página de /dashboard quando estiverem logados na plataforma, nós vamos precisar criar um middleware que seja capaz de:

Para isso, vamos criar um novo arquivo chamado de tokenMiddleware.js dentro da pasta raiz do nosso projeto:

const { generateAccessToken, verifyAccessToken, verifyRefreshToken } = require('./manageTokens');

// Middleware de validação de token
const tokenMiddleware = (req, res, next) => {
    const accessToken = req.session.accessToken; // Obtém o accessToken da sessão
    const refreshToken = req.cookies.refreshToken; // Obtém o refreshToken do cookie

    // Verifica o Access Token
    if (verifyAccessToken(accessToken) !== null) {
        return next(); // Se o Access Token for válido, segue com a requisição
    }

    // Verifica o Refresh Token caso o Access Token seja inválido ou ausente
    if (verifyRefreshToken(refreshToken) !== null) {
        //Gera um novo AccessToken e o registra no objeto de sessão
        req.session.accessToken = generateAccessToken(1, 60); // expira em 1 minuto
        return next(); // Se o Refresh Token for válido, segue com a requisição
    }

    //Limpa a sessão e o cookie
    req.session.destroy();
    res.clearCookie('refreshToken');

    // Caso nenhum dos tokens seja válido, redireciona para a página de login
    res.redirect('/login');
};

module.exports = tokenMiddleware;

O comando acima é um middleware que será executado antes do usuário tentar acessar a rota de /dashboard.

Aqui nós estamos recuperando o AccessToken e o RefreshToken, de modo a validar se o AccessToken ainda é válido, e se for, ele abre a rota, se não for, ele tenta válidar o RefreshToken.

Se o RefreshToken for válido, ele gera um novo AccessToken (para que o sistema não precise fazer validações exclusivamente pelo RefreshToken) e o deixa seguir com a rota, caso não for válido, os próximos comandos incluem limpar a sessão e o cookie, além de redirecionar o usuário de volta a tela de /login.

Observação: o middleware tokenMiddleware atua como um gerenciador de rotas privadas dentro da nossa aplicação.

Por fim, basta adicionar este middleware dentro do nosso index.js, e incluí-lo dentro da rota de /dashboard:

const tokenMiddleware = require('./tokenMiddleware');

....

// Rota para a página de dashboard
app.get('/dashboard', tokenMiddleware, (req, res) => {
    ....
});

Só com essas configurações você já é capaz de ver o funcionamento dos Tokens JWT em ação 😉

Arquivo complexo do index.js

Caso você tenha se perdido durante as explicações acima, não tem problema, vou deixar aqui com você o código complexo de como ficou o index.js 😁

const express = require('express');
const path = require('path');
const app = express();
const cookieParser = require('cookie-parser');
const session = require('express-session');
const { generateAccessToken, generateRefreshToken } = require('./manageTokens');
const tokenMiddleware = require('./tokenMiddleware');

// Middleware para interpretar o body de requisições POST
app.use(express.urlencoded({ extended: true })); // Para dados de formulário (application/x-www-form-urlencoded)
app.use(express.json()); // Para dados em formato JSON

// Definindo o diretório de arquivos estáticos (HTML)
app.use(express.static(path.join(__dirname, 'views')));

// Configuração da sessão
app.use(session({
    secret: 'seu-segredo-aqui', // Deve ser uma string segura
    resave: false,              // Não salvar a sessão se nada foi modificado
    saveUninitialized: true,    // Salvar uma sessão nova, mesmo sem modificações
    cookie: {
        secure: false, // Apenas para HTTPS, se for true, não funcionará no localhost
        maxAge: 60000 // 1 minuto (60000 ms)
    }
}));

//Configuração do cookie-parser
app.use(cookieParser());

// Rota para a página home
app.get('/', (req, res) => {
    res.sendFile(path.join(__dirname, 'views', 'home.html'));
});

// Rota para a página de login
app.get('/login', (req, res) => {
    res.sendFile(path.join(__dirname, 'views', 'login.html'));
});

// Rota para a página de dashboard
app.get('/dashboard', tokenMiddleware, (req, res) => {
    res.sendFile(path.join(__dirname, 'views', 'dashboard.html'));
});

// Rota para realizar o login
app.post('/loginUser', (req, res) => {
    //Verifica de forma direta se o usuário e senha estão corretos
    if (req.body.email === 'admin@admin.com' && req.body.password === 'admin') {
        //Gera os tokens de acesso e refresh
        const accessToken = generateAccessToken(1, 60); // expira em 1 minuto
        const refreshToken = generateRefreshToken(1);// expira em 30 dias

        //Salva o accessToken na sessão do usuário
        req.session.accessToken = accessToken;

        //Salva o RefreshToken em um cookie
        res.cookie('refreshToken', refreshToken, {
            expires: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000), // expira em 30 dias
            path: '/',
            secure: true, // apenas HTTPS
            httpOnly: true, // acessível apenas via HTTP
            sameSite: 'None' // ajuste conforme necessário
        });

        //Se estiver tudo OK, devemos redirecionar o usuário para /dashboard
        res.redirect('/dashboard');
    } else {
        //Se estiver errado, devemos retornar um erro 401, com uma mensagem com um link para voltar para a tela de /login
        res.status(401).send('Usuário ou senha inválidos. <a href="/login">Voltar</a>');
    }
});

// Servidor rodando na porta 3000
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Servidor rodando na porta ${PORT}`);
});

Testando o funcionamento do nosso sistema

Com a sua aplicação rodando na porta 3000 (node ./index.js). Basta que você acesse a página inicial do seu mais novo site http://localhost:3000:

Antes de clicar no link que vai te levar diretamente a tela de /login, experimente acessar a rota de /dashboard diretamente pelo navegador (http://localhost:3000/dashboard).

Se esta for a sua primeira tentativa de acesso, você será direcionado a tela de /login assim que tentar acessar a tela de /dashboard. O que é um comportamento esperado, uma vez que o usuário não pode acessar uma rota privada sem antes passar pelo /login 🙃

Observação: caso você tenha conseguido acessar a tela de /dashboard de forma direta, experimente limpar as sessões e os cookies do localhost no seu navegador.

Já dentro da tela de /login (http://localhost:3000/login):

Digite o mesmo email e senha que configuramos dentro do index.js, que são:

Observação: a ideia é que durante a construção de uma aplicação real, tais verificações sejam realizadas de forma direta com o seu banco de dados, em vez de fazer o uso de "dados mocados".

Se tudo ocorrer bem, tanto o AccessToken quanto o RefreshToken serão criados, e você será direcionado a tela de /dashboard:

E pronto, você acaba de criar um sistema de login e autenticação utilizando Tokens JWT 🥳

Arquivos da lição

Os arquivos que você viu durante o decorrer desta lição, podem ser encontrados neste link.

Conclusão

Nesta lição, você aprendeu a implementar a lógica de autenticação utilizando Tokens JWT, em conjunto com uma aplicação que faz o uso do NodeJS e a biblioteca Express.

A partir de agora você terá aplicações muito mais seguras e confiáveis 😋

Até a próxima!