MongoDB CRUD Operations

CRUD Operations with Mongoose

Mongoose is an Object Data Modeling (ODM) library for MongoDB and Node.js that provides a higher-level abstraction with schemas, validation, and more.

Defining a Schema

// Node.js with Mongoose - Define a schema
const mongoose = require('mongoose');
const Schema = mongoose.Schema;

const productSchema = new Schema({
  name: {
    type: String,
    required: true,
    trim: true,
    unique: true
  },
  manufacturer: {
    type: String,
    required: true,
    trim: true
  },
  price: {
    type: Number,
    required: true,
    min: 0
  },
  specs: {
    screen: String,
    processor: String,
    storage: String,
    camera: String
  },
  colors: [String],
  available: {
    type: Boolean,
    default: true
  },
  releaseDate: {
    type: Date,
    default: Date.now
  },
  category: {
    type: String,
    enum: ['budget', 'standard', 'premium'],
    default: 'standard'
  },
  reviews: [{
    user: String,
    rating: {
      type: Number,
      min: 1,
      max: 5
    },
    comment: String,
    date: {
      type: Date,
      default: Date.now
    }
  }]
}, {
  timestamps: true // Adds createdAt and updatedAt fields
});

// Add instance methods
productSchema.methods.applyDiscount = function(percentage) {
  this.price = this.price * (1 - percentage / 100);
  return this.save();
};

// Add static methods
productSchema.statics.findByManufacturer = function(manufacturer) {
  return this.find({ manufacturer: new RegExp(manufacturer, 'i') });
};

// Add virtual property (not stored in the database)
productSchema.virtual('summary').get(function() {
  return `${this.name} by ${this.manufacturer} - $${this.price}`;
});

// Create model
const Product = mongoose.model('Product', productSchema);

module.exports = Product;
            

Creating Data with Mongoose

// Create a single document
const smartphone = new Product({
  name: "Smartphone X1",
  manufacturer: "TechCorp",
  price: 699.99,
  specs: {
    screen: "6.5 inch",
    processor: "OctaCore 2.4GHz",
    storage: "128GB",
    camera: "48MP"
  },
  colors: ["Black", "Silver", "Blue"]
});

// Save to database
await smartphone.save();

// Alternative creation method
const laptop = await Product.create({
  name: "Laptop Pro",
  manufacturer: "TechCorp",
  price: 1299.99,
  specs: {
    screen: "15.6 inch",
    processor: "QuadCore 3.2GHz",
    storage: "512GB SSD"
  },
  colors: ["Silver", "Space Gray"]
});

// Create multiple documents
await Product.insertMany([
  {
    name: "Wireless Earbuds",
    manufacturer: "AudioTech",
    price: 149.99,
    specs: {
      batteryLife: "8 hours",
      bluetoothVersion: "5.2"
    },
    colors: ["White", "Black"]
  },
  {
    name: "Smart Watch",
    manufacturer: "TechCorp",
    price: 299.99,
    specs: {
      screen: "1.5 inch",
      batteryLife: "48 hours"
    },
    colors: ["Black", "Silver"]
  }
]);
            

Reading Data with Mongoose

// Find all documents
const allProducts = await Product.find();

// Find with conditions
const techCorpProducts = await Product.find({ manufacturer: "TechCorp" });

// Find one document
const smartphone = await Product.findOne({ name: "Smartphone X1" });

// Find by ID
const product = await Product.findById("6176f67c8baf56a52bd8f3e2");

// Query with chaining
const expensiveProducts = await Product.find()
  .where('price').gt(500)
  .where('available').equals(true)
  .select('name price')
  .sort('-price')
  .limit(5);

// Using static methods
const techProducts = await Product.findByManufacturer("Tech");

// Using a virtual property
const product = await Product.findOne({ name: "Smartphone X1" });
console.log(product.summary);  // "Smartphone X1 by TechCorp - $699.99"
            

Updating Data with Mongoose

// Find and update directly with the model
const updatedProduct = await Product.findByIdAndUpdate(
  "6176f67c8baf56a52bd8f3e2",
  { price: 649.99, available: false },
  { new: true }  // Return the updated document
);

// Update multiple documents
const result = await Product.updateMany(
  { manufacturer: "TechCorp" },
  { $set: { manufacturer: "TechCorp Inc." } }
);
console.log(`${result.modifiedCount} products updated`);

// Update with validate/save pattern
const product = await Product.findById("6176f67c8baf56a52bd8f3e2");
if (product) {
  product.price = 629.99;
  product.colors.push("Rose Gold");
  await product.save();  // Validation runs before saving
}

// Using instance methods
const product = await Product.findOne({ name: "Laptop Pro" });
await product.applyDiscount(10);  // Apply 10% discount
            

Deleting Data with Mongoose

// Delete a single document
await Product.deleteOne({ name: "Obsolete Product" });

// Delete multiple documents
const result = await Product.deleteMany({ available: false });
console.log(`${result.deletedCount} products deleted`);

// Find and delete
const deletedProduct = await Product.findByIdAndDelete("6176f67c8baf56a52bd8f3e2");
if (deletedProduct) {
  console.log(`Deleted ${deletedProduct.name}`);
}

// Delete with the document instance
const product = await Product.findOne({ name: "Discontinued Item" });
if (product) {
  await product.deleteOne();
  console.log("Product deleted");
}
            

Validation with Mongoose

// Define a schema with advanced validation
const productSchema = new Schema({
  name: {
    type: String,
    required: [true, 'Product name is required'],
    trim: true,
    minlength: [3, 'Name must be at least 3 characters'],
    maxlength: [100, 'Name cannot exceed 100 characters']
  },
  price: {
    type: Number,
    required: true,
    min: [0, 'Price cannot be negative'],
    validate: {
      validator: function(v) {
        return v % 0.01 === 0;  // Ensure price has at most 2 decimal places
      },
      message: props => `${props.value} is not a valid price format`
    }
  },
  sku: {
    type: String,
    required: true,
    unique: true,
    validate: {
      validator: function(v) {
        return /^[A-Z]{2}-\d{4}$/.test(v);  // Format: XX-0000
      },
      message: props => `${props.value} is not a valid SKU format`
    }
  }
});

// Handling validation errors
try {
  const product = new Product({
    name: "AB",  // Too short
    price: -10,  // Negative
    sku: "invalid"  // Wrong format
  });
  await product.save();
} catch (error) {
  if (error.name === 'ValidationError') {
    for (const field in error.errors) {
      console.log(`${field}: ${error.errors[field].message}`);
    }
  } else {
    console.error("Error:", error);
  }
}