Mongoose ODM for MongoDB in Node.js

const mongoose = require('mongoose');

const MONGO_URI = process.env.MONGO_URI || 'mongodb://localhost:27017/myapp';

mongoose.connect(MONGO_URI, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
  serverSelectionTimeoutMS: 5000,
  socketTimeoutMS: 45000,
});

mongoose.connection.on('connected', () => {
  console.log('Mongoose connected to', MONGO_URI);
});

mongoose.connection.on('error', (err) => {
  console.error('Mongoose connection error:', err);
});

mongoose.connection.on('disconnected', () => {
  console.log('Mongoose disconnected');
});

module.exports = mongoose;

const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  email: {
    type: String,
    required: true,
    unique: true,
    lowercase: true,
    trim: true,
    match: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
  },
  password: {
    type: String,
    required: true,
    minlength: 8,
  },
  role: {
    type: String,
    enum: ['user', 'admin'],
    default: 'user',
  },
  createdAt: {
    type: Date,
    default: Date.now,
    immutable: true,
  },
});

userSchema.index({ email: 1 }, { unique: true });

module.exports = mongoose.model('User', userSchema);

const User = require('./user.model');

async function createUser(email, password, role = 'user') {
  const user = new User({ email, password, role });
  return await user.save();
}

async function getUserByEmail(email) {
  return await User.findOne({ email }).lean();
}

async function updateUserRole(userId, newRole) {
  return await User.findByIdAndUpdate(
    userId,
    { role: newRole },
    { new: true, runValidators: true }
  );
}

module.exports = { createUser, getUserByEmail, updateUserRole };

const mongoose = require('mongoose');

const orderSchema = new mongoose.Schema({
  items: [{
    productId: { type: mongoose.Schema.Types.ObjectId, ref: 'Product', required: true },
    quantity: { type: Number, required: true, min: 1, max: 100 },
  }],
  total: { type: Number, required: true, min: 0 },
  status: { type: String, enum: ['pending', 'shipped', 'delivered'], default: 'pending' },
  createdAt: { type: Date, default: Date.now },
});

// Custom validator: ensure total matches sum of item prices (async example)
orderSchema.pre('save', async function(next) {
  if (this.isModified('items')) {
    const Product = mongoose.model('Product');
    let calculatedTotal = 0;
    for (const item of this.items) {
      const product = await Product.findById(item.productId).lean();
      if (!product) {
        return next(new Error(`Product ${item.productId} not found`));
      }
      calculatedTotal += product.price * item.quantity;
    }
    if (Math.abs(calculatedTotal - this.total) > 0.01) {
      return next(new Error('Total does not match item prices'));
    }
  }
  next();
});

module.exports = mongoose.model('Order', orderSchema);

const mongoose = require('mongoose');
const bcrypt = require('bcrypt');

const userSchema = new mongoose.Schema({
  email: { type: String, required: true, unique: true },
  password: { type: String, required: true },
});

// Pre-save hook to hash password
userSchema.pre('save', async function(next) {
  if (!this.isModified('password')) return next();
  try {
    const salt = await bcrypt.genSalt(10);
    this.password = await bcrypt.hash(this.password, salt);
    next();
  } catch (err) {
    next(err);
  }
});

// Instance method to compare passwords
userSchema.methods.comparePassword = async function(candidatePassword) {
  return bcrypt.compare(candidatePassword, this.password);
};

module.exports = mongoose.model('User', userSchema);

const User = require('./user.model');
const Order = require('./order.model');

// Find active users with pagination
async function getActiveUsers(page = 1, limit = 20) {
  return await User.find({ active: true })
    .sort({ createdAt: -1 })
    .skip((page - 1) * limit)
    .limit(limit)
    .lean();
}

// Populate orders with product details
async function getOrdersWithProducts(userId) {
  return await Order.find({ userId })
    .populate('items.productId', 'name price')
    .lean();
}

