Validación de strings con JSON Schema en MongoDB

Contenido del curso

Introducción

Proyecto

Validación de datos

Relaciones

Bonus: patrones

Próximos pasos

22
Modelado de Datos con MongoDB: Relaciones y Consultas Avanzadas
02:03 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0016:07

Validación de strings con JSON Schema en MongoDB

Curso de Modelado de Datos en MongoDB

Clase 7 de 22

Clase 7 / 22

Recursos

MongoDB es flexible, pero esa flexibilidad no significa caos. Cuando aprendes a validar datos con JSON Schema en MongoDB, proteges la integridad de tus colecciones y aseguras que cada documento cumpla las reglas de negocio que tu aplicación necesita.

Esta guía te muestra cómo definir esquemas explícitos en una base de datos NoSQL documental, empezando por los strings, para que tus colecciones mantengan estructura sin perder la versatilidad que distingue a Mongo.

¿Por qué validar datos si MongoDB es una base NoSQL flexible?

La flexibilidad de las bases documentales permite que cada documento tenga atributos distintos, pero no protege la integridad de la información. Si insertas un usuario con un email numérico o sin password, Mongo lo aceptará por defecto.

Desde la terminal de VS Code conectada a MongoDB Atlas [01:45], al ejecutar db.users.insertOne() con un email en formato entero y sin nombre ni password, el documento se inserta sin error. Eso es justo lo que queremos evitar.

¿Qué es un BSON Type en MongoDB? Es el sistema de tipos que usa Mongo internamente y que soporta más formatos que JSON estándar, como double, date, array, bool o expresiones regulares.

¿Cómo se crea una colección con validador en MongoDB?

El método db.createCollection() recibe un objeto con la propiedad validator, donde defines un $jsonSchema que describe la estructura esperada [05:30].

El esquema base se construye así:

bsonType: "object" declara que cada documento es un objeto.
properties lista cada atributo del documento.
Dentro de cada propiedad, defines su bsonType esperado, por ejemplo string.

Un detalle importante: si la colección ya existe porque se creó dinámicamente con un insertOne previo, debes ejecutar un drop antes de aplicar el nuevo esquema. Por eso conviene tener un archivo drop.mongodb separado para borrar la colección y reiniciar las validaciones [07:50].

¿Cómo defino propiedades obligatorias y opcionales con required?

El arreglo required dentro del esquema indica qué campos no pueden faltar. El resto sigue siendo opcional, respetando la naturaleza flexible de Mongo.

En el ejemplo de la colección users, los campos email y password son obligatorios, mientras que name y lastName quedan opcionales [10:20]. La regla queda así:

Si envías email o password, deben existir y ser string.
Si envías name o lastName, también deben ser string, aunque puedes omitirlos.
Cualquier intento de insertar un documento sin password dispara un error de validación.

Esta combinación de required con bsonType te da control sin sacrificar dinamismo. Puedes seguir agregando atributos extra a documentos individuales y la colección los aceptará, siempre que se cumpla el mínimo definido.

¿Qué pasa si inserto un email numérico con un esquema activo? MongoDB rechaza el documento y lanza un error de document validation, evitando que datos inválidos lleguen a la colección.

¿Qué tipos de datos puedo validar con JSON Schema?

Gracias a BSON Type, el validador acepta una variedad amplia de tipos para reflejar reglas reales de negocio:

string para cadenas de texto como nombres o correos.
double o int para valores numéricos.
bool para banderas verdadero/falso.
date para marcas de tiempo.
array y object para estructuras anidadas.
regex para validar formato, por ejemplo longitud mínima y caracteres del password.

Las validaciones más finas, como verificar que un correo tenga formato usuario@dominio.com con caracteres específicos, suelen quedar en la capa de aplicación con JavaScript, Python u otro lenguaje. Mongo se enfoca en el tipo y la presencia del campo; tu API se encarga de las reglas de negocio detalladas.

¿Cómo se ve el flujo completo de validación en VS Code?

El flujo práctico para mantener la integridad sigue una secuencia clara dentro del MongoDB Playground [02:10]:

Conectas a la base con use("platzi_store").
Defines un archivo collection.mongodb con db.createCollection("users", { validator: { $jsonSchema: {...} } }).
Si la colección ya existía, ejecutas db.users.drop() desde un archivo separado.
Insertas documentos de prueba con db.users.insertOne({...}) y observas qué acepta o rechaza el validador.
Consultas con db.users.find() para confirmar que solo entran documentos válidos.

