Bypass Schema Validation in MongoDB

MongoDB was released in February 2009. It is an open-source document-oriented database and is classified as a NoSQL database. It follows the CAP theorem (Consistency Availability and Partition tolerance). MongoDB stores the records in a document in BSON format. It is an unstructured language and provides horizontal scalability and high-performance, data persistence. It follows the BASE ( Basically Available, Soft State, and Eventual Consistency )properties.

Schema Validation in MongoDB

MongoDB documents are in BSON format and can be in any form. There are instances where a document should be in a specific structure. Schema Validation in MongoDB enables to set the structure for the data in the document. Validation rules are defined for the schema when a collection is created. This validation rule ensures that the data to be inserted follows the specified criteria. If a document is updated with the new values, updated values must also follow the validation rule. The validation rule can contain required fields, BSON type, and descriptions for fields in the collection. The documents that satisfy Validation rules are called valid documents and those that don’t satisfy are invalid documents.

Bypass Schema Validation in MongoDB

Documents in the collection follow the validation rule if they are mentioned during the creation of the collection. There are instances when a collection’s schema validation rules are bypassed. Validation rules are bypassed when restoring invalid data from the backup to a collection. Old documents may not follow the new validation rules. Documents that bypass the validation rule during restoration or in another scenario must also bypass schema validation or become valid during future updates.

These are the below list of Operations That Support Bypassing Validation Rules

• Insert Command: Insert Commands are insertMany() and insertOne() which are used to insert data into the documents of collections of MongoDB.

• Update Command: Update Commands are updateOne() and updateMany() which are used to alter or update the data of documents of collections of MongoDB.

• findAndModify command and db.collection.findAndModify() method.
• mapReduce command and db.collection.mapReduce() method
• $out and $merge stages for the Aggregate command and db.collection.aggregate() method.
• applyOps Command

Steps to Bypass Schema Validation in MongoDB

• Step 1. Create a Collection with Validation Rules
• Step 2. Bypass the Validation to Insert an Invalid Document
• Step 3. Check Invalid Document Bypass Validation rule

Step 1. Create a Collection with Validation Rules

Let’s create an collection which is used in this article to perform operations and queries.

Query:

use database_name;
db.createCollection(  ' Collection_name',
{  validator: {  $jsonSchema : { details_about_collection} } });

We define with a particular name and create a Collection with validation rules using JSON schema.Through JSON schema we define the structure for the documents in the collection.

• The createCollection() method is used to create a collection with a particular name.
• validator is used to specify the validation rule which contains bsonType, required field, enum, minimum or maximum field.
• $jsonSchema Used to define the JSON Schema, to specify validation rule and structure for a document in a collection.

Example: Create a Employee Collection with Validation Rules.

Query:

Let’s Create an collection called Employee in GeeksforGeeks database and applying structure and data integrity rules for employee documents

use GeeksforGeeks
db.createCollection("Employee", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["Name", "joining_year", "Address"],
      properties: {
        Name: {
          bsonType: "string",
          description: "Employee's name must be a string",
        },
        joining_year: {
          bsonType: "int",
          minimum: 2010,
          maximum: 2024,
          description:
            "Employee's joining year must be an integer between 2010 and 2024",
        },
        Address: {
          bsonType: "string",
          description: "Employee's Address must be a string",
        },
      },
    },
  },
});

Output:

Create collection with validation rule

Explanation: Employee collection is created in GeeksforGeeks database. Collection is created using validation rule using JSON schema for the three fields. Fields in the document are [Name, joining_year,Address] .For each field bsontype and description is provided.

Step 2: Bypass the Validation to Insert an Invalid Document

In this step, as per requirements invalid document bypass the validation rule. insert command is used to bypass the validation rules of the collection. bypassDocumentValidation is set to true.

Example:

Following Document is invalid as it don’t satisfy the validation rule for the joining_year field.

Query:

{
  Name:"Anil",
joining_year:2005,
Address:"Delhi"
}

Shema validation is bypassed using insert command ,bypassDocumentValidation option is set to true.

Query:

Let’s insert into the Employee Collection which violates the validation rules and requires a bypass to ensure successful insertion.

db.runCommand({
  insert: "Employee",
  documents: [
    {
      name: "Anil",
      joining_year: 2005,
      Address: "Delhi"
    }
  ],
  bypassDocumentValidation: true
})

Output:

Bypass the validation to insert an invalid Document

Explanation: In the above example, document don’t satisfy the validation rule of the collection. It don’t satisfy the condition of the joining_year field. Minimum of the field is set to 2010 but 2005 is used. Hence to bypass the schema validation insert command and bypassDocumentValidation are used.

Step 3: Check Invalid Document Bypass Validation Rule

In this step, check whether invalid document successfully bypass the validation rule. Run the find() method to check the document has been inserted into the collection or not.

Query:

db.Employee.find()

Output:

Check invalid document bypass validation rule.

Explanation: In the above example, Invalid document successfully bypass the schema validation and the find() method is used to check the document which are present in the collection.

Conclusion

Collection may be associated with a validation rule.There are some scenario where bypassing validation rule is required. Bypassing validation rule can be risky as it may lead to invalid document in the collection. But it is useful in certain scenario like restoration of database and data handling. There are many command to bypass the validation like insert, update etc. Here we have successfully bypassed the schema validation using the insert command.