Validando strings

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}$"
                }
            }
        }
    }
})

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'
        }
      }
    }
  }
})

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:

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

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

2. 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
                }
            }
        }
    }
})

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.

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"
                }
            }
        }
    }
})```

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/

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

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

Esto es algo parecido a lo que nos aporta Mongoose?

Validación de datos

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",
        },
      },
    },
  },
});