Con este patrón conviertes una colección flexible en una colección confiable. Tus usuarios siempre tendrán email y password, los tipos serán consistentes y tu aplicación podrá confiar en la forma de los datos al leerlos.

¿Has aplicado validaciones con JSON Schema en tus propios proyectos? Cuéntame en los comentarios qué reglas de negocio te ha tocado modelar y cómo resolviste la tensión entre flexibilidad e integridad.

Sebastián Groselj Pausic

Hace 3 años

Validacion de datos

Hay que realizar validacion de datos para la integridad de la informacion.

MongoDB es muy flexible, como tambien otras bases de datos noSQL basadas en documentos.

Pero hay que respetar ciertas reglas de negocio. Y tambien las entidades tienen ciertas reglas de negocio que hay que respetar.

Crear una colleccion

Primero, hay dos formas de crear una coleccion:

Implicitamente: Donde al crear datos, esta es creada. Usando un:

use ("nueva_db")
db.nueva_coleccion.insertOne({...})

Explicitamente: Donde se le dice que cree una nueva coleccion. Que ademas se le pueden dar parametros, como las validaciones. Se hace con:

use ("nueva_db")
db.createCollection(
    'nueva_coleccion', 
    {
        validator: 
        {...}
    }
)

Operadores

$jsonSchema: Es el operador que hace coincidir los documentos con el cumplimiento del esquema JSON especificado. https://www.mongodb.com/docs/manual/reference/operator/query/jsonSchema/

Validacion

validator: {
    $jsonSchema: {
        bsonType: 'object', // Los documentos que se inserten seran objetos
        required: ['email', 'password'], // requeridos / obligatorios
        properties: { // Como seran las propiedades de esos objetos
            name: {
                bsonType: 'string'
            },
            email: { // propiedad
                bsonType: 'string', // tipo
                pattern: "^[A-Za-z\d.-]{1,}@[A-Za-z\d.-]{1,}[.]{1}[A-Za-z\d.-]{1,}$" // patron
            },
            password: {
                bsonType: 'string',
                pattern: "^.{16,40}$"
            }
        }
    }
}

Tipos de datos

BSON es un formato de serialización binaria que se utiliza para almacenar documentos y realizar llamadas a procedimientos remotos en MongoDB. La especificación BSON se encuentra en bsonspec.org/.

Y la referencia de mongoDB con los tipos Bson son: https://www.mongodb.com/docs/manual/reference/bson-types/

Drop

Para eliminar documentos y esquemas

use("platzi_store")
db.users.drop() // Elimina documentos y esquemas

Validando Strings

Para validar un string se requiere usar el bsontype de tipo string. Pero solo con eso tambien acepta que no exista, por ello hay que agregarlo al required.

use("platzi_store");

db.createCollection('users', {
    validator: {
        $jsonSchema: {
            bsonType: 'object',
            required: ['name'], // obligatorio
            properties: { 
                name: { 
                    bsonType: 'string' // tipo de objeto string
                }
            }
        }
    }
})

Comentarios (15)15 comentarios

Àlex Grau Roca

Hace 4 años

Les dejo mi definición con validaciones regex del email, para asegurar que es un email, y password, para asegurar que tiene un tamaño de 16 a 40 caracteres.

db.createCollection('users', {
    validator: {
        $jsonSchema: {
            bsonType: 'object',
            required: ['email', 'password'],
            properties: {
                name: {
                    bsonType: 'string'
                },
                last_name: {
                    bsonType: 'string'
                },
                email: {
                    bsonType: 'string',
                    pattern: "^[A-Za-z\d.-]{1,}@[A-Za-z\d.-]{1,}[.]{1}[A-Za-z\d.-]{1,}$"
                },
                password: {
                    bsonType: 'string',
                    pattern: "^.{16,40}$"
                }
            }
        }
    }
})

Santiago Marino Naranjo Villanueva

collecion.mongodb

use("platzi_store")

db.createCollection('users',{
  validator: {
    $jsonSchema:{
      bsonType: 'object',
      required: ['email','password'],
      properties:{
        name:{
          bsonType:'string'
        },
        last_name:{
          bsonType:'string'
        },
        email:{
          bsonType:'string'
        },
        password:{
          bsonType:'string'
        }
      }
    }
  }
})

Lissett Paez

excelente aporte !!

