Ejemplos de validación de Mongoose

Al igual que todos los demás marcos, Mongoose proporciona una forma de validar los datos antes de guardarlos en una base de datos. La validación de datos es importante para asegurarse de que los datos "malos" no se conserven en su aplicación. Una ventaja de usar Mongoose al insertar datos en MongoDB es su soporte integrado para esquemas de datos y la validación automática de datos cuando se conservan. No obtendrías esto sin Mongoose. Los validadores de Mongoose son fáciles de configurar. Al definir el esquema, un desarrollador puede agregar opciones adicionales a la propiedad que deben validarse. Veamos ahora algunos ejemplos básicos de validación en Mongoose.

Empezar con `required`

En este momento tenemos un esquema en Mongoose que no tiene validación. En otras palabras, todas las propiedades definidas a continuación son opcionales. Si proporciona cada propiedad al crear un documento, ¡excelente! Si no, ¡eso también es genial!

1
2
3
4
5
6
7
8
const gameSchema = new mongoose.Schema({
    title: String,
    publisher: String,
    tags: [String],
    date: { type: Date, default: Date.now },
    onSale: Boolean,
    price: Number
});

Por supuesto, casi siempre es necesario validar cualquier dato que desee conservar. Podemos modificar el esquema para agregar validación como tal. En el fragmento a continuación, estamos haciendo que titleel juego sea obligatorio. Ya no es opcional. Podemos hacer esto con la requiredpropiedad.

1
2
3
4
5
6
7
8
const gameSchema = new mongoose.Schema({
    title: { type: String, required: true },
    publisher: String,
    tags: [String],
    date: { type: Date, default: Date.now },
    onSale: Boolean,
    price: Number
});

Con nuestra validación para el título del juego, intentemos guardar un juego en la base de datos sin especificar un título.

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
const mongoose = require('mongoose');
 
mongoose.connect('mongodb://localhost/mongo-games')
    .then(() => console.log('Now connected to MongoDB!'))
    .catch(err => console.error('Something went wrong', err));
 
const gameSchema = new mongoose.Schema({
    title: { type: String, required: true },
    publisher: String,
    tags: [String],
    date: { type: Date, default: Date.now },
    onSale: Boolean,
    price: Number
});
 
const Game = mongoose.model('Game', gameSchema);
 
async function saveGame() {
    const game = new Game({
        publisher: "Nintendo",
        tags: ["adventure", "action"],
        onSale: false,
        price: 59.99,
    });
 
    const result = await game.save();
    console.log(result);
}
 
saveGame();

Podemos ejecutar index.js usando node index.jsen la terminal para probar esto.

mongo-crud $ node index.js
(nodo: 10176) UnhandledPromiseRejectionWarning: Rechazo de promesa no manejado 
(ID de rechazo: 2): ValidationError: Falló la validación del juego: título: Ruta title 
es requerido. (nodo: 10176) [DEP0018] DeprecationWarning: Rechazos de promesa no gestionados
están en desuso. En el futuro, los rechazos de promesas que no se manejan
Termine el proceso de Node.js con un código de salida distinto de cero.

Interesante. Obtenemos mucha información de error sobre el rechazo de una promesa no manejada. Podemos solucionar esto actualizando nuestra lógica en la saveGame()función. Sin embargo, lo bueno es que dentro de la información enumerada vemos que la validación funcionó ya que la validación del juego falló: title: Path titleis required nos lo indica. Actualicemos el código para manejar la promesa correctamente implementando un bloque try / catch.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
async function saveGame() {
    const game = new Game({
        publisher: "Nintendo",
        tags: ["adventure", "action"],
        onSale: false,
        price: 59.99,
    });
 
    try {
        const result = await game.save();
        console.log(result);
    } catch (err) {
        console.log(err.message)
    }
}
 
saveGame();

Ejecutar el archivo index.js ahora nos da un mensaje más fácil de leer.

mongo-crud $ node index.js
Falló la validación del juego: título: titlese requiere la ruta .

¡Excelente! La validación está funcionando. Es importante señalar que este ejemplo de validación en Mongoose es solo eso, validación en Mongoose. Esto no tiene nada que ver con la validación de datos a nivel de base de datos o MongoDb. Otra cosa a tener en cuenta es que este tipo de validación en Mongoose es complementario a un paquete de validación como Joi que usamos en el tutorial de la API de node rest. Al usar tanto la validación en la capa REST como la capa Mongoose, puede asegurarse de que los documentos defectuosos no se conserven en la base de datos.

