MongoDB Basics Explained — Documents, Collections and Queries That Actually Make Sense

// Connect to MongoDB using the Node.js driver (mongosh syntax works identically)
// Run this in mongosh or as a Node.js script with the mongodb package

// --- Step 1: Switch to (or create) our working database ---
use('ecommerce_store');

// --- Step 2: Insert two product documents with intentionally DIFFERENT shapes ---
// Notice: 'simple_mug' has no variants, but 'custom_tshirt' does.
// In SQL you'd need a separate 'variants' table. Here it's just an array inside the doc.

db.products.insertMany([
  {
    // A simple product — flat structure, no variants needed
    name: 'Ceramic Coffee Mug',
    sku: 'MUG-001',
    price_usd: 12.99,
    stock_count: 150,
    category: 'kitchenware',
    tags: ['ceramic', 'handmade', 'dishwasher-safe'],
    created_at: new Date('2024-01-15')
  },
  {
    // A complex product — has nested variants (size + colour combos)
    // This would require 3 tables in SQL. Here it's one document.
    name: 'Custom Logo T-Shirt',
    sku: 'TSH-042',
    base_price_usd: 24.99,
    category: 'apparel',
    tags: ['cotton', 'customizable', 'unisex'],
    variants: [
      { size: 'S',  color: 'black', additional_stock: 80 },
      { size: 'M',  color: 'black', additional_stock: 120 },
      { size: 'L',  color: 'white', additional_stock: 60 }
    ],
    customization_options: {
      max_logo_size_cm: 10,
      allowed_positions: ['chest', 'back', 'sleeve']
    },
    created_at: new Date('2024-03-22')
  }
]);

// --- Step 3: Query all products in the 'apparel' category ---
const apparelProducts = db.products.find(
  { category: 'apparel' },   // filter: only apparel
  { name: 1, base_price_usd: 1, _id: 0 }  // projection: only return name and price
).toArray();

console.log('Apparel products found:', JSON.stringify(apparelProducts, null, 2));

use('saas_platform');

// ─────────────────────────────────────────
// CREATE — Register a new user
// ─────────────────────────────────────────
const insertResult = db.users.insertOne({
  email: 'priya.sharma@example.com',
  display_name: 'Priya Sharma',
  hashed_password: '$2b$12$exampleHashedPasswordHere',
  plan: 'free',
  address: {
    city: 'Mumbai',
    country: 'IN'
  },
  permissions: ['read', 'comment'],
  joined_at: new Date(),
  last_login: null   // null is valid — she hasn't logged in yet
});

console.log('Inserted ID:', insertResult.insertedId);
// Inserted ID: ObjectId('664a1f...')

// ─────────────────────────────────────────
// READ — Find users in Mumbai on the free plan
// Dot-notation queries nested fields cleanly
// ─────────────────────────────────────────
const mumbaiFreeUsers = db.users.find(
  {
    'address.city': 'Mumbai',  // dot-notation for nested field
    plan: 'free'
  },
  { email: 1, display_name: 1, _id: 0 }  // only return these fields
).toArray();

console.log('Mumbai free-plan users:', mumbaiFreeUsers);
// Mumbai free-plan users: [ { email: 'priya.sharma@example.com', display_name: 'Priya Sharma' } ]

// ─────────────────────────────────────────
// UPDATE — Priya upgrades to 'pro' and gets new permissions
// $set only touches the named fields — everything else is UNTOUCHED
// $push appends to the permissions array without overwriting it
// ─────────────────────────────────────────
const updateResult = db.users.updateOne(
  { email: 'priya.sharma@example.com' },  // filter
  {
    $set:  { plan: 'pro', last_login: new Date() },
    $push: { permissions: 'write' }  // appends 'write' to her permissions array
  }
);

console.log('Documents modified:', updateResult.modifiedCount);
// Documents modified: 1

// ─────────────────────────────────────────
// VERIFY — Confirm her updated document
// ─────────────────────────────────────────
const updatedUser = db.users.findOne(
  { email: 'priya.sharma@example.com' },
  { email: 1, plan: 1, permissions: 1, _id: 0 }
);

console.log('Updated user:', JSON.stringify(updatedUser, null, 2));
/*
Updated user: {
  "email": "priya.sharma@example.com",
  "plan": "pro",
  "permissions": ["read", "comment", "write"]
}
*/

// ─────────────────────────────────────────
// DELETE — Remove a test/spam account
// deleteOne removes the FIRST match only
// ─────────────────────────────────────────
const deleteResult = db.users.deleteOne({ email: 'spam-bot@junk.io' });
console.log('Deleted count:', deleteResult.deletedCount);
// Deleted count: 1 (or 0 if the email didn't exist — it won't throw an error)

use('saas_platform');

// ─────────────────────────────────────────
// INDEXES — Create targeted indexes for known query patterns
// ─────────────────────────────────────────

// Single-field index: we frequently filter users by email (login lookups)
db.users.createIndex(
  { email: 1 },         // 1 = ascending sort order
  { unique: true }      // enforces no two users share an email at DB level
);

// Compound index: we filter by plan AND sort by joined_at on the admin dashboard
// The ORDER of fields in a compound index matters — put the equality filter first
db.users.createIndex({ plan: 1, joined_at: -1 });  // -1 = descending (newest first)

