Home / Questions / 382940
Accepted
Nicolas Cavilla
Asked: 2020-08-19 13:40:00 +0800 CST 2020-08-19 13:40:00 +0800 CST

Execute an operation after atomically deleting a document in mongo

  • 772

I have the following schematics:

const ClienteSchema = new Schema({
    nombre: {
        type: String,
        required: [true, "El cliente es requerido"]
    }

    apellido: {
        type: String,
        required: [true, "El cliente es requerido"]
    }

})

const AlquilerSchema = new Schema({
    
    fecha_pago: {
        type: Date,
        required: [true, "La fecha de pago es requerida"]
    }

    cliente: {
        type: Schema.Types.ObjectId,
        ref: 'Cliente',
        required: [true, "El cliente es requerido"]
    }
})

What I want to achieve is that when I delete a client, all the rentals made by the client are eliminated atomically.

I found that Mongo Atlas provides a trigger system, I can't use it since my DB is not hosted in Mongo Atlas.

What I did was use the middleware provided by mongoose, but I'm not sure if this operation is atomic, that is, if removing the client and an error occurs when removing the rentals, the client is not removed.

ClienteSchema.post('remove', doc => {

    AlquilerSchema.deleteMany({cliente: doc._id})

});
javascript

1 Answers

  1. Best Answer

    A solution for what you are looking for is to make a transaction with Mongoose, in this way you make sure that all the documents are deleted correctly and if an error occurs it will return to the previous state of the transaction.

    Regarding the middlewaresMongoose ones (pre and post), keep in mind that they are designed to handle possible errors that may occur in the actions you want to perform (save, update, etc.).

    I detail an example of a transaction so you can understand it:

    const mongoose = require('mongoose')

/**
 * Method Transaction
 * 
 * @param {string | ObjectId} cliente          ObjectId del cliente
 * @returns {Promise<boolean>}
 */
module.exports = async function (cliente) {
    // Generamos una Session para agrupar todas las acciones en la transacción
    const session = await mongoose.startSession()
    session.startTransaction()

    try {
        await mongoose.model('Cliente') // Nombre del modelo que le has indicado al generar el Schema (ej. db.model('Cliente', ClienteSchema)) 
                   .deleteOne({ _id: cliente }, { session }) // Añadimos la session
       
        await mongoose.model('Alquiler').deleteMany({ cliente },  { session })

        await session.commitTransaction() // Ejecutamos la transacción

        return true
    } catch (e) {
        // Si ocurre un error, aborta la transacción y deshacer cualquier cambio que pudiera haber ocurrido
        await session.abortTransaction()

        return false
    } finally {
        // Finaliza la session
        session.endSession()
    }
}

    This function could be added as a method to the schema of the collection Clienteand thus call it when it is instantiated, I give you an example of how the method could go in the Schema (I skip the connection step) and how it would be used:

    // Archivo Cliente.js

const ClienteSchema = new Schema({
    nombre: {
        type: String,
        required: [true, "El cliente es requerido"]
    }

    apellido: {
        type: String,
        required: [true, "El cliente es requerido"]
    }

})

ClienteSchema.methods.transactionRemove = async function () {
    const session = await mongoose.startSession()
    session.startTransaction()

    try {
        await mongoose.model('Cliente').deleteOne({ _id: this._id }, { session }) 
       
        await mongoose.model('Alquiler').deleteMany({ cliente: this._id },  { session })

        await session.commitTransaction() 

        return true
    } catch (e) {
        await session.abortTransaction()

        return false
    } finally {
        // Finaliza la session
        session.endSession()
    }
}

module.exports = mongoose.model('Cliente', ClienteSchema)

    It would be used:

    const Cliente = require('./Cliente.js')

const removeClient = async (nombre) => {

      const cliente = Cliente.findOne({ nombre: nombre })

      const results = await cliente.transactionRemove()

      return results
}

removeClient('pepe')

    I hope that with this explanation you can solve your problem.

    For any questions, do not hesitate to ask.

    All the best

    • 3