MongoDB $replaceWith Stage

db.developers.drop()
db.sales.drop()
db.orders.drop()

db.developers.insertMany([
  { _id: 1, name: { first: "Grace", last: "Hopper"  }, lang: "COBOL" },
  { _id: 2, name: { first: "John",  last: "Backus"  }, lang: "Fortran" },
  { _id: 3, lang: "Python", note: "Missing name object" }
])

db.sales.insertMany([
  { _id: 1, item: "butter",  price: 10, quantity: 2, status: "C", date: ISODate("2025-03-01T08:00:00Z") },
  { _id: 2, item: "cream",   price: 20, quantity: 1, status: "A", date: ISODate("2025-03-01T09:00:00Z") },
  { _id: 3, item: "jam",     price: 5,  quantity: 10, status: "C", date: ISODate("2025-03-15T09:00:00Z") },
  { _id: 4, item: "muffins", price: 5,  quantity: 10, status: "C", date: ISODate("2025-03-15T09:00:00Z") }
])

db.orders.insertMany([
  {
    _id: 1,
    customer: "Acme Corp",
    items: [
      { sku: "WGT-01", qty: 3, price: 29.99 },
      { sku: "WGT-02", qty: 1, price: 49.99 }
    ]
  },
  {
    _id: 2,
    customer: "Beta LLC",
    items: [
      { sku: "LMP-01", qty: 2, price: 19.99 }
    ]
  }
])

db.developers.aggregate([
  {
    $replaceWith: {
      $ifNull: [
        {
          $mergeObjects: [
            { _id: "$_id", lang: "$lang" },
            "$name"
          ]
        },
        { _id: "$_id", lang: "$lang", first: "", last: "", missingName: true }
      ]
    }
  },
  { $sort: { last: 1 } }
])

// Grace Hopper → { _id: 1, lang: "COBOL", first: "Grace", last: "Hopper" }
// Doc 3 (no name) → fallback with missingName: true — no pipeline error
// Shorter than: $replaceRoot: { newRoot: { ... } }

db.sales.aggregate([
  { $match: { status: "C" } },
  {
    $replaceWith: {
      _id: "$_id",
      item: "$item",
      amount: { $multiply: ["$price", "$quantity"] },
      status: "Complete",
      asofDate: "$$NOW"
    }
  },
  { $sort: { amount: -1 } }
])

// status "C" → completed; "A" excluded by $match
// amount = price × quantity (replaces separate price/qty fields)
// asofDate stamped at pipeline run time

db.orders.aggregate([
  { $unwind: "$items" },
  {
    $replaceWith: {
      $mergeObjects: [
        "$items",
        {
          orderId: "$_id",
          customer: "$customer",
          lineTotal: {
            $multiply: ["$items.qty", "$items.price"]
          }
        }
      ]
    }
  },
  { $sort: { orderId: 1, sku: 1 } }
])

// Each line item becomes its own top-level document
// orderId + customer merged from parent (lost on bare "$items")
// lineTotal computed at replace time

// Same result — $replaceWith (shorter)
db.developers.aggregate([
  { $match: { "name.first": { $exists: true } } },
  {
    $replaceWith: {
      $mergeObjects: ["$name", { _id: "$_id", language: "$lang" }]
    }
  }
])

// Same result — $replaceRoot (explicit newRoot)
db.developers.aggregate([
  { $match: { "name.first": { $exists: true } } },
  {
    $replaceRoot: {
      newRoot: {
        $mergeObjects: ["$name", { _id: "$_id", language: "$lang" }]
      }
    }
  }
])

// Prefer $replaceWith in new pipelines
// Use $match first when some docs lack the nested field