DEV Community: Ahmed Afzal

MongoDB with Mongoose: Schema Design, CRUD Operations & Validations (Part 2)

Ahmed Afzal — Sun, 20 Jul 2025 15:59:19 +0000

Before diving in, make sure you’ve read Part 1 of this series, where we explore what MongoDB is, its document-based structure, and why it's different from relational databases.

Introduction

In Part 1, we explored the foundations of MongoDB — a NoSQL, document-oriented database. Now in Part 2, we’ll take the next step by learning how to interact with MongoDB using Mongoose, a powerful ODM (Object Data Modeling) library for Node.js. We'll cover:

Schema design in MongoDB
Data types and relationships
Setting up Mongoose
CRUD operations
Validations in Mongoose
Key methods like .save(), .find(), .findById(), etc.

Let’s dive in! 🚀

1. Understanding Schema-less Nature of MongoDB

🔹 What is a Schema?

In relational databases like MySQL or PostgreSQL, a schema defines the structure of tables, columns, and their relationships. For example:

Student
Course
Section

Each has a strict format and is connected through foreign keys. If you want to change the structure (add a new field), you need to alter the schema manually.

📌 This strict structure enforces consistency but reduces flexibility.

🔹 MongoDB is Schema-less

MongoDB doesn’t enforce any schema. Instead, it stores data in JSON-like documents, making it highly flexible and scalable.

For example, this is perfectly valid in MongoDB:

{ "name": "Ahmed Afzal", "age": 25 }

You can add more fields later without modifying the existing schema. However, this doesn't mean we should store data in a disorganized way. Best practice: define a logical document structure for consistency.

2. Data Types in MongoDB

Like all databases, MongoDB supports different data types:

Type	Example
String	`{ "name": "Ahmed" }`
Number	`{ "age": 25 }`, `{ "price": 99.99 }`
Boolean	`{ "isActive": true }`
Date	`{ "createdAt": ISODate("2025-07-07T00:00:00Z") }`
Array	`{ "skills": ["React", "Node.js"] }`
Object	`{ "address": { "city": "Karachi", "country": "Pakistan" } }`
Null	`{ "middleName": null }`

3. Embedded vs Referenced Documents

MongoDB allows you to structure related data in two ways:

✅ Embedded Documents (Denormalized)

Nested documents inside a parent document.

{
  "title": "Intro to MongoDB",
  "comments": [
    { "user": "Ali", "message": "Great post!" },
    { "user": "Sara", "message": "Helpful!" }
  ]
}

Benefits:

Fast reads
Fewer queries

Drawbacks:

Documents can become large (max 16MB)
Harder to update deeply nested data

🔗 Referenced Documents (Normalized)

Separate documents linked by IDs.

// Blog
{ "_id": 1, "title": "Intro to MongoDB", "comments": [101, 102] }

// Comments Collection
{ "_id": 101, "postId": 1, "message": "Nice Article" }
{ "_id": 102, "postId": 1, "message": "Great Concept" }

Benefits:

More scalable
Reusable data

Drawbacks:

Slower reads due to multiple queries

4. Relationships in MongoDB

➤ One-to-One (1:1)

Each document relates to one other.

// User
{ "_id": 101, "name": "Ahmed" }

// Profile
{ "_id": 1, "userId": 101, "bio": "Engineer" }

➤ One-to-Many (1:N)

One document relates to many others.

// Author
{ "_id": 1, "name": "Ahmed" }

// Books
[
  { "_id": 101, "authorId": 1, "title": "Book A" },
  { "_id": 102, "authorId": 1, "title": "Book B" }
]

➤ Many-to-Many (M:N)

Both documents relate to many others.

// Student
{ "_id": 1, "name": "Ahmed", "enrolledCourses": [101, 102] }

// Courses
{ "_id": 101, "title": "React JS", "students": [1, 2] }

5. What is Mongoose and Why Use It?

Mongoose is an ODM library for Node.js that helps:

Enforce structure (via schemas)
Apply validations
Easily perform CRUD operations

Without Mongoose, MongoDB allows unstructured data — e.g., inserting a string into a number field would still work. Mongoose prevents that.

6. Setting Up Mongoose in Node.js

✅ Prerequisites

Install Node.js
Ensure MongoDB is running locally (mongod)
Optionally use MongoDB Compass

📁 Folder Structure

mongoose-app/
├── models/
│   └── User.js
├── app.js

📦 Initialize Project

mkdir mongoose-app
cd mongoose-app
npm init -y
npm install mongoose

🔌 Connect to MongoDB

// app.js
const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/mydb', {
  useNewUrlParser: true,
  useUnifiedTopology: true,
})
.then(() => console.log("Connected to MongoDB"))
.catch((err) => console.error("Connection error:", err));

7. Creating Schemas and Models

// models/User.js
const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  name: String,
  age: Number,
});

const User = mongoose.model('User', userSchema);

module.exports = User;

