Como desarrollador, es su responsabilidad salvaguardar los datos de sus usuarios a través de la autenticación. Puede usar Passport.js para autenticar a los usuarios en una aplicación de Node y Postgres.
Comience por crear un servidor Node con puntos finales para registrar, iniciar sesión y cerrar sesión de usuarios. Puede dejar que Passport maneje la autenticación para restringir el acceso no autorizado a su aplicación.
Creación de una tabla de usuarios
Para la autenticación de usuario, utilizará un correo electrónico y una contraseña. Esto significa que la tabla de usuarios debe contener un campo de correo electrónico y contraseña. En el símbolo del sistema de psql, cree una nueva base de datos llamada nodeapp:
CREARBASE DE DATOS aplicación de nodo;
A continuación, cree una tabla para almacenar los usuarios:
CREARMESAusuarios (
id INT GENERADO SIEMPRE COMO CLAVE PRIMARIA DE IDENTIDAD,
correo electrónico CHAR(128),
contraseña CHAR(60)
);
Este código creará una nueva tabla que contiene el correo electrónico, la contraseña y un campo de identificación generado automáticamente.
Creación de un servidor de nodo
Node.js es un entorno de tiempo de ejecución de JavaScript del lado del servidor que nos permite crear servidores HTTP rápidamente. Para simplificar el proceso de creación del servidor y diferentes rutas HTTP, puede usar Express, un marco web Node.js.
Ejecute este comando para crear una nueva carpeta llamada postgres-auth:
mkdir postgres-autorización
A continuación, inicialice npm:
npm inicializar -y
Finalmente, instale Express:
npm instalar express
Tu puedes ahora crear el servidor web del nodo.
En un nuevo archivo llamado índice.js, agrega lo siguiente:
constante expresar = requerir("Rápido");
constante aplicación = expreso();
aplicación.uso (express.json());
app.use (express.urlencoded({ extendido: verdadero }));
aplicación.escuchar(3000, () => consola.log("Escuchando en el puerto 3000"));
Ejecutar este código iniciará el servidor y registrará lo siguiente en la consola:
Escuchando en el puerto 3000Conexión a PostgreSQL
A conectarse a PostgreSQL usar nodo-postgres. node-postgres es un controlador de conexión que proporciona una interfaz entre Node y Postgres.
Ejecute lo siguiente para instalar node-postrges a través de npm:
npm instalar página
Una vez que haya instalado esa biblioteca, cree un nuevo archivo llamado db.js y conectarlo a la base de datos:
constante { Cliente } = requerir("pág");
constante {usuario, host, base de datos, contraseña, puerto} = requerir("./dbConfig");constante cliente = nuevo Cliente({
usuario,
anfitrión,
base de datos,
clave,
Puerto,
});
cliente.conectar();
módulo.exportaciones = cliente;
El método de cliente de node-postgres toma los detalles de la base de datos a la que se está conectando. Este programa importa sus detalles de conexión desde un archivo llamado dbConfig. Por lo tanto, cree ese archivo y agréguele el siguiente código:
módulo.exportaciones = {
usuario: "postgres",
anfitrión: "localhost",
base de datos: "nodeapp",
contraseña: "tuContraseña",
Puerto: 5432,
};
Crear funciones auxiliares de base de datos
Siempre es una buena práctica usar funciones individuales para interactuar con la base de datos. Facilitan la escritura de pruebas unitarias y mejoran la reutilización. Para el punto final de registro, debe crear dos funciones:
- Para comprobar si el correo electrónico ya está registrado.
- Para crear el usuario.
El objetivo es registrar un usuario solo si no existe en la base de datos.
Crear un nuevo archivo llamado ayudante.js e importe el cliente de la base de datos desde db.js:
constante cliente = requerir("./db.js")
A continuación, agregue una nueva función llamada emailExists():
constante emailExiste = asíncrono (correo electrónico) => {
constante datos = esperar client.query("SELECCIONE * DE usuarios DONDE email=$1", [
Email,
]);
si (datos.rowCount == 0) devolverfalso;
devolver datos.filas[0];
};
Esta función toma un correo electrónico y verifica si ya está en uso. Lo hace mediante el uso de la cláusula SELECT que devuelve una fila que tiene un campo de correo electrónico que coincide con el valor proporcionado por el usuario que se registra. Si el correo electrónico no existe, devuelve falso.
Para crear una función que cree el usuario, agregue una función llamada createUser() a helper.js:
constante crearUsuario = asíncrono (correo electrónico, contraseña) => {
constante sal = esperar bcrypt.genSalt(10);
constante hash = esperar bcrypt.hash (contraseña, sal);constante datos = esperar cliente.consulta(
"INSERTAR EN usuarios (correo electrónico, contraseña) VALORES ($1, $2) DEVOLUCIÓN id, correo electrónico, contraseña",
[correo electrónico, hash]
);
si (datos.rowCount == 0) devolverfalso;
devolver datos.filas[0];
};
Esta función toma los valores de correo electrónico y contraseña. Utiliza la cláusula INSERT para crear una nueva fila con estos detalles y, si tiene éxito, devuelve el usuario recién creado. Tenga en cuenta que antes de almacenar la contraseña, debe hash usando bcrypt. Nunca es una buena idea almacenar contraseñas como texto sin formato. Si los piratas informáticos tuvieran acceso a su base de datos de usuarios, podrían acceder fácilmente a información confidencial.
Instale bcryptjs para comenzar a usarlo:
npm instalar bcryptjs
En helper.js, importe bcryptjs:
constante bcripta = requerir("bcryptjs")
Al usar Bcryptjs, la base de datos solo almacena la contraseña cifrada. Por lo tanto, durante el inicio de sesión, deberá comparar la contraseña de texto sin formato proporcionada por el usuario y la contraseña codificada en la base de datos. Para ello, puede utilizar el método de comparación proporcionado por Bcryptjs.
Crea una función llamada matchPassword():
constante coincidencia de contraseña = asíncrono (contraseña, hashPassword) => {
constante partido = esperar bcrypt.compare (contraseña, hashPassword);
devolver juego
};
Recibe la contraseña simple y el hash y luego usa Bcrypt.compare() para determinar si la contraseña proporcionada es correcta. Si es así, devuelve verdadero; de lo contrario, devuelve falso.
Estas son todas las funciones que usaremos para interactuar con la base de datos. Asegúrate de exportarlos todos al final:
módulo.exportaciones = { emailExists, createUser, matchPassword };
Configurar pasaporte
Passport es un middleware de autenticación de Node que proporciona más de 500 estrategias de autenticación como inicio de sesión social, JSON Web Tokens (JWT) y autenticación de correo electrónico. Usaremos este último que proporciona la estrategia de pasaporte local.
Use el siguiente comando para instalar el pasaporte y el pasaporte local:
npm instalar pasaporte
npm instalar pasaporte-local
A continuación, configure Passport para que inicie sesión con los usuarios existentes y registre nuevos usuarios.
Comience creando un nuevo archivo pasaporteConfig.js. Luego, importe la estrategia local de Passport y las funciones auxiliares de la base de datos que acaba de crear:
constante Estrategia local = requerir("pasaporte-local");
constante { emailExists, createUser, matchPassword } = requerir("./ayudante");
En el mismo archivo, agregue lo siguiente para configurar el registro de usuario:
módulo.exportaciones = (pasaporte) => {
pasaporte.use(
"inscripción local",
nuevo Estrategia local(
{
campo de nombre de usuario: "correo electrónico",
campo de contraseña: "contraseña",
},
asíncrono (correo electrónico, contraseña, listo) => {
probar {
constante el usuario existe = esperar emailExiste (correo electrónico)si (el usuario existe) {
devolver hecho(nulo, falso);
}
constante usuario = esperar createUser (correo electrónico, contraseña);
devolver hecho(nulo, usuario);
} captura (error) {
hecho (error);
}
}
)
);
}
Dado que pasaporte-local espera un nombre de usuario y una contraseña, y usted está utilizando un correo electrónico, establezca el campo de nombre de usuario en un correo electrónico. El usuario o más bien la parte frontal de esta aplicación enviará el correo electrónico y la contraseña en el cuerpo de la solicitud. Sin embargo, no es necesario que extraiga los valores usted mismo, ya que Passport se encargará de eso en segundo plano.
Este programa primero verifica si el correo electrónico ya se tomó usando la función emailExists() de helper.js. Si el correo electrónico no existe en la base de datos, crea un nuevo usuario con la función createUser(). Finalmente, devuelve el objeto de usuario.
Para iniciar sesión de usuarios, agregue lo siguiente a pasaporteConfig.js:
módulo.exportaciones = (pasaporte) => {
pasaporte.use(
"inscripción local",
nuevo Estrategia local(
// inscribirse
)
);
pasaporte.use(
"inicio de sesión local",
nuevo Estrategia local(
{
campo de nombre de usuario: "correo electrónico",
campo de contraseña: "contraseña",
},
asíncrono (correo electrónico, contraseña, listo) => {
probar {
constante usuario = esperar emailExiste (correo electrónico);
si (!usuario) devolver hecho(nulo, falso);
constante esCoincidencia = esperar matchPassword (contraseña, usuario.contraseña);
si (!esCoincidencia) devolver hecho(nulo, falso);
devolver hecho(nulo, {identificación: usuario.id, Email: usuario.email});
} captura (error) {
devolver hecho (error, falso);
}
}
)
);
};
Aquí, el programa primero verifica si el correo electrónico está registrado. Si no, devuelve falso. Si encuentra el correo electrónico, compara su contraseña con la de la solicitud. Si las contraseñas coinciden, inicia sesión en el usuario y devuelve el objeto de usuario.
El último paso es crear los puntos finales de la API:
- POST /autorización/registro
- POST /autorización/inicio de sesión
Ambos extremos recibirán un correo electrónico y una contraseña en el cuerpo de la solicitud. También incluirán las funciones de middleware de autenticación de pasaportes que acabamos de configurar.
Importe y configure Passport en un nuevo archivo llamado servidor.js:
constante pasaporte = requerir("pasaporte");
requerir("./passportConfig")(pasaporte);
Luego, agregue las siguientes rutas:
aplicación.post(
"/auth/inscribirse",
pasaporte.authenticate("registro-local", { sesión: falso }),
(requerido, res, siguiente) => {
res.json({
usuario: req.usuario,
});
}
);
aplicación.post(
"/auth/acceso",
pasaporte.authenticate("inicio de sesión local", { sesión: falso }),
(requerido, res, siguiente) => {
res.json({ usuario: req.usuario });
}
);
Ambas rutas devuelven un objeto JSON que contiene al usuario si tiene éxito.
Verifique su API usando pruebas unitarias
Puede usar Passport para autenticar una aplicación de Nodo usando una aplicación PostgreSQL. Creó puntos finales de API para registrarse e iniciar sesión en los usuarios.
Si bien puede usar clientes REST como Postman para probar qué tan bien funciona una API, escribir pruebas unitarias es mucho más simple. Las pruebas unitarias le permiten probar las partes individuales de su aplicación. De esta manera, incluso si falla un punto final, puede identificar el punto exacto de falla. Una de las herramientas que puede usar para probar las aplicaciones de Node es Jest.
