How to merge multiple $group into $project in aggregate mongodb?

I am using aggregate to query data in MongoDB but I have an issue with $group, I want to merge multiple $group stage to one $project at final but look like it doesn't seem to works as my expected. In the code below when I am excute it I don't get any results except _id. How can I resolve this issue?

Here is my aggregate pipelines:

const user = userCollection.aggregate([
{
$match: {
_id: ObjectId(id)
}
},
// lookup images list
{
$lookup: {...}
},
{
$unwind: {
path: '$images',
preserveNullAndEmptyArrays: true,
},
},
{ $sort: { 'images.createdAt': -1 } },
{
$group: {
_id: '$_id',            
images: {
$push: '$images',
},
},
},
// lookup blocked list
{
$lookup: {...}
},
{
$unwind: {
path: '$blocked',
preserveNullAndEmptyArrays: true,
},
},
{ $sort: { 'blocked.createdAt': -1 } },
{
$group: {
_id: '$_id',            
blocked: {
$push: '$blocked',
},
},
},
// lookup followers list
{
$lookup: {...}
},
{
$unwind: {
path: '$followers',
preserveNullAndEmptyArrays: true,
},
},
{ $sort: { 'followers.createdAt': -1 } },
{
$group: {
_id: '$_id',            
followers: {
$push: '$followers',
},
},
},
{
$project: {
_id: 1,
name: 1,
age: 1,
bio: 1,
images: 1,
blocked: 1,
followers: 1,
}
}
]);
console.log(user);
// Results: [{ _id: '...' }, { _id: '...' }, { _id: '...' }, { _id: '...' }]

A general guideline to keep in mind is that the the following sequence to process arrays is an anti-pattern:

1. $unwind
2. Processing the unwound array, eg filtering it with $match or $sorting it
3. $grouping the data back together using `_id: '$_id'

Anytime you see that you should try to look around for other operators that can process the arrays inline without having to deconstruct and then reconstruct the documents.

In your situation, I'd look to do something similar to the following:

[
{ $match: { ... } },
{ $lookup: { ... as: 'images' } },
{ $lookup: { ... as: 'blocked' } },
{ $lookup: { ... as: 'followers' } },
{
$project: {
_id: 1,
name: 1,
age: 1,
bio: 1,
images: {
$sortArray: { input: "$images", sortBy: { createdAt: -1 } }
},
blocked: {
$sortArray: { input: "$blocked", sortBy: { createdAt: -1 } }
},
followers: {
$sortArray: { input: "$followers", sortBy: { createdAt: -1 } }
},
}
}
]

Specifically we are using the $sortArray operator in the final $project stage to do the array processing that was mentioned.

A simple demonstration of $sortArray can be found in this playground example.

Alternatively, either if on a version prior to that operator becoming available or if additional logic is required, you could consider using this $lookup syntax:

[
...
{ $lookup: 
{
from: 'images',
localField: 'imageField',
foreignField: 'imageField',
pipeline: [
{ $sort: { createdAt: -1 } }
]
as: 'images'
} 
},
...
]