Autenticação em Node.js com Passport e PostgreSQL

Recentemente escrevi um tutorial ensinando como utilizar o Passport, uma popular lib JavaScript para construção de middlewares de autenticação. Neste tutorial, fiz toda a gestão de sessão e de autenticação em memória, usando um array simples, para fins didáticos.

A gestão de sessão não é incomum ser feita em memória, mas possivelmente você irá querer a gestão dos seus usuários persistida em um banco de dados, certo?

No tutorial de hoje, vamos adaptar o projeto anterior (então baixe ele na sua máquina) para uso com PostgreSQL, um popular banco de dados SQL.

Atenção: este é um tutorial intermediário. Parto do pressuposto aqui que você já conhece Node.js e PostgreSQL em níveis básicos e também que já realizou o tutorial anterior, onde criamos este projeto com persistência em array.

Para ver a construção de uma aplicação web completa usando Node.js e MySQL (perfeitamente compatível com PG também), conheça meu curso online e meu livro.

#1 – Configurando o banco de dados e variáveis de ambiente

Os dados de sessão dos usuários e os próprios usuários vão ficar armazenados em um banco PostgreSQL, substituindo o array do tutorial anterior.

Eu já expliquei tudo que você precisa saber sobre como configurar o ambiente PostgreSQL pra uso com Node neste tutorial.

Voltando ao nosso projeto Node.js, instale o driver do PostgreSQL para Node:

npm i pg dotenv-safe

1	npm i pg dotenv-safe

Note que instalei também o pacote dotenv-safe, que permitirá guardarmos variáveis de ambiente de uma maneira muito prática e profissional, permitindo fazer deploy do nosso projeto em produção sem ter de ficar trocando connection strings e coisas do tipo.

Para que o dotenv-safe funcione (ensino em videoaulas do meu curso de fullstack JS), você precisa criar dois arquivos novos: “.env” e “.env.example”. O “.env.example” é o template contendo quais variáveis de ambiente são obrigatórias para sua aplicação funcionar, em nosso caso, as abaixo:

#.env.example commit to repo
DATABASE_URL=
SESSION_SECRET=

#.env.example commit to repo

DATABASE_URL=

SESSION_SECRET=

Já o “.env”, contém a sua versão local das variáveis e o ideal é que você inclua no seu .gitignore o .env, para que ele não seja commitado em produção (em produção você deve setar as variáveis de ambiente de produção, e não vai querer elas sobrescritas de maneira alguma):

#.env.example commit to repo
DATABASE_URL=postgres://root@localhost/passport
SESSION_SECRET=mysecret

#.env.example commit to repo

DATABASE_URL=postgres://root@localhost/passport

SESSION_SECRET=mysecret

Agora vamos criar um módulo db.js, que vai fazer a gestão da conexão com o PostgreSQL. Crie-o na raiz do projeto.

//db.js
async function connect() {
    if (global.connection)
        return global.connection.connect();

    const { Pool } = require('pg');
    const pool = new Pool({
        connectionString: process.env.DATABASE_URL
    });

    const client = await pool.connect();

    //apenas testando a conexão
    const res = await client.query('SELECT NOW()');
    console.log(res.rows[0]);
    client.release();

    //guardando para usar sempre o mesmo pool
    global.connection = pool;
    return pool.connect();
}

module.exports = { connect }

//db.js

async function connect() {

if (global.connection)

return global.connection.connect();

const { Pool } = require('pg');

const pool = new Pool({

connectionString: process.env.DATABASE_URL

});

const client = await pool.connect();

//apenas testando a conexão

const res = await client.query('SELECT NOW()');

console.log(res.rows[0]);

client.release();

//guardando para usar sempre o mesmo pool

global.connection = pool;

return pool.connect();

}

module.exports = { connect }

Esta função apenas garante que teremos um único pool de conexões com o banco de dados sendo reaproveitada em toda aplicação. Existem técnicas bem mais avançadas que isso, como usar um ORM por exemplo. Note que exportei a função ao final, para que quando este módulo for carregado a primeira vez, possamos criar a conexão.

Agora modifique o seu bin/www (geramos este projeto com o express-generator, lembra?) para que importe o nosso db.js e chame o connect:

#!/usr/bin/env node

(async () => {

  require('dotenv-safe').config();
  const app = require('../app');
  const debug = require('debug')('nodejs-passport-login:server');
  const http = require('http');

  try {
    await require('../db').connect();
  } catch (err) {
    return console.log(err);
  }

//daqui pra baixo eu não mexi, apenas feche o iife ao final

})()

#!/usr/bin/env node

(async () => {

require('dotenv-safe').config();

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

const debug = require('debug')('nodejs-passport-login:server');

const http = require('http');

try {

await require('../db').connect();

} catch (err) {

return console.log(err);

}

//daqui pra baixo eu não mexi, apenas feche o iife ao final

})()

Repare que eu encapsulei todo o conteúdo do bin/www em um IIFE. Isso foi necessário para conseguir usar async/await na conexão com o banco.

