Registro de usuario de Node.js MongoDB

Así que vamos a empezar a construir los sistemas de registro de usuarios más básicos en Node.js utilizando MongoDB como almacén de datos, Express como sistema de enrutamiento, Joi como validador y, por supuesto, Mongoose para facilitar la interacción con Mongo desde Node. A continuación tenemos nuestro diseño de proyecto de muestra. User-Registration es el directorio de nivel superior que contiene el archivo index.js, y luego tenemos un directorio de modelos y un directorio de rutas. Vamos a ver cómo construir los archivos JavaScript ahora para que esto funcione.

proyecto tutorial de registro de usuario

Paso 1. Cree un modelo de usuario

Primero, necesitamos crear un modelo de usuario . Puede crear un user.jsarchivo y colocarlo en el modelsdirectorio. En la parte superior del archivo, requerimos Joi y Mongoose, ya que los necesitaremos para la validación y para crear el esquema User Mongodb. Luego, creamos el esquema de usuario y definimos los requisitos de nombre, correo electrónico y contraseña. El esquema de usuario se almacena en User. A continuación, creamos una función de validación llamada validateUser. Por último, exportamos estos módulos para poder requerirlos en otro lugar.

/models/user.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
const Joi = require('joi');
const mongoose = require('mongoose');
 
const User = mongoose.model('User', new mongoose.Schema({
    name: {
        type: String,
        required: true,
        minlength: 5,
        maxlength: 50
    },
    email: {
        type: String,
        required: true,
        minlength: 5,
        maxlength: 255,
        unique: true
    },
    password: {
        type: String,
        required: true,
        minlength: 5,
        maxlength: 1024
    }
}));
 
function validateUser(user) {
    const schema = {
        name: Joi.string().min(5).max(50).required(),
        email: Joi.string().min(5).max(255).required().email(),
        password: Joi.string().min(5).max(255).required()
    };
    return Joi.validate(user, schema);
}
 
exports.User = User;
exports.validate = validateUser;

Paso 2. Configurar rutas de usuarios

Ahora que tenemos un modelo de usuario configurado que define el esquema que debemos seguir y las reglas de validación, podemos crear un users.jsarchivo de rutas en nuestro routesdirectorio. En este archivo, lo primero que hacemos en la parte superior es solicitar, o importar, el esquema de usuario y validar el esquema que acabamos de exportar en user.js. A continuación, nos aseguramos de que Express esté inicializado. La función router.post () hace todo el trabajo pesado aquí. Primero se valida la solicitud de publicación http, luego verificamos si el usuario ya existe en la base de datos, y finalmente creamos un nuevo usuario si no existe en la base de datos y también si pasa todos los requisitos de validación. Por último exportamos el enrutador, para que podamos usarlo en el archivo index.js.

/routes/users.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
const { User, validate } = require('../models/user');
const express = require('express');
const router = express.Router();
 
router.post('/', async (req, res) => {
    // First Validate The Request
    const { error } = validate(req.body);
    if (error) {
        return res.status(400).send(error.details[0].message);
    }
 
    // Check if this user already exisits
    let user = await User.findOne({ email: req.body.email });
    if (user) {
        return res.status(400).send('That user already exisits!');
    } else {
        // Insert the new user if they do not exist yet
        user = new User({
            name: req.body.name,
            email: req.body.email,
            password: req.body.password
        });
        await user.save();
        res.send(user);
    }
});
 
module.exports = router;

Paso 3. Registrar la ruta de los usuarios en index.js

index.js

La mayor parte del texto estándar aquí debería resultarle familiar si ya siguió el tutorial de la API de resto. Aquí se destacan los puntos clave de este tutorial. Tenga en cuenta que necesitamos el archivo users.js en la línea 4. Esto nos permite configurar la ruta para la /api/userslínea 13.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const Joi = require('joi');
Joi.objectId = require('joi-objectid')(Joi);
const mongoose = require('mongoose');
const users = require('./routes/users');
const express = require('express');
const app = express();
 
mongoose.connect('mongodb://localhost/mongo-games')
    .then(() => console.log('Now connected to MongoDB!'))
    .catch(err => console.error('Something went wrong', err));
 
app.use(express.json());
app.use('/api/users', users);
 
const port = process.env.PORT || 4000;
app.listen(port, () => console.log(`Listening on port ${port}...`));

Paso 4. Pruebe las solicitudes de publicación con Postman

Ahora podemos hacer uso de Postman para enviar una solicitud de publicación a nuestro servidor para ver si podemos persistir un nuevo usuario en MongoDB. Primero, iniciemos la aplicación.

registro de usuario $ node index.js
Escuchando en el puerto 4000 ...
¡Ahora conectado a MongoDB!

