mongo aggregate based on conditions to filter the document for versioning

Update based on comment:

but the UUIDs are alphanumeric strings, as shown above, does it have an effect on these sorting, and since we are not using conditions to get the results, I am worried it will cause issues.

You could use additional field to match the sort order to be the same order as values in the in expression. Make sure you provide the values with default as the last value.

[
  {"$match":{"jobUuid":{"$in":["d275781f-ed7f-4ce4-8f7e-a82e0e9c8f12","default"]}}},
  {"$addFields":{ "order":{"$indexOfArray":[["d275781f-ed7f-4ce4-8f7e-a82e0e9c8f12","default"], "$jobUuid"]}}},
  {"$sort":{"uuid":1, "order":1}},
  {
    "$group": {
      "_id": "$uuid",
      "doc":{"$first":"$$ROOT"}
    }
  },
  {"$project":{"doc.order":0}},
  {"$replaceRoot":{"newRoot":"$doc"}}
]

example here - https://mongoplayground.net/p/wXiE9i18qxf

Original

You could use below query. The query will pick the non default document if it exists for uuid or else pick the default as the only document.

[
  {"$match":{"jobUuid":{"$in":[1,"default"]}}},
  {"$sort":{"uuid":1, "jobUuid":1}},
  {
    "$group": {
      "_id": "$uuid",
      "doc":{"$first":"$$ROOT"}
    }
  },
  {"$replaceRoot":{"newRoot":"$doc"}}
]

example here - https://mongoplayground.net/p/KrL-1s8WCpw

Here is what I would do:

1. match stage with $in rather than an $or (for readability)
2. group stage with _id on $uuid, just as you did, but instead of pushing all the data into an array, be more selective. _id is already storing $uuid, so no reason to capture it again. name must always be the same for each $uuid, so take only the first instance. Based on the match, there are only two possibilities for jobUuid, but this will assume it will be either "default" or something else, and that there can be more than one occurrence of the non-"default" jobUuid. Using "$addToSet" instead of pushing to an array in case there are multiple occurrences of the same jobUuid for a user, also, before adding to the set, use a conditional to only add non-"default" jobUuids, using $$REMOVE to avoid inserting a null when the jobUuid is "default".
3. Finally, "$project" to clean things up. If element 0 of the jobUuids array does not exist (is null), there is no other possibility for this user than for the jobUuid to be "default", so use "$ifNull" to test and set "default" as appropriate. There could be more than 1 jobUuid here, depending if that is allowed in your db/application, up to you to decide how to handle that (take the highest, take the lowest, etc).

Tested at: https://mongoplayground.net/p/e76cVJf0F3o

[{
    "$match": {
        "jobUuid": {
            "$in": [
                "1",
                "default"
            ]
        }
    }
},
{
    "$group": {
        "_id": "$uuid",
        "name": {
            "$first": "$name"
        },
        "jobUuids": {
            "$addToSet": {
                "$cond": {
                    "if": {
                        "$ne": [
                            "$jobUuid",
                            "default"
                        ]
                    },
                    "then": "$jobUuid",
                    "else": "$$REMOVE"
                }
            }
        }
    }
},
{
    "$project": {
        "_id": 0,
        "uuid": "$_id",
        "name": 1,
        "jobUuid": {
            "$ifNull": [{
                    "$arrayElemAt": [
                        "$jobUuids",
                        0
                    ]
                },
                "default"
            ]
        }
    }
}]

I was able to solve this problem with the following aggregate query,

• We are first extracting the results matching only the jobUuid provided by the user or the "default" in the match section.

• Then the results are grouped based on the uuid, using a group stage and we are counting the results as well.

• Using the conditions in replaceRoot first we are checking the length of the grouped document,

• If the grouped document length is greater than or equal to 2, we are filtering the document that matches the provided jobUuid.

• If it's less or equal to the 1, then we are checking if it's matching the default jobUuid and returning it.

The Query is below:

[
    {
      $match: {
        $or: [{ jobUuid:1 },{ jobUuid: 'default'}]
      }
    },
    {
      $group: {
        _id: '$uuid',
        count: {
          $sum: 1
        },
        docs: {
          $push: '$$ROOT'
        }
      }
    },
    {
      $replaceRoot: {
        newRoot: {
          $cond: {
            if: {
              $gte: [
                '$count',
                2
              ]
            },
            then: {
              $arrayElemAt: [
                {
                  $filter: {
                    input: '$docs',
                    as: 'item',
                    cond: {
                      $ne: [
                        '$$item.jobUuid',
                        'default'
                      ]
                    }
                  }
                },
                0
              ]
            },
            else: {
              $arrayElemAt: [
                {
                  $filter: {
                    input: '$docs',
                    as: 'item',
                    cond: {
                      $eq: [
                        '$$item.jobUuid',
                        'default'
                      ]
                    }
                  }
                },
                0
              ]
            }
          }
        }
      }
    }
  ]