O objeto db possuirá as funções de manipulação com o banco e mesmo que a gente carregue ele em outros pontos da aplicação, ele usará o que já está em cache. Também coloquei como primeira linha o carregamento das variáveis de ambiente. Caso o .env não exista, teremos um erro. Caso não consiga se conectar ao banco, teremos um erro (certifique-se criar um banco com o nome ‘passport’ no seu PostgreSQL, ou mude a connection string de acordo). O projeto somente vai “subir” se estiver tudo 100%.

Se você rodar este projeto agora e tudo estiver 100%, você deve ver a mensagem no console de que a conexão foi bem sucedida.

Antes de prosseguirmos, é de bom tom cadastrarmos no mínimo um usuário em nosso banco de dados, para poder realizar os testes depois. Acesse o seu banco PostgreSQL local ou remoto e crie no banco ‘passport’, a tabela ‘users’, conforme SQL abaixo:

-- Table: public.users

-- DROP TABLE public.users;

CREATE TABLE public.users
(
    id integer NOT NULL GENERATED ALWAYS AS IDENTITY ( INCREMENT 1 START 1 MINVALUE 1 MAXVALUE 2147483647 CACHE 1 ),
    username character varying(150) COLLATE pg_catalog."default" NOT NULL,
    password character varying(150) COLLATE pg_catalog."default" NOT NULL,
    email character varying(150) COLLATE pg_catalog."default" NOT NULL,
    CONSTRAINT users_pkey PRIMARY KEY (id),
    CONSTRAINT "UQ_email" UNIQUE (email),
    CONSTRAINT "UQ_username" UNIQUE (username)
)

TABLESPACE pg_default;

ALTER TABLE public.users
    OWNER to postgres;

-- Table: public.users

-- DROP TABLE public.users;

CREATE TABLE public.users

(

id integer NOT NULL GENERATED ALWAYS AS IDENTITY ( INCREMENT 1 START 1 MINVALUE 1 MAXVALUE 2147483647 CACHE 1 ),

username character varying(150) COLLATE pg_catalog."default" NOT NULL,

password character varying(150) COLLATE pg_catalog."default" NOT NULL,

email character varying(150) COLLATE pg_catalog."default" NOT NULL,

CONSTRAINT users_pkey PRIMARY KEY (id),

CONSTRAINT "UQ_email" UNIQUE (email),

CONSTRAINT "UQ_username" UNIQUE (username)

)

TABLESPACE pg_default;

ALTER TABLE public.users

OWNER to postgres;

Depois, adicione nela um usuário com os seguintes dados:

INSERT INTO public.users(
	username, password, email)
	VALUES ('adm', '$2a$06$HT.EmXYUUhNo3UQMl9APmeC0SwoGsx7FtMoAWdzGicZJ4wR1J8alW', 'contato@luiztools.com.br');

INSERT INTO public.users(

username, password, email)

VALUES ('adm', '$2a$06$HT.EmXYUUhNo3UQMl9APmeC0SwoGsx7FtMoAWdzGicZJ4wR1J8alW', '[email protected]');

Coloque no campo email, um email seu de verdade, pois precisaremos dele funcionando mais tarde. Note que o password do usuário está criptografado em formato de hash Bcrypt. Esta senha na verdade é o hash da palavra “123”. 🙂

#2 – Refatorando o app.js

Antes de mais nada, no nosso app.js nós definimos um secret que é usado pelo Passport para criptografar algumas coisas dele. Hoje este secret está chumbado, mas vamos mudar isso para usar uma variável de ambiente, como abaixo.

require('./auth')(passport);
app.use(session({  
  secret: process.env.SESSION_SECRET,//configure um segredo seu aqui,
  resave: false,
  saveUninitialized: false,
  cookie: { maxAge: 30 * 60 * 1000 }//30min
}))
app.use(passport.initialize());
app.use(passport.session());

require('./auth')(passport);

app.use(session({

secret: process.env.SESSION_SECRET,//configure um segredo seu aqui,

resave: false,

saveUninitialized: false,

cookie: { maxAge: 30 * 60 * 1000 }//30min

}))

app.use(passport.initialize());

app.use(passport.session());

Além disso, vamos instalar uma nova dependência no projeto para que o express-session use o PostgreSQL ao invés da memória para gerenciar as sessões. O express-session é muito extensível e basta instalarmos o conector para o banco de dados apropriado e fazer umas poucas configurações.

npm i connect-pg-simple

1	npm i connect-pg-simple

No app.js, no mesmo bloco de configuração do Passport, carregue o middleware de sessão do connect-pg-simple e adicione-o na chamada do session, para que ele passe a apontar para o PostgreSQL corretamente.

require('./auth')(passport);
app.use(session({
  store: new (require('connect-pg-simple')(session))(),//usa process.env.DATABASE_URL internamente
  secret: process.env.SESSION_SECRET,
  resave: false,
  saveUninitialized: false,
  cookie: { maxAge: 30 * 60 * 1000 }//30min
}))
app.use(passport.initialize());
app.use(passport.session());