¡Impresionante, todo está funcionando sin fallas! Ahora podemos probar algunas solicitudes de publicación. Aquí enviamos una solicitud de publicación como application / json con un objeto json en el cuerpo de la solicitud. Solo configuramos el nombre de usuario, pero dejamos tanto el correo electrónico como la contraseña. Podemos ver que nuestra validación está funcionando ya que la respuesta que obtenemos del servidor es "correo electrónico".
la validación está funcionando

Ahora completemos un objeto de usuario adecuado para ver si podemos hacer que el usuario se almacene en la base de datos de MongoDB. Esta vez, no obtenemos un error, pero vemos el objeto de usuario. ¡Esto significa que tuvo éxito!
publicar solicitud para expresar con json

Ahora podemos mirar dentro de MongoDB usando Compass y ver si este nuevo usuario está en su lugar. ¡Agradable!
nuevo usuario listado en mongodb

Recuerde que pusimos algo de lógica en el código para asegurarnos de que si ya había un usuario en la base de datos, entonces no deberíamos mantener ese usuario nuevamente. Para probar esto, enviamos esa misma solicitud nuevamente al servidor y obtenemos la respuesta que esperamos. No podemos insertar el mismo usuario dos veces. ¡Muy agradable!
comprobar si hay un usuario existente antes de un nuevo registro

Hash de contraseñas con Bcrypt

La parte rudimentaria del registro de usuario ahora funciona, sin embargo, la contraseña está en texto sin cifrar. Este es un gran no, no, así que veamos cómo encriptar la contraseña antes de guardarla en la base de datos usando el paquete bcrypt. Primero, lo instalamos.

registro de usuario $ npm i bcrypt

> bcrypt@2.0.1 instalar C: nodeuser-registrationnode_modulesbcrypt
> instalación de node-pre-gyp --fallback-to-build

[bcrypt] Éxito: "C: nodeuser-registrationnode_modulesbcryptlibbindingbcrypt_lib.node" se instala de forma remota

+ bcrypt@2.0.1
agregó 69 paquetes de 47 contribuyentes y auditó 247 paquetes en 8.548s
encontró 1 vulnerabilidad de gravedad baja
  corre npm audit fixpara arreglarlos, o npm auditpara detalles

Ahora que tenemos bcrypt instalado, podemos usarlo en el archivo de rutas users.js así. En la parte superior del archivo, ahora necesitamos el paquete bcrypt que lo hace disponible para usar más abajo en el archivo. En las líneas 24 y 25 generamos una sal y la usamos para codificar la contraseña antes de guardar.

/routes/users.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
const bcrypt = require('bcrypt');
const { User, validate } = require('../models/user');
const express = require('express');
const router = express.Router();
 
router.post('/', async (req, res) => {
    // First Validate The Request
    const { error } = validate(req.body);
    if (error) {
        return res.status(400).send(error.details[0].message);
    }
 
    // Check if this user already exisits
    let user = await User.findOne({ email: req.body.email });
    if (user) {
        return res.status(400).send('That user already exisits!');
    } else {
        // Insert the new user if they do not exist yet
        user = new User({
            name: req.body.name,
            email: req.body.email,
            password: req.body.password
        });
        const salt = await bcrypt.genSalt(10);
        user.password = await bcrypt.hash(user.password, salt);
        await user.save();
        res.send(user);
    }
});
 
module.exports = router;

Ahora, ejecutemos la aplicación y luego probemos con Postman.

registro de usuario $ node index.js
Escuchando en el puerto 4000 ...
¡Ahora conectado a MongoDB!

Con eso, podemos abrir Postman y enviar una solicitud POST a http: // localhost: 4000 / api / users / con un nuevo usuario especificado como un objeto JSON en el cuerpo de la solicitud.
nodo de registro de usuario de contraseña hash

¡Excelente! Obtenemos un objeto de respuesta que significa que se creó un nuevo usuario y notamos el campo de contraseña: está completamente hash. De esta manera, la contraseña está segura en la base de datos de Mongo. De hecho, inspeccionémoslo también con Compass. Tenga en cuenta que el primer usuario que hemos creado tiene una contraseña almacenada en texto sin formato. El nuevo usuario tiene una contraseña mucho más segura que está correctamente cifrada con bcrypt.
la contraseña ahora tiene hash en mongodb

Usar Lodash para simplificar nuestro código

Vamos a importar el paquete lodash a nuestro proyecto para que podamos usarlo. Lodash es una poderosa biblioteca de utilidades de JavaScript similar a la popular Biblioteca de subrayado. Aquí continuamos e instalamos Lodash.

registro de usuario $ npm i lodash

+ lodash@4.17.10
actualizó 1 paquete y auditó 247 paquetes en 13.631 y encontró 1 vulnerabilidad de baja gravedad
  corre npm audit fixpara arreglarlos, o npm auditpara detalles