Más sobre validadores integrados

En la sección anterior, vimos cómo usar la requiredpropiedad para que sea obligatorio que un usuario proporcione el título de un juego cuando persiste en la base de datos. También puede usar una función con requiredpara requerir algo condicionalmente. En el fragmento a continuación, decimos que si el juego está en oferta, se requiere el precio.

1
2
3
4
5
6
7
8
9
10
11
const gameSchema = new mongoose.Schema({
    title: { type: String, required: true },
    publisher: String,
    tags: [String],
    date: { type: Date, default: Date.now },
    onSale: Boolean,
    price: {
        type: Number,
        required: function () { return this.onSale }
    }
});

Ahora podemos intentar guardar un juego, pero omitiremos el título y el precio para ver si nuestras reglas de validación siguen funcionando. Nuestra lógica para insertar el juego está aquí.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
const Game = mongoose.model('Game', gameSchema);
 
async function saveGame() {
    const game = new Game({
        publisher: "Nintendo",
        tags: ["adventure", "action"],
        onSale: true,
    });
 
    try {
        const result = await game.save();
        console.log(result);
    } catch (err) {
        console.log(err.message)
    }
}
 
saveGame();

La ejecución del programa muestra que estas reglas funcionan bien. Se requiere tanto el precio como el título, por lo que el juego no se conserva.

mongo-crud $ node index.js
Error de validación del juego: precio: pricese requiere la ruta ., Título: titlese requiere la ruta .

minlength y maxlength

Además de hacer necesaria una cadena, también puede especificar la longitud mínima y la longitud máxima que debería tener. Considere este esquema.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const gameSchema = new mongoose.Schema({
    title: {
        type: String,
        required: true,
        minlength: 4,
        maxlength: 200
    },
    publisher: String,
    tags: [String],
    date: { type: Date, default: Date.now },
    onSale: Boolean,
    price: {
        type: Number,
        required: function () { return this.onSale }
    }
});

Ahora, proporcionemos un título, pero con solo 3 caracteres y veamos qué sucede.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
const Game = mongoose.model('Game', gameSchema);
 
async function saveGame() {
    const game = new Game({
        title: "Pac",
        publisher: "Nintendo",
        tags: ["adventure", "action"],
        onSale: true,
    });
 
    try {
        const result = await game.save();
        console.log(result);
    } catch (err) {
        console.log(err.message)
    }
}
 
saveGame();

Cuando ejecutamos el programa, el validador nos dice que nuestro título es demasiado corto.

mongo-crud $ node index.js
Error de validación del juego: precio: pricese requiere la ruta .,
title: Path title( Pac) es más corto que la longitud mínima permitida (4).

validación de enumeración

Al crear un juego, le estamos asignando algunas etiquetas. Usando la validación de enumeración, podemos especificar las etiquetas disponibles que se pueden usar. A continuación, decimos que las etiquetas de un juego deben ser deportes, carreras, acción o rpg.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
const gameSchema = new mongoose.Schema({
    title: {
        type: String,
        required: true,
        minlength: 4,
        maxlength: 200
    },
    publisher: String,
    tags: {
        type: [String],
        required: true,
        enum: ['sports', 'racing', 'action', 'rpg']
    },
    date: { type: Date, default: Date.now },
    onSale: Boolean,
    price: {
        type: Number,
        required: function () { return this.onSale }
    }
});

Ahora intentamos guardar un juego usando una etiqueta que no hemos tenido en cuenta en la validación de enumeración, aventura.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
const Game = mongoose.model('Game', gameSchema);
 
async function saveGame() {
    const game = new Game({
        title: "Pacman",
        publisher: "Nintendo",
        tags: ["adventure", "action"],
        onSale: true,
        price: 29.99
    });
 
    try {
        const result = await game.save();
        console.log(result);
    } catch (err) {
        console.log(err.message)
    }
}
 
saveGame();

Efectivamente, al intentar insertar ese juego en la base de datos falla y obtenemos el error que adventureno es un valor de enumeración válido para la ruta tags.

mongo-crud $ node index.js La validación del juego falló: tags.0: adventureno es un valor de enumeración válido para la ruta tags.

Validadores personalizados

También puede configurar un validador personalizado en Mongoose. Aquí modificaremos la validación de las etiquetas de modo que un usuario deba proporcionar más de una.

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 gameSchema = new mongoose.Schema({
    title: {
        type: String,
        required: true,
        minlength: 4,
        maxlength: 200
    },
    publisher: String,
    tags: {
        type: [String],
        validate: {
            validator: function (v) {
                return v.length > 1
            },
            message: 'You must provide more than 1 tag.'
        }
    },
    date: { type: Date, default: Date.now },
    onSale: Boolean,
    price: {
        type: Number,
        required: function () { return this.onSale }
    }
});

