Joins with $lookup

db.orders.aggregate([
  { $lookup: {
      from: 'customers',          // the other collection
      localField: 'customerId',   // field in orders
      foreignField: '_id',        // field in customers
      as: 'customer'              // name of the new array field
  } }
])

• The result always adds an array, even when only one document matches.
• To turn a single match into a plain field, follow with $unwind: '$customer', or use $set: { customer: { $first: '$customer' } }.
• Documents without matches get an empty array, so they're kept, like a left outer join. Filter them out with { $match: { customer: { $ne: [] } } } if you only want matches.
• If localField is an array of ids, $lookup matches every id in it.

For extra conditions, sorting, limits or projections on the joined documents, use let and pipeline:

{ $lookup: {
    from: 'orders',
    localField: '_id',
    foreignField: 'customerId',
    pipeline: [
      { $match: { status: 'paid' } },
      { $sort: { total: -1 } },
      { $project: { _id: 0, total: 1 } }
    ],
    as: 'paidOrders'
} }

You can combine localField/foreignField with a pipeline (MongoDB 5.0+), or use let to pass variables into the pipeline and compare them with $expr for more complex matches.

• Index the foreignField in the joined collection. Without an index, every lookup scans the whole collection, once for every input document.
• Put $match, $sort and $limit before $lookup, so only the documents you'll actually show are joined.
• Return only needed fields from the joined collection with a pipeline and $project.
• $graphLookup follows references recursively, for hierarchies such as categories or an organisation chart.

A frequent request is "list customers with how many orders each has placed". Because $lookup always produces an array, its size is the count, and array expressions work on the joined documents directly:

db.customers.aggregate([
  { $lookup: { from: 'orders', localField: '_id', foreignField: 'customerId', as: 'orders' } },
  { $project: { _id: 0, name: 1, orders: { $size: '$orders' }, spent: { $sum: '$orders.total' } } }
])
// { name: 'Ada', orders: 2, spent: 12 }, { name: 'Bob', orders: 0, spent: 0 }

Customers without orders still appear, with 0, because $lookup keeps unmatched documents. When customers have thousands of orders each, avoid pulling all of them in just to count them: put { $count: 'n' } inside a pipeline lookup so only one small document per customer comes back.

When localField is an array of ids, keep in mind that the joined array does not follow the order of your ids. A post with tagIds: ['c', 'a', 'b'] can come back with its tags as a, b, c. Ids that don't exist are silently missing from the result, too. If the order matters, such as a hand-picked list of related products, rebuild it from the original array:

{ $set: { tags: { $map: {
    input: '$tagIds', as: 'id',
    in: { $first: { $filter: { input: '$tags', cond: { $eq: ['$$this._id', '$$id'] } } } }
} } } }

$map walks your ids in their stored order and picks the matching joined document for each. Missing ids become null, which you can remove with another $filter.