tl;博士

简短的回答

您可以使用聚合方法来实现您打算做的事情，我将尝试尽可能详细地向您解释这一点。但这将是一个相当长的解释。

注意：此处公开的方法适用于 MongoDB 4.0 或更高版本。

我将使用聚合方法，分阶段执行任务，直到达到预期的结果。您可以在MongoDB文档中阅读有关聚合的更多信息。

使用您的问题中提供的数据作为模型，我们将编写一个聚合方法，当请求对用户进行更改时，我们将执行该方法，就像您在路由中所拥有的那样。

使用聚合 API 时的主要区别之一是它将返回一个Array包含简单 JSON 文档的文件，然后您可以在仍然需要时对其进行修改。另一方面，Queries对模型进行的查询 ( ) 返回模型的一个实例（在本例中为Mongoose 文档），以及它的方法和属性。

使用聚合：

const id:String = req.params.id;

// CREAMOS la agregación:
// la llameré aggregateByArea porque la misma realizará un $lookup sobre la colección 'areas'

const aggregateByArea = UserModel.aggregate([
    {
      $match: {
          _id: mongoose.Types.ObjectId(id)
      }
    },
    {
      $project: {
        modification: {
          $map: {
            input: '$modification',
            as: 'mod',
            in: {
              'user': '$$mod.user',
              'date': '$$mod.date',
              'updated': {
                $map: {
                  input: '$$mod.updated',
                  as: 'item',
                  in: {
                    $convert: {
                      input: '$$item',
                      to: 'objectId',
                      onError: '$$item'
                    }
                  }
                }
              }
            }
          }
        }
      }
    },
    { $unwind: '$modification'},
    {
      $lookup: {
        from: 'users',
        localField: 'modification.user',
        foreignField: '_id',
        as: 'user'
      }
    },
    {
      $lookup: {
        from: 'areas',
        localField: 'modification.updated',
        foreignField: '_id',
        as: 'updated'
      }
    },
    {
      $project: {
        modification: {
          user: {
            $arrayElemAt: ['$user', 0]
          },
          date: 1,
          updated: {
            $map: {
              input: '$modification.updated',
              as: 'item',
              in: {
                $let: {
                  vars: {
                    from: {
                      $arrayElemAt: ['$updated', 0]
                    },
                    to: {
                      $arrayElemAt: ['$updated', 1]
                    }
                  },
                  in: {
                    $cond: [
                      {
                        $eq: ['$$item', '$$from._id']
                      },
                      '$$from.name',
                      {
                        $cond: [
                          {
                            $eq: ['$$item', '$$to._id']
                          },
                          '$$to.name',
                          '$$item'
                        ]
                      }
                    ]
                  }
                }
              }
            }
          }
        }
      }
    },
    {
      $sort: {
        'modification.date': 1
      }
    },
    {
      $project: {
        modification: {
          date: 1,
          user: {
            name: 1,
            last_name: 1
          },
          updated: 1
        }
      }
    },
    {
      $group: {
        _id: '$_id',
        modification: {
          $push: '$modification'
        }
      }
    }
]);

// USAMOS la agregación, ejecutando el método 'exec()'

aggregateByArea.exec((err: any, results: any) => {
    if(err) {
      return res.status(500).json({error: err.message});
    }
    if(!results.length) { // el método aggregate devuelve un array con los resultados
      return res.status(404).json({ message: 'Not found'});
    }
    return res.status(200).json({results});
});

一开始可能有点吓人，但是一旦我们理解了阶段和管道的概念，作为MongoDB 聚合过程的一部分，它就很容易了。

这样，文件将Array根据您的问题要求如您所愿地返回。

长答案

简短回答说明

我反对这样的答案：复制粘贴这个解决方案，所以我会分阶段解释聚合方法，以便您了解我们在做什么。

阶段$match：

id第一阶段接收我们要在其上执行聚合过程的用户文档作为参数。需要注意的是，Mongoose 聚合 API在管道阶段不执行cast数据类型转换，这就是我们将使用从String返回req.params.id类型ObjectId转换为 Mongo 类型的原因。

此阶段返回其字段_id与我们作为参数传递的值匹配的文档。可以等同于方法findById(id)。

_id: mongoose.Types.ObjectId(id) //<= se realiza la conversión usando mongoose.Types.ObjectId(str)

阶段$project：

