MongoDB: حذف المستندات والبدء في استخدام Node.js

// ❌ Counterexample:Query multiple times, then delete(Slow + Race Condition)
const expiredOrders = await Order.find({ expiryDate: { $lt: new Date() } });
for (const order of expiredOrders) {
  await Order.deleteOne({ _id: order._id });
}
// N Sub-network round trip，N Second deletion operation

// ✅ Correct Example:Bulk Deletion in One Go
const result = await Order.deleteMany({
  expiryDate: { $lt: new Date() }
});
// Delete all expired orders in a single operation

// mongoose Schema Definition
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 Basic Usage ===
db.products.deleteOne({ sku: 'PHONE-001' });

// Return Results:
// { acknowledged: true, deletedCount: 1 }

// === Delete Specified _id the document ===
db.users.deleteOne({ _id: ObjectId('507f1f77bcf86cd799439011') });

// === Delete Based on Specified Criteria(First match)===
db.logs.deleteOne({ level: 'debug' });

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

// === deleteMany Basic Usage ===
db.products.deleteMany({ category: 'Discontinued' });

// === Delete all expired orders ===
db.orders.deleteMany({
  expiryDate: { $lt: new Date() }
});

// === Delete Multiple Documents That Meet Specific Criteria ===
db.logs.deleteMany({
  level: { $in: ['debug', 'info'] },
  createdAt: { $lt: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) }
});

// === Cleanup 30 Entries from a few days ago ===
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`);

// === Delete the session of a logged-out user ===
await Session.deleteMany({ userId: deletedUserId });

// === Delete all documents from the entire collection(Use with caution!)===
db.products.deleteMany({});
// ⚠️ This will delete products All documents in the collection

// === findOneAndDelete Atomic Manipulation ===
const deletedDoc = db.products.findOneAndDelete({ sku: 'PHONE-001' });

// Restore Deleted Documents(Status before default deletion)
console.log(deletedDoc);
// { _id: ..., sku: 'PHONE-001', title: 'Phone', price: 599, ... }

// === Return if it does not exist null ===
const result = db.products.findOneAndDelete({ sku: 'NOT_EXIST' });
console.log(result);  // null

// === Scene:Message Queue(FIFO)===
const message = await Queue.findOneAndDelete(
  { status: 'pending' },
  { sort: { createdAt: 1 } }  // Consume the oldest ones first
);

// === Scene:Claim a Mission ===
const task = await Task.findOneAndDelete({
  status: 'available',
  assignee: null
});
if (task) {
  console.log(`Claimed task: ${task._id}`);
}

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

// === Delete Set ===
db.products.drop();
// true(Success)or false(The set does not exist)

// === Delete the database ===
db.dropDatabase();
// { "dropped" : "shopdb", "ok" : 1 }

// === Use with caution: Delete all data from the entire collection but keep the collection itself ===
db.products.deleteMany({});
// Equivalent but preserves the set structure(Index、capped Settings)

// Scene:Cleaning Up Temporary Test Sets
// ✅ Recommendations:drop(Delete Set+Index，Clean)
db.test_results.drop();

// ✅ Preserve the collection structure:deleteMany(Clear the document only)
db.user_sessions.deleteMany({});

npm install mongoose --save

// === Basic Connections ===
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));

// === Complete Connection Configuration ===
await mongoose.connect('mongodb://localhost:27017/shopdb', {
  // Server selection timeout
  serverSelectionTimeoutMS: 5000,

  // Socket Timeout
  socketTimeoutMS: 45000,

  // Connection Pool Size
  maxPoolSize: 50,
  minPoolSize: 5,

  // Automatic Reconnection
  autoReconnect: true,

  // Certification(If enabled)
  user: 'admin',
  pass: 'password',

  // Certification Database
  authSource: 'admin'
});

// === Atlas Concatenate Strings ===
await mongoose.connect(
  'mongodb+srv://user:pass@cluster0.mongodb.net/mydb?retryWrites=true&w=majority'
);

// === With environment variables ===
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}`);

    // Listening for Connection Events
    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 };

// === Schema Defining the User Model ===
const UserSchema = new mongoose.Schema({
  // Field Definitions
  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  // The default query returns no results.
  },
  age: {
    type: Number,
    min: 0,
    max: 150
  },
  role: {
    type: String,
    enum: ['customer', 'admin', 'moderator'],
    default: 'customer'
  },
  isActive: {
    type: Boolean,
    default: true
  }
}, {
  // Schema Options
  timestamps: true,           // Auto-add createdAt/updatedAt
  collection: 'users',       // Explicitly Specify the Set Name
  strict: true,              // Strict Mode(Do not save undeclared fields)
  versionKey: false          // Disable __v
});

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

  // Numbers
  stock: Number,
  price: mongoose.Schema.Types.Decimal128,

  // Date
  releaseDate: Date,

  // Boolean
  isActive: Boolean,

  // Array
  tags: [String],

  // Nested Documents
  specs: {
    screen: String,
    battery: String
  },

  // Buffer(Binary)
  thumbnail: Buffer,

  // ObjectId Quote
  categoryId: mongoose.Schema.Types.ObjectId,

  // Mixed Type(Any)
  metadata: mongoose.Schema.Types.Mixed,

  // Map(Key-value pairs)
  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  // Serialize to a string
  },
  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 }
});

// Virtual Fields
ProductSchema.virtual('isInStock').get(function() {
  return this.stock > 0;
});

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

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

// === model.create() Create a Single Document ===
const user = await User.create({
  email: 'alice@example.com',
  username: 'alice_chen',
  passwordHash: 'hashed_password',
  age: 28
});
console.log(user._id);  // ObjectId

// === Create Multiple Documents ===
const users = await User.create([
  { email: 'bob@example.com', username: 'bob' },
  { email: 'charlie@example.com', username: 'charlie' }
]);

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

// === find Search for multiple ===
const users = await User.find({ isActive: true });

// === findOne Query a single ===
const user = await User.findOne({ email: 'alice@example.com' });

// === findById Through _id Search ===
const user = await User.findById('507f1f77bcf86cd799439011');

// === Chain Query ===
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 }  // Return to the updated document
);

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

// === save() Replace the entire document ===
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. Create a User ===
const alice = await User.create({
  email: 'alice@example.com',
  username: 'alice_chen',
  passwordHash: await bcrypt.hash('password123', 10),
  age: 28
});

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

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

// === 4. Delete Test User ===
await User.deleteMany({ email: { $regex: '@test\\.com$' } });