0Pricing
MongoDB Academy · Aula

Restrições de tipo, obrigatoriedade e enumeração

Defina restrições de tipo, campos obrigatórios e valores permitidos enumerados dentro de um validador de Esquema JSON.

Restrições de tipo, obrigatoriedade e enumeração é uma aula grátis de MongoDB Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de MongoDB Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de MongoDB Academy inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em 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.

Perguntas Frequentes

A aula “Restrições de tipo, obrigatoriedade e enumeração” é grátis?

Sim — o texto completo de “Restrições de tipo, obrigatoriedade e enumeração” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de MongoDB Academy, atualize para CoddyKit PRO. O curso de MongoDB Academy inclui 4 aulas no total.

O que vou aprender em “Restrições de tipo, obrigatoriedade e enumeração”?

Defina restrições de tipo, campos obrigatórios e valores permitidos enumerados dentro de um validador de Esquema JSON. Você pratica MongoDB Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar MongoDB Academy?

Nenhuma experiência prévia é necessária. MongoDB Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Restrições de tipo, obrigatoriedade e enumeração”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de MongoDB Academy?

Sim. Cada aula de MongoDB Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Adicionando um validador a uma coleção
  2. Restrições de tipo, obrigatoriedade e enumeração
  3. Níveis e ações de validação
  4. Evoluindo esquemas sem indisponibilidade
← Voltar para MongoDB Academy