Como desenvolvedor, é sua responsabilidade proteger os dados de seus usuários por meio de autenticação. Você pode usar o Passport.js para autenticar usuários em um aplicativo Node e Postgres.
Comece criando um servidor Node com endpoints para registrar, entrar e desconectar usuários. Você pode permitir que o Passport manipule a autenticação para restringir o acesso não autorizado ao seu aplicativo.
Criando uma tabela de usuários
Para autenticação do usuário, você usará um e-mail e uma senha. Isso significa que a tabela de usuários deve conter um campo de e-mail e senha. No prompt de comando do psql, crie um novo banco de dados chamado nodeapp:
CRIOBASE DE DADOS nodeapp;
Em seguida, crie uma tabela para armazenar os usuários:
CRIOTABELAusuários (
id INT GERADO SEMPRE COMO CHAVE PRIMÁRIA DE IDENTIDADE,
e-mail CHAR(128),
senha CHAR(60)
);
Esse código criará uma nova tabela contendo e-mail, senha e um campo de ID gerado automaticamente.
Criando um servidor de nós
Node.js é um ambiente de tempo de execução JavaScript do lado do servidor que nos permite criar servidores HTTP rapidamente. Para simplificar o processo de criação do servidor e diferentes rotas HTTP, você pode usar
Express, uma estrutura da Web Node.js.Execute este comando para criar uma nova pasta chamada postgres-auth:
mkdir postgres-auth
Em seguida, inicialize o npm:
npm init -y
Por fim, instale o Express:
npm instalar expresso
Agora você pode crie o servidor web Node.
Em um novo arquivo chamado index.js, adicione o seguinte:
const expresso = exigir("expressar");
const aplicativo = expresso();
app.use (express.json());
app.use (express.urlencoded({ estendido: verdadeiro }));
app.listen(3000, () => console.log("Ouvindo na porta 3000"));
A execução deste código iniciará o servidor e registrará o seguinte no console:
Ouvindo na porta 3000Conectando-se ao PostgreSQL
Para conectar ao PostgreSQL usar node-postgres. node-postgres é um driver de conexão que fornece uma interface entre o Node e o Postgres.
Execute o seguinte para instalar o node-postrges via npm:
npm instalar pg
Depois de instalar essa biblioteca, crie um novo arquivo chamado db.js e conecte-o ao banco de dados:
const { Cliente } = exigir("pg");
const { usuário, host, banco de dados, senha, porta } = exigir("./dbConfig");const cliente = novo Cliente({
do utilizador,
hospedeiro,
base de dados,
senha,
porta,
});
cliente.conectar();
módulo.exports = cliente;
O método client do node-postgres pega os detalhes do banco de dados ao qual você está se conectando. Este programa importa seus detalhes de conexão de um arquivo chamado dbConfig. Portanto, crie esse arquivo e adicione o seguinte código a ele:
módulo.exports = {
usuário: "postgres",
host: "localhost",
banco de dados: "nodeapp",
senha: "suasenha",
porta: 5432,
};
Criar funções auxiliares de banco de dados
É sempre uma boa prática usar funções individuais para interagir com o banco de dados. Eles facilitam a escrita de testes de unidade e melhoram a reutilização. Para o endpoint de inscrição, você precisa criar duas funções:
- Para verificar se o e-mail já está cadastrado.
- Para criar o usuário.
O objetivo é registrar um usuário apenas se ele não existir no banco de dados.
Crie um novo arquivo chamado helper.js e importe o cliente de banco de dados do db.js:
const cliente = exigir("./db.js")
Em seguida, adicione uma nova função chamada emailExists():
const emailExist = assíncrono (e-mail) => {
const dados = aguardam client.query("SELECT * FROM users WHERE email=$1", [
o email,
]);
E se (data.rowCount == 0) Retornafalso;
Retorna data.rows[0];
};
Esta função recebe um e-mail e verifica se já está em uso. Ele faz isso usando a cláusula SELECT que retorna uma linha que possui um campo de email que corresponde ao valor fornecido pelo usuário registrador. Se o e-mail não existir, ele retornará false.
Para criar uma função que cria o usuário, adicione uma função chamada createUser() ao helper.js:
const criarUsuário = assíncrono (e-mail, senha) => {
const sal = aguardam bcrypt.genSalt(10);
const hash = aguardam bcrypt.hash (senha, sal);const dados = aguardam cliente.consulta(
"INSERIR EM USUÁRIOS (e-mail, senha) VALORES ($1, $2) ID DE RETORNO, e-mail, senha",
[e-mail, hash]
);
E se (data.rowCount == 0) Retornafalso;
Retorna data.rows[0];
};
Esta função recebe os valores de email e senha. Ele usa a cláusula INSERT para criar uma nova linha com esses detalhes e, se for bem-sucedida, retorna o usuário recém-criado. Observe que antes de armazenar a senha, você deve hash usando bcrypt. Nunca é uma boa ideia armazenar senhas como texto simples. Se os hackers tivessem acesso ao seu banco de dados de usuários, eles poderiam acessar facilmente informações confidenciais.
Instale bcryptjs para começar a usá-lo:
npm instala bcryptjs
Em helper.js, importe bcryptjs:
const bcript = exigir("bcryptjs")
Ao usar o Bcryptjs, o banco de dados armazena apenas a senha criptografada. Portanto, durante o login, você precisará comparar a senha de texto simples fornecida pelo usuário e a senha com hash no banco de dados. Para isso, você pode usar o método de comparação fornecido pelo Bcryptjs.
Crie uma função chamada matchPassword():
const matchPassword = assíncrono (senha, hashSenha) => {
const corresponder = aguardam bcrypt.compare (senha, hashPassword);
Retorna Combine
};
Ele recebe a senha simples e o hash e então usa Bcrypt.compare() para determinar se a senha fornecida está correta. Se for, retorna true, caso contrário, retorna false.
Estas são todas as funções que usaremos para interagir com o banco de dados. Certifique-se de exportar todos eles no final:
módulo.exports = { emailExists, createUser, matchPassword };
Configurar passaporte
O Passport é um middleware de autenticação Node que fornece mais de 500 estratégias de autenticação, como login social, JSON Web Tokens (JWT) e autenticação de e-mail. Estaremos usando o último que a estratégia local do passaporte fornece.
Use o seguinte comando para instalar o passaporte e o passaporte-local:
npm instalar passaporte
npm instala o passaporte-local
Em seguida, configure o Passport para fazer login de usuários existentes e registrar novos usuários.
Comece criando um novo arquivo passaporteConfig.js. Em seguida, importe a estratégia local do Passport e as funções auxiliares do banco de dados que você acabou de criar:
const LocalStrategy = exigir("passaporte-local");
const { emailExists, createUser, matchPassword } = exigir("./ajudante");
No mesmo arquivo, adicione o seguinte para configurar a inscrição do usuário:
módulo.exports = (passaporte) => {
passaporte.use(
"inscrição local",
novo LocalStrategy(
{
usernameField: "e-mail",
passwordField: "senha",
},
assíncrono (e-mail, senha, concluído) => {
tentar {
const userExist = aguardam emailExiste (e-mail)E se (userExists) {
Retorna feito(nulo, falso);
}
const usuário = aguardam createUser (e-mail, senha);
Retorna feito(nulo, do utilizador);
} truque (erro) {
feito (erro);
}
}
)
);
}
Como o passaporte-local espera um nome de usuário e uma senha e você está usando um e-mail, defina o campo de nome de usuário como um e-mail. O usuário, ou melhor, a parte frontend deste aplicativo enviará o e-mail e a senha no corpo da solicitação. No entanto, você não precisa extrair os valores sozinho, pois o Passport lidará com isso em segundo plano.
Este programa primeiro verifica se o email já foi recebido usando a função emailExists() do helper.js. Se o email não existir no banco de dados, ele cria um novo usuário com a função createUser(). Por fim, ele retorna o objeto do usuário.
Para fazer login de usuários, adicione o seguinte ao passaporteConfig.js:
módulo.exports = (passaporte) => {
passaporte.use(
"inscrição local",
novo LocalStrategy(
// inscrever-se
)
);
passaporte.use(
"login local",
novo LocalStrategy(
{
usernameField: "e-mail",
passwordField: "senha",
},
assíncrono (e-mail, senha, concluído) => {
tentar {
const usuário = aguardam emailExiste (e-mail);
E se (!do utilizador) Retorna feito(nulo, falso);
const éCorrespondência = aguardam matchPassword (senha, usuário.senha);
E se (!isCorrespondência) Retorna feito(nulo, falso);
Retorna feito(nulo, {Eu iria: ID do usuário, o email: usuário.email});
} truque (erro) {
Retorna feito (erro, falso);
}
}
)
);
};
Aqui, o programa primeiro verifica se o e-mail está registrado. Se não, ele retorna falso. Se encontrar o e-mail, ele compara sua senha com a da solicitação. Se as senhas corresponderem, ele efetuará login no usuário e retornará o objeto de usuário.
A etapa final é criar os endpoints da API:
- POST /auth/signup
- POST /auth/login
Ambos os endpoints receberão um e-mail e senha no corpo da solicitação. Eles também incluirão as funções de middleware de autenticação de passaporte que acabamos de configurar.
Importe e configure o Passport em um novo arquivo chamado server.js:
const passaporte = exigir("Passaporte");
exigir("./passportConfig")(passaporte);
Em seguida, adicione as seguintes rotas:
app.post(
"/auth/inscrever-se",
passaporte.authenticate("local-signup", { sessão: falso }),
(req, res, próximo) => {
res.json({
usuário: req.user,
});
}
);
app.post(
"/auth/Conecte-se",
passaporte.authenticate("local-login", { sessão: falso }),
(req, res, próximo) => {
res.json({ do utilizador: req.user });
}
);
Ambas as rotas retornam um objeto JSON contendo o usuário se forem bem-sucedidas.
Verifique sua API usando testes de unidade
Você pode usar o Passport para autenticar um aplicativo Node usando um aplicativo PostgreSQL. Você criou endpoints de API para inscrever e fazer login de usuários.
Embora você possa usar clientes REST como o Postman para testar o funcionamento de uma API, escrever testes de unidade é muito mais simples. Os testes de unidade permitem que você teste as partes individuais de seu aplicativo. Dessa forma, mesmo que um endpoint falhe, você pode identificar o ponto exato da falha. Uma das ferramentas que você pode usar para testar aplicativos Node é o Jest.
