Restricciones de tipo, obligatoriedad y enumeración
Definirá restricciones de tipo, campos obligatorios y valores permitidos enumerados dentro de un validador de JSON Schema.
Restricciones de tipo, obligatoriedad y enumeración es una lección gratuita de MongoDB Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de MongoDB Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de MongoDB Academy incluye 4 lecciones en total.
Partes de esta lección aún no han sido traducidas y se muestran en inglés.
The Three Core Constraint Types
MongoDB JSON Schema validators support three fundamental constraint categories that cover the majority of real-world validation needs: type constraints that enforce the BSON data type of a field, required constraints that mandate the presence of certain fields, and enum constraints that restrict a field's value to a predefined whitelist. Together they form the backbone of any production schema validator.
BSON Types vs JSON Schema Types
JSON Schema uses standard JSON types like string, number, and object. MongoDB extends this with BSON types declared via the bsonType keyword—values like objectId, date, int, long, double, and decimal. Always use bsonType in MongoDB validators (not type) when you need precision about numeric subtypes or MongoDB-specific types like objectId and date.
// BSON type names to use in validators
// 'string', 'bool', 'int', 'long', 'double', 'decimal',
// 'objectId', 'date', 'array', 'object', 'null', 'binData'
db.createCollection('products', {
validator: {
$jsonSchema: {
bsonType: 'object',
properties: {
_id: { bsonType: 'objectId' },
price: { bsonType: 'decimal' },
stock: { bsonType: 'int' },
isActive: { bsonType: 'bool' },
createdAt: { bsonType: 'date' }
}
}
}
});Declaring Required Fields
The required keyword takes an array of field names that must be present in every document inserted or updated in the collection. If any required field is missing, the write is rejected. Required fields are declared at the schema level, not inside individual property definitions.
db.createCollection('employees', {
validator: {
$jsonSchema: {
bsonType: 'object',
required: ['firstName', 'lastName', 'email', 'hiredAt'],
properties: {
firstName: { bsonType: 'string' },
lastName: { bsonType: 'string' },
email: { bsonType: 'string' },
hiredAt: { bsonType: 'date' },
salary: { bsonType: 'decimal' } // optional
}
}
}
});Enum Constraints: Restricting Allowed Values
The enum keyword restricts a field to a fixed list of permitted values. This is ideal for status fields, category codes, or any field that must come from a controlled vocabulary. Attempting to insert a value outside the enum list causes the write to fail with a validation error.
db.createCollection('tickets', {
validator: {
$jsonSchema: {
bsonType: 'object',
required: ['title', 'status', 'priority'],
properties: {
title: { bsonType: 'string' },
status: { enum: ['open', 'in_progress', 'resolved', 'closed'] },
priority: { enum: ['low', 'medium', 'high', 'critical'] }
}
}
}
});Numeric Range Constraints
For numeric fields, JSON Schema provides minimum, maximum, exclusiveMinimum, and exclusiveMaximum keywords. These work alongside bsonType to enforce valid ranges—for example, ensuring a product price is positive and a rating falls between 1 and 5.
db.createCollection('reviews', {
validator: {
$jsonSchema: {
bsonType: 'object',
required: ['productId', 'rating'],
properties: {
productId: { bsonType: 'objectId' },
rating: {
bsonType: 'int',
minimum: 1,
maximum: 5,
description: 'Rating must be between 1 and 5'
},
price: {
bsonType: 'decimal',
minimum: 0,
exclusiveMinimum: true
}
}
}
}
});String Length Constraints
String fields support minLength and maxLength to enforce character count limits. A username might need to be at least 3 characters and at most 30. A description field might have a 2000-character cap. These constraints prevent accidentally storing empty strings or truncated text that exceeds UI display limits.
db.createCollection('profiles', {
validator: {
$jsonSchema: {
bsonType: 'object',
required: ['username'],
properties: {
username: {
bsonType: 'string',
minLength: 3,
maxLength: 30,
description: 'Username must be 3-30 characters'
},
bio: {
bsonType: 'string',
maxLength: 500
}
}
}
}
});Pattern Constraints for Strings
The pattern keyword accepts a regular expression string and validates that the field value matches it. This is useful for enforcing email format, phone number patterns, UUID format, or slug conventions. Unlike regex queries used for search, pattern constraints run at write time to block non-conforming data from entering the collection.
db.runCommand({
collMod: 'users',
validator: {
$jsonSchema: {
bsonType: 'object',
required: ['email'],
properties: {
email: {
bsonType: 'string',
pattern: '^[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,}$',
description: 'Must be a valid email address'
},
slug: {
bsonType: 'string',
pattern: '^[a-z0-9]+(?:-[a-z0-9]+)*$'
}
}
}
}
});Combining Type and Enum
Type and enum can be combined. Providing both bsonType and enum ensures the value is both of the correct type and within the allowed set. Without bsonType, an enum will accept any type that matches—including a number equal to the string value if JavaScript coercion were involved. Explicit types make validation intent clear.
properties: {
role: {
bsonType: 'string',
enum: ['admin', 'editor', 'viewer'],
description: 'Must be a string and one of the allowed roles'
}
}additionalProperties to Disallow Unknown Fields
By default, MongoDB validators allow any extra fields not mentioned in properties. Setting additionalProperties: false prevents documents from containing fields not declared in the schema. This is a strict mode that can catch typos in field names during development, though it can be too rigid for schemas that evolve frequently.
db.createCollection('strictUsers', {
validator: {
$jsonSchema: {
bsonType: 'object',
required: ['name', 'email'],
additionalProperties: false, // reject any undeclared fields
properties: {
_id: { bsonType: 'objectId' },
name: { bsonType: 'string' },
email: { bsonType: 'string' }
}
}
}
});Providing Helpful Error Descriptions
The description keyword inside each property definition is included in the validation error message returned to the client. Writing clear, human-readable descriptions like 'Email must be a valid address' or 'Rating must be between 1 and 5' makes it much easier for developers and API consumers to understand and fix validation failures without reading the schema.
Testing Your Validator
After adding a validator, always test it with both valid and invalid documents to confirm it behaves as expected. Try inserting a document missing a required field, a field with the wrong type, and a field with a value outside the enum. Also insert a perfectly valid document to confirm it is accepted. This two-sided testing prevents overly strict validators that block legitimate writes.
// Should FAIL — missing required 'email'
try { db.users.insertOne({ name: 'Bob' }); } catch(e) { console.log('Correctly rejected:', e.code); }
// Should FAIL — wrong type for 'age'
try { db.users.insertOne({ name: 'Bob', email: 'b@b.com', age: 'thirty' }); } catch(e) { console.log('Correctly rejected'); }
// Should PASS
db.users.insertOne({ name: 'Bob', email: 'b@b.com', age: 30 });
console.log('Valid document accepted');Quick Check
Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.
Lesson Recap
In this lesson you learned: bsonType enforces BSON-specific data types including objectId and date, required declares mandatory fields at the schema level, and enum restricts a field to a fixed list of allowed values. Next up we explore validation levels and actions to control how strictly MongoDB enforces these rules.
Preguntas frecuentes
¿La lección «Restricciones de tipo, obligatoriedad y enumeración» es gratis?
Sí — el texto completo de «Restricciones de tipo, obligatoriedad y enumeración» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de MongoDB Academy, actualiza a CoddyKit PRO. El curso de MongoDB Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Restricciones de tipo, obligatoriedad y enumeración»?
Definirá restricciones de tipo, campos obligatorios y valores permitidos enumerados dentro de un validador de JSON Schema. Practicas MongoDB Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar MongoDB Academy?
No se requiere experiencia previa. MongoDB Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Restricciones de tipo, obligatoriedad y enumeración»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de MongoDB Academy?
Sí. Cada lección de MongoDB Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Añadir un validador a una colección
- Restricciones de tipo, obligatoriedad y enumeración
- Niveles y acciones de validación
- Evolucionar esquemas sin tiempo de inactividad