Introdução

Olá, futuros arquitetos de sistemas! Sejam muito bem-vindos à Aula 40, onde desvendaremos os mistérios do Cookie Handling em suas APIs Node.js e Express. Preparem-se para um mergulho profundo e prático em um tema que é, sem dúvida, vital para qualquer aplicação web moderna.

Para começarmos com uma analogia, imagine que você está em um grande congresso. Ao entrar, recebe um crachá personalizado. Este crachá não é apenas uma identificação; ele indica suas áreas de interesse, quais palestras você já assistiu, e talvez até mesmo seus pedidos de café. Ao se mover pelos diferentes ambientes do congresso, os organizadores, sem você precisar dizer nada, já sabem quem você é e o que você precisa, tudo graças ao seu crachá. Em nosso universo digital, este crachá é o que chamamos de cookie HTTP.

Por que isso é tão necessário para APIs contemporâneas? Em sua essência, o protocolo HTTP é “stateless”, ou seja, ele não guarda informações sobre as requisições anteriores. Cada pedido é tratado de forma isolada. Contudo, para construir experiências de usuário ricas – como manter um usuário logado, lembrar as preferências de um tema escuro, ou rastrear itens em um carrinho de compras –, precisamos de um mecanismo que persista o estado entre as requisições. É aqui que os cookies se tornam um recurso imprescindível, atuando como essa memória de curto prazo entre o navegador e o servidor.

Nesta lição, você vai aprender a manipular esses “crachás digitais” de forma eficaz usando o pacote cookie-parser no Express.js. Vamos explorar como desenvolver, ler, modificar e remover cookies, e, mais importante, como fazer isso seguindo as melhores práticas de segurança e performance. Você irá entender o que são cookies assinados, quais atributos são essenciais para a segurança e como integrar tudo isso em um fluxo de trabalho profissional.

No ecossistema Node.js e Express, o cookie-parser é um middleware de uso corrente que simplifica enormemente a complexidade de interagir com os cabeçalhos HTTP brutos para gerenciar cookies. Ele transforma a manipulação de cookies de uma tarefa tediosa em algo direto e intuitivo, pavimentando o caminho para APIs mais robustas e amigáveis ao usuário.

Conceito Fundamental

Os cookies HTTP são pequenos pedaços de dados que um servidor envia para o navegador do usuário. O navegador armazena esses dados e os envia de volta ao servidor em todas as requisições subsequentes para o mesmo domínio. Esta mecânica viabiliza a manutenção do estado entre as solicitações HTTP, que, como mencionamos, são inerentemente sem estado.

A terminologia da indústria é precisa neste domínio:

• Cliente (Navegador): Onde os cookies são armazenados.
• Servidor (API): Onde os cookies são criados, lidos e gerenciados.
• Persistência: A capacidade de manter dados entre múltiplas requisições ou sessões de navegação.
• Sessão: Um período de interação entre o usuário e a aplicação. Cookies de sessão são excluídos quando o navegador é fechado.
• Set-Cookie Header: O cabeçalho HTTP que o servidor usa para enviar um cookie para o cliente.
• Cookie Header: O cabeçalho HTTP que o cliente envia de volta ao servidor contendo os cookies armazenados.

Além do simples par chave-valor, os cookies possuem atributos que controlam seu comportamento e segurança:

• Expires ou Max-Age: Define a data de expiração ou a duração máxima do cookie. Sem esses atributos, o cookie é de sessão.
• Domain: Especifica os hosts para os quais o cookie será enviado.
• Path: Indica o caminho da URL que deve existir na URL requisitada para enviar o cabeçalho Cookie.
• Secure: Garante que o cookie só será enviado em requisições HTTPS, protegendo-o contra interceptações em redes não seguras. Este é um atributo crucial em ambientes de produção.
• HttpOnly: Impede que scripts do lado do cliente (JavaScript) acessem o cookie. Isso é uma salvaguarda valiosa contra ataques de Cross-Site Scripting (XSS), pois mesmo que um atacante consiga injetar código malicioso, ele não poderá roubar o cookie.
• SameSite: Protege contra ataques de Cross-Site Request Forgery (CSRF), controlando como os cookies são enviados em requisições de origem cruzada. Valores comuns são Lax (padrão em muitos navegadores), Strict e None.

Os casos de uso reais em produção são numerosos. Pense em:

