Bagaimana cara menghapus objek dengan mempertimbangkan referensi akun di Mongoose Node.js?

Anda harus menyarangkan panggilan Anda untuk menghapus id produk dari model lain. Misalnya, dalam panggilan Anda untuk menghapus produk dari Product koleksi, Anda juga dapat melakukan panggilan lain untuk menghapus referensi dari Partner model dalam panggilan balik hasil. Menghapus produk secara default akan menghapus referensinya ke Campaign Model.

Kode berikut menunjukkan intuisi di atas:

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

Untuk menghapus kampanye terkait, Anda mungkin memerlukan operasi penghapusan tambahan yang menggunakan id kampanye terkait dari id produk tertentu. Pertimbangkan peretasan kotor berikut yang berpotensi memberi Anda tiket sekali jalan ke callback hell jika tidak berhati-hati dengan panggilan balik bersarang:

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

Meskipun berhasil, potensi jebakan di atas dapat dihindari dengan menggunakan async/await atau async Perpustakaan. Tetapi pertama-tama, untuk memberi Anda pemahaman yang lebih baik tentang penggunaan beberapa panggilan balik dengan async modul, mari kita ilustrasikan ini dengan contoh dari Seven Hal yang Harus Anda Berhenti Lakukan dengan Node.js dari beberapa operasi dengan panggilan balik untuk menemukan entitas induk, lalu temukan entitas anak yang menjadi milik induk:

methodA(function(a){
    methodB(function(b){
        methodC(function(c){
            methodD(function(d){
                // Final callback code        
            })
        })
    })
})

Dengan async/await, panggilan Anda akan direstrukturisasi terstruktur sebagai

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

Dengan modul async, Anda dapat menggunakan metode seri untuk mengatasi penggunaan callback untuk kode bersarang dari beberapa metode yang dapat mengakibatkan Panggilan Balik Neraka :

Seri :

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

Atau air terjun :

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

Sekarang kembali ke kode Anda, dengan menggunakan metode air terjun async, Anda kemudian dapat menyusun ulang kode Anda menjadi

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