Пользователи могут одновременно снимать средства, превышающие баланс их кошелька, инициируя несколько одновременных выводов средств

Прежде всего, я рекомендую установить ограничение скорости на вашей конечной точке, например 1 запрос в секунду.

Во-вторых, если вы еще не определили столбец проверки баланса для предотвращения отрицательных балансов, вам следует это сделать.

(Хотя я не являюсь экспертом по MongoDB), этого можно добиться, используя сериализуемую транзакцию. Это потребует выбора и обновления баланса пользователя, добавления новой записи в таблицу вывода средств и последующего подтверждения транзакции. Если проверка не пройдена, транзакция будет отменена.

Для финансовых приложений хорошим подходом могут быть хранимые процедуры.

Вот пример:

BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE;

select "balance", "recordID" into "_balance", "_recordID" 
from "Balance"
where "userID" = "in_userID"
for update;

if ("_balance"< "in_amount") raise exception('INSUFFICENT_BALANCE'); end if;

update "Balance" set "balance" = "balance" - "in_amount" where "recordID" = "_recordID";

insert into "Withdrawal" () values ();

COMMIT;

Короткий ответ:

Состояние гонки, которое вызывает проблему в этом вопросе, можно решить с помощью метода findOneAndUpdate. Самый важный момент — это условие, переданное в этот метод. При этом всегда следует проверять, что выполняемое обновление не должно приводить к отрицательному значению. Ниже приведен пример кода. При его чтении воспользуйтесь комментариями, включенными в него.

Подробный ответ:

Пожалуйста, прочитайте этот пост последовательно.

Условное обновление: Условное обновление — это распространенный оптимистический подход к обеспечению согласованности данных в условиях одновременного доступа, то есть согласованности в условиях параллелизма.

Он работает по принципу, что любой клиент, выполняющий обновление, проверяет значение непосредственно перед обновлением, чтобы увидеть, изменилось ли оно с момента последнего чтения. Если тест не пройден, то произошло состояние гонки — конфликт записи-записи, и текущее обновление следует прервать, проинформировав пользователей о ситуации. Для этого исходного вопроса был реализован тест на состояние гонки, поскольку обновление не приведет к отрицательному балансу.

Следующий код продемонстрирует это. В основном он основан на методе findOneAndUpdate, поскольку он выполняет три операции: поиск, обновление и чтение атомарным способом. Более подробную информацию можно найти в комментариях, приведенных в коде. Два оператора в коде требуют некоторой дополнительной информации, как показано ниже.

Оператор — оператор №1: это оператор, вызывающий состояние гонки в коде. На данный момент оно не прокомментировано. Чтобы запустить код без возникновения состояния гонки, прокомментируйте это утверждение.

Оператор - оператор № 2: это оператор, в котором было реализовано условное обновление, условие - { a: 'A', b: { $gte: orgdoc.b } } выполняет задание.

// MongoDB: 7.0.2
// Mongoose : 8.3.2
// Node.js v21.6.0.
//conditionalUpdate.mjs

import mongoose, { Schema } from 'mongoose';

main().catch((err) => {
  console.info(err);
});

async function main() {
  await mongoose.connect('mongodb://127.0.0.1:27017/myapp');

  const someSchema = new Schema({ a: String, b: Number });
  const SomeModel = mongoose.model('SomeModel', someSchema);
  await SomeModel.deleteMany();

  // creating original document.
  const orgdoc = await SomeModel({
    a: 'A',
    b: 1,
  }).save();

  // deducting value
  const latestvalue = orgdoc.b - 1;

  // let us assume this operation is being executed by a separate client program in another session
  // performing a concurrent update against the same document
  // statement #1
  await SomeModel.updateOne({ a: 'A' }, { $inc: { b: -1 } });

  // performing a conditional update to safeguard
  // the possible write-write conflict
  // statement #2
  const updateQuery = SomeModel.findOneAndUpdate(
    { a: 'A', b: { $gte: orgdoc.b } },
    { b: latestvalue },
    { new: true }
  );
  const newdoc = await updateQuery.exec();

  // informing user for the needful action
  if (newdoc) {
    console.info(`Updation passed`);
  } else {
    console.info(
      `Updation failed - write-write conflict detected, please check the latest document against yours`
    );
  }
  console.info(`Original document: ${orgdoc}`);
  console.info(`Update Query: ${updateQuery}`);
  console.info(`Latest document : ${await SomeModel.findOne({ a: 'A' })}`);
}

// Output 1: When statement #1 is uncommented
// Updation failed - write-write conflict detected, please check the latest document against yours
// Original document: { a: 'A', b: 1, _id: ..., __v: 0 }
// Update Query: SomeModel.findOneAndUpdate({ a: 'A', b: { '$gte': 1 } }, { '$set': { b: 0 } })
// Latest document : { _id: ..., a: 'A', b: 0, __v: 0 }

// Output 2: When statement #1 is commented
// Updation passed
// Original document: { a: 'A', b: 1, _id: ..., __v: 0 }
// Update Query: SomeModel.findOneAndUpdate({ a: 'A', b: { '$gte': 1 } }, { '$set': { b: 0 } })
// Latest document : { _id: ..., a: 'A', b: 0, __v: 0 }

Схемы Mongoose v5 поддерживают валидаторы схемы min и max , поэтому вы можете применить min из 0 к balance, чтобы невозможно было опуститься ниже нее следующим образом:

const userSchema = new mongoose.Schema({
    name: String,
    balance: { 
        type: Number, 
        min: 0
    }
})

Вы можете использовать $inc, чтобы увеличить поле balance на отрицательную величину, но я бы сначала проверил, что req.body.amount является положительным целым числом. Затем, когда вы выполняете обновление, убедитесь, что вы используете опцию findByIdAndUpdate или findOneAndUpdate с { runValidators: true }, например:

// convert string to integer
const amount = parseInt(req.body.amount);

// now only do update if positive integer
if (Math.sign(amount) > 0){
   const user = await User.findByIdAndUpdate(req.user._id,
   {
      $inc: {
         balance: -amount
      }
   },{ runValidators: true, new: true });
}else{
  //Return a response that amount must be positive amount
}