Ahora intentamos guardar un juego y solo proporcionamos una etiqueta.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
const Game = mongoose.model('Game', gameSchema);
 
async function saveGame() {
    const game = new Game({
        title: "Pacman",
        publisher: "Nintendo",
        tags: ["arcade"],
        onSale: true,
        price: 29.99
    });
 
    try {
        const result = await game.save();
        console.log(result);
    } catch (err) {
        console.log(err.message)
    }
}
 
saveGame();

Ejecutar el programa nos da el error de validación que esperamos.

mongo-crud $ node index.js
Error de validación del juego: etiquetas: debes proporcionar más de una etiqueta.

Validadores asíncronos

La validación asincrónica entra en juego cuando necesita obtener algunos datos remotos o realizar algún otro tipo de tarea asincrónica antes de persistir en la base de datos. Para esto podemos usar un validador asíncrono. Echemos un vistazo a uno. Simularemos el trabajo asincrónico con la función setTimeout ().

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
const gameSchema = new mongoose.Schema({
    title: {
        type: String,
        required: true,
        minlength: 4,
        maxlength: 200
    },
    publisher: String,
    tags: {
        type: [String],
        validate: {
            isAsync: true,
            validator: function (v, callback) {
                // Complete async task
                setTimeout(() => {
                    const result = v.length > 1;
                    callback(result);
                }, 2000);
            },
            message: 'You must provide more than 1 tag.'
        }
    },
    date: { type: Date, default: Date.now },
    onSale: Boolean,
    price: {
        type: Number,
        required: function () { return this.onSale }
    }
});

Para habilitar la validación asincrónica, todo lo que necesita hacer es agregar la propiedad isAsync al objeto de validación y establecerlo en true. Luego, puede realizar su trabajo asincrónico, ya sea para obtener datos remotos, leer desde el sistema de archivos o trabajar con una base de datos, y la validación seguirá funcionando correctamente.

Resumen de ejemplos de validación de Mongoose

En este tutorial sobre Validación de Mongoose, aprendimos que al definir un esquema, puede establecer el tipo de propiedad en un objeto SchemaType. Utilice este objeto para definir los requisitos de validación para la propiedad dada. Podemos agregar validación con código como este.

1
2
3
new mongoose.Schema({
    name: { type: String, required: true }
})

Mongoose ejecuta la lógica de validación antes de que se pueda guardar un documento en la base de datos. También es posible activarlo manualmente llamando al método validate (). Algunos de los validadores integrados incluyen:

Cuerdas: minlength , maxlength, match,enum
Números: min ,max
Fechas: min ,max
Todos los tipos: required

Para configurar la validación personalizada, puede configurar el objeto de validación y utilizar una función en la propiedad de validación.

1
2
3
4
5
6
7
tags: [
    type: Array,
    validate: {
        validator: function (v) { return v && v.length > 0; },
        message: 'A game should have at least 1 tag.'
    }
]

Al hablar con una base de datos o un servicio remoto para realizar la validación, es necesario que utilice un validador asíncrono. Habilita esto con la isAsyncpropiedad establecida en true.

1
2
3
4
5
6
7
validate: {
    isAsync: true
    validator: function(v, callback) {
        // Do the validation, when the result is ready, call the callback
        callback(isValid);
    }
}

Algunas otras propiedades útiles de SchemaType incluyen:

Cuerdas: lowercase , uppercase,trim
Todos los tipos: get , set(para definir un captador de encargo / definidor)

¡Feliz validación!

Header Ads Widget

Ejemplos de validación de Mongoose

Empezar con `required`

Más sobre validadores integrados

minlength y maxlength

validación de enumeración

Validadores personalizados

Validadores asíncronos

Resumen de ejemplos de validación de Mongoose

Publicar un comentario

0 Comentarios

Random Posts

Información relevante

Colaboraciones

Menu Footer Widget

Header Ads Widget

Ejemplos de validación de Mongoose

Empezar con required

Más sobre validadores integrados

minlength y maxlength

validación de enumeración

Validadores personalizados

Validadores asíncronos

Resumen de ejemplos de validación de Mongoose

Publicar un comentario

0 Comentarios

Random Posts

Información relevante

Colaboraciones

Menu Footer Widget

Empezar con `required`