Marcelo Leonel Barba Carvajal

Usualmente los frameworks para backend permiten hacer validaciones a nivel de aplicación. FastAPI (Framework Python), por ejemplo, realiza la validación de esquemas con Pydantic.

Junto a la validación de MongoDB tendríamos 2 formas de validar los campos, una a nivel de aplicación y otra a nivel de base de datos.

Sergio Brandon De Lucio Chavero

Hace 2 años

Si, de hecho podria haber validacion a 3 diferentes capas de la aplicacion, en los datos de entrada a la API, en las validaciones correspondientes al ORM y a los datos que valida correspondientemente la base de datos, y si nos ponemos estrictos y estas usando typescript, validacion estatica :v

Fernando José Aguilar Rivas

collection.mongodb

use("platzi_store")

db.createCollection("users", {
    validator: {
        $jsonSchema: {
            bsonType: 'object',
            required: ['name', 'lastname', 'email', 'password'],
            properties: {
                name: {
                    bsonType: 'string',
                    description: "'name' must be a string and is required"
                },
                lastname: {
                    bsonType: 'string',
                    description: "'lastname' must be a string and is required"
                },
                email: {
                    bsonType: 'string',
                    description: "'email' must be a string and is required"
                },
                password: {
                    bsonType: 'string',
                    description: "'password' must be a string and is required"
                }
            }
        }
    }
})```

Bryan Castano

Hola Chicos \nComo todos han subido su aporte, \nLuego Yo tambien subo el mio para futuros Mongoers en este curso .

use("CustomersDataStorage")

db.createCollection('Users', {
    validator: {
        $jsonSchema: {
            bsonType: 'object',
            required: ['firstName', 'lastName', 'email', 'password', 'gender'], // Corrección aquí
            properties: {
                firstName: {
                    bsonType: 'string'
                },
                lastName: {
                    bsonType: 'string'
                },
                email: {
                    bsonType: 'string',
                    pattern: "^[A-Za-z\\d._%+-]+@[A-Za-z\\d.-]+\\.[A-Za-z]{2,}$" // Ajuste menor al patrón
                },
                password: {
                    bsonType: 'string',
                    pattern: "^.{16,40}$" // Ya está correcto
                },
                Age: {
                    bsonType: 'int'
                },
                Nation: {
                    bsonType: 'string'
                },
                Gender: {
                    bsonType: 'bool',
                    description : " Please Provide 1 if it is Male\n and 0 is Female"
                }
            }
        }
    }
})

db.Users.insertOne( { 

    firstName : "Carlos",
    lastName :  "DuBois",
    email     :  "carlos_127@gmail.com",
    password  : "Mcarlosgarcia13579",
    Age       : 24,
    Nation    : "Colombia",
    Gender    :  true 

})


```use("CustomersDataStorage")
db.createCollection('Users', {    validator: {        $jsonSchema: {            bsonType: 'object',            required: \['firstName', 'lastName', 'email', 'password', 'gender'], // Corrección aquí            properties: {                firstName: {                    bsonType: 'string'                },                lastName: {                    bsonType: 'string'                },                email: {                    bsonType: 'string',                    pattern: "^\[A-Za-z\\\d.\_%+-]+@\[A-Za-z\\\d.-]+\\\\.\[A-Za-z]{2,}$" // Ajuste menor al patrón                },                password: {                    bsonType: 'string',                    pattern: "^.{16,40}$" // Ya está correcto                },                Age: {                    bsonType: 'int'                },                Nation: {                    bsonType: 'string'                },                Gender: {                    bsonType: 'bool',                    description : " Please Provide 1 if it is Male\n and 0 is Female"                }            }        }    }})
db.Users.insertOne( {&#x20;
&#x20;   firstName : "Carlos",    lastName :  "DuBois",    email     :  "carlos\_127@gmail.com",    password  : "Mcarlosgarcia13579",    Age       : 24,    Nation    : "Colombia",    Gender    :  true&#x20;
})

Juan Pablo Meza Gazabón

El schema validation de mongo es bastante poderso y útil para ciertas situaciones. Aquí les dejo el link a la documentación si quieren profundizar mucho más en el tema https://www.mongodb.com/docs/manual/core/schema-validation/

Joan paredes yupanqui

Consulta: En un proyecto profesional para backend cuando armo mi API, es necesario que dentro del proyecto este creado cada archivo de collection.mongodb que haga referencia a cada coleccion (user, products, etc ), o solo se arma la estructura, se ejecuta para crear la colleccion en MongoDB y ya no seria necesario tener esos archivos??

Platzi

En un proyecto profesional para backend, es recomendable tener una estructura de archivos que representen cada colección en MongoDB. Sin embargo, una vez que se ejecuta el código para crear las colecciones en MongoDB, los archivos específicos ya no son necesarios.

José Alexis Rivera Díaz

me surgio una duda, si en mi colección users tuviera un permiso_id de manera referencial hacia la colección permisos ¿Como puedo validar que el permiso_id que se va a guardar exista en la colección permisos?

Mario Garcia

En que tipos de proyectos se usa mongo db? yo en todos los que he visto en node js se usa mongoose pero nunca he trabajado con otro tipo de backend

Emanuel Salazar

Para modificar la estructura de un esquema en MongoDB sin borrarlo, puedes usar el método collMod. Este comando permite cambiar el validador de una colección, ajustar índices y más sin necesidad de eliminar la colección. Por ejemplo:

db.runCommand({
   collMod: "users",
   validator: {
      $jsonSchema: {
         bsonType: "object",
         required: ["email", "password"],
         properties: {
            email: { bsonType: "string" },
            password: { bsonType: "string" },
            lastName: { bsonType: "string", description: "optional" }
         }
      }
   }
});

Esto ajusta el esquema existente sin perder datos.

Vidale C.

Por si tenía la duda de: “¿Y que pasa si ya cree mi jsonSchema y después añado más campos y/o quiero editar mis validaciones?”

Pues si es posible hacerlo haciendo uso de collMod

andres fierro

NO existe alguna forma por medio de código de actualizar el esquema sin necesidad de borrarlo

Santiago Ruberto

Esto es algo parecido a lo que nos aporta Mongoose?

Cesar Augusto Guzman Garrido

La validación de los datos nos va a permitir garantizar la integridad de la información. Dicha validación se lleva a cabo a través del uso de esquemas (Schemas) de MongoDB que nos permiten definir las propiedades que tendrá nuestra colección así como el tipo de datos de cada una de ellas.

Además de especificar el tipo de cada propiedad, también podemos indicar si un atributo es obligatorio con el fin de garantizar que en la estructura de los datos siempre esté presente

Validando strings

La validación de textos lo haremos definiendo la propiedad tipo string el cual nos dirá que ese campo solo admitirá valores de tipo texto

db.createCollection("users", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["email", "password"],
      properties: {
        name: {
          bsonType: "string",
        },
        last_name: {
          bsonType: "string",
        },
        email: {
          bsonType: "string",
        },
        password: {
          bsonType: "string",
        },
      },
    },
  },
});

Introducción

Modelado de datos en MongoDB desde cero

Modelado de Datos en MongoDB: Uso de JSON y Diagrama Entidad-Relación

Metodología de modelado de datos en MongoDB

Proyecto

Creación de Clúster y Bases de Datos en Mongo Atlas

Modelado de Workloads en Bases de Datos con MongoDB

Configuración de Entorno y Conexión a MongoDB con VSCode

Validación de datos

Validación de strings con JSON Schema en MongoDB

Validación de números, booleanos y enums en MongoDB

Validar arrays y subdocumentos en MongoDB

Validar contraseñas en MongoDB con regex

Validación de Datos en MongoDB: JSON Schema y Actualizaciones

Relaciones

Relaciones en Bases de Datos NoSQL: Embebidas y Referenciales

Relaciones uno a uno embebidas en MongoDB

Relaciones uno a uno con $lookup en MongoDB

Relaciones Uno a Muchos: Embebidas y Referenciadas en Bases de Datos

Relaciones Uno a Muchos con Referencias en Bases de Datos

Relaciones Muchos a Muchos en Bases de Datos: Tiendas y Productos

Relaciones Muchos a Muchos en Bases de Datos Documentales

Bonus: patrones

Desnormalización en Bases de Datos Documentales: Optimización Avanzada

Computed pattern en MongoDB para totales

Balance entre Simplicidad y Rendimiento en MongoDB

Próximos pasos

Modelado de Datos con MongoDB: Relaciones y Consultas Avanzadas

Validación de strings con JSON Schema en MongoDB

Progreso del curso

Introducción

Proyecto

Validación de datos

Relaciones

Bonus: patrones

Próximos pasos

Recursos

Recursos