在这个阶段，我们将创建我们想要的文档的基本结构。在这种情况下，我将您在问题中提出的内容作为参考。

由于该字段是modificationtype Array，为了使用它，我们将使用 operator $map，它迭代我们数组的每个元素。

对于数组的每个元素，我将指出我想要返回的字段。因此，如果我想要该字段user，我必须将其表示为：

'user': '$$mod.user',

在这个阶段，关键是我们如何处理字段updated，它是一个类型Array。

在所述字段上，我们将使用运算符$map并将每个item（如果可能）转换为 type ObjectId。为此，我们将使用运算符$convert。

笔记

该运算符$convert仅在 MongoDB 4.0 或更高版本中可用。

我们要做的是尝试将 的每个值转换updated为 ObjectId 类型。我说尝试是因为并非我们数组中的所有值都是可以转换为ObjectIdMongo 类型的有效字符串。

考虑到该字段updated包含类似于以下的值：

[ 'area', '5d144642416ada46385d01b8', '5d144681416ada46385d01b9', 'Área'];

String很明显，我们数组的第一个和最后一个元素不是要转换为的有效值ObjectId。这就是我们使用onErroroperator 属性的原因$convert，它允许我们在转换过程中出现错误时返回一个值：

$convert: {
    input: '$$item',   //<- Elemento a convertir
    to: 'objectId',    //<- Tipo al que será convertido
    onError: '$$item'  //<- Elemento a devolver en caso de error
}

现在该字段updated将具有以下结构：

[ 'area', ObjectId('5d144642416ada46385d01b8'), ObjectId('5d144681416ada46385d01b9'), 'Área'];

为什么我们将类型转换String为类型ObjectId？

这个问题的答案在舞台上给出$lookup。

阶段$unwind：

这个阶段将使我们在处理数组数据时变得更容易modification。这个阶段所做的是为我们数组中存在的每个元素创建一个文档，并将该字段modification转换为 type document。

由于在看到结果之前很难理解该过程，因此我将留下一些可以澄清发生了什么的图像：

在执行阶段之前$unwind，我们的聚合如下图所示：

我们可以注意到只有一个文档包含该字段中的所有修改数据modification。

执行 step$unwind时，结果如下：

Ahora claramente podemos observar que se han creado 3 documentos (1 por cada elemento del campo modification), además, el campo modification pasó de ser un tipo Array a ser un campo que contiene un documento.

Ahora podremos trabajar sin problemas sobre el campo updated de cada documento.

Etapa $lookup:

En esta etapa lo que hacemos es algo parecido al JOIN de SQL. La idea es traer los datos de otra colección (aunque la misma no tenga una referencia directa con la que estamos procesando). Para ello debemos establecer el campo por el cual deseamos hacer la referencia.

Aquí cobra importancia la primera etapa de $project y la etapa de $unwind, ya que vamos a buscar datos de la colección areas usando como campo de referencia los valores ObjectId del campo updated (el cual es un tipo Array). Además, haremos una etapa $lookup adicional para traer los datos de la colección users (si entiendo bien el propósito del campo modification: se almacena el _id del usuario que realizó la modificación).

{
  $lookup: {
    from: 'areas', // <= Colección desde donde se extrae la data
    localField: 'modification.updated',  // <= valor sobre el que se va a realizar el lookup
    foreignField: '_id', // <= Campo de la colección externa sobre el que se realizará el lookup
    as: 'updated' // <= Nombre del nuevo campo que contendrá los resultados del lookup
  }
}

Siendo que modification.updated es un campo de tipo Array, el proceso de $lookup se llevará a cabo sobre cada elemento de dicho Array, cada documento devuelto por $lookup será añadido a un Array llamado updated que es el nombre que le hemos pasado como valor al atributo as.

Un ejemplo de nuestro documento hasta este momento sería el siguiente:

Como se aprecia en la imagen (sólo se muestra el primer documento), se han añadido 2 campos: user y updated, ambos contienen documentos de las colecciones users y areas que corresponden a los _id sobre los que se ha hecho el $lookup. Para este ejemplo, el modelo Area es muy básico, solo contiene el campo name, nuestro modelo User también es básico para usarlo en este ejemplo.

Segunda etapa $project

Ahora que ya tenemos los datos que necesitamos, pasaremos a la siguiente etapa. En esta, vamos a construir lo que se convertirá en nuestro documento final.