// Text index: enables full-text search on product names and descriptions
db.products.createIndex({ name: 'text', description: 'text' });

// ─────────────────────────────────────────
// EXPLAIN — Verify a query USES an index, not a COLLSCAN
// Run this BEFORE shipping a new query to production
// ─────────────────────────────────────────
const queryPlan = db.users.find({ plan: 'pro' }).sort({ joined_at: -1 }).explain('executionStats');

// What to look for in the output:
console.log('Stage used:', queryPlan.queryPlanner.winningPlan.inputStage.stage);
// Good output: 'IXSCAN'  (index scan — fast)
// Bad output:  'COLLSCAN' (collection scan — reads every document)

console.log('Docs examined:', queryPlan.executionStats.totalDocsExamined);
console.log('Docs returned:', queryPlan.executionStats.nReturned);
// If totalDocsExamined >> nReturned, your index is wrong or missing

// ─────────────────────────────────────────
// SCHEMA DESIGN: Embed vs Reference example
// ─────────────────────────────────────────

// EMBED approach — Order stores its own line items
// Use when: you always load the order WITH its items, items belong to one order only
db.orders.insertOne({
  order_number: 'ORD-20240312-001',
  customer_id: ObjectId('664a1f3b2c1d4e5f6a7b8c9d'),  // reference to users collection
  status: 'shipped',
  placed_at: new Date('2024-03-12'),
  line_items: [
    // Embedded — no separate 'order_items' collection needed
    { sku: 'MUG-001', product_name: 'Ceramic Coffee Mug', qty: 2, unit_price_usd: 12.99 },
    { sku: 'TSH-042', product_name: 'Custom Logo T-Shirt', qty: 1, unit_price_usd: 24.99 }
  ],
  total_usd: 50.97
});

// REFERENCE approach — Blog post stores author as an ObjectId, not embedded name
// Use when: the author exists independently and may write many posts
db.blog_posts.insertOne({
  title: 'Getting Started with MongoDB Indexes',
  slug: 'mongodb-indexes-guide',
  author_id: ObjectId('664a1f3b2c1d4e5f6a7b8c9d'),  // reference — not embedded
  // If we embedded author details, updating the author name would require
  // updating EVERY post they wrote. With a reference, update once in 'users'.
  body: 'Indexes are the single biggest performance lever in MongoDB...',
  published_at: new Date('2024-04-01'),
  tags: ['mongodb', 'performance', 'indexing']
});

console.log('Schema examples inserted successfully.');

use('ecommerce_store');

// ─────────────────────────────────────────
// EXAMPLE 1: Revenue by category for March 2024
// This replaces what would be a multi-JOIN GROUP BY query in SQL
// ─────────────────────────────────────────
const revenueByCategory = db.orders.aggregate([

  // Stage 1 — $match: only look at March 2024 orders (filters EARLY for performance)
  {
    $match: {
      placed_at: {
        $gte: new Date('2024-03-01'),
        $lt:  new Date('2024-04-01')
      },
      status: { $in: ['shipped', 'delivered'] }  // exclude cancelled orders
    }
  },

  // Stage 2 — $unwind: flatten the line_items array so each item becomes its own doc
  // Before unwind: 1 order doc with 3 line items
  // After unwind:  3 docs, one per line item, each carrying the parent order fields
  { $unwind: '$line_items' },

  // Stage 3 — $group: sum revenue per SKU prefix (our crude category proxy)
  {
    $group: {
      _id: '$line_items.sku',   // group by SKU
      total_revenue: {
        $sum: {
          $multiply: ['$line_items.qty', '$line_items.unit_price_usd']  // qty × price
        }
      },
      total_units_sold: { $sum: '$line_items.qty' }
    }
  },

  // Stage 4 — $sort: highest revenue first
  { $sort: { total_revenue: -1 } },

  // Stage 5 — $limit: only show top 5 products
  { $limit: 5 },

  // Stage 6 — $project: rename _id to sku, round revenue to 2 decimal places
  {
    $project: {
      _id: 0,
      sku: '$_id',
      total_revenue: { $round: ['$total_revenue', 2] },
      total_units_sold: 1
    }
  }

]).toArray();

console.log('Top 5 products by March revenue:');
console.log(JSON.stringify(revenueByCategory, null, 2));

// ─────────────────────────────────────────
// EXAMPLE 2: $lookup — Join blog posts with their author's display name
// This is MongoDB's equivalent of a LEFT JOIN
// ─────────────────────────────────────────
const postsWithAuthors = db.blog_posts.aggregate([
  { $match: { published_at: { $gte: new Date('2024-01-01') } } },
  {
    $lookup: {
      from: 'users',                  // the collection to join
      localField: 'author_id',        // field in blog_posts
      foreignField: '_id',            // field in users
      as: 'author_details'            // result goes into this new array field
    }
  },
  // $lookup always returns an array — unwrap it since each post has one author
  { $unwind: '$author_details' },
  {
    $project: {
      _id: 0,
      title: 1,
      author_name: '$author_details.display_name',  // pull up the nested name
      published_at: 1
    }
  }
]).toArray();

console.log('Posts with authors:', JSON.stringify(postsWithAuthors, null, 2));