8. CRUD Operations in Mongoose

📌 Create

const ahmed = new User({ name: "Ahmed", age: 25 });
ahmed.save();

📌 Read

User.find().then(users => console.log(users));

📌 Update

User.updateOne({ name: "Ahmed" }, { age: 30 });

📌 Delete

User.deleteOne({ name: "Ahmed" });

✅ Full Example (`app.js`)

const mongoose = require('mongoose');
const User = require('./models/User');

mongoose.connect('mongodb://localhost:27017/mydb', {
  useNewUrlParser: true,
  useUnifiedTopology: true,
})
.then(async () => {
  console.log("Connected to MongoDB");

  // Create
  const user = new User({ name: "Ahmed", age: 22 });
  await user.save();

  // Read
  const users = await User.find();
  console.log(users);

  // Update
  await User.updateOne({ name: "Ahmed" }, { age: 30 });

  // Delete
  await User.deleteOne({ name: "Ahmed" });

  mongoose.disconnect();
})
.catch(console.error);

9. Mongoose Validations

Without validation:

const user = new User({ name: 123, age: "abc" }); // Allowed!

With validation:

const userSchema = new mongoose.Schema({
  name: { type: String, required: true, minlength: 3 },
  age: { type: Number, required: true, min: 18, max: 60 },
  email: { type: String, required: true, match: /.+\@.+\..+/ }
});

✨ Example:

const user = new User({
  name: "Ah",    // too short
  age: 17,       // too young
  email: "invalidemail"
});

user.save().catch(err => console.log("Validation Error:", err.message));

🔧 Other Validation Options

Validator	Description
`required`	Must be present
`min` / `max`	Numbers only
`minlength` / `maxlength`	String length
`match`	Regex pattern
`enum`	Limited values

status: {
  type: String,
  enum: ['active', 'inactive', 'pending'],
  default: 'pending'
}

10. Mongoose Query Methods Explained

Method	Use
`.save()`	Save new document
`.find()`	Get all or filtered documents
`.findOne()`	Get one document
`.findById()`	Get by ObjectId
`.updateOne()`	Update first match
`.findByIdAndUpdate()`	Update by ID and return updated doc
`.deleteOne()`	Delete first match
`.findByIdAndDelete()`	Delete by ID

Conclusion

In this part, you learned how to:

Understand MongoDB’s flexible data model
Use embedded and referenced documents
Create and validate schemas using Mongoose
Perform full CRUD operations

🔁 If you haven't already, read Part 1 here to better understand MongoDB fundamentals.

👉 Coming Up Next (Part 3 – Final Part):

In the next article, we’ll explore:

Relationships using populate()
Advanced queries and filtering
Indexing for performance
Aggregation framework
Project structure best practices

Stay tuned! 🎯

MongoDB Made Easy: A Beginner’s Practical Guide (Part 1)

Ahmed Afzal — Wed, 09 Jul 2025 13:36:10 +0000

Welcome to your first step into the world of MongoDB! If you’ve ever felt overwhelmed by traditional SQL databases, or you're looking for something more flexible for your next project — you’re in the right place. In this guide, we’ll break down MongoDB in a super simple, practical, and beginner-friendly way. By the end of this article, you'll not only understand MongoDB, but you'll also perform real CRUD operations using both code and visual tools.

🚀 What is MongoDB?

MongoDB is an open-source, document-oriented NoSQL database. Unlike traditional relational databases that store data in tables, rows, and columns, MongoDB stores data in documents and collections, making it more flexible and scalable.

Each document in MongoDB is a JSON-like structure (called BSON internally), which allows you to store structured or unstructured data as key-value pairs. BSON makes it easier for machines to understand and process data quickly.

📄 Understanding MongoDB Structure

🧾 Document:

A document is a single unit of data in MongoDB, similar to a row in SQL but stored in a JSON-like format.

{
  _id: "abc123",
  title: "Post Title 1",
  body: "Body of post.",
  category: "News",
  likes: 1,
  tags: ["news", "events"],
  date: new Date()
}

_id is auto-generated by MongoDB using ObjectId. You can use it to fetch, update, or delete that specific document.

📦 Collection:

A collection is a group of documents, like an array of objects or a table in SQL.

// Collection: articles
[
  { title: "Post 1", author: "Ahmed" },
  { title: "Post 2", author: "Sara" }
]

Each collection can store multiple documents with different structures.

💻 Installing MongoDB Locally

1️⃣ Go to MongoDB Download Page

👉 https://www.mongodb.com/try/download/community

2️⃣ Select Platform

Choose Windows, macOS, or Linux. For Windows:

Version: MongoDB Community Server
OS: Windows
Package: MSI Installer

Click Download.

“Below you can see the MongoDB download page and installer setup selection.”

3️⃣ Install MongoDB

Run the downloaded installer:

Choose Complete
✅ Check “Install MongoDB Compass” (GUI tool)
Finish setup

