No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Validando strings

7/22
Recursos

Aportes 10

Preguntas 3

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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

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: 鈥溌縔 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",
        },
      },
    },
  },
});