require('./auth')(passport);

app.use(session({

store: new (require('connect-pg-simple')(session))(),//usa process.env.DATABASE_URL internamente

secret: process.env.SESSION_SECRET,

resave: false,

saveUninitialized: false,

cookie: { maxAge: 30 * 60 * 1000 }//30min

}))

app.use(passport.initialize());

app.use(passport.session());

Aqui estou carregando nosso módulo auth.js passando o objeto passport pra ele configurar a estratégia de autenticação. Depois digo para o express-session usar o connect-pg-simple que, sem configuração alguma, usa a variável de ambiente DATABASE_URL, e que os dados de sessão devem ser apagados automaticamente após 30 minutos.

Esse módulo espera que já exista uma tabela session criada no banco de dados. Você pode usar este script para fazê-lo, recomendado pelos criadores do pacote: https://github.com/voxpelli/node-connect-pg-simple/blob/HEAD/table.sql

#3 – Refatorando o auth.js

Agora que temos nosso banco rodando, vamos refatorar as partes do projeto que usavam o array em memória para fazer a gestão dos usuários para que usem nosso banco de dados. Vamos começar voltando ao nosso db.js e criando duas novas funções lá.

async function findUser(username) {
    const conn = await connect();
    const res = await conn.query(`SELECT * FROM users WHERE username=$1 LIMIT 1`, [username]);

    if (res.rows.length > 0)
        return res.rows[0];
    else return null;
}

async function findUserById(id) {
    const conn = await connect();
    const res = await conn.query(`SELECT * FROM users WHERE id=$1 LIMIT 1`, [id]);
    if (res.rows.length > 0)
        return res.rows[0];
    else return null;
}

module.exports = { connect, findUser, findUserById }

async function findUser(username) {

const conn = await connect();

const res = await conn.query(`SELECT * FROM users WHERE username=$1 LIMIT 1`, [username]);

if (res.rows.length > 0)

return res.rows[0];

else return null;

}

async function findUserById(id) {

const conn = await connect();

const res = await conn.query(`SELECT * FROM users WHERE id=$1 LIMIT 1`, [id]);

if (res.rows.length > 0)

return res.rows[0];

else return null;

}

module.exports = { connect, findUser, findUserById }

Agora, vamos abrir nosso auth.js, removendo o array de users, removendo as funções de findUser e findUserById originais e depois refatorando as duas chamadas das funções antigas para que usem as novas do objeto db, como abaixo.

const bcrypt = require('bcryptjs');
const LocalStrategy = require('passport-local').Strategy;

module.exports = function (passport) {

    passport.serializeUser((user, done) => {
        done(null, user.id);
    });

    passport.deserializeUser(async (id, done) => {
        try {
            const db = require('./db');
            const user = await db.findUserById(id);
            done(null, user);
        } catch (err) {
            done(err, null);
        }
    });

    passport.use(new LocalStrategy({
        usernameField: 'username',
        passwordField: 'password'
    },
        async (username, password, done) => {
            try {
                const db = require('./db');
                const user = await db.findUser(username);

                // usuário inexistente
                if (!user) { return done(null, false) }

                // comparando as senhas
                const isValid = bcrypt.compareSync(password, user.password);
                if (!isValid) return done(null, false)
                
                return done(null, user)
            } catch (err) {
                done(err, false);
            }
        }
    ));
}

const bcrypt = require('bcryptjs');

const LocalStrategy = require('passport-local').Strategy;

module.exports = function (passport) {

passport.serializeUser((user, done) => {

done(null, user.id);

});

passport.deserializeUser(async (id, done) => {

try {

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

const user = await db.findUserById(id);

done(null, user);

} catch (err) {

done(err, null);

}

});

passport.use(new LocalStrategy({

usernameField: 'username',

passwordField: 'password'

async (username, password, done) => {

try {

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

const user = await db.findUser(username);

// usuário inexistente

if (!user) { return done(null, false) }

// comparando as senhas

const isValid = bcrypt.compareSync(password, user.password);

if (!isValid) return done(null, false)

return done(null, user)

} catch (err) {

done(err, false);

}

));

}

Assim, ao invés de estarmos procurando em um array, estaremos procurando diretamente no banco de dados.

Como as funções do PostgreSQL são assíncronas, ou usamos callbacks, promises ou ainda async/await, que foi a opção que escolhi aqui. Devido a isso, tive de alterar as funções que chamam as findUser para que usem async/await.

E com isso você tem novamente a sua aplicação web em Node.js funcionando e exigindo autenticação, mas agora com o PostgreSQL como persistência de dados!

Quer aprender a publicar esta aplicação na Amazon? Dê uma olhada neste tutorial!

Ou então publique na Heroku, com este tutorial. 🙂

Quer aprender a construir aplicações web usando Node.js e MySQL (compatível com PG SQL) com a mesma didática deste tutorial? Conheça o meu curso online ou meu livro.