4️⃣ Verify Installation

Open your terminal or command prompt:

mongosh

“📸 Below is the output you’ll see if MongoDB is installed correctly.”

If it opens the MongoDB shell, you're all set!

5️⃣ Optional: Install MongoDB Compass

Download: https://www.mongodb.com/try/download/compass

Compass provides a graphical interface to view and manipulate your data — like phpMyAdmin for MongoDB.

🧪 Creating a Database and Collection

Launch your terminal and type:

mongosh

You'll be connected to the local MongoDB instance.

test> use blogDB

This switches to blogDB or creates it when you insert data.

➕ Insert One Document

db.articles.insertOne({
  title: "How to Use MongoDB",
  author: "Ahmed Afzal",
  content: "This is my first blog post.",
  category: "Database",
  tags: ["mongodb", "beginner"],
  published: true,
  date: new Date()
})

Breakdown:

db = current database
articles = collection
insertOne = insert 1 document

📸 Below you can see the image showing how MongoDB confirms the inserted document with an ObjectId.

➕ Insert Multiple Documents

db.articles.insertMany([
  { title: "Post 1", author: "Ahmed", tags: ["tech", "mongodb"] },
  { title: "Post 2", author: "Sara", tags: ["javascript", "nodejs"] },
  { title: "Post 3", author: "Ali", tags: ["nosql", "database"] }
])

🔍 Finding & Filtering Data

📄 View All Documents

db.articles.find().pretty()

.find() = get all documents
.pretty() = display in a clean format

“Below you can see all the inserted data displayed in a clean format”

🔎 Filtering

// Find all articles by Ahmed
db.articles.find({ author: "Ahmed" })

// Find all published articles
db.articles.find({ published: true })

“📸 Here’s an example of how filtered data appears using the find command.”

🧠 Projections (Show/Hide Fields)

// Show only title and author
db.articles.find(
  { published: true },
  { title: 1, author: 1, _id: 0 }
)

// Hide 'content' field
db.articles.find({}, { content: 0 })

🔄 Updating Documents

✏️ `updateOne()`

db.articles.updateOne(
  { author: "Ahmed" },
  { $set: { published: false } }
)

Updates the first article by Ahmed.

“📸 Below is the terminal output after running an updateOne operation.”

✏️ `updateMany()`

db.articles.updateMany(
  { published: true },
  { $set: { category: "Tech" } }
)

Updates all published articles.

“📸 Below is the terminal output after running an updateMany operation.”

🔧 Common Update Operators

$set → Set or update a value
$inc → Increment a number
$unset → Remove a field
$push → Add to array
$addToSet → Add if not already present

🗑️ Deleting Documents

❌ `deleteOne()`

db.articles.deleteOne({ author: "Ahmed" })

Deletes the first document where author is Ahmed.

“📸 Below is the terminal output after running an deleteOne operation.”

❌ `deleteMany()`

db.articles.deleteMany({ published: false })

Deletes all documents where published is false.

⚠️ deleteMany({}) will delete everything in the collection — use with care!

🆔 Working with ObjectId

ObjectId("66a3f20c8ae6c5f5f9637a5d")

Used to uniquely identify documents

🧭 Use ObjectId in Queries

// Find by ID
db.articles.find({ _id: ObjectId("66a3f20c8ae6c5f5f9637a5d") })

// Update by ID
db.articles.updateOne(
  { _id: ObjectId("66a3f20c8ae6c5f5f9637a5d") },
  { $set: { title: "Updated Title" } }
)

// Delete by ID
db.articles.deleteOne({ _id: ObjectId("66a3f20c8ae6c5f5f9637a5d") })

🎯 Above you can review how _id helps in exact targeting of operations.

🧭 Using MongoDB Compass (GUI Method)

✅ 1. Open Compass & Connect

Click on Add New Connection

Paste: mongodb://localhost:27017

than click Save & Connect

✅ 2. Create Database & Collection

Click “Create Database”
Name: blogDB, Collection: articles

✅ 3. Insert Document

Click “Insert Document” → Paste your JSON → Click Insert

✅ 4. Read/View Documents

Documents will show in table view. Click {} to view raw JSON.

✅ 5. Update Document

Click ✏️ icon → Edit → REPLACE✅

✅ 6. Delete Document

Click 🗑️ icon → DELETE

📸 Above you can see a visual walk-through of inserting, updating, and deleting using Compass

🎯 Wrapping Up

Well done! You’ve successfully completed your first hands-on experience with MongoDB. From understanding core concepts to performing CRUD operations using both the shell and Compass, you now have a strong foundation to build upon.

In the next part of this series, we’ll explore advanced MongoDB topics including optimized queries, indexing strategies, relationships, and best practices for data modeling.

📌 Stay connected, and consider bookmarking this series to continue your learning journey.

🙏 As a continuous learner, I welcome your suggestions or feedback to improve this guide and support others on the same path.