// Aggregation: total sales per product
async function getTotalSales() {
  return await Order.aggregate([
    { $match: { status: 'delivered' } },
    { $unwind: '$items' },
    { $group: { _id: '$items.productId', totalQuantity: { $sum: '$items.quantity' } } },
    { $lookup: { from: 'products', localField: '_id', foreignField: '_id', as: 'product' } },
    { $unwind: '$product' },
    { $project: { productName: '$product.name', totalQuantity: 1 } },
  ]);
}

const mongoose = require('mongoose');
const Account = require('./account.model');

async function transferFunds(fromAccountId, toAccountId, amount) {
  const session = await mongoose.startSession();
  session.startTransaction();
  try {
    const fromAccount = await Account.findById(fromAccountId).session(session);
    const toAccount = await Account.findById(toAccountId).session(session);

    if (fromAccount.balance < amount) {
      throw new Error('Insufficient funds');
    }

    fromAccount.balance -= amount;
    toAccount.balance += amount;

    await fromAccount.save({ session });
    await toAccount.save({ session });

    await session.commitTransaction();
    console.log('Transfer successful');
  } catch (error) {
    await session.abortTransaction();
    console.error('Transfer failed:', error);
    throw error;
  } finally {
    session.endSession();
  }
}

const mongoose = require('mongoose');

function handleMongooseError(err, req, res, next) {
  if (err instanceof mongoose.Error.ValidationError) {
    const messages = Object.values(err.errors).map(e => e.message);
    return res.status(400).json({ error: 'Validation failed', details: messages });
  }

  if (err instanceof mongoose.Error.CastError) {
    return res.status(400).json({ error: 'Invalid ID format' });
  }

  if (err.code === 11000) { // duplicate key
    const field = Object.keys(err.keyValue)[0];
    return res.status(409).json({ error: `Duplicate ${field}` });
  }

  // Fallback to generic error
  console.error('Unhandled error:', err);
  res.status(500).json({ error: 'Internal server error' });
}

module.exports = handleMongooseError;

const mongoose = require('mongoose');

const orderSchema = new mongoose.Schema({
  userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
  status: { type: String, enum: ['pending', 'shipped', 'delivered'], required: true },
  createdAt: { type: Date, default: Date.now },
});

// Compound index for common query pattern: find orders by user and status
orderSchema.index({ userId: 1, status: 1 });

// Index for sorting by creation date
orderSchema.index({ createdAt: -1 });

module.exports = mongoose.model('Order', orderSchema);

const mongoose = require('mongoose');

const MONGO_URI = process.env.MONGO_URI;

mongoose.connect(MONGO_URI, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
  maxPoolSize: 10,
  minPoolSize: 2,
  serverSelectionTimeoutMS: 5000,
  socketTimeoutMS: 45000,
  readPreference: 'secondaryPreferred',
  retryWrites: true,
  w: 'majority',
});

mongoose.connection.on('error', (err) => {
  console.error('MongoDB connection error:', err);
  // Implement retry logic with exponential backoff
});

mongoose.connection.on('disconnected', () => {
  console.log('MongoDB disconnected. Attempting to reconnect...');
});

module.exports = mongoose;

// migrate-mongo migration script
module.exports = {
  async up(db, client) {
    // Add 'phone' field to all users
    await db.collection('users').updateMany(
      { phone: { $exists: false } },
      { $set: { phone: '' } }
    );
  },

  async down(db, client) {
    // Remove 'phone' field
    await db.collection('users').updateMany(
      {},
      { $unset: { phone: '' } }
    );
  }
};

const mongoose = require('mongoose');
const { MongoMemoryServer } = require('mongodb-memory-server');
const User = require('./user.model');

let mongoServer;

beforeAll(async () => {
  mongoServer = await MongoMemoryServer.create();
  await mongoose.connect(mongoServer.getUri());
});

afterAll(async () => {
  await mongoose.disconnect();
  await mongoServer.stop();
});

