MongoDB: 删除文档与Node.js入门

// ❌ 反例：多次查询再删除（慢 + 竞态）
const expiredOrders = await Order.find({ expiryDate: { $lt: new Date() } });
for (const order of expiredOrders) {
  await Order.deleteOne({ _id: order._id });
}
// N 次网络往返，N 次删除操作

// ✅ 正例：一次性批量删除
const result = await Order.deleteMany({
  expiryDate: { $lt: new Date() }
});
// 单次操作删除所有过期订单

// mongoose Schema 定义
const OrderSchema = new mongoose.Schema({
  userId: { type: mongoose.Schema.Types.ObjectId, required: true },
  items: [{ sku: String, qty: Number, price: mongoose.Schema.Types.Decimal128 }],
  total: { type: mongoose.Schema.Types.Decimal128, required: true },
  status: { type: String, enum: ['pending', 'paid', 'shipped', 'delivered'], default: 'pending' },
  expiryDate: Date,
  createdAt: { type: Date, default: Date.now }
}, { timestamps: true });

const Order = mongoose.model('Order', OrderSchema);

// === deleteOne 基本用法 ===
db.products.deleteOne({ sku: 'PHONE-001' });

// 返回结果：
// { acknowledged: true, deletedCount: 1 }

// === 删除指定 _id 的文档 ===
db.users.deleteOne({ _id: ObjectId('507f1f77bcf86cd799439011') });

// === 删除指定条件（第一个匹配）===
db.logs.deleteOne({ level: 'debug' });

// === mongoose 等价 ===
const result = await Product.deleteOne({ sku: 'PHONE-001' });
console.log(result.deletedCount);  // 1

// mongoose 操作成功执行
// 数据库查询/更新结果

// === deleteMany 基本用法 ===
db.products.deleteMany({ category: 'Discontinued' });

// === 删除所有过期订单 ===
db.orders.deleteMany({
  expiryDate: { $lt: new Date() }
});

// === 删除特定条件的多个文档 ===
db.logs.deleteMany({
  level: { $in: ['debug', 'info'] },
  createdAt: { $lt: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) }
});

// === 清理 30 天前的日志 ===
const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
const result = await Log.deleteMany({ createdAt: { $lt: thirtyDaysAgo } });
console.log(`Deleted ${result.deletedCount} old logs`);

// === 删除已注销用户的会话 ===
await Session.deleteMany({ userId: deletedUserId });

// === 删除整个集合的所有文档（慎用！）===
db.products.deleteMany({});
// ⚠️ 这会删除 products 集合的所有文档

// 执行成功

// === findOneAndDelete 原子操作 ===
const deletedDoc = db.products.findOneAndDelete({ sku: 'PHONE-001' });

// 返回被删除的文档（默认删除前的状态）
console.log(deletedDoc);
// { _id: ..., sku: 'PHONE-001', title: 'Phone', price: 599, ... }

// === 不存在时返回 null ===
const result = db.products.findOneAndDelete({ sku: 'NOT_EXIST' });
console.log(result);  // null

// === 场景：消息队列（FIFO）===
const message = await Queue.findOneAndDelete(
  { status: 'pending' },
  { sort: { createdAt: 1 } }  // 优先消费最早的
);

// === 场景：任务领取 ===
const task = await Task.findOneAndDelete({
  status: 'available',
  assignee: null
});
if (task) {
  console.log(`Claimed task: ${task._id}`);
}

// === mongoose 等价 ===
const message = await Queue.findOneAndDelete(
  { status: 'pending' },
  { sort: { createdAt: 1 } }
);

// mongoose 操作成功执行
// 数据库查询/更新结果

// === 删除集合 ===
db.products.drop();
// true（成功）或 false（集合不存在）

// === 删除数据库 ===
db.dropDatabase();
// { "dropped" : "shopdb", "ok" : 1 }

// === 慎用：删除整个集合的所有数据但保留集合 ===
db.products.deleteMany({});
// 等效但保留集合结构（索引、capped 设置）

