MongoDB CRUD — The updateOne Without $Set Data Wipe

// Connect to a local MongoDB instance using the official Node.js driver
const { MongoClient, ObjectId } = require('mongodb');

async function insertOrders() {
  const client = new MongoClient('mongodb://localhost:27017');

  try {
    await client.connect();
    const db = client.db('storefront');           // target database
    const ordersCollection = db.collection('orders'); // target collection

    // --- insertOne: single document ---
    // MongoDB auto-generates _id if you don't provide one
    const singleInsertResult = await ordersCollection.insertOne({
      customerId: 'cust_8821',
      items: [
        { productSku: 'SHOE-RED-42', quantity: 1, unitPrice: 79.99 },
        { productSku: 'LACE-BLK',   quantity: 2, unitPrice:  3.50 }
      ],
      orderStatus: 'pending',
      createdAt: new Date()                        // always store dates as Date objects, not strings
    });

    // insertedId is the ObjectId MongoDB assigned — save this, don't query for it again
    console.log('New order ID:', singleInsertResult.insertedId);

    // --- insertMany: bulk insert with ordered:false so one bad doc doesn't abort the rest ---
    const bulkOrders = [
      {
        customerId: 'cust_1103',
        items: [{ productSku: 'HAT-GRN-M', quantity: 1, unitPrice: 24.00 }],
        orderStatus: 'pending',
        createdAt: new Date()
      },
      {
        customerId: 'cust_4477',
        items: [{ productSku: 'BELT-BRN-L', quantity: 1, unitPrice: 34.50 }],
        orderStatus: 'pending',
        createdAt: new Date()
      }
    ];

    const bulkInsertResult = await ordersCollection.insertMany(bulkOrders, {
      ordered: false   // continue inserting even if one document fails validation
    });

    // insertedCount tells you how many actually landed
    console.log('Orders inserted:', bulkInsertResult.insertedCount);
    console.log('Inserted IDs:', bulkInsertResult.insertedIds);

  } finally {
    await client.close();                          // always close the connection
  }
}

insertOrders().catch(console.error);

const { MongoClient } = require('mongodb');

async function queryOrders() {
  const client = new MongoClient('mongodb://localhost:27017');

  try {
    await client.connect();
    const ordersCollection = client.db('storefront').collection('orders');

    // --- findOne: grab the first match, returns a plain object (not a cursor) ---
    const latestPendingOrder = await ordersCollection.findOne(
      { orderStatus: 'pending' },                 // filter: only pending orders
      {
        projection: { customerId: 1, items: 1, createdAt: 1, _id: 0 },  // only return these fields
        sort: { createdAt: -1 }                   // newest first
      }
    );
    console.log('Latest pending order:', latestPendingOrder);

    // --- find with range filter: orders created in the last 7 days ---
    const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);

    const recentOrders = await ordersCollection
      .find(
        {
          createdAt: { $gte: sevenDaysAgo },       // $gte = greater than or equal to
          orderStatus: { $in: ['pending', 'processing'] }  // $in matches any value in the array
        },
        {
          projection: { customerId: 1, orderStatus: 1, createdAt: 1 }
        }
      )
      .sort({ createdAt: -1 })
      .limit(25)                                  // ALWAYS limit open-ended queries in production
      .toArray();                                 // materialise the cursor into an array

    console.log(`Found ${recentOrders.length} recent orders`);
    recentOrders.forEach(order => {
      console.log(`  ${order.customerId} — ${order.orderStatus} — ${order.createdAt.toISOString()}`);
    });

    // --- countDocuments: how many total pending orders exist? ---
    // Use countDocuments() NOT count() — count() is deprecated and ignores filters in some edge cases
    const pendingTotal = await ordersCollection.countDocuments({ orderStatus: 'pending' });
    console.log('Total pending orders:', pendingTotal);

  } finally {
    await client.close();
  }
}

queryOrders().catch(console.error);

const { MongoClient, ObjectId } = require('mongodb');

