Create unique subdocuments in mongoose

ISSUE

You want to create a non-repeating list of a specific field in a MongoDB document .

Suppose we have the list of collaborations as follows:

let collaborations = [
  {role:"USER", company: 1, state: true},
  {role:"USER", company: 2, state: true},
  {role:"USER", company: 1, state: false}
]

As can be seen, the first and third elements differ only by the field state.

The thing to keep in mind is what value can be repeated and what value cannot.

If a user can only collaborate on 1 company, then the unique field for each document in the list must be company.

In your question it is clear that this is the situation, you can only add collaborations in different companies to the list. A user cannot be a collaborator more than once in the same company (regardless of role or status or any other field).

This poses a problem for us when updating the data, since although MongoDB provides us with the operator $addToSetto add values ​​to a list without repetition, as we have already seen, the objects compared in this way may be different in some other field and therefore both are cataloged as different.

SOLUTION

One solution is to filter the collaboration documents based on the value of company, this way you won't be able to add duplicate items.

However we have 2 scenarios:

1. Create documents usinginsert
2. Updating documents usingupdate

Creating documents with insertin MongoDB or savein Mongoose

Assuming I'm going to create a document in MongoDB, we have no way to ensure during creation that the list of collaborations doesn't contain duplicate items. So we need to purge the data, before inserting it, in some way.

filterFor this we will rely on the Javascript method .

For example:

// teniendo el siguiente documento:
let user = {
  name: "JOSE",
  collaborations: [
    { role:"USER", company: 1, state: true },
    { role:"USER", company: 2, state: true },
    { role:"USER", company: 1, state: false}
  ]
}
// depuramos usando filter
let uniqueCollaborations = user.collaborations.filter((element, index) => {
  let notExist = true;
  for(let i = 0; i < index; i++) {
    if(user.collaborations[i].company === element.company) {
      notExist = false;
      break;
    }
  }
  return notExist;
});

// establecemos la lista filtrada
user.collaborations = uniqueCollaborations;

//ahora podemos insertar
db.users.insert(user);

If we want to do the same thing with Mongoose, it's easy since the code is basically the same, except we'll use save()our model's method:

User.save(user, callback);

Mongoose: Using a middleware function in a type hookpre-save

If we want to automate the task of filtering the documents by the field company, we can delegate this task to a pre - type middleware that will always be executed before saving a document created from our model.

Our scheme would look like this:

const UsuarioSchema = new mongoose.Schema({
  name: {
    type: String,
    required: 'El nombre es requerido'
  },
  collaborations: {
    type: [CollaborationSchema],
    required: 'La colaboración es requerida'
  }
});

//Creamos una función middleware tipo 'pre' para el evento 'save'
UsuarioSchema.pre('save', function() {
  //this se refiere al documento que estamos salvando en BD
  let uniqueCollaborations = this.collaborations.filter((element, index) => {
    let notExist = true;
    for(let i = 0; i < index; i++) {
      if(this.collaborations[i].company === element.company) {
        notExist = false;
        break;
      }
    }
    return notExist;
  });
  this.collaborations = uniqueCollaborations;
  // llamamos a next() para que se siga ejecutando el proceso de salvar el documento
  next();
});

// Ahora podemos instanciar el modelo
const Usuario = mongoose.model('Usuario', UsuarioSchema);

// definimos un documento
let user = new Usuario({
  name: 'JOSE',
  collaborations: [
    { role:"USER", company: 1, state: true },
    { role:"USER", company: 2, state: true },
    { role:"USER", company: 1, state: false}
  ]
});

// ya no es necesario filtrar el documento antes de salvarlo, ya que esto lo hará nuestro middleware

user.save()
.then(saved => {
  console.log(saved.collaborations);
  /* muestra la lista con sólo 2 elementos
  
  [
    { role:"USER", company: 1, state: true },
    { role:"USER", company: 2, state: true }
  ]
  
  */
})
.catch(errorHandler);

In this way, every time a document is created using the user model, when saving it, our middleware function is executed , which is responsible for eliminating duplicate records on the field company.

Updating documents with updateMongoDB and/or Mongoose

We are now faced with the situation of updating an existing document. For this we have 2 scenarios:

1. Update an existing collaboration list item. For example if the user changed the role.
2. Add a new collaboration to the list.

In both cases it is an update on a document in the users collection.

Update an existing item

Attacking the first case is very simple using a filter Array( arrayFilters ) that work the same in both MongoDB and Mongoose.

Suppose we are going to modify the field rolof the list item whose field companyis 2, in the document belonging to the user identified by the name 'JOSE' (although it is more common to use the _iddocument field).

So, our filter Arraycan be written as:

let filtroLista = [
  { 'element.company': 2 } // <- nótese que uso notación de punto encerrada entre comillas (pueden ser simples o dobles)
];

I am indicating with this that I am going to update the element of the list, whose field companyis equal to 2.

Then in the update statement I use this filter as follows:

db.users.update(
  { name: 'JOSE' },
  { $set: { 'collaborations.$[element].role': 'ADMIN' } }, // <- nótese que uso el nombre del elemento usado en el fitro: element
  { arrayFilters: filtroLista }
);

If everything is correct we will have the message:

WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

And the document could look like this:

{
    "_id" : ObjectId("5f4b8c5b9d730d7dbbd726fb"),
    "name" : "JOSE",
    "collaborations" : [
        {
            "role" : "USER",
            "company" : 1,
            "state" : true
        },
        {
            "role" : "ADMIN",
            "company" : 2,
            "state" : true
        }
    ]
}

We have successfully changed the user role for collaboration in the company identified by the number 2.

In Mongoose the code is the same, except we apply it to the user model:

User.update(
  { name: 'JOSE'},
  { $set: { 'collaborations.$[element].role': 'ADMIN' } },
  { arrayFilters: filtroLista },
  callback
);

Insert a new item in the list

To insert a new element in the list we are going to resort to the operator $ninand of the $pushMongoDB operator.

Let's suppose that now our user is a collaborator in a company identified by the number 3. Then we could use the method updateOne()in the following way.

// nuestra nueva colaboración
let collaboration: {
  role: 'USER',
  company: 3,
  state: false
};

db.users.updateOne(
  { name: 'JOSE', 'collaborations.company': { $nin: [collaboration.company] } },
  { $push: { collaborations: collaboration } },
  { upsert: false}
);

In this case, I am updating a document from the users collection whose field nameis 'JOSE' and that does not have any element in the list of collaborations with the field companyequal to the field companyof the collaboration that I want to insert.

If said filter does not return any document, it means that a collaboration already exists in the company indicated by the field company, therefore the operation of adding the collaboration to the list is not carried out.

On the contrary, if there is a document in the users collection that in its list of collaborations are all different from the one I want to insert, then the update will be performed.

If all goes well the output will look similar to the following:

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

We have used the parameterupsert explicitly to tell MongoDB that if the document does not exist (based on the filter used) it should not create a new document. Although this parameter is the falsedefault, it is always a good practice to show it in the code so that the intention is understood when performing the update operation.

Again in the case of Mongoose the code is the same except for the fact that we are going to use the updateOnemodel method:

User.updateOne(
  { name: 'JOSE', 'collaborations.company': { $nin: [collaboration.company] } },
  { $push: { collaborations: collaboration } },
  { upsert: false},
  callback
);

This would be a way to attack the problem posed in the question.