CODEWITHSUNDEEP
node.jsmongodb
Faris Malik
Faris Malik

Reputation: 23

Handling concurrent request that finds and update the same resource in Node Js & Mongo DB?

I have a function in node that runs after a clicking the checkout button. It checks the availability of the items in cart and if the item is available it will deduct it from the inventory.

I'm currently testing with two users clicking the checkout button at the same time. Both users have the exact same content in their cart (10 apples each) which gives a total of 20 apples, but there are only 10 apples in inventory.

If there is no item in cart it should return an error to the user but both orders are going through.

NOTE: This works if there is a 1 second delay between the clicks.

What can i do to prevent this?

  // Check if items in inventory
  const availability = await checkInventory(store, cart, seller);

  if (!availability.success) {
    return res.status(400).json({
      success: false,
      type: 'unavailable',
      errors: availability.errors,
    });
  }

  // Deduct Inventory
  const inventory = await deductInventory(store, seller, cart);

  if (!inventory) {
    return next(new ErrorResponse('Server Error', 500));
  }

checkInventory

exports.checkInventory = asyncHandler(async (store, cart, seller) => {
  let isAvailable = true;
  const unavailableProducts = [];

  const inventory = await Inventory.find({
    $and: [
      {
        store: store,
        user: seller,
      },
    ],
  });

  const products = inventory[0].products;

  cart.forEach((item) => {
    const product = products.find(
      (product) => product._id.toString() === item.productId
    );

    if (!item.hasvariation) {
      if (product.stock < item.qty) {
        isAvailable = false;
        unavailableProducts.push(
          `${item.title} is not available, only ${product.stock} left available`
        );
      }
    }

    if (item.hasvariation) {
      const variation = product.variations.find(
        (variation) => variation._id.toString() === item.variationId
      );

      const option = variation.options.find(
        (option) => option._id.toString() === item.optionId
      );

      if (option.stock < item.qty) {
        isAvailable = false;
        unavailableProducts.push(
          `${item.title} is not available, only ${product.stock} left available`
        );
      }
    }
  });

  return {
    success: isAvailable,
    errors: unavailableProducts,
  };
});

deductInventory

exports.deductInventory = asyncHandler(async (store, seller, cart) => {
  const inventory = await Inventory.findOne({
    $and: [
      {
        store: store,
        user: seller,
      },
    ],
  });

  const products = inventory.products;

  cart.forEach((item) => {
    const product = products.find(
      (product) => product._id.toString() === item.productId
    );
    if (!item.hasvariation) {
      product.stock = product.stock - item.qty;
    }

    if (item.hasvariation) {
      const variation = product.variations.find(
        (variation) => variation._id.toString() === item.variationId
      );

      const option = variation.options.find(
        (option) => option._id.toString() === item.optionId
      );

      option.stock = option.stock - item.qty;
    }
  });

  const saveInventory = await Inventory.findOneAndUpdate(
    {
      $and: [
        {
          store: store,
          user: seller,
        },
      ],
    },
    {
      $set: { products: products },
    },
    { new: true, runValidator: true }
  );

  if (!saveInventory) {
    return {
      success: false,
      errors: ['Server Error'],
    };
  }

  return {
    success: true,
  };
});

Upvotes: 1

Views: 715

Answers (1)

solognt
solognt

Reputation: 66

The problem is that the 2 checkout calls run at (almost) the same time and your routine is not thread-safe. Both calls read a copy of the inventory data in memory. So both calls get a products.stock=10 and based on that local info you check and set the products counter by calculating the new amount in your function (stock-qty) and use an update query to set it as a fixed value (so both calls update the products.stock to 0). Resulting in your concurrency issues.

What you should do is let mongodb handle the concurrency for you. There are several ways to handle concurrency but you could for example use the $inc to decrease the stock amount directly in mongo. That way the stock amount in the db can never be wrong.

result = await update({stock: {$ge: 10}}, {$inc: {stock : -10}})

As I added a filter to the query the order amount can not be lower than 0 plus you can now check the result of the update call to see if the update modified any documents. If it did not (result.nModified==0) you know the inventory was too low and you can report that back to the user.

https://docs.mongodb.com/manual/reference/operator/update/inc/ https://docs.mongodb.com/manual/reference/method/db.collection.update/#std-label-writeresults-update

Upvotes: 1

Related Questions