等待云Function完成

Question

Is there any way to wait for a Cloud Function, that was triggered by a Firestore document write, to finish?

Context:

My app has groups. Owners can invite other users to a group via an invite code. Users can write themselves as member of a group if they have the right invite code. They do this by writing the groups/{groupId}/members/{userId} document that contains their profile info.

To make reading more efficient, this info is copied to array members in the groups/{groupId} document by a Cloud Function.

The Cloud Function that does that is triggered by the document write. It is usually finished after a couple of seconds, but there's no predictable execution time and it might take a bit longer if it is a cold start.

After the user has joined the group, I forward them to the groups view in my app which reads the group document. In order for the view to render correctly, the membership info needs to be available. So I would like to forward AFTER the Cloud Function has finished.

I found no way to track the execution of a Cloud Function that was triggered by a Firestore document write.

A fellow developer recommended to just poll the groups/{groupId} document until the info is written and then proceed but this doesn't seem like a clean solution to me.

Any ideas how this could be done better?

Is it possible to get a promise that resolves after the Cloud Function has finished? Is there a way to combine a Firestore document write and a Cloud Function execution into one transaction?

Answer 1

Thanks for the hints, I came up with the following ways to deal with the problem. The approach depends on if/when the user is allowed to read a document:

A) User is member and leaves the group > at the start of the transaction they are allowed to read the group > the moment they can't read anymore confirms that the membership was successfully revoked:

async function leaveGroup (groupId) {
  await deleteDoc(doc(db, 'groups', groupId, 'members', auth.currentUser.uid))

  // Cloud Function removes the membership info
  // from the group doc...

  await new Promise((resolve) => {
    const unsubscribeFromSnapshot = onSnapshot(
      doc(db, 'groups', groupId),
      () => { }, // success callback
      () => { // error callback
        // membership info is not in the group anymore
        //   > user can't read the doc anymore
        //     > transaction was successful
        // read access was revoked > transaction was successful:
        unsubscribeFromSnapshot()
        resolve()
      }
    )
  })
}

B) User is not a member and wants to join the group > at the start of the transaction they are allowed to read the group > the moment they can read the group confirms that the membership was successfully confirmed (this is a simplified version that does not check the invite code):

async function joinGroup (groupId) {
  try {
    await setDoc(
      doc(db, 'groups', groupId, 'members', auth.currentUser.uid),
      {
        userId: auth.currentUser.uid,
        userDisplayName: auth.currentUser.displayName
      }
    )

    // Cloud Function adds the membership
    // information to the group doc ...

    await new Promise((resolve) => {
      let maxRetries = 10
      const interval = setInterval(async () => {
      try {
        const docSnap = await getDoc(doc(db, 'groups', groupId))
        if (docSnap.data().members.includes(auth.currentUser.uid)) {
          // membership info is in the group doc
          //   > transaction was successful
          clearInterval(interval)
          resolve()                
        }
      } catch (error) {
        if (maxRetries < 1) {
          clearInterval(interval)
        }
      }
      maxRetries--
    }, 2000)
  })
}

Note: I went with polling here, but similar to what @samthecodingman suggested, another solution could be that the Cloud Function confirms the membership by writing back to the members document (which the user can always read) and you listen to snapshot changes on this document.

C) Most straightforward way: someone else (the group owner) removes a member from the group > they have read access through the whole transaction > directly listen to snapshot changes:

async function endMembership (groupId, userId) {

  await deleteDoc(doc(db, 'groups', groupId, 'members', userId))
    
  // Cloud Function removes the membership info
  // from the group doc...
    
  await new Promise((resolve) => {
    const unsubscribe = onSnapshot(doc(db, 'groups', groupId), (doc) => {
      if (!doc.data().members.includes(userId)) {
        // membership info is not in the group doc anymore
        //   > transaction was successful
        unsubscribe()
        resolve()
      }
    })
  })
}

In any case you should do proper error handling that covers other causes. I left them out to demonstrate how to use the error handlers when waiting for gaining/loosing read access.