How to avoid overriding set data in Cloud Function - node.js

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.