Validation Rules and Data Integrity

# CHAPTER 18

Validation Rules and Data Integrity #

1. Introduction #

2. Learning Objectives #

• Understand the purpose of Database-Level Validation.

• Use $jsonSchema to define a collection's rules.

• Enforce required fields.

• Restrict data types (e.g., Age MUST be an integer).

• Apply validation rules to existing collections.

3. The Danger of Application-Level Validation #

4. Creating a Validated Collection #

Let's create a users collection. We will enforce three rules:

1. 1. email is REQUIRED and must be a String.

1. 2. age is OPTIONAL, but if provided, it MUST be an Integer.

1. 3. status MUST be either "Active" or "Suspended".

db.createCollection("users", {
   validator: {
      $jsonSchema: {
         bsonType: "object",
         required: [ "email" ], // email is mandatory!
         properties: {
            email: {
               bsonType: "string",
               description: "must be a string and is required"
            },
            age: {
               bsonType: "int",
               minimum: 18,
               description: "must be an integer greater than or equal to 18"
            },
            status: {
               enum: [ "Active", "Suspended" ],
               description: "can only be one of the enum values"
            }
         }
      }
   }
})

5. Testing the Validation Shield #

// Attempt 1: Fails! (Missing the required 'email' field)
db.users.insertOne({ name: "Alice" })
// Result: Document failed validation!

// Attempt 2: Fails! (Age is a string, not an integer)
db.users.insertOne({ email: "bob@example.com", age: "twenty" })
// Result: Document failed validation!

// Attempt 3: Success! (Meets all rules)
db.users.insertOne({ email: "charlie@example.com", status: "Active" })

6. Adding Validation to an EXISTING Collection #

db.runCommand({
   collMod: "products",
   validator: {
      $jsonSchema: {
         bsonType: "object",
         required: [ "price" ],
         properties: {
            price: { bsonType: "double" }
         }
      }
   },
   validationLevel: "moderate" // CRITICAL! See below.
})

7. Validation Levels (strict vs moderate) #

• strict (Default): Applies rules to ALL inserts and updates. If you try to update an old, legacy document that doesn't meet the new rules, MongoDB will block the update!

• moderate: Applies rules to ALL new inserts, but allows you to update old legacy documents even if they fail the new validation rules. (This is highly recommended for existing production databases).

8. Mini Project: The Bulletproof Employee Collection #

db.createCollection("employees", {
   validator: {
      $jsonSchema: {
         bsonType: "object",
         required: [ "name", "salary" ],
         properties: {
            name: { bsonType: "string" },
            salary: { bsonType: "double", minimum: 30000.00 },
            skills: { 
                bsonType: "array",
                items: { bsonType: "string" } // Every item inside the array MUST be a string!
            }
         }
      }
   }
})

9. Common Mistakes #

• Applying JSON Schema like SQL: If you strictly define every single possible field in $jsonSchema, you have essentially re-invented MySQL, destroying the developmental agility of NoSQL. Best Practice: Only validate the absolute bare minimum fields required for the application to function (like email and password_hash). Leave the rest dynamic!

10. Best Practices #

• Regex Validation: You can use Regular Expressions in your schema. For example, pattern: "^.+@.+$" ensures that the string inserted into the email field actually looks like an email address!

11. Exercises #

1. 1. What MongoDB keyword is used to explicitly define database-level rules for a collection?

1. 2. If you want to restrict a role field to only accept the exact words "Admin" or "User", what keyword do you use inside the $jsonSchema properties?

12. MongoDB Challenges #

{
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["username"],
      properties: {
        username: { bsonType: "string" }
      }
    }
  }
}

13. MCQ Quiz with Answers #

14. Interview Questions #

• Q: Explain the conflict between MongoDB's philosophy of "Dynamic Schemas" and the Enterprise requirement of "JSON Schema Validation". How do you strike an architectural balance between the two?

• Q: Describe how you would enforce a minimum and maximum numerical value on an age field using $jsonSchema.

15. FAQs #

16. Summary #

17. Next Chapter Recommendation #