// 场景：临时测试集合清理
// ✅ 推荐：drop（删除集合+索引，干净）
db.test_results.drop();

// ✅ 保留集合结构：deleteMany（仅清空文档）
db.user_sessions.deleteMany({});

// 执行成功

npm install mongoose --save

// === 基本连接 ===
const mongoose = require('mongoose');

async function connectDB() {
  await mongoose.connect('mongodb://localhost:27017/shopdb');
  console.log('✅ MongoDB connected');
}

connectDB().catch(err => console.error('❌ Connection error:', err));

// === 完整连接配置 ===
await mongoose.connect('mongodb://localhost:27017/shopdb', {
  // 服务器选择超时
  serverSelectionTimeoutMS: 5000,

  // 套接字超时
  socketTimeoutMS: 45000,

  // 连接池大小
  maxPoolSize: 50,
  minPoolSize: 5,

  // 自动重连
  autoReconnect: true,

  // 认证（如果启用）
  user: 'admin',
  pass: 'password',

  // 认证数据库
  authSource: 'admin'
});

// === Atlas 连接字符串 ===
await mongoose.connect(
  'mongodb+srv://user:pass@cluster0.mongodb.net/mydb?retryWrites=true&w=majority'
);

// === 带环境变量 ===
require('dotenv').config();
await mongoose.connect(process.env.MONGODB_URI);

// db.js
const mongoose = require('mongoose');

const connectDB = async () => {
  try {
    const conn = await mongoose.connect(process.env.MONGODB_URI || 'mongodb://localhost:27017/shopdb', {
      serverSelectionTimeoutMS: 5000,
      maxPoolSize: 50
    });
    console.log(`✅ MongoDB connected: ${conn.connection.host}`);

    // 监听连接事件
    mongoose.connection.on('error', (err) => console.error('❌ MongoDB error:', err));
    mongoose.connection.on('disconnected', () => console.warn('⚠️ MongoDB disconnected'));
    mongoose.connection.on('reconnected', () => console.log('🔄 MongoDB reconnected'));
  } catch (err) {
    console.error('❌ Connection failed:', err.message);
    process.exit(1);
  }
};

const disconnectDB = async () => {
  await mongoose.disconnect();
  console.log('MongoDB disconnected');
};

module.exports = { connectDB, disconnectDB, mongoose };

❌ MongoDB error:
⚠️ MongoDB disconnected
🔄 MongoDB reconnected
❌ Connection failed:
MongoDB disconnected

// === Schema 定义用户模型 ===
const UserSchema = new mongoose.Schema({
  // 字段定义
  email: {
    type: String,
    required: true,
    unique: true,
    lowercase: true,
    trim: true
  },
  username: {
    type: String,
    required: true,
    unique: true,
    minlength: 3,
    maxlength: 30
  },
  passwordHash: {
    type: String,
    required: true,
    select: false  // 默认查询不返回
  },
  age: {
    type: Number,
    min: 0,
    max: 150
  },
  role: {
    type: String,
    enum: ['customer', 'admin', 'moderator'],
    default: 'customer'
  },
  isActive: {
    type: Boolean,
    default: true
  }
}, {
  // Schema 选项
  timestamps: true,           // 自动添加 createdAt/updatedAt
  collection: 'users',       // 显式指定集合名
  strict: true,              // 严格模式（不保存未声明字段）
  versionKey: false          // 禁用 __v
});

const ProductSchema = new mongoose.Schema({
  // 字符串
  sku: String,

  // 数字
  stock: Number,
  price: mongoose.Schema.Types.Decimal128,

  // 日期
  releaseDate: Date,

  // 布尔
  isActive: Boolean,

  // 数组
  tags: [String],

  // 嵌套文档
  specs: {
    screen: String,
    battery: String
  },

  // Buffer（二进制）
  thumbnail: Buffer,

  // ObjectId 引用
  categoryId: mongoose.Schema.Types.ObjectId,

  // 混合类型（任意）
  metadata: mongoose.Schema.Types.Mixed,

  // Map（键值对）
  translations: {
    type: Map,
    of: String
  }
});