¡Excelente! Ahora podemos usar lodash en nuestro proyecto. Específicamente en este caso vamos a utilizar la función de selección que hace que trabajar con objetos sea más conciso. Ahora, una vez que importamos lodash a nuestro archivo, podemos hacer uso de estos prácticos liners resaltados aquí.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
const bcrypt = require('bcrypt');
const _ = require('lodash');
const { User, validate } = require('../models/user');
const express = require('express');
const router = express.Router();
 
router.post('/', async (req, res) => {
    // First Validate The Request
    const { error } = validate(req.body);
    if (error) {
        return res.status(400).send(error.details[0].message);
    }
 
    // Check if this user already exisits
    let user = await User.findOne({ email: req.body.email });
    if (user) {
        return res.status(400).send('That user already exisits!');
    } else {
        // Insert the new user if they do not exist yet
        user = new User(_.pick(req.body, ['name', 'email', 'password']));
        const salt = await bcrypt.genSalt(10);
        user.password = await bcrypt.hash(user.password, salt);
        await user.save();
        res.send(_.pick(user, ['_id', 'name', 'email']));
    }
});
 
module.exports = router;

Cómo autenticar usuarios

Ahora que el registro de usuario está en su lugar, podemos configurar el proceso de autenticación de usuarios. Primero, siga adelante y cree un archivo auth.js en el directorio de rutas. Una vez completado, podemos comenzar con este texto estándar.

/routes/auth.js

1
2
3
4
5
6
7
8
9
10
11
12
const Joi = require('joi');
const bcrypt = require('bcrypt');
const _ = require('lodash');
const { User } = require('../models/user');
const express = require('express');
const router = express.Router();
 
router.post('/', async (req, res) => {
 
});
 
module.exports = router;

Ahora tenemos que volver al archivo index.js y configurar la ruta para 'api / auth' así.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
const Joi = require('joi');
Joi.objectId = require('joi-objectid')(Joi);
const mongoose = require('mongoose');
const users = require('./routes/users');
const auth = require('./routes/auth');
const express = require('express');
const app = express();
 
mongoose.connect('mongodb://localhost/mongo-games')
    .then(() => console.log('Now connected to MongoDB!'))
    .catch(err => console.error('Something went wrong', err));
 
app.use(express.json());
app.use('/api/users', users);
app.use('/api/auth', auth);
 
const port = process.env.PORT || 4000;
app.listen(port, () => console.log(`Listening on port ${port}...`));

Ok, volvamos al archivo auth.js. Aquí necesitamos configurar la lógica que autenticará a un usuario cuando se proporcionen las credenciales durante un intento de inicio de sesión. Eso significa que necesitamos validar la solicitud HTTP que se envía, encontrar al usuario en la base de datos y luego usar bcrypt para comparar la contraseña almacenada con la contraseña proporcionada en la solicitud. Este código logrará esos objetivos.

/routes/auth.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
const Joi = require('joi');
const bcrypt = require('bcrypt');
const _ = require('lodash');
const { User } = require('../models/user');
const express = require('express');
const router = express.Router();
 
router.post('/', async (req, res) => {
    // First Validate The HTTP Request
    const { error } = validate(req.body);
    if (error) {
        return res.status(400).send(error.details[0].message);
    }
 
    //  Now find the user by their email address
    let user = await User.findOne({ email: req.body.email });
    if (!user) {
        return res.status(400).send('Incorrect email or password.');
    }
 
    // Then validate the Credentials in MongoDB match
    // those provided in the request
    const validPassword = await bcrypt.compare(req.body.password, user.password);
    if (!validPassword) {
        return res.status(400).send('Incorrect email or password.');
    }
 
    res.send(true);
});
 
function validate(req) {
    const schema = {
        email: Joi.string().min(5).max(255).required().email(),
        password: Joi.string().min(5).max(255).required()
    };
 
    return Joi.validate(req, schema);
}
 
module.exports = router; 

¡Excelente! Ahora probemos el punto final de autenticación usando Postman. Podemos proporcionar un correo electrónico y una contraseña válidos y ver qué sucede.
Nodejs de autenticación de usuario exitosa

Ahora enviemos una solicitud con la contraseña incorrecta y veamos el resultado. ¡Ah, ja, se ve bien! Está detectando la contraseña incorrecta, por lo que el usuario no puede autenticarse.
Correo o contraseña incorrectos

Implementación de tokens web JSON