Tal vez visualmente esta etapa es muy compleja, pero lo cierto es que los procesos que allí se realizan son muy sencillos.

En la primera parte de la etapa declaramos el campo modification e incluimos dentro del mismo los siguientes valores:

user: {
  $arrayElemAt: ['$user', 0]
}

Debemos recordar que el campo user agregado en la etapa anterior es un tipo Array que contiene los documentos encontrados al realizar la búsqueda sobre el campo _id. Es por ello que se usa el operador $arrayElemAt al cual se le pasa como parámetro la ruta del Array ($user) y la posición del elemento que queremos obtener (en este caso el primer elemento). esto nos devolverá el documento que contiene los datos del usuario, algo equiparable al método populate() de Mongoose.

date: 1,

Esto indica que se incluirá el campo date que hemos venido agregando en cada etapa.

Por último, crearemos un campo llamado updated que contendrá los valores nuevos que hemos obtenido en la etapa de $lookup.

La construcción la haremos usando el operador $map, ya que el campo updated es de tipo Array.

El Array de entrada será el que hemos modificado en nuestra primera etapa de $project, el cual contiene la siguiente estructura:

['area', ObjectId('5d144642416ada46385d01b8'), ObjectId('5d144681416ada46385d01b9'), 'Área'];

Luego definiremos 2 variables:

from: { $arrayElemAt: ['$updated', 0]},
to: { $arrayElemAt: ['$updated', 1]}

Las mismas hacen referencia a los 2 documentos del campo updated que hemos creado durante la etapa de $lookup. La idea es comparar el valor de ObjectId del Array de origen con el valor de ObjectId del documento que hemos llenado de la colección areas.

Una vez establecidas nuestras variables realizaremos un retorno condicional, es decir, retornaremos un valor de acuerdo a si se cumple una condición o no. Para ello usaremos el operador $cond, usando la siguiente sintaxis:

{ $cond: [ <boolean-expression>, <true-case>, <false-case> ] }

Nuestra expresión booleana será:

{ $eq: ['$$item', '$$from._id']}

Donde $$item se refiere al valor del iterando de nuestro Array de entrada, y $$from._id será el valor del campo _id de nuestro primer elemento.

Si hay coincidencia devolvemos el valor de $$from.name, de lo contrario pasamos a la siguiente parte del condicional, donde realizaremos nuevamente una operación de comparación condicional para determinar si se devuelve el valor de $$to.name o simplemente devolvemos el valor de $item.

Una vez realizadas todas estas tareas, el campo updated debe tener la siguiente estructura:

['area', 'Sistemas', 'Recursos Humanos', 'Área'];

Que es la estructura deseada.

Nota: Se puede hacer la asignación de forma directa, ya que en teoría el orden en que aparecen es el mismo y la comparación sería innecesaria. Sin embargo, para este ejemplo he decidido realizar las cosas mostrando un poco las capacidades que tenemos al usar un método de agregación. Aunque eso significa escribir un poco más de código.

Etapa $sort:

Hasta ahora ya tenemos la estructura armada de nuestro documento, ahora vamos a ordenarla usando el campo modification.date en orden ascendente (fecha más antigua hacia la más reciente).

{ $sort: { 'modification.date': 1 }},

Tercera etapa $project:

En esta tercera y última etapa $project, vamos a sanitizar o sanear los datos que deseamos mostrar en el campo user. Hasta ahora se muestran todos los campos del documento, pero deseamos mostrar solamente los campos _id, name y last_name. Es por ello que escribimos lo siguiente:

user: {
  name: 1,
  last_name: 1
},

En donde le indicamos a MongoDB que deseamos sólo el campo name y el campo last_name. El campo _id siempre se incluirá a menos que escribamos explícitamente: _id: 0.

Etapa $group:

Esta será nuestra última etapa. Recordemos que durante la agregación separamos los documentos en tantos ítems como elementos tuviera el campo modification. Ahora es tiempo de reagrupar todos estos documentos, en uno solo y convertir nuevamente el campo modification en un Array, tal como aparece el documento original.

Dado que todos los documentos creados en la etapa $unwind corresponden al mismo _id de usuario, usaremos dicho campo como _id de nuestra agrupación:

{ $group: { _id: '$_id', modification: { $push: '$modification' }}}