• Autenticação de Usuário: Armazenar tokens de sessão ou JWTs em cookies HttpOnly para manter o usuário logado de forma segura.
• Personalização: Lembrar preferências do usuário, como idioma, tema (claro/escuro) ou layout da página.
• Carrinho de Compras: Manter itens adicionados ao carrinho antes de um login ou finalização da compra.
• Rastreamento: (Com ressalvas devido a preocupações de privacidade) Monitorar o comportamento do usuário para fins analíticos ou de marketing.

Como isso se integra com outras tecnologias? Em um contexto de APIs RESTful, os cookies frequentemente trabalham lado a lado com JSON Web Tokens (JWTs). O JWT pode ser armazenado dentro de um cookie HttpOnly e Secure, sendo enviado em cada requisição para o servidor, que então valida o token para autorizar o acesso aos recursos. Para gerenciamento de sessões mais complexas, o cookie-parser é a base, mas bibliotecas como express-session se constroem sobre ele, oferecendo uma camada de abstração mais elevada para gerenciar sessões no servidor.

As vantagens dos cookies são claras: eles oferecem um método direto e amplamente suportado para persistir dados no lado do cliente, sendo uma solução madura e robusta para muitos desafios de estado. Contudo, não estão isentos de desvantagens. Eles possuem um limite de tamanho (geralmente 4KB por cookie e um número limitado por domínio), o que inviabiliza o armazenamento de grandes volumes de dados. Sem os atributos de segurança Secure e HttpOnly, tornam-se vulneráveis a interceptação e manipulação, respectivamente. As crescentes preocupações com a privacidade (GDPR, LGPD) também demandam atenção extra ao uso de cookies para rastreamento.

Implementação Prática

Agora que compreendemos a teoria, vamos colocar a mão na massa e implementar o cookie-parser em uma API Express. Nosso objetivo é construir um servidor simples que demonstre a criação, leitura e remoção de cookies, incluindo cookies assinados para maior segurança.

Primeiro, crie um novo diretório para o seu projeto e inicialize-o:

mkdir aula-cookie-parser
cd aula-cookie-parser
npm init -y
npm install express cookie-parser winston dotenv

Precisamos de um arquivo .env para armazenar o segredo do cookie-parser. Crie um arquivo chamado .env na raiz do seu projeto:

# .env
COOKIE_SECRET="seuSegredoSuperSecretoParaAssinarCookies"

Crie um arquivo index.js (ou app.js) com o código a seguir:

// index.js