async function updateOrders() {
  const client = new MongoClient('mongodb://localhost:27017');

  try {
    await client.connect();
    const ordersCollection = client.db('storefront').collection('orders');

    // --- updateOne with $set: change a single order's status ---
    // ALWAYS use $set — without it, your whole document gets replaced
    const targetOrderId = new ObjectId('64f3a2b1c9e77f001a3d8e12');

    const statusUpdateResult = await ordersCollection.updateOne(
      { _id: targetOrderId },                         // filter: match by exact _id
      {
        $set: {
          orderStatus: 'dispatched',
          dispatchedAt: new Date()                    // add a new field on the fly — no schema migration needed
        }
      }
    );

    console.log('Documents matched:', statusUpdateResult.matchedCount);   // how many matched the filter
    console.log('Documents modified:', statusUpdateResult.modifiedCount); // how many were actually changed

    // --- $inc: atomically decrement stock without a read-modify-write ---
    // This is safe under concurrent writes; plain read+write is NOT
    const inventoryCollection = client.db('storefront').collection('inventory');

    await inventoryCollection.updateOne(
      { productSku: 'SHOE-RED-42' },
      { $inc: { stockCount: -1 } }                   // subtract 1 from stockCount atomically
    );

    // --- upsert: create a shipment record if it doesn't exist, update if it does ---
    const shipmentResult = await client.db('storefront').collection('shipments').updateOne(
      { orderId: targetOrderId },                    // filter: does a shipment for this order exist?
      {
        $set: {
          orderId: targetOrderId,
          carrier: 'FastFreight',
          trackingNumber: 'FF-993821-XZ',
          estimatedDelivery: new Date('2024-09-05')
        }
      },
      { upsert: true }                               // create it if it doesn't exist
    );

    // upsertedId is non-null only when a new document was created
    if (shipmentResult.upsertedId) {
      console.log('Shipment record created with ID:', shipmentResult.upsertedId);
    } else {
      console.log('Existing shipment record updated');
    }

    // --- updateMany: mark all orders older than 30 days as 'archived' ---
    const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);

    const archiveResult = await ordersCollection.updateMany(
      { createdAt: { $lt: thirtyDaysAgo }, orderStatus: 'dispatched' }, // tight filter!
      { $set: { orderStatus: 'archived', archivedAt: new Date() } }
    );

    console.log(`Archived ${archiveResult.modifiedCount} old orders`);

  } finally {
    await client.close();
  }
}

updateOrders().catch(console.error);

const { MongoClient, ObjectId } = require('mongodb');

async function deleteOrders() {
  const client = new MongoClient('mongodb://localhost:27017');

  try {
    await client.connect();
    const db = client.db('storefront');
    const ordersCollection = db.collection('orders');

    // --- PATTERN 1: Soft delete (recommended for business data) ---
    // Don't physically remove — mark as deleted so you keep the audit trail
    const orderToSoftDelete = new ObjectId('64f3a2b1c9e77f001a3d8e13');

    await ordersCollection.updateOne(
      { _id: orderToSoftDelete },
      {
        $set: {
          isDeleted: true,
          deletedAt: new Date()    // lets you audit WHEN it was deleted and query "deleted in last 30 days"
        }
      }
    );
    console.log('Order soft-deleted (record preserved for audit)');

    // --- PATTERN 2: Hard delete with deleteOne ---
    // Appropriate for test data, temp records, or GDPR erasure requests
    const tempOrderId = new ObjectId('64f3a2b1c9e77f001a3d8e14');

    const hardDeleteResult = await ordersCollection.deleteOne({ _id: tempOrderId });
    console.log('Hard-deleted document count:', hardDeleteResult.deletedCount);
    // deletedCount will be 0 if the _id didn't exist — not an error, just a miss

    // --- PATTERN 3: findOneAndDelete — atomic claim-and-remove for job queues ---
    const jobsCollection = db.collection('pendingEmailJobs');

    // Grab the highest-priority job AND remove it in one atomic step
    // If two workers call this simultaneously, only one gets the document
    const claimedJob = await jobsCollection.findOneAndDelete(
      { status: 'queued' },
      {
        sort: { priority: -1, queuedAt: 1 },  // highest priority, then FIFO
        returnDocument: 'before'              // return the document as it was before deletion
      }
    );

    if (claimedJob) {
      console.log('Worker claimed job:', claimedJob.jobId, '| Recipient:', claimedJob.recipientEmail);
    } else {
      console.log('No jobs in queue right now');
    }

    // --- PATTERN 4: deleteMany for bulk cleanup (always preview first!) ---
    // Step 1: preview — what would get deleted?
    const toDeleteCount = await ordersCollection.countDocuments({
      isDeleted: true,
      deletedAt: { $lt: new Date(Date.now() - 90 * 24 * 60 * 60 * 1000) } // older than 90 days
    });
    console.log(`About to permanently purge ${toDeleteCount} soft-deleted orders...`);

    // Step 2: execute only when you're sure
    const purgeResult = await ordersCollection.deleteMany({
      isDeleted: true,
      deletedAt: { $lt: new Date(Date.now() - 90 * 24 * 60 * 60 * 1000) }
    });
    console.log('Purged:', purgeResult.deletedCount, 'old orders');

  } finally {
    await client.close();
  }
}

deleteOrders().catch(console.error);

const { MongoClient } = require('mongodb');

async function insertWithRetry(collection, doc, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      // Set high writeConcern for critical data
      const result = await collection.insertOne(doc, {
        writeConcern: { w: 'majority', j: true }
      });
      return result;
    } catch (err) {
      // Differentiate transient vs permanent
      if (err.code === 11000) {
        // Duplicate key — permanent, log and abort
        console.error('Duplicate key for doc:', JSON.stringify(doc));
        throw err;  // Re-throw for caller to handle
      }
      if (err.hasErrorLabel('TransientTransactionError') || err.message.includes('timeout')) {
        // Transient — retry with backoff
        if (attempt === maxRetries) {
          console.error('Max retries reached, write failed');
          throw err;
        }
        const delay = Math.pow(2, attempt) * 100;  // 200ms, 400ms, 800ms
        console.log(`Retrying write, attempt ${attempt + 1} after ${delay}ms`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        // Other permanent error
        throw err;
      }
    }
  }
}