En la sección anterior, simplemente devolvimos un truevalor cuando se realizó un intento de inicio de sesión exitoso. Ahora vamos a modificar esta respuesta para enviar un token web JSON, que puede identificar de forma única a cualquier usuario en el sistema. Entonces, en general, la forma en que funciona es que la API genera un JSON Web Token al iniciar sesión correctamente y luego, en el futuro, ese usuario debe proporcionar el JSON Web Token para identificarse como un usuario válido al realizar varias solicitudes http a la API. En el lado del cliente, este token podría almacenarse en el almacenamiento local. Eso está más allá del alcance de este tutorial, ya que aquí nos centraremos en el lado del servidor. De acuerdo, para comenzar a generar JSON Web Tokens, necesitamos instalar un paquete npm para manejar eso por nosotros.

registro de usuario $ npm i jsonwebtoken

+ jsonwebtoken@8.3.0
agregó 13 paquetes de 9 contribuyentes y auditó 263 paquetes en 4.659 y encontró 1 vulnerabilidad de baja gravedad
  corre npm audit fixpara arreglarlos, o npm auditpara detalles

Aquí modificamos el archivo auth.js para hacer uso del paquete jsonwebtoken. También lo usamos para generar un nuevo JSON Web Token, y lo enviamos como respuesta a una solicitud http adecuada.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
const jwt = require('jsonwebtoken');
const Joi = require('joi');
const bcrypt = require('bcrypt');
const _ = require('lodash');
const { User } = require('../models/user');
const express = require('express');
const router = express.Router();
 
router.post('/', async (req, res) => {
    // First Validate The HTTP Request
    const { error } = validate(req.body);
    if (error) {
        return res.status(400).send(error.details[0].message);
    }
 
    //  Now find the user by their email address
    let user = await User.findOne({ email: req.body.email });
    if (!user) {
        return res.status(400).send('Incorrect email or password.');
    }
 
    // Then validate the Credentials in MongoDB match
    // those provided in the request
    const validPassword = await bcrypt.compare(req.body.password, user.password);
    if (!validPassword) {
        return res.status(400).send('Incorrect email or password.');
    }
    const token = jwt.sign({ _id: user._id }, 'PrivateKey');
    res.send(token);
});
 
function validate(req) {
    const schema = {
        email: Joi.string().min(5).max(255).required().email(),
        password: Joi.string().min(5).max(255).required()
    };
 
    return Joi.validate(req, schema);
}
 
module.exports = router; 

¡Fantástico! Probemos el envío de un nombre de usuario y un correo electrónico válidos como una solicitud POST a nuestro punto final / api / auth. Vemos que se nos devuelve un JSON Web Token válido.
token web json generado api

Realmente no deberíamos hacer que PrivateKey sea parte del código fuente, debería estar en una variable de entorno de algún tipo. Hagamos esto ahora. Primero podemos instalar el paquete de configuración.

registro de usuario $ npm i config

+ config@1.30.0
Se agregaron 3 paquetes de 5 colaboradores y se auditaron 266 paquetes en 5.314 y se encontró 1 vulnerabilidad de baja gravedad.
  corre npm audit fixpara arreglarlos, o npm auditpara detalles

Una vez instalado, podemos solicitarlo en el archivo auth.js.

1
const config = require('config');

Ahora creemos una carpeta de configuración en nuestro proyecto y coloquemos un archivo default.json y un archivo custom-environment-variables.json allí.
default.json

1
2
3
{
  "PrivateKey": ""
}

variables de entorno personalizadas.json

1
2
3
{
  "PrivateKey": "PrivateKey"
}

Ahora, en lugar de hacer referencia a la clave privada directamente, hacemos referencia a ella usando la función config.get () como vemos aquí.

1
const token = jwt.sign({ _id: user._id }, config.get('PrivateKey'));

También deberíamos incluir esto en index.js así.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
const config = require('config');
const Joi = require('joi');
Joi.objectId = require('joi-objectid')(Joi);
const mongoose = require('mongoose');
const users = require('./routes/users');
const auth = require('./routes/auth');
const express = require('express');
const app = express();
 
if (!config.get('PrivateKey')) {
    console.error('FATAL ERROR: PrivateKey is not defined.');
    process.exit(1);
}
 
mongoose.connect('mongodb://localhost/mongo-games')
    .then(() => console.log('Now connected to MongoDB!'))
    .catch(err => console.error('Something went wrong', err));
 
app.use(express.json());
app.use('/api/users', users);
app.use('/api/auth', auth);
 
const port 

Header Ads Widget

Ticker

Registro de usuario de Node.js MongoDB

Paso 1. Cree un modelo de usuario

/models/user.js

Paso 2. Configurar rutas de usuarios

/routes/users.js

Paso 3. Registrar la ruta de los usuarios en index.js

index.js

Paso 4. Pruebe las solicitudes de publicación con Postman

Hash de contraseñas con Bcrypt

/routes/users.js

Usar Lodash para simplificar nuestro código

Cómo autenticar usuarios

/routes/auth.js

/routes/auth.js

Implementación de tokens web JSON