MongoDB with Node.js — Complete Guide

npm install mongodb
npm install --save-dev @types/mongodb

# Or use Mongoose (higher-level)
npm install mongoose

import { MongoClient } from "mongodb";

const client = new MongoClient("mongodb://localhost:27017");
await client.connect();

const db = client.db("myapp");
const users = db.collection("users");

// Insert
const result = await users.insertOne({
  name: "Alice",
  email: "alice@example.com",
});

// Find
const user = await users.findOne({ _id: result.insertedId });

// Update
await users.updateOne(
  { _id: result.insertedId },
  { $set: { name: "Alice Updated" } }
);

// Delete
await users.deleteOne({ _id: result.insertedId });

// Find many
const allUsers = await users.find({}).toArray();

import mongoose from "mongoose";

await mongoose.connect("mongodb://localhost:27017/myapp");

// Define schema
const userSchema = new mongoose.Schema({
  name: String,
  email: { type: String, unique: true },
  age: Number,
  createdAt: { type: Date, default: Date.now },
});

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

// Create
const user = await User.create({
  name: "Alice",
  email: "alice@example.com",
});

// Find
const found = await User.findById(user._id);

// Update
await User.updateOne({ _id: user._id }, { name: "Alice Updated" });

// Delete
await User.deleteOne({ _id: user._id });

// Filter
const adults = await User.find({ age: { $gte: 18 } });

// Regular expression
const names = await User.find({ name: /^A/ });

// Multiple conditions
const result = await User.find({
  $or: [
    { age: { $lt: 18 } },
    { email: { $regex: "@example.com" } },
  ],
});

// Projection
const emails = await User.find({}, { email: 1, _id: 0 });

// Sorting and pagination
const page = await User.find()
  .sort({ createdAt: -1 })
  .skip(10)
  .limit(10);

// Aggregation
const stats = await User.aggregate([
  { $group: { _id: "$email", count: { $sum: 1 } } },
  { $sort: { count: -1 } },
]);

// Schema with references
const postSchema = new mongoose.Schema({
  title: String,
  content: String,
  author: {
    type: mongoose.Schema.Types.ObjectId,
    ref: "User",
  },
});

const Post = mongoose.model("Post", postSchema);

// Populate relationships
const postsWithAuthors = await Post.find().populate("author");

// Nested populate
const detailed = await Post.findById(postId).populate({
  path: "author",
  populate: { path: "profile" },
});

userSchema.index({ email: 1 }); // Ascending
userSchema.index({ name: "text" }); // Text search
userSchema.index({ location: "2dsphere" }); // Geospatial

// Compound index
userSchema.index({ email: 1, createdAt: -1 });

const userSchema = new mongoose.Schema({
  name: { type: String, required: true, minlength: 3 },
  email: {
    type: String,
    required: true,
    match: /.+@.+\..+/,
  },
  age: { type: Number, min: 0, max: 150 },
  role: {
    type: String,
    enum: ["user", "admin"],
    default: "user",
  },
});

userSchema.pre("save", async function () {
  if (!this.isModified("password")) return;
  this.password = await bcrypt.hash(this.password, 10);
});

userSchema.post("save", function (doc) {
  console.log("User saved:", doc._id);
});

const session = await mongoose.startSession();
session.startTransaction();

try {
  const user = await User.create({ name: "Alice" }, { session });
  const post = await Post.create(
    { title: "First Post", authorId: user._id },
    { session }
  );
  await session.commitTransaction();
} catch (error) {
  await session.abortTransaction();
  throw error;
} finally {
  await session.endSession();
}