En esta etapa le estamos diciendo a MongoDB que agrupe todos los documentos que contengan el mismo campo _id, y que en dicha agrupación, cree un campo llamado modification que será de tipo Array ya que usaremos el operador $push, para insertar cada valor del campo modification de cada uno de los documentos que estamos agrupando.

Dado que todos los documentos tienen el mismo _id, el resultado será un documento único, que contiene un campo de tipo Array cuyos elementos se corresponden con los cambios realizados sobre el usuario, y donde hemos agregado los datos del usuario que realizó los cambios y además hemos cambiado los valores de id de área por el nombre del área.

Ejemplo de agregación antes de realizar la etapa de $group:

Se puede apreciar que la agregación devuelve varios documentos, todos tienen el mismo valor para el campo _id.

Ejemplo de agregación después de realizar la etapa de $group:

Ahora se aprecia que la agregación devuelve un solo documento donde el campo modification es un tipo Array, cuyos elementos se corresponden con cada modificación realizada sobre el usuario.

RECOMENDACIONES FINALES

Una de las recomendaciones que puedo hacerte es que escribas la agregación como un método del modelo. De esta forma, puedes usarlo desde cualquier otro método en que lo necesites y así no tienes que repetir nada de código, sólo la llamada.

Puedes consultar la documentación sobre métodos de instancia de Mongoose, para mayor información, o consultar la API de mongoose sobre métodos de Schema.

Por ejemplo podrías hacer lo siguiente en tu modelo:

user.model.js

import mongoose from 'mongoose'
import validator from 'mongoose-unique-validator'

const UserSchema = new mongoose.Schema({
  // Defines tu modelo
});

UserSchema.methods = {
  getModByArea: function(id) {
    return this.model('User').aggregate([
      // aquí va el documento de agregación que usamos al principio.
      // Recuerda siempre que el documento de agregación va dentro de un array
      // por ello se abre el método usando 'aggregate(['
    ]);
  }
}

Luego, para usar la agregación puedes hacer lo siguiente:

UserChangesRoute.get( '/:id', ( req: Request, res: Response ) => {
  const id:String = req.params.id;
  User.findById(id, (error,user) => { //realizamos la búsqueda en la DB para asegurarnos que el usuario existe
    if(error) {
      return res.status(500).json({error: error.message});
    }
    if(!user) {
      return res.status(404).json({ message: 'Not found'});
    }
    const modificationByArea = user.getModByArea(user._id); // <- Se llama al método de la instancia
    getModByArea.exec((err, results) => {
      if(err) {
        return res.status(500).json({error: err.message});
      }
      return res.status(200).json({results});
    });
  });
});

De esta forma tienes todo centralizado en el modelo User. Además, así como has escrito una agregación para area, puedes escribirla para roles y jefes, etc. Siempre que el valor de update cumpla el formato especificado. Sólo cambias el valor de la colección sobre la que harás el $lookup.

Incluso puedes hacer una agregación que te devuelva todo, haciendo varias etapas $lookup, una por cada colección sobre la que desees obtener la información.

Por ejemplo:

{
  $lookup: {
    from: 'areas',
    localField: 'modification.updated',
    foreignField: '_id',
    as: 'areas'
  }
},
{
  $lookup: {
    from: 'roles',
    localField: 'modification.updated',
    foreignField: '_id',
    as: 'roles'
  }
},
{
  $lookup: {
    from: 'jefes',
    localField: 'modification.updated',
    foreignField: '_id',
    as: 'jefes'
  }
}

Como puedes ver, he encadenado varias etapas $lookup, cada una apunta a una colección diferente, luego debes ir refactorizando el código según sea necesario.

La ventaja de usar la agregación sobre lo que intentabas hacer (realizando una consulta a la DB por cada id en el campo updated), es que la agregación implica una sola llamada a la base de datos, todos los procesos se realizan del lado del motor de base de datos, y en teoría serán más rápidos que realizar el proceso manualmente desde tu aplicación.

假设一个用户在修改字段中有 10 个（可以说很少）条目，这意味着您必须向数据库发出 20 个请求（每个条目 2 个）才能获取与id每个条目关联的字段名称的信息。入口。这根本不切实际，不计算你必须做的链接，或者使用async能够await与 DB 调用一起使用的函数。

我希望这可以解决您的问题，并帮助您稍微了解聚合的世界。