How to avoid overriding set data in Cloud Function

Question

I have a function to adding player like so:

inside my external js (player.js)

module.exports.player = function(appPlayer, db){

appPlayer.post('/', async(req, res) => {
            const data = req.body
            // data
            const ipAdress = data.ipAdress
            const carslidekey = data.id
            const nickname = data.nickname
            // random color for 
            const randomCol = Math.floor(Math.random()*16777215).toString(16)
    
            let player = {
                ipAdress: ipAdress,
                nickname: nickname,
                color: `#${randomCol}`
            }
    
            await db.collection('kartesian').doc(carslidekey)
                    .collection('player')
                    .doc(ipAdress)
                    .set(player).then(() => {
                        let dataResponse = {
                            status: true,
                            idDoc: ipAdress,
                            ipAdress: ipAdress,
                            color: `#${randomCol}`
                        }
                        const jsonStr_1 = JSON.stringify(dataResponse)
                        res.send(jsonStr_1)
                        
                    }).catch((err) => {
                        let dataResponse = {
                            status: false,
                            idDoc: ipAdress,
                            ipAdress: ipAdress,
                            msg: `Terjadi kesalahan ${err.data}`
                        }
                        const jsonStr_1 = JSON.stringify(dataResponse)
                        res.send(jsonStr_1)
                    })
            
        })
}

and my index.js (cloud functions) i wrote https request like below:

    ......
    
    const playerHandler = require('./src/player')
    playerHandler.player(app, db)
    exports.player = functions.https.onRequest(app)

    ......

My problem is sometime this function called by different devices and might be concurrently, even though I've created a method set with a different id but why sometimes I find the previous documentation replaced by the document after. how to ensure that there is no overlap? Thanks

Answer 1

Option 1:

I don't think there is a way besides reading the document as a pre-check before writing. I would recommend implementing a queue -> the cloud function would push to the queue, and a separate cloud function would read the queue and execute on it synchronously.

Also, you're mixing await and promises (e.g. .then), you do not need to do that, see code below.

For example:

Note: I didn't run this code, but it should be close to working

Note2: @Nanda Z made a good point, it's probably not a good idea to run background functions without implementing them as cloud tasks and cloud events

let playerQueue = []
var isProcessingQueue = false

async function handlePlayerQueue(appPlayer, db) {
    if (isProcessingQueue) return
    isProcessingQueue = true

    if (playerQueue.length == 0) return

    // remove the first item from the queue
    player = playerQueue.shift()

    let ref = db.collection('kartesian').doc(player.carslidekey)
                    .collection('player')
                    .doc(player.ipAdress)

    // Check if player exists

    var playerExists = false

    try {

        playerExists = await ref.get().exists

    } catch (err) {

        console.error("Could not get player record", err)

    }

    // exit early
    if (playerExists) {

        isProcessingQueue = false

        // recursively handle queue
        handlePlayerQueue(appPlayer, db)
        
        return
    }


    // wrap await in try...catch to catch exceptions.
    try {
        let setResponse = await ref.set(player)
        let dataResponse = {
            status: true,
            idDoc: player.ipAdress,
            ...player
        }
        const jsonStr_1 = JSON.stringify(dataResponse)
        console.log(`Player data pushed: ${jsonStr_1}`)

    } catch(err) {
        let dataResponse = {
            status: false,
            idDoc: player.ipAdress,
            ...player
            msg: `Terjadi kesalahan ${err.data}`
        }
        const jsonStr_1 = JSON.stringify(dataResponse)
        console.error(`Failed to set player: ${jsonStr_1}`)
    }

    isProcessingQueue = false

    // recursively handle queue
    handlePlayerQueue(appPlayer, db)
}

module.exports.player = function(appPlayer, db){
appPlayer.post('/', async(req, res) => {

    const data = req.body
    // data
    const ipAdress = data.ipAdress
    const carslidekey = data.id
    const nickname = data.nickname
    // random color for 
    const randomCol = Math.floor(Math.random()*16777215).toString(16)

    let player = {
        carslidekey, // need to add this so that the queueHandler can use it
        ipAdress: ipAdress,
        nickname: nickname,
        color: `#${randomCol}`
    }

    // if javascript wasn't singlethreaded, this is where there'd be a lock =)
    playerQueue.push(player)

    // call the queue handler
    handlePlayerQueue(appPlayer, db)

    // Tell the client we received the request, they won't know the status, but you can set up another endpoint to check if the record exists
    res.send({message: "Request received and queue\'d!"})
    
})
}

Option 2:

You could instead add a Firestore rule to not allow writing to a document if it's already populated:

match /kartesian/{carslidekey}/player/{player} {
    // you can use the `resource.data` variable to access the player document:
    // resource will be null if the player doesn't exist. resource.data is overkill but I put it there just fyi 
    allow write: if request.auth != null && (resource == null || resource.data == null);
}

I tested this rule to make sure it behaves as expected. It should let you write only if you're authenticated AND the resource is empty. So writes that come in later will fail.

---

It's important to note that rules only apply for online writing and will not be applied to offline/cached data.