Node.js MongoDB 利用承诺进行 MongoDB 方法调用

Question

EDIT

So I am creating an e-commerce website and I'm running into a few road blocks. I have since updated my code to make it cleaner and easier to read and I somewhat pinpointed where my issue stems from (though there could be more). Here is the updated code:

StoreDB.prototype.addOrder = function(order) {
    console.log('addOrder');
    return this.connected.then(function(db) {
        console.log(order);
        var orders = db.collection('orders');
        var products = db.collection('products');
        return insert(order, orders, db)
        .then(function(updatedOrdersList) {
            return obtainOrders(updatedOrdersList);
        })
        .then(function(orderList) {
            return updateProducts(orderList, products);
        })
        .catch((err) => console.log('There was an issue in the promise chain\n' + err));
    });
}

function insert(order, orders, db) {
    return new Promise(function(resolve, reject) {
        console.log('Inserting order into orders collection');
        orders.insert(order);
        resolve(db.collection('orders'));
    });
}

function obtainOrders(orders) {
    return new Promise(function(resolve, reject) {
        console.log('Obtaining orders');
        var orderList = orders.find({}).toArray();
        resolve(orderList);
    });
}

function updateProducts(orderList, products) {
    return new Promise(function(resolve, reject) {
        console.log('Getting the products that match the cart')
        var promises = [];
        var promises2 = [];
        console.log('orderList', orderList);
        for (var item in orderList[0].cart) {
            console.log('item', item);
            promises.push(products.find({$and : [{"_id" : item}, {"quantity" : {$gte: 0}}]}).toArray());
        }
        Promise.all(promises)
            .then(() => {
                console.log('Updating the cart quantity')
                for (var i = 0; i < promises.length; i++) {
                    console.log(promises);
                    // console.log(productList[item], productList[item]._id, productList[item].quantity, cart);
                    promises2.push(products.update({"_id" : productList[item]._id}, {$set :{"quantity" : (productList[item].quantity - cart[productList[item]._id])}}));

                    promises2.push(products.find({}).toArray());
                    Promise.all(promises2)
                        .then(() => promises[promises2.length-1]);                          
                }                       
            }); 
    });
}

It appears that when obtainOrders is called in the promise chain, it returns an empty array. I'm not too sure why it does this because in the chain where:

return insert(order, orders, db)
.then(function(updatedOrdersList) {
    return obtainOrders(updatedOrdersList);
})
.then(function(orderList) {
    return updateProducts(orderList, products);
})

The function call to obtainOrders from above waits for the method call to Collections.find to be completed before it is resolved (returning an array of orders). Some reason it is returning an empty array.

Any help would be greatly appreciated!

Answer 1

Not sure what the relationship between the first block and second is, but in the first block:

function insert(order, orders, db) {
    return new Promise(function(resolve, reject) {
        console.log('Inserting order into orders collection');
        orders.insert(order);
        resolve(db.collection('orders'));
    });
}

At a glance it seems like orders.insert(order) is asynchronous, but you're not waiting for it to finish before resolving.

You could either make the function asynchronous and

await orders.insert(order);

or

orders.insert(order)
  .then(() => resolve(db.collection('orders')))

But doesn't having the method Collections.insert inside a promise make that method call asynchronous?

Yes, Collections.insert is implicitly asynchronous in that it returns a Promise. I was talking about declaring it async explicitly so you can await other async calls in the function body. Note the addition of async at the start and await orders.insert() .

async function insert(order, orders, db) {
    return new Promise(function(resolve, reject) {
        console.log('Inserting order into orders collection');
        await orders.insert(order);
        resolve(db.collection('orders'));
    });
}

If you don't await orders.insert (either via await or .then ) you're calling insert and immediately returning the db.collection call, which creates a race condition where the new order may not be inserted yet. It's possible the new order could be there but it seems unlikely, and it's not going to be there reliably.

There's also no need to create a new Promise here. db.collection already returns a Promise. Just return the one you already have:

function insert(order, orders, db) {
    console.log('Inserting order into orders collection');
    return orders.insert(order)
        .then(() => db.collection('orders'));
}

Take a look at this sample code snippet. I've mocked out the orders.insert and db.collection methods.

 // mock orders.insert const orders = { insert: async() => { return new Promise((resolve) => { // wait a second then resolve setTimeout(resolve, 1000); }); } } // mock db.collection const db = { collection: async() => { return new Promise((resolve) => { // wait a second then resolve with mock data setTimeout(() => resolve(['foo', 'bar', 'baz']), 1000); }); } } function insert(order, orders, db) { return orders.insert(order).then(() => db.collection('orders')); } // same as above, but with async/await async function insertAsync(order, orders, db) { await orders.insert(order); return await db.collection('orders'); } function go() { // using then insert(null, orders, db).then(console.log); // using async/await; insertAsync(null, orders, db).then(console.log); } go();