Mongoose ODM

Advanced Mongoose Techniques

Here are some advanced techniques that can enhance your Mongoose applications:

Plugins

Plugins are reusable packages of schema functionality:

// Define a plugin for adding timestamps
function timestampPlugin(schema, options) {
  // Add createdAt and updatedAt fields
  schema.add({
    createdAt: {
      type: Date,
      default: Date.now,
      immutable: true
    },
    updatedAt: {
      type: Date,
      default: Date.now
    }
  });
  
  // Add pre-save middleware to update the updatedAt field
  schema.pre('save', function(next) {
    if (this.isModified() && !this.isNew) {
      this.updatedAt = new Date();
    }
    next();
  });
  
  // Add pre-update middleware
  schema.pre(['updateOne', 'findOneAndUpdate'], function(next) {
    this.set({ updatedAt: new Date() });
    next();
  });
}

// Use the plugin in multiple schemas
userSchema.plugin(timestampPlugin);
postSchema.plugin(timestampPlugin);
commentSchema.plugin(timestampPlugin);
            

Discriminators (Inheritance)

Discriminators provide a way to implement inheritance-like functionality in Mongoose:

// Base schema for all types of users
const userSchema = new mongoose.Schema({
  email: { type: String, required: true, unique: true },
  password: { type: String, required: true },
  name: { type: String, required: true },
  createdAt: { type: Date, default: Date.now },
  role: { type: String, required: true },
}, { discriminatorKey: 'role' });

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

// Customer model (inherits from User)
const Customer = User.discriminator('customer', new mongoose.Schema({
  shippingAddresses: [{
    street: String,
    city: String,
    state: String,
    zipCode: String,
    isPrimary: Boolean
  }],
  orders: [{
    type: mongoose.Schema.Types.ObjectId,
    ref: 'Order'
  }]
}));

// Admin model (inherits from User)
const Admin = User.discriminator('admin', new mongoose.Schema({
  permissions: [String],
  department: String,
  adminLevel: {
    type: Number,
    min: 1,
    max: 5,
    default: 1
  }
}));

// Usage
async function createUsers() {
  // Create a customer
  const customer = await Customer.create({
    email: 'customer@example.com',
    password: 'hashed_password',
    name: 'John Customer',
    shippingAddresses: [{
      street: '123 Main St',
      city: 'Anytown',
      state: 'CA',
      zipCode: '12345',
      isPrimary: true
    }]
  });
  
  // Create an admin
  const admin = await Admin.create({
    email: 'admin@example.com',
    password: 'hashed_password',
    name: 'Jane Admin',
    permissions: ['users.view', 'users.edit', 'products.manage'],
    department: 'IT',
    adminLevel: 3
  });
  
  // Find all users regardless of role
  const allUsers = await User.find();
  
  // This will include both customers and admins
  console.log(`Total users: ${allUsers.length}`);
}
            

Aggregation Framework

Mongoose provides a wrapper around MongoDB's powerful aggregation framework:

// Get sales statistics by product category
async function getProductCategoryStats() {
  return await Order.aggregate([
    // Unwind the items array to work with individual items
    { $unwind: '$items' },
    
    // Look up the product for each item
    {
      $lookup: {
        from: 'products',
        localField: 'items.product',
        foreignField: '_id',
        as: 'productData'
      }
    },
    
    // Unwind the productData array (which has one element)
    { $unwind: '$productData' },
    
    // Group by category and calculate statistics
    {
      $group: {
        _id: '$productData.category',
        totalSales: { $sum: { $multiply: ['$items.price', '$items.quantity'] } },
        count: { $sum: '$items.quantity' },
        averagePrice: { $avg: '$items.price' }
      }
    },
    
    // Sort by total sales descending
    { $sort: { totalSales: -1 } },
    
    // Add a category name field from the _id
    {
      $project: {
        category: '$_id',
        totalSales: 1,
        count: 1,
        averagePrice: 1,
        _id: 0
      }
    }
  ]);
}

// Get customer purchase statistics
async function getCustomerPurchaseStats() {
  return await Order.aggregate([
    // Match only completed orders
    { $match: { status: 'completed' } },
    
    // Group by customer
    {
      $group: {
        _id: '$user',
        totalSpent: { $sum: '$totalAmount' },
        orderCount: { $sum: 1 },
        averageOrderValue: { $avg: '$totalAmount' },
        firstOrder: { $min: '$createdAt' },
        lastOrder: { $max: '$createdAt' }
      }
    },
    
    // Look up customer details
    {
      $lookup: {
        from: 'users',
        localField: '_id',
        foreignField: '_id',
        as: 'customerData'
      }
    },
    
    // Unwind the customerData array
    { $unwind: '$customerData' },
    
    // Project only the fields we need
    {
      $project: {
        _id: 1,
        customer: {
          name: '$customerData.name',
          email: '$customerData.email'
        },
        totalSpent: 1,
        orderCount: 1,
        averageOrderValue: 1,
        daysSinceFirstOrder: {
          $divide: [
            { $subtract: [new Date(), '$firstOrder'] },
            1000 * 60 * 60 * 24 // Convert milliseconds to days
          ]
        },
        daysSinceLastOrder: {
          $divide: [
            { $subtract: [new Date(), '$lastOrder'] },
            1000 * 60 * 60 * 24
          ]
        }
      }
    },
    
    // Sort by total spent
    { $sort: { totalSpent: -1 } },
    
    // Limit to top 100 customers
    { $limit: 100 }
  ]);
}
            

