MongoDB
 sql >> Base de Dados >  >> NoSQL >> MongoDB

Como remover o objeto levando em consideração as referências no Mongoose Node.js?


Você teria que aninhar suas chamadas para remover o ID do produto do outro modelo. Por exemplo, em sua chamada para remover o produto do Produto coleção, você também pode fazer outra chamada para remover a referência do Partner model dentro do retorno de chamada de resultados. A remoção do produto por padrão removerá suas referências da Campanha Modelo.

O código a seguir mostra a intuição acima:
var campSchema = require('../model/camp-schema');

router.post('/removeProduct', function (req, res) {
    campSchema.Product.findOneAndRemove({ _id: req.body.productId }, function (err, response) {
        if (err) throw err;
        campSchema.Partner.update(
            { "products": req.body.productId },
            { "$pull": { "products": req.body.productId } },
            function (err, res){
                if (err) throw err;
                res.json(res);
            }
        );
    });
});

Para remover as campanhas associadas, você pode precisar de uma operação de remoção extra que inclua o ID da campanha associada de um determinado ID do produto. Considere o seguinte hack sujo que pode potencialmente conceder a você uma passagem só de ida para callback hell se não for cuidadoso com o aninhamento de retorno de chamada:
router.post('/removeProduct', function (req, res) {
    campSchema.Product.findOneAndRemove(
        { _id: req.body.productId }, 
        { new: true },
        function (err, product) {
            if (err) throw err;
            campSchema.Partner.update(
                { "products": req.body.productId },
                { "$pull": { "products": req.body.productId } },
                function (err, res){
                    if (err) throw err;
                    var campaignList = product.campaign
                    campSchema.Campaign.remove({ "_id": { "$in": campaignList } })
                                .exec(function (err, res){
                                    if (err) throw err;
                                    res.json(product);
                                })
                }
            );
        }
    );
});

Embora funcione, a armadilha potencial acima pode ser evitada usando async/await ou o async biblioteca. Mas primeiro, para lhe dar uma melhor compreensão do uso de vários retornos de chamada com o async módulo, vamos ilustrar isso com um exemplo de Seven Coisas que você deve parar de fazer com o Node.js de várias operações com retornos de chamada para encontrar uma entidade pai e, em seguida, encontre entidades filhas que pertençam ao pai:
methodA(function(a){
    methodB(function(b){
        methodC(function(c){
            methodD(function(d){
                // Final callback code        
            })
        })
    })
})

Com async/await, suas chamadas serão reestruturadas estruturadas como
router.post('/removeProduct', async (req, res) => {
    try {
        const product = await campSchema.Product.findOneAndRemove(
            { _id: req.body.productId }, 
            { new: true }
        )

        await campSchema.Partner.update(
            { "products": req.body.productId },
            { "$pull": { "products": req.body.productId } }
        )

        await campSchema.Campaign.remove({ "_id": { "$in": product.campaign } })

        res.json(product)
    } catch(err) {
        throw err
    }
})

Com o módulo assíncrono, você pode usar o método de série para abordar o uso de retornos de chamada para código de aninhamento de vários métodos que podem resultar em Inferno de retorno de chamada :

Série :
async.series([
    function(callback){
        // code a
        callback(null, 'a')
    },
    function(callback){
        // code b
        callback(null, 'b')
    },
    function(callback){
        // code c
        callback(null, 'c')
    },
    function(callback){
        // code d
        callback(null, 'd')
    }],
    // optional callback
    function(err, results){
        // results is ['a', 'b', 'c', 'd']
        // final callback code
    }
)

Ou a cachoeira :
async.waterfall([
    function(callback){
        // code a
        callback(null, 'a', 'b')
    },
    function(arg1, arg2, callback){
        // arg1 is equals 'a' and arg2 is 'b'
        // Code c
        callback(null, 'c')
    },
    function(arg1, callback){      
        // arg1 is 'c'
        // code d
        callback(null, 'd');
    }], function (err, result) {
        // result is 'd'    
    }
)

Agora, voltando ao seu código, usando o método de cascata assíncrona, você pode reestruturar seu código para
router.post('/removeProduct', function (req, res) {
    async.waterfall([
        function (callback) {
            // code a: Remove Product
            campSchema.Product.findOneAndRemove(
                { _id: req.body.productId }, 
                function (err, product) {
                    if (err) callback(err);
                    callback(null, product);
                }
            );
        },

        function (doc, callback) {
            // code b: Remove associated campaigns
            var campaignList = doc.campaign;
            campSchema.Campaign
                .remove({ "_id": { "$in": campaignList } })
                .exec(function (err, res) {
                if (err) callback(err);
                callback(null, doc);
            }
            );
        },

        function (doc, callback) {
            // code c: Remove related partner
            campSchema.Partner.update(
                { "products": doc._id },
                { "$pull": { "products": doc._id } },
                function (err, res) {
                    if (err) callback(err);
                    callback(null, doc);
                }
            );
        }
    ], function (err, result) {
        if (err) throw err;
        res.json(result);  // OUTPUT OK
    });
});