Database Relationships — ref aur populate()

Now let's see how ref and populate() work together in real API endpoints.

// routes/order.routes.js — Orders with populated relationships
import express from 'express';
import Order from '../models/Order.js';
import User from '../models/User.js';

const router = express.Router();

// POST /api/orders — Place an order (creates references)
router.post('/', async (req, res) => {
  try {
    const { userId, items, deliveryAddress } = req.body;

    // Verify user exists
    const user = await User.findById(userId);
    if (!user) {
      return res.status(404).json({
        success: false,
        message: 'User nahi mila! Pehle account banao.'
      });
    }

    // Calculate total from referenced biryani items
    // In real app, you'd query Biryani prices from DB
    const total = items.reduce((sum, item) => sum + (item.price * item.qty), 0);

    const order = await Order.create({
      user: userId,       // Store ObjectId reference
      items: items.map(i => ({
        biryani: i.biryaniId,  // Store ObjectId reference
        qty: i.qty
      })),
      total,
      deliveryAddress,
      status: 'confirmed'
    });

    // Populate the created order for the response
    const populatedOrder = await Order.findById(order._id)
      .populate('user', 'name phone')
      .populate('items.biryani', 'name price category');

    res.status(201).json({
      success: true,
      message: 'Order placed! 🎉 Delivery in 30-40 minutes.',
      data: populatedOrder
    });
  } catch (error) {
    res.status(500).json({ success: false, message: error.message });
  }
});

// GET /api/orders/:id — Get order with populated data
router.get('/:id', async (req, res) => {
  try {
    const order = await Order.findById(req.params.id)
      .populate({
        path: 'user',
        select: 'name email phone address'
      })
      .populate({
        path: 'items.biryani',
        select: 'name price category spicyLevel',
        match: { isAvailable: true }  // Only populate available items
      });

    if (!order) {
      return res.status(404).json({
        success: false,
        message: 'Order nahi mila! ID check karo.'
      });
    }

    res.json({ success: true, data: order });
  } catch (error) {
    if (error.name === 'CastError') {
      return res.status(400).json({ success: false, message: 'Invalid ID format!' });
    }
    res.status(500).json({ success: false, message: error.message });
  }
});

// GET /api/users/:userId/orders — All orders for a user
router.get('/user/:userId', async (req, res) => {
  try {
    const orders = await Order.find({ user: req.params.userId })
      .populate('items.biryani', 'name price')
      .sort('-createdAt');

    res.json({
      success: true,
      count: orders.length,
      data: orders
    });
  } catch (error) {
    res.status(500).json({ success: false, message: error.message });
  }
});

export default router;

Key patterns to remember:

• Store the ObjectId when creating (just userId, not the whole user doc)
• Populate when reading — replace IDs with actual data for the response
• Always populate after creation — return meaningful data to the client
• Use select to limit fields — don't send the entire user object if you only need name

This pattern gives you the best of both worlds: efficient writes (just store IDs) and rich reads (get full data when you need it).