MongoDB多lookup/unwind后无法正确分组，求解决方案

模型关系 #

• policy包含多个asset
• asset关联一个assetType
• asset包含多个field
• field关联一个fieldType

目标数据结构 #

{
  policy: {
    ..., // policy字段
    assets: [
      {
        ..., // asset字段
        assetType: {},
        fields: [
          {
            ..., // field字段
            fieldType: {},
          },
        ],
      },
    ],
  },
} 

现有聚合管道及问题 #

我编写了以下聚合管道，但分组步骤无法得到理想的嵌套结构：

mongoose.model('policy').aggregate([
  {
    $lookup: {
      from: 'assets',
      localField: 'assets',
      foreignField: '_id',
      as: 'assets',
    },
  },
  {
    $lookup: {
      from: 'assettypes',
      let: {
        id: '$assets._id',
        fields: '$assets.fields',
        name: '$assets.displayName',
        atId: '$assets.assetType',
      },
      pipeline: [
        {
          $match: {
            $expr: {
              $eq: ['$_id', '$$atId'],
            },
          },
        },
        {
          $project: {
            _id: '$$id',
            assetId: '$$id',
            assetDisplayName: '$$name',
            assetFields: '$$fields',
            type: 1,
            name: 1,
          },
        },
      ],
      as: 'assets',
    },
  },
  {
    $unwind: {
      path: '$assets',
    },
  },
  {
    $unwind: {
      path: '$assets.fields',
    },
  },
  {
    $lookup: {
      from: 'fieldtypes',
      let: {
        ftId: '$assets.fields.fieldType',
        value: '$assets.fields.value',
        ref: '$assets._id',
      },
      pipeline: [
        {
          $match: {
            $expr: {
              $eq: ['$_id', '$$ftId'],
            },
          },
        },
        {
          $addFields: {
            value: '$$value',
            assetId: '$$ref',
          },
        },
      ],
      as: 'assets.fields',
    },
  },
]) 

修正后的聚合管道 #

mongoose.model('policy').aggregate([
  // 关联policy对应的assets
  {
    $lookup: {
      from: 'assets',
      localField: 'assets',
      foreignField: '_id',
      as: 'assets'
    }
  },
  // 逐个处理asset关联对应的assetType
  {
    $set: {
      assets: {
        $map: {
          input: '$assets',
          as: 'asset',
          in: {
            $mergeObjects: [
              '$$asset',
              {
                assetType: {
                  $first: {
                    $lookup: {
                      from: 'assettypes',
                      localField: '$$asset.assetType',
                      foreignField: '_id',
                      as: 'temp'
                    }
                  }
                }
              }
            ]
          }
        }
      }
    }
  },
  // 逐个处理asset的fields关联对应的fieldType
  {
    $set: {
      assets: {
        $map: {
          input: '$assets',
          as: 'asset',
          in: {
            $mergeObjects: [
              '$$asset',
              {
                fields: {
                  $map: {
                    input: '$$asset.fields',
                    as: 'field',
                    in: {
                      $mergeObjects: [
                        '$$field',
                        {
                          fieldType: {
                            $first: {
                              $lookup: {
                                from: 'fieldtypes',
                                localField: '$$field.fieldType',
                                foreignField: '_id',
                                as: 'temp'
                              }
                            }
                          }
                        }
                      ]
                    }
                  }
                }
              }
            ]
          }
        }
      }
    }
  },
  // 包装成目标嵌套结构
  {
    $project: {
      policy: {
        $mergeObjects: [
          // 按需保留policy的其他字段，比如_id、name等
          { _id: '$_id', name: '$name' },
          { assets: '$assets' }
        ]
      }
    }
  }
])

关键修正说明 #

1. 替换错误的嵌套Lookup：原管道中错误地将整个assets数组的字段传入assetType的子管道，导致数据结构混乱。改用$map+$lookup逐个处理每个asset的关联，避免批量字段传递的问题。
2. 处理Lookup返回的数组：$lookup默认返回数组，用$first提取单个关联文档，直接嵌入目标结构。
3. 避免不必要的Unwind/Group：通过逐层嵌套的$map处理关联，不需要拆分数据后再重组，简化管道逻辑同时保障结构正确性。

内容的提问来源于stack exchange，提问作者Hani Ghazi