tl;dr

SHORT ANSWER

You can achieve what you set out to do using an aggregation method, I'll try to explain this to you in as much detail as possible. But it will be quite a long explanation.

Note : The method exposed here works on MongoDB 4.0 or higher.

I will use an aggregation method, which will carry out the task in stages, until the desired result is achieved. You can read more about aggregation in the MongoDB documentation .

Using the data provided in your question as a model, we are going to write an aggregation method that we will execute when the request for changes made to a user is made, as you have it in your route.

One of the main differences when using the aggregation API is that it will return a Arraycontaining simple JSON documents, which you can then modify if you still need it. On the other hand, the queries ( Queries) made on the model, return an instance of the model (a Mongoose document in this case), and as such its methods and properties.

Using Aggregation:

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});
});

It can be a bit intimidating at first, however it is very easy once we understand the concepts of stages and pipeline , as part of the MongoDB Aggregation process .

In this way, the documents are returned Arrayas you wish according to the requirement of your question.

LONG ANSWER

SHORT ANSWER EXPLANATION

I am opposed to answers like: copy and paste this solution , so I will give the explanation of the aggregation method in stages, so that you understand what we are doing.

Stage $match:

The first stage receives as a parameter the iduser document on which we want to perform the Aggregation process. As a note, the Mongoose Aggregation API does not perform castdata type conversion during pipeline stages, which is why we will use the cast from the Stringreturn req.params.idtype ObjectIdof to the Mongo type.

This stage returns the document whose field _idmatches the value that we have passed as a parameter. It could be equated to the method findById(id).

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

Stage $project:

In this stage we will create the basic structure of the document that we want as a result. In this case I am taking as a reference what you raise in your question.

Since the field is modificationof type Array, in order to work with it we will use the operator $map, which iterates over each element of our array.

For each element of the array, I'm going to indicate the fields that I want to be returned. Thus, if I want the field user, I must indicate it as:

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

At this stage, the crucial thing is what we do with the field updated, which is a type Array.

On said field we will use the operator $mapand convert each item(if possible) to a type ObjectId. For this we will use the operator $convert.

NOTE

The operator $convertis only available in MongoDB version 4.0 or later.

What we'll do is try to convert each value of updatedto an ObjectId type. I say try because not all the values ​​in our array are valid strings to convert to a ObjectIdMongo type.

Taking into account that the field updatedcontains a value similar to the following:

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

It is clear that the first and last elements of our array are not valid values String​​to be converted to ObjectId. That is why we use the attribute onErrorof our operator $convert, which allows us to return a value in case of an error during the conversion:

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

Now the field updatedwill have the following structure:

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

Why have we converted types Stringto types ObjectId?

The answer to this question is given in the stage $lookup.

Stage $unwind:

This stage will make things easier for us when working with the array data modification. What this stage does is create a document for each element present in our array, and the field modificationis converted to a type document.

Since it is a bit difficult to understand the process until you see the result, I will leave some images that can clarify a bit what happens:

Before performing the stage $unwind, our aggregation looks like the following image:

We can notice that there is only one document that contains all the modification data in the field modification.

When performing the step $unwind, the result will be the following:

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.

Imagine that a user has 10 (to say few) entries in the field of modifications, that means that you must make 20 requests (2 for each entry) to the database to obtain the information about the name of the field associated with ideach entry. entry. That's not practical at all, not counting the chaining you have to do, or the use of a function asyncto be able to use awaitwith DB calls.

I hope this is a solution to your problem and helps you understand the world of aggregations a bit.