// 1. Carregar variáveis de ambiente imediatamente
require('dotenv').config();
// 2. Importar módulos essenciais
const express = require('express');
const cookieParser = require('cookie-parser');
const winston = require('winston'); // Para logging profissional
// 3. Configuração do Logger (Winston)
// Um logger profissional é fundamental para monitorar a aplicação em produção.
const logger = winston.createLogger({
    level: 'info', // Nível mínimo de log para exibir
    format: winston.format.combine(
        winston.format.timestamp(), // Adiciona timestamp aos logs
        winston.format.json() // Formato JSON para fácil parseamento por ferramentas de monitoramento
    ),
    transports: [
        // Saída para o console (útil durante o desenvolvimento)
        new winston.transports.Console({
            format: winston.format.combine(
                winston.format.colorize(), // Cores para o console
                winston.format.simple() // Formato mais legível para console
            )
        }),
        // Saída para arquivo de logs (essencial em produção para auditoria e depuração)
        new winston.transports.File({ filename: 'error.log', level: 'error' }), // Logs de erro separados
        new winston.transports.File({ filename: 'combined.log' }) // Todos os logs
    ]
});
// 4. Inicializar a aplicação Express
const app = express();
// Definir a porta, priorizando a variável de ambiente (HostGator) ou 3000 como padrão
const PORT = process.env.PORT || 3000;
// 5. Configurar o middleware cookie-parser
// O segredo é vital para assinar cookies e verificar suas assinaturas.
// NUNCA exponha o COOKIE_SECRET em código fonte público! Use variáveis de ambiente.
app.use(cookieParser(process.env.COOKIE_SECRET));
// 6. Middleware para logging de requisições
// Um middleware customizado para registrar cada requisição recebida.
app.use((req, res, next) => {
    logger.info(Requisição recebida: ${req.method} ${req.url});
    next(); // Passa o controle para o próximo middleware ou rota
});
// 7. Rota Principal
// Retorna uma mensagem de boas-vindas e instrui o usuário.
app.get('/', (req, res) => {
    logger.info('Acessando a rota principal.');
    res.send('
Aula 40: Cookie Handling com cookie-parser



    
📚 Informações da Aula

    
Curso: API Completo - Node.js & Express

    
Tempo estimado: 25 minutos

    
Pré-requisitos: JavaScript básico


Visite /set-cookie para definir um cookie. Visite /read-cookie para ler. Visite /clear-cookie para remover.
Visite /set-signed-cookie e /read-signed-cookie para cookies assinados.
');
});

// 8. Rota para definir um cookie simples
app.get('/set-cookie', (req, res) => {
    // res.cookie(nome, valor, [opções])
    // Definimos um cookie chamado 'nomeUsuario' com valor 'AlunoPhDApi'
    // 'maxAge' define o tempo de vida do cookie em milissegundos (aqui, 1 hora)
    // 'httpOnly: true' é uma MELHOR PRÁTICA de SEGURANÇA. Impede que JavaScript no navegador acesse o cookie.
    // 'secure: true' (descomente em produção) garante que o cookie só seja enviado via HTTPS.
    // 'sameSite: "Lax"' é uma defesa contra CSRF. 'Strict' é mais rigoroso, 'None' exige 'secure: true'.
    res.cookie('nomeUsuario', 'AlunoPhDApi', {
        maxAge: 60  60  1000, // 1 hora
        httpOnly: true, // Essencial para segurança contra XSS
        // secure: process.env.NODE_ENV === 'production', // Use apenas em produção com HTTPS
        sameSite: 'Lax' // Proteção contra CSRF
    });
    logger.info('Cookie "nomeUsuario" definido.');
    res.send('Cookie "nomeUsuario" definido com sucesso! (Expira em 1 hora)');
});
// 9. Rota para ler cookies
app.get('/read-cookie', (req, res) => {
    // req.cookies contém os cookies não assinados enviados pelo cliente
    const nomeUsuario = req.cookies.nomeUsuario;
    if (nomeUsuario) {
        logger.info(Cookie "nomeUsuario" lido: ${nomeUsuario});
        res.send(Seu nome de usuário é: ${nomeUsuario});
    } else {
        logger.warn('Cookie "nomeUsuario" não encontrado.');
        res.status(404).send('Cookie "nomeUsuario" não encontrado. Tente definir em /set-cookie primeiro.');
    }
});
// 10. Rota para definir um cookie assinado
// Cookies assinados são úteis para verificar a integridade do cookie no servidor.
// Se o cookie for adulterado pelo cliente, o servidor saberá pois a assinatura não corresponderá.
app.get('/set-signed-cookie', (req, res) => {
    res.cookie('authToken', 'valorSecretoParaAutenticacao123', {
        maxAge: 15  60  1000, // 15 minutos
        httpOnly: true,
        signed: true, // Indica que este cookie deve ser assinado
        // secure: process.env.NODE_ENV === 'production',
        sameSite: 'Lax'
    });
    logger.info('Cookie "authToken" assinado e definido.');
    res.send('Cookie "authToken" assinado definido com sucesso! (Expira em 15 minutos)');
});
// 11. Rota para ler cookies assinados
app.get('/read-signed-cookie', (req, res) => {
    // req.signedCookies contém os cookies que foram assinados e cuja assinatura foi verificada pelo servidor.
    // Se um cookie assinado for adulterado, ele não estará presente em req.signedCookies.
    const authToken = req.signedCookies.authToken;
    // MELHORES PRÁTICAS: Sempre valide o conteúdo do cookie lido.
    if (authToken && typeof authToken === 'string' && authToken.length > 0) {
        logger.info(Cookie assinado "authToken" lido e validado.);
        res.send(Seu token de autenticação (assinado) é: ${authToken});
    } else if (req.cookies.authToken) {
        // Se o cookie existe em req.cookies mas não em req.signedCookies, significa que foi adulterado.
        logger.error('Tentativa de acesso com cookie assinado adulterado ou inválido!');
        res.status(401).send('Erro: Cookie assinado "authToken" adulterado ou inválido!');
    } else {
        logger.warn('Cookie assinado "authToken" não encontrado.');
        res.status(404).send('Cookie assinado "authToken" não encontrado. Tente definir em /set-signed-cookie primeiro.');
    }
});
// 12. Rota para remover um cookie
app.get('/clear-cookie', (req, res) => {
    // res.clearCookie(nomeDoCookie, [opções])
    // As opções devem ser as mesmas usadas para definir o cookie para garantir que ele seja removido corretamente.
    // É uma boa prática incluir 'httpOnly' e 'sameSite' se eles foram usados na definição.
    res.clearCookie('nomeUsuario', { httpOnly: true, sameSite: 'Lax' });
    res.clearCookie('authToken', { httpOnly: true, signed: true, sameSite: 'Lax' }); // Para cookies assinados, a opção 'signed: true' não é necessária na remoção, mas os outros atributos sim.
    logger.info('Cookies "nomeUsuario" e "authToken" removidos.');
    res.send('Cookies "nomeUsuario" e "authToken" removidos com sucesso!');
});
// 13. Exemplo de rota protegida (requer um cookie específico)
app.get('/area-protegida', (req, res) => {
    const nomeUsuario = req.cookies.nomeUsuario;
    if (nomeUsuario === 'AlunoPhDApi') {
        logger.info('Acesso permitido à área protegida para AlunoPhDApi.');
        res.send(Bem-vindo à área protegida, ${nomeUsuario}!);
    } else {
        logger.warn('Tentativa de acesso não autorizado à área protegida.');
        res.status(403).send('Acesso negado. Você não tem permissão para acessar esta área.');
    }
});
// 14. Error Handling global (Melhor prática para APIs robustas)
app.use((err, req, res, next) => {
    logger.error(Ocorreu um erro: ${err.message}, { stack: err.stack });
    res.status(500).send('Ocorreu um erro interno no servidor.');
});
// 15. Iniciar o servidor
app.listen(PORT, () => {
    logger.info(Servidor Express rodando na porta ${PORT});
    logger.info(Acesse: http://localhost:${PORT});
    console.log(Servidor Express rodando na porta ${PORT});
    console.log(Acesse: http://localhost:${PORT});
});

Para executar este código, salve-o como index.js e execute no terminal:

node index.js

Abra seu navegador e navegue para http://localhost:3000. Siga as instruções fornecidas na página principal para testar a funcionalidade dos cookies.

Melhores Práticas Enterprise e Configurações para HostGator Plano M:

• Variáveis de Ambiente: Sempre utilize process.env para dados sensíveis como o COOKIE_SECRET. Isso impede que segredos sejam vazados no controle de versão e facilita a gestão de diferentes ambientes (desenvolvimento, produção). No HostGator Plano M, você pode configurar variáveis de ambiente diretamente através do painel de controle ou via um arquivo .env carregado por bibliotecas como dotenv, como fizemos aqui.
• HTTPS em Produção: O atributo secure: true em cookies é um requisito inquestionável para qualquer aplicação em produção. Ele assegura que os cookies são transmitidos apenas sobre conexões HTTPS criptografadas, protegendo-os contra interceptação. No HostGator, o HTTPS geralmente é configurado a nível de servidor web (Apache/Nginx) ou via certificados SSL.
• HttpOnly: Mantenha httpOnly: true para cookies que não precisam ser acessados via JavaScript. Esta é uma defesa elementar contra XSS.
• SameSite: Configure o atributo sameSite (geralmente para Lax ou Strict) para mitigar ataques de CSRF.
• Cookies Assinados: Para qualquer dado de cookie que não deve ser alterado pelo cliente, como IDs de sessão ou tokens de autenticação, use cookies assinados. O cookie-parser faz o trabalho pesado de verificação de integridade para você.
• Logging Profissional: A inclusão do winston não é apenas um detalhe. Em ambientes de produção, ter logs estruturados e persistentes é fundamental para monitoramento, depuração e auditoria. O HostGator permite o acesso aos arquivos de log do seu servidor Node.js.
• Validação Robusta: Nunca confie cegamente nos dados provenientes do cliente, inclusive cookies. Sempre valide o tipo, formato e conteúdo dos cookies recebidos antes de utilizá-los na lógica da sua aplicação.
• Porta da Aplicação: Usar process.env.PORT || 3000 garante que sua aplicação seja flexível e possa ser configurada para usar a porta fornecida pelo ambiente de hospedagem (como o HostGator), que geralmente não é 3000.

Error Handling Eficiente:

Nossa implementação inclui um middleware de tratamento de erros global (app.use((err, req, res, next) => { ... })). Este middleware é um pilar para qualquer API enterprise. Ele captura erros que ocorrem em suas rotas e middlewares, evitando que a aplicação trave e fornecendo uma resposta genérica e segura ao cliente, enquanto registra os detalhes completos do erro (incluindo o stack trace) no seu sistema de logging para depuração posterior.

Testes Básicos Incluídos:

Para testar as funcionalidades, utilize seu navegador. Após iniciar o servidor:

• Acesse http://localhost:3000/set-cookie. Verifique os cookies no console do desenvolvedor (Application tab no Chrome, Storage no Firefox).
• Acesse http://localhost:3000/read-cookie. O cookie nomeUsuario deve ser exibido.
• Acesse http://localhost:3000/set-signed-cookie.
• Acesse http://localhost:3000/read-signed-cookie. O cookie authToken assinado deve ser lido. Tente editar o valor de authToken manualmente no console do navegador e veja o resultado ao acessar read-signed-cookie novamente. Ele não será lido corretamente por req.signedCookies.
• Acesse http://localhost:3000/clear-cookie. Verifique se os cookies foram removidos.
• Acesse http://localhost:3000/area-protegida (primeiro sem o cookie, depois de definir o cookie nomeUsuario via /set-cookie).

Exercício Hands-On

Excelente trabalho até agora! Chegou o momento de solidificar seu conhecimento com um desafio prático que irá exigir que você combine os conceitos aprendidos.

Desafio Prático: Sistema de Autenticação Simples com Cookie

Sua tarefa é expandir o servidor Express existente para criar um fluxo de autenticação básico. Você deverá:

• Implementar uma nova rota POST /login que aceita um usuario e uma senha no corpo da requisição.
• Se as credenciais forem “admin” e “senha123”, defina um cookie assinado chamado jwtToken com um valor de sua escolha (simulando um token JWT). Este cookie deve ter httpOnly: true, secure: true (se estiver usando HTTPS), sameSite: 'Lax' e expirar em 10 minutos.
• Se as credenciais estiverem incorretas, retorne um status 401 (Unauthorized).
• Criar uma rota GET /dashboard que só seja acessível se o cookie jwtToken estiver presente, for assinado corretamente e seu valor corresponder a um valor esperado (que você definirá).
• Se o cookie jwtToken não for válido ou estiver ausente, redirecione o usuário para a rota /login-page (crie uma rota GET /login-page simples que apenas informe o usuário para fazer login).
• Criar uma rota GET /logout que remova o cookie jwtToken.
• Adicionar logging profissional para todas as ações de login, logout e acesso ao dashboard.
• Garantir que todas as respostas ao cliente sejam informativas.

Solução Detalhada Passo a Passo:

Adicione as seguintes rotas e lógicas ao seu arquivo index.js:

// ... (código existente acima, incluindo imports, logger, app, cookieParser) ...

// Adicione este middleware para parsear JSON no corpo das requisições POST
app.use(express.json());
// Rota de login simples (GET para exibir formulário, POST para processar)
app.get('/login-page', (req, res) => {
    logger.info('Acessando página de login.');
    res.send(
Página de Login

Usuário:

Senha:


Use "admin" e "senha123"
);
});

// 1. Rota POST para processar o login
app.post('/login', (req, res) => {
    // Validação de entrada robusta
    const { usuario, senha } = req.body;
    if (!usuario || !senha) {
        logger.warn('Tentativa de login com credenciais incompletas.');
        return res.status(400).send('Usuário e senha são obrigatórios.');
    }
    // Simulando autenticação
    if (usuario === 'admin' && senha === 'senha123') {
        const tokenPayload = 'meuJWTSuperSecretoEValido'; // Simula o payload de um JWT real
        res.cookie('jwtToken', tokenPayload, {
            maxAge: 10  60  1000, // 10 minutos
            httpOnly: true,
            signed: true,
            // secure: process.env.NODE_ENV === 'production',
            sameSite: 'Lax'
        });
        logger.info(Usuário '${usuario}' logado com sucesso. Cookie 'jwtToken' definido.);
        res.status(200).send('Login realizado com sucesso! Você será redirecionado para o dashboard.');
        // Em um cenário real, você redirecionaria o cliente para a dashboard aqui.
        // Ex: res.redirect('/dashboard');
    } else {
        logger.warn(Tentativa de login falha para usuário '${usuario}'.);
        res.status(401).send('Credenciais inválidas.');
    }
});
// 2. Rota GET para o Dashboard (protegida)
app.get('/dashboard', (req, res) => {
    const jwtToken = req.signedCookies.jwtToken;
    const VALOR_ESPERADO_JWT = 'meuJWTSuperSecretoEValido'; // Deve corresponder ao valor definido no login
    if (jwtToken && jwtToken === VALOR_ESPERADO_JWT) {
        logger.info('Acesso concedido ao dashboard.');
        res.send('
Bem-vindo ao Dashboard Protegido!
Você está logado.
Sair');
    } else if (req.cookies.jwtToken) {
        logger.error('Tentativa de acesso ao dashboard com cookie JWT adulterado ou expirado!');
        res.status(401).send('Seu token de autenticação é inválido ou expirou. Faça login novamente.');
        // Em um cenário real, redirecionaríamos para a página de login
        // res.redirect('/login-page');
    }
    else {
        logger.warn('Acesso negado ao dashboard. Cookie JWT não encontrado.');
        // Redireciona para a página de login
        res.redirect('/login-page');
    }
});

// 3. Rota GET para Logout
app.get('/logout', (req, res) => {
    res.clearCookie('jwtToken', { httpOnly: true, signed: true, sameSite: 'Lax' });
    logger.info('Usuário deslogado. Cookie "jwtToken" removido.');
    res.send('Você foi deslogado com sucesso! Fazer Login Novamente');
});
// ... (código existente abaixo, incluindo error handling e app.listen) ...

Como Testar e Validar o Resultado:

• Inicie o servidor (node index.js).
• Abra seu navegador e vá para http://localhost:3000/dashboard. Você deve ser redirecionado para /login-page.
• Na página de login (http://localhost:3000/login-page), insira “admin” e “senha123” e clique em “Entrar”.
• Se o login for bem-sucedido, o servidor retornará uma mensagem. Verifique os cookies no console do desenvolvedor. Você deve ver o jwtToken.
• Agora, acesse http://localhost:3000/dashboard novamente. Você deve ter acesso à página do dashboard.
• Clique em “Sair” ou vá para http://localhost:3000/logout. Verifique se o cookie jwtToken foi removido.
• Tente acessar /dashboard novamente. Você deverá ser redirecionado para a página de login.
• Verifique seus arquivos de log (combined.log, error.log) para ver as entradas de login, logout e acesso.

Troubleshooting dos Erros Mais Comuns:

• Cookie não aparece ou não é lido:
  • Verifique se o cookie-parser está configurado corretamente com o segredo (process.env.COOKIE_SECRET).
  • Certifique-se de que os atributos domain e path do cookie correspondem à sua URL. No nosso caso, como não especificamos, eles assumem o domínio e path atuais (localhost:3000, ‘/’).
  • Se for um cookie assinado e não aparece em req.signedCookies, o segredo usado para defini-lo pode ser diferente do segredo usado para parseá-lo, ou o cookie foi adulterado.
• Redirecionamento não funciona:
  • Confira as URLs de redirecionamento.
  • Verifique se o jwtToken está sendo definido e lido corretamente antes da lógica de redirecionamento.
• Crescimento excessivo de logs:
  • Ajuste o level do logger (winston.createLogger({ level: 'info' ... })) para controlar a verbosidade. Em produção, você pode querer apenas info e error.
• Erro 400 (Bad Request) no login:
  • Certifique-se de ter adicionado app.use(express.json()); para que o Express possa parsear o corpo JSON das requisições POST.
  • Verifique se os nomes dos campos no seu formulário (name="usuario", name="senha") correspondem aos nomes que você está esperando em req.body.

Próximos Passos Sugeridos:

• Integração com um Banco de Dados: Em vez de credenciais “hardcoded”, integre sua lógica de login com um banco de dados real (MongoDB, PostgreSQL, etc.) para buscar e validar usuários.
• Geração Real de JWT: Substitua o tokenPayload estático pela geração de um JWT real usando uma biblioteca como jsonwebtoken. Isso inclui a assinatura com um segredo mais complexo e a inclusão de claims (dados do usuário) no token.
• Refresh Tokens: Para sessões de longa duração, implemente um sistema de refresh tokens. O jwtToken (cookie de curta duração) seria usado para requisições, e um refresh token (cookie de longa duração) para obter novos jwtTokens quando o atual expirar, tudo gerenciado por cookies HttpOnly e Secure.
• Testes Automatizados: Crie testes unitários e de integração para suas rotas e lógica de cookie, usando ferramentas como Jest ou Mocha.
• Deploy em HostGator Plano M: Prepare seu ambiente configurando as variáveis de ambiente necessárias e garantindo que o package.json esteja com os scripts corretos para iniciar sua aplicação.

Parabéns por chegar até aqui! A manipulação de cookies é uma competência fundamental para desenvolver APIs seguras e eficientes. Com este conhecimento, você está um passo à frente na construção de sistemas robustos e profissionais.