How to handle scarce resource disputes in a procurement system - node.js

Question

In the code below, when you have a purchase order for a product with 1 unit and two users try to buy at the same time, both are able to buy. I'm using transactions in this process and I believed that the transaction idea would handle this case.
I'm using DB postgres and I've already tested using ISOLATION LEVEL for this transaction, but without success.
try {
//I tried this, but doesn't work
const trx = await knex.transaction({ isolationLevel: 'read uncommitted' });
let order_total = 0;
const products = [];
const sales = [];
for (const pBought of data.products) {
let prod = await trx('tb_product')
.select('tb_product.id', 'tb_product.title', 'tb_product.price', 'tb_product.price_total', 'tb_product.quantity', 'tb_product.id_salesman', 'tb_product.width', 'tb_product.height', 'tb_product_discount.value', 'tb_product_discount.is_deleted')
.leftJoin('tb_product_discount', 'tb_product_discount.id', 'tb_product.id_discount')
.where({ 'tb_product.id': pBought.id_product, 'tb_product.is_active': true, 'tb_product.is_deleted': false });
prod = prod[0];
if (!prod) throw new Error('Produto inexistente!');
let salesman = await trx('tb_salesman')
.select('*')
.where({ 'id': prod.id_salesman, 'is_deleted': false });
salesman = salesman[0];
if (!salesman) throw new Error('Vendedor inexistente!');
if (salesman.id !== prod.id_salesman)
throw new Error('Vendedor inconsistente!');
if (!prod || !salesman)
throw new Error('Não foi possível recuperar as informações!');
if (pBought.quantity <= 0)
throw new Error(`Quantidade informada de ${prod.title} menor que 1!`);
console.log(prod.quantity, pBought.quantity);
if (prod.quantity < pBought.quantity)
throw new Error(`Quantidade de ${prod.title} maior que a disponível!`);
if (prod.price !== pBought.price)
throw new Error(`Preço de produtos inválido, atualize a página!`);
let aux;
if (prod.value && !prod.is_deleted) {
aux = (prod.price - prod.value) * prod.width * prod.height;
order_total += roundToTwo(aux * pBought.quantity);
} else {
aux = prod.price_total;
order_total += roundToTwo(aux * pBought.quantity);
}
sales.push({
id_salesman: salesman.id,
id_product: prod.id,
product_title: prod.title,
quantity: prod.quantity,
unit_price: parseInt(aux.toFixed(0)),
price: pBought.quantity * aux
});
products.push({ id_product: prod.id, price: aux, discount: prod.value, quantity: pBought.quantity, available_quantity: prod.quantity, tax: process.env.PERCENTAGE_TAX });
}
let order = await trx('tb_order').insert({ order_total, id_client: client.client.id_client, id_address: address.address.id, portions: data.portions, method: data.method }).returning('*');
order = order[0];
for (const prod of products) {
if (prod.available_quantity - prod.quantity)
await trx('tb_product').update('quantity', prod.available_quantity - prod.quantity)
.where({ 'id': prod.id_product });
else
await trx('tb_product').update({ 'quantity': 0, 'is_active': false })
.where({ 'id': prod.id_product });
delete prod['available_quantity'];
prod.id_order = order.id;
}
await trx('tb_order_product').insert(products);
const wasPaid = await Payment.execute(sales, { portions: data.portions, method: data.method, card_hash: data.card_hash, document: data.document, name: data.name, total: parseInt((order_total * 100)).toFixed(0) }, client, address, order.id);
if (!wasPaid.success) throw new Error(wasPaid.message);
trx.commit();
return { success: true, order };
} catch (error) {
Message.warning(error);
return { success: false, message: error.message }
}
I'm using Node.js and Knex.
I want know how can I handle this scenario for allow only one user take a product at once.
Using serializable for isolation level I get error, because even non-scarce products cannot be acquired simultaneously, because it locks the table and, if another user tries to buy, any product that is at the same instant, will receive an error.