Transactions

For operations that need to be atomic across multiple documents or collections, use transactions:

// Transfer funds between accounts
async function transferFunds(fromAccountId, toAccountId, amount) {
  // Start a session
  const session = await mongoose.startSession();
  session.startTransaction();
  
  try {
    // Find the source account and update its balance
    const fromAccount = await Account.findOneAndUpdate(
      { _id: fromAccountId, balance: { $gte: amount } },
      { $inc: { balance: -amount } },
      { new: true, session }
    );
    
    if (!fromAccount) {
      throw new Error('Insufficient funds or account not found');
    }
    
    // Find the destination account and update its balance
    const toAccount = await Account.findOneAndUpdate(
      { _id: toAccountId },
      { $inc: { balance: amount } },
      { new: true, session }
    );
    
    if (!toAccount) {
      throw new Error('Destination account not found');
    }
    
    // Create a transaction record
    await Transaction.create([{
      fromAccount: fromAccountId,
      toAccount: toAccountId,
      amount,
      type: 'transfer',
      date: new Date()
    }], { session });
    
    // Commit the transaction
    await session.commitTransaction();
    session.endSession();
    
    return { fromAccount, toAccount };
  } catch (error) {
    // Abort the transaction on error
    await session.abortTransaction();
    session.endSession();
    throw error;
  }
}
            

Text Search

MongoDB's text search capabilities can be accessed through Mongoose:

// Create a text index on the product schema
productSchema.index({
  name: 'text',
  description: 'text',
  tags: 'text'
}, {
  weights: {
    name: 10,      // Name is most important
    tags: 5,       // Tags are next
    description: 1  // Description is least important
  },
  name: 'product_text_index'
});

// Search for products
async function searchProducts(query, options = {}) {
  const { limit = 20, page = 1, sortBy = 'relevance' } = options;
  const skip = (page - 1) * limit;
  
  let sort = {};
  if (sortBy === 'relevance') {
    sort = { score: { $meta: 'textScore' } };
  } else if (sortBy === 'price_asc') {
    sort = { price: 1 };
  } else if (sortBy === 'price_desc') {
    sort = { price: -1 };
  } else if (sortBy === 'newest') {
    sort = { createdAt: -1 };
  }
  
  // Perform the text search
  const products = await Product.find(
    { $text: { $search: query } },
    { score: { $meta: 'textScore' } }
  )
    .sort(sort)
    .skip(skip)
    .limit(limit);
  
  // Get total count for pagination
  const totalProducts = await Product.countDocuments({
    $text: { $search: query }
  });
  
  return {
    products,
    pagination: {
      totalProducts,
      totalPages: Math.ceil(totalProducts / limit),
      currentPage: page,
      limit
    }
  };
}
            

Geospatial Queries

MongoDB has robust support for geospatial queries, which Mongoose can leverage:

// Store location with geospatial index
const storeSchema = new mongoose.Schema({
  name: { type: String, required: true },
  address: {
    street: String,
    city: String,
    state: String,
    zipCode: String
  },
  location: {
    type: {
      type: String,
      enum: ['Point'],
      required: true
    },
    coordinates: {
      type: [Number], // [longitude, latitude]
      required: true
    }
  },
  storeHours: {
    monday: String,
    tuesday: String,
    wednesday: String,
    thursday: String,
    friday: String,
    saturday: String,
    sunday: String
  }
});

// Create a 2dsphere index for geospatial queries
storeSchema.index({ location: '2dsphere' });

const Store = mongoose.model('Store', storeSchema);

// Find stores near a location
async function findNearbyStores(longitude, latitude, maxDistance = 10000) {
  return await Store.find({
    location: {
      $near: {
        $geometry: {
          type: 'Point',
          coordinates: [longitude, latitude]
        },
        $maxDistance: maxDistance // in meters
      }
    }
  })
    .select('name address location storeHours')
    .limit(10);
}

// Find stores within a polygon (e.g., delivery area)
async function findStoresInArea(polygonCoordinates) {
  return await Store.find({
    location: {
      $geoWithin: {
        $geometry: {
          type: 'Polygon',
          coordinates: [polygonCoordinates] // Array of [lng, lat] points
        }
      }
    }
  });
}