How can I handle concurrency in Node.js

Question

I am using Angular as my front-end and Node.js as back-end alongside knex.js SQL builder and PostgreSQL. I am building web application where the users can make appointments. If some appointment is made by user#1 for example at 10:00 then the user#2 can't make the same appointment.

I am using setInterval() to get the available hour appointments on every three seconds, but the problem is that if the user#1 make an appointment at 10:00 and at the same time user#2 make too at 10:00, then they both have appointments at 10:00. After three seconds the created appointment will be not available for user#2 but how can I guarantee that user#2 will not click on the button 'Make appointment' at the same time with user#1 until three seconds are passed?

How can I handle this?

Angular

 setInterval(() => {
     this.getAvailableHourAppointments();
 }, 3000);

 getAvailableHourAppointments() {
     console.log('available called');
     this.appointmentService.getAvailableAppointmentHours(this.user.id,
         this.selected_appointment_date).subscribe(availavable_appointment_hours => {
         console.log('available', availavable_appointment_hours);
         this.availavable_appointment_hours = availavable_appointment_hours;
     })
 } 

Node.js

router.get('/available/:selected_appointment_date', (req, res) => {
    appointment.getAllAppointments().then(all_appointments => {
        all_appointments = all_appointments.filter(appointment => appointment.appointment_date == req.params.selected_appointment_date);
        const appointment_hours = appointment.getAppointmentHours();
        let availavable_appointment_hours = appointment_hours.filter(a => !all_appointments.some(b => a.value === b.appointment_hour));
        res.json(availavable_appointment_hours)
    })
})

Knex.js

function getAllAppointments() {
  return db.select('*').from('appointment');
}

EDIT WHAT I TRIED WITH MUTEX

router.post("make-appointment", (req, res) => {
    let user = req.body;
    user['id'] = helpers.generateUuid();
    appointment.sendMail(user, info => {
        // console.log(`The mail has beed send  and the id is ${info.messageId}`);
        // res.send(info);
        res.send([user]);

        appointment.postAppointment(user).then(app => {
            console.log(app);
            let locks = new Map();
            // console.log(user.id);
            if (!locks.has(user.id)) {
                console.log(1111);
                locks.set(user.id, new Mutex());
            }
            locks
                .get(user['id'])
                .acquire()
                .then(async (release) => {
                    try {
                        const existAppoinment = await appointment.getAppointmentById(app.appId).then(x => {
                            console.log(x);
                            if (x.length == 0) {
                                appointment.postAppointment(req.body).then(data => {
                                    res.json(data);
                                }).catch(err => res.json(err));
                            }
                        }).catch(err => {
                            console.log(err);
                        })
                    } catch (error) {
                        console.log(errror);
                    } finally {
                        console.log('FINALLY CALED')
                        release();
                    }
                },
                );
        })
    }, err => {
        // console.log('err', err);
    });
});

Answer 1

It's the Mutual Exclusion problem which you have to handle in your backend (Node.js App). There is some packages in Node like Mutex which implements primitives for synchronizing asynchronous operations in JavaScript. So you have to "Handle Mutual Exclusion In NodeJS Using Mutex" and here is a helpfule article for you: Handle Race Conditions In NodeJS Using Mutex

Here is a sample of creating a lock using mutex:

import { Mutex, MutexInterface } from 'async-mutex';

class PaymentService {
    private locks : Map<string, MutexInterface>;

    constructor() {
        this.locks = new Map();
    }

    public async participateInFreeEvent(user: User, eventId: number): Promise<void> {
        if (!this.locks.has(user.id)) {
          this.locks.set(user.id, new Mutex());
        }
        
        this.locks
            .get(user.id)
            .acquire()
            .then(async (release) => {
                try {
                    const existOrder = await findOrder(eventId, user.id);
                    if (!existOrder) {
                        const order = buildNewOrder(eventId, user.id);
                        createOrder(order.id, eventId, user.id);
                    }
                } catch (error) {
                } finally {
                    release();
                }
            },
        );
    }
}

Answer 2

Usually people think that we cannot have a race condition in Nodejs due to its single-threaded nature. Even though it is true theoretically, we might still have tasks belonging to different logical transactions executing in an order that might come up with stale reads and make a race condition. With this definition there might be a situation where several logical transactions are scheduled concurrently on the event loop and the discrete task end up being intermingled that makes the race condition happened.

To overcome this race condition and lock the critical path (Mutual Exclusion) we have two ways in Nodejs.

First way as is to use "async-mutex" module and the second way is to make a shared promise object.

using "async-mutex"

async function operationOnCriticalPath() {
  mutex = mutex.then(() => {
   // implement functionality
  })
  .catch(() => {
    // manage errors
  })
  return mutex
}

Using share promise object

let mutex = Promise.resolve()
async function operationOnCriticalPath() {
  mutex=mutex.then(async()=>{
   //implement functionality
  }).catch((){
   // handle errors
  });
  return mutex;
})

}

More information here