deleteOne과 deleteMany로 안전하게 문서 삭제하기

// deleteOne: removes first matching document
const res1 = await db.collection('sessions').deleteOne(
  { token: expiredToken }
);
console.log(res1.deletedCount); // 0 or 1

// deleteMany: removes all matching documents
const res2 = await db.collection('sessions').deleteMany(
  { expiresAt: { $lt: new Date() } }
);
console.log(res2.deletedCount); // 0 or more

// DANGER: Deletes ALL documents in the collection!
db.users.deleteMany({});
// Before you run deleteMany - always verify your filter first:

// Step 1: Count what will be deleted
const count = await db.collection('users').countDocuments(
  { status: 'temp' }  // Your intended filter
);
console.log('Will delete:', count, 'documents');

// Step 2: Only delete after reviewing the count
if (count > 0 && count < SAFE_LIMIT) {
  await db.collection('users').deleteMany({ status: 'temp' });
}

// Soft delete: mark as deleted instead of removing
async function softDelete(collection, id) {
  await db.collection(collection).updateOne(
    { _id: new ObjectId(id) },
    { $set: { deletedAt: new Date(), deletedBy: currentUserId } }
  );
}

// All queries must exclude deleted records:
db.posts.find({ deletedAt: { $exists: false } });

// Purge records deleted more than 30 days ago:
const cutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
db.posts.deleteMany({ deletedAt: { $lt: cutoff } });

// Atomic pop from a task queue
async function claimNextTask() {
  const task = await db.collection('taskQueue').findOneAndDelete(
    { status: 'pending' },
    { sort: { priority: -1, createdAt: 1 } }  // Highest priority, oldest first
  );

  if (!task) {
    return null;  // Queue is empty
  }

  // Process the task - it's already removed from the queue
  await processTask(task);
  return task._id;
}

// Cascading delete with transaction
async function deleteUser(userId) {
  const session = client.startSession();
  try {
    await session.withTransaction(async () => {
      const id = new ObjectId(userId);
      // Delete user
      await db.collection('users').deleteOne({ _id: id }, { session });
      // Delete all user's posts
      await db.collection('posts').deleteMany({ authorId: id }, { session });
      // Delete user's sessions
      await db.collection('sessions').deleteMany({ userId: id }, { session });
    });
    console.log('User and all related data deleted');
  } finally {
    await session.endSession();
  }
}

// Create a TTL index: delete sessions 24 hours after createdAt
db.sessions.createIndex(
  { createdAt: 1 },
  { expireAfterSeconds: 86400 }  // 24h in seconds
);

// Sessions are automatically deleted 24h after their createdAt date
// No cron job needed!

// For user-defined expiry per document:
db.verificationCodes.createIndex(
  { expiresAt: 1 },
  { expireAfterSeconds: 0 }  // Delete at the date stored in expiresAt
);
// Each document controls its own expiry: expiresAt: new Date(Date.now() + 3600000)

// Batched deletion of old logs (prevents locking)
async function purgeOldLogs(cutoffDate) {
  const BATCH_SIZE = 1000;
  let totalDeleted = 0;

  while (true) {
    const result = await db.collection('logs').deleteMany(
      { createdAt: { $lt: cutoffDate } },
      { limit: BATCH_SIZE }  // Note: deleteMany has no built-in limit
      // Instead, use find + deleteOne in a loop for true batching
    );
    totalDeleted += result.deletedCount;
    if (result.deletedCount === 0) break;
    await new Promise(r => setTimeout(r, 100)); // Brief pause between batches
  }
  return totalDeleted;
}

// Slow: deletes each document individually (keeps collection + indexes)
await db.collection('testData').deleteMany({});

// Fast: drops entire collection (collection and indexes are gone)
await db.collection('testData').drop();

// Recreate with indexes after drop:
await db.collection('testData').createIndex({ email: 1 }, { unique: true });
// Or just start inserting - collection recreates on first insert

async function safeDeleteMany(collection, filter, options = {}) {
  const { dryRun = false, maxAllowed = 1000 } = options;

  // Always count first
  const count = await db.collection(collection).countDocuments(filter);
  console.log(`[DRY RUN] Would delete ${count} documents from ${collection}`);

  if (dryRun) return { wouldDelete: count };

  if (count > maxAllowed) {
    throw new Error(`Safety: ${count} > max allowed ${maxAllowed}. Pass override to proceed.`);
  }

  const result = await db.collection(collection).deleteMany(filter);
  console.log(`[DELETED] ${result.deletedCount} from ${collection}`);
  return result;
}

// Archive old orders then delete from primary collection
async function archiveOldOrders(beforeDate) {
  // Step 1: Copy old orders to archive collection
  await db.collection('orders').aggregate([
    { $match: { createdAt: { $lt: beforeDate }, status: 'completed' } },
    { $merge: { into: 'orders_archive', whenMatched: 'keepExisting' } }
  ]).toArray();

  // Step 2: Delete them from primary collection
  const del = await db.collection('orders').deleteMany({
    createdAt: { $lt: beforeDate },
    status: 'completed'
  });
  console.log('Archived and deleted:', del.deletedCount);
}

// Atlas point-in-time restore via Atlas API or UI
// No mongosh command - done through Atlas console or API

// Using oplog to find what was deleted (expert operation)
// Connect to replica set and inspect oplog:
use local
db.oplog.rs.find({
  op: 'd',              // delete operation
  ns: 'myapp.users',   // your namespace
  wall: { : new Date(Date.now() - 3600000) }  // last hour
}).sort({ ts: -1 });
// Each entry shows the _id of the deleted document