describe('User Model', () => {
  it('should create a user with valid data', async () => {
    const user = new User({ email: 'test@test.com', password: 'password123' });
    const saved = await user.save();
    expect(saved.email).toBe('test@test.com');
  });

  it('should fail validation for invalid email', async () => {
    const user = new User({ email: 'invalid', password: 'password123' });
    await expect(user.save()).rejects.toThrow(mongoose.Error.ValidationError);
  });
});

const mongoose = require('mongoose');
const { Schema } = mongoose;

const productSchema = new Schema({
  name: { type: String, required: true },
  price: { type: mongoose.Decimal128, required: true },
  tags: { type: Map, of: String },
  uuid: { type: Schema.Types.UUID, default: () => crypto.randomUUID() },
  metadata: { type: Schema.Types.Mixed },
  category: { type: Schema.Types.ObjectId, ref: 'Category' }
});

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

// Usage
const product = new Product({
  name: 'Widget',
  price: '19.99', // string is cast to Decimal128
  tags: { color: 'red', size: 'M' },
  metadata: { any: 'thing' }
});
await product.save();
console.log(product.price.toString()); // "19.99"

const userSchema = new Schema({
  firstName: String,
  lastName: String,
  email: { type: String, unique: true }
}, {
  timestamps: true,
  toJSON: {
    virtuals: true,
    transform: (doc, ret) => {
      delete ret.__v;
      ret.id = ret._id.toString();
      delete ret._id;
      return ret;
    }
  }
});

userSchema.virtual('fullName').get(function() {
  return `${this.firstName} ${this.lastName}`;
});

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

const user = new User({ firstName: 'Jane', lastName: 'Doe' });
console.log(user.toJSON()); // { id: '...', firstName: 'Jane', lastName: 'Doe', fullName: 'Jane Doe', createdAt: ..., updatedAt: ... }

const eventSchema = new Schema({
  timestamp: { type: Date, default: Date.now },
  ip: String
}, { discriminatorKey: 'kind' });

const Event = mongoose.model('Event', eventSchema);

const clickSchema = new Schema({
  element: String
});
const Click = Event.discriminator('Click', clickSchema);

const pageviewSchema = new Schema({
  url: String
});
const Pageview = Event.discriminator('Pageview', pageviewSchema);

// Usage
const click = new Click({ element: '#button', ip: '1.2.3.4' });
await click.save();
// Document in 'events' collection: { _id, kind: 'Click', timestamp, ip, element }

const events = await Event.find({}); // returns both Click and Pageview docs

// Embedded subdocument
const orderSchema = new Schema({
  items: [{
    product: { type: Schema.Types.ObjectId, ref: 'Product' },
    quantity: Number,
    price: Number
  }],
  shippingAddress: {
    street: String,
    city: String,
    zip: String
  }
});

// Referenced document
const postSchema = new Schema({
  author: { type: Schema.Types.ObjectId, ref: 'User' },
  content: String
});

// Hybrid: embed summary, reference details
const userSchema = new Schema({
  profile: {
    displayName: String,
    avatar: String
  },
  // full details in separate collection
});

const userSchema = new Schema({
  name: String
});

const postSchema = new Schema({
  author: { type: Schema.Types.ObjectId, ref: 'User' },
  title: String
});

userSchema.virtual('posts', {
  ref: 'Post',
  localField: '_id',
  foreignField: 'author'
});

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

// Usage
const user = await User.findById(userId).populate('posts');
console.log(user.posts); // array of Post documents

const postSchema = new Schema({
  author: { type: Schema.Types.ObjectId, ref: 'User' }
});

const userSchema = new Schema({
  name: String,
  company: { type: Schema.Types.ObjectId, ref: 'Company' }
});

const companySchema = new Schema({
  name: String
});

// Deep populate
const post = await Post.findById(postId)
  .populate({
    path: 'author',
    populate: { path: 'company' }
  });

console.log(post.author.company.name); // "Acme Inc."