const ProductSchema = new mongoose.Schema({
  sku: {
    type: String,
    required: [true, 'SKU is required'],
    unique: true,
    index: true,
    match: /^[A-Z0-9-]+$/
  },
  title: {
    type: String,
    required: true,
    trim: true,
    maxlength: 200
  },
  description: {
    type: String,
    maxlength: 5000
  },
  price: {
    type: mongoose.Schema.Types.Decimal128,
    required: true,
    min: 0,
    get: v => v ? v.toString() : v  // 序列化为字符串
  },
  category: {
    type: String,
    enum: ['Electronics', 'Books', 'Clothing', 'Home'],
    required: true,
    index: true
  },
  tags: [String],
  attributes: {
    type: Map,
    of: mongoose.Schema.Types.Mixed,
    default: {}
  },
  stock: {
    type: Number,
    default: 0,
    min: 0
  },
  rating: {
    type: Number,
    default: 0,
    min: 0,
    max: 5
  },
  isActive: {
    type: Boolean,
    default: true,
    index: true
  }
}, {
  timestamps: true,
  toJSON: { virtuals: true, getters: true },
  toObject: { virtuals: true }
});

// 虚拟字段
ProductSchema.virtual('isInStock').get(function() {
  return this.stock > 0;
});

// 索引
ProductSchema.index({ category: 1, price: 1 });
ProductSchema.index({ title: 'text', description: 'text' });

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

// mongoose 操作成功执行
// 数据库查询/更新结果

// === model.create() 创建单个文档 ===
const user = await User.create({
  email: 'alice@example.com',
  username: 'alice_chen',
  passwordHash: 'hashed_password',
  age: 28
});
console.log(user._id);  // ObjectId

// === 创建多个文档 ===
const users = await User.create([
  { email: 'bob@example.com', username: 'bob' },
  { email: 'charlie@example.com', username: 'charlie' }
]);

// === new + save 模式 ===
const user = new User({
  email: 'alice@example.com',
  username: 'alice_chen'
});
await user.save();

// === find 查询多个 ===
const users = await User.find({ isActive: true });

// === findOne 查询单个 ===
const user = await User.findOne({ email: 'alice@example.com' });

// === findById 通过 _id 查询 ===
const user = await User.findById('507f1f77bcf86cd799439011');

// === 链式查询 ===
const products = await Product.find({ category: 'Electronics' })
  .select('sku title price')
  .sort({ price: 1 })
  .limit(20)
  .lean();

// === findByIdAndUpdate ===
const user = await User.findByIdAndUpdate(
  userId,
  { $set: { lastLoginAt: new Date() } },
  { new: true, runValidators: true }  // 返回更新后文档
);

// === updateOne ===
const result = await User.updateOne(
  { email: 'alice@example.com' },
  { $set: { age: 29 } }
);

// === save() 完整文档替换 ===
const user = await User.findById(userId);
user.age = 30;
await user.save();

// === findByIdAndDelete ===
const user = await User.findByIdAndDelete(userId);

// === deleteOne ===
const result = await User.deleteOne({ email: 'alice@example.com' });

// === deleteMany ===
const result = await User.deleteMany({ isActive: false });

// === 1. 创建用户 ===
const alice = await User.create({
  email: 'alice@example.com',
  username: 'alice_chen',
  passwordHash: await bcrypt.hash('password123', 10),
  age: 28
});

// === 2. 查询用户 ===
const users = await User.find({ age: { $gte: 18 } })
  .select('email username age')
  .lean();

// === 3. 更新用户 ===
await User.updateOne(
  { _id: alice._id },
  { $set: { lastLoginAt: new Date() }, $inc: { loginCount: 1 } }
);

// === 4. 删除测试用户 ===
await User.deleteMany({ email: { $regex: '@test\\.com$' } });

// mongoose 操作成功执行
// 数据库查询/更新结果