等待 Firebase 函数中的多个 Promise

Question

我试图弄清楚如何在函数结束之前等待多个承诺的执行。

本质上，这就是我尝试做的：

• 如果用户删除他/她的帐户，我想清理与他相关的所有数据
• 直接数据可以删除
• 如果用户是某个组的一部分，并且其他用户也在该组中，则该组仍然存在；否则该群组也将被删除

这是我到目前为止所尝试的：

A）主要功能（启动第一级承诺）：

export function cleanUpAllData(user) {
  const userId = user.uid;
  const promises = [];
  promises.push(deleteCategoriesData(userId)); // this works fine
  promises.push(deleteUserAndGroupData(userId)); // this one has other promises which still run when Promise.all() is finished
  Promise.all(promises)
    .then(() => {
      return "ok"; // this works so far, but not all promises are resolved
    })
    .catch(errPromises => {
      console.log("an error occured during the processing of main promises");
      console.log(errPromises, errPromises.code);
      return "error";
    })
}

B）deleteUserAndGroupData 函数（另一个 Promise 工作正常）：在用户数据中找到的每个组启动另一个级别的 Promise，并且还触发第三个级别的 Promise（deleteGroup） - 其余的工作正常

function deleteUserAndGroupData(userId) {
  const promisesUserData = [];

  return admin.firestore().collection('users').doc(userId).collection('groups').get()
    .then(userGroups => {
        userGroups.forEach(userGroupData => {
            // delete group data
            promisesUserData.push(deleteGroups(userId, userGroupData.id)); // here are other promises that need to be resolved - somewhere is a problem              
            // delete all Groups in Users (subcollection)
            promisesUserData.push(deleteGroupInUser(userId, userGroupData.id)); // this works fine          
        });
        Promise.all(promisesUserData)
        .then(() => {
            admin.firestore().collection('users').doc(userId).delete()
                .then(() => {
                    return "user data deleted"; // works fine
                })
                .catch(() => {
                    console.log("an error occured during deleting of user");
                    return "error";
                });
        })
        .catch(errPromises => {
            console.log("an error occured during the processing of promisesUserData");
            console.log(errPromises, errPromises.code);
            return "error";
        })
    })
    .catch(errUserGroups => {
        console.log(errUserGroups, errUserGroups.code);
        return "no groups in User";
    });
}

C）deleteGroups功能：删除组中的子集合（工作正常），之后如果没有其他用户，则应删除该组（这不起作用）

function deleteGroups(userId,groupId) {
  const promisesDeleteGroups = [];
  // delete groups subcollection data 
  promisesDeleteGroups.push(deleteGroupRole(userId, groupId));
  promisesDeleteGroups.push(deleteGroupUser(userId, groupId));

  return Promise.all(promisesDeleteGroups).then(() => {
    checkForOthers(groupId);
  }).catch(errDeleteGroupSubcollections => {
    console.log("an error occured during the processing of promisesDeleteGroups");
    console.log(errDeleteGroupSubcollections, errDeleteGroupSubcollections.code);
    return "error";
  });
}

D) checkForOthers 函数 - 检查子集合中是否有任何条目并应开始删除该组（但不删除）

function checkForOthers(groupId) {
  return admin.firestore().collection('groups').doc(groupId).collection('users').get()
    .then(groupUsers => {
        return "other users exist - group should not be deleted";
    })
    .catch(errGroupUsers => {
        // console.log("no other group members - group can be deleted");
        // return "no other group members - group can be deleted";
        console.log(errGroupUsers, errGroupUsers.code);
        checkForInvitesAndDelete(groupId);
    });;
}

E) checkForInvitesAndDelete：首先，如果另一个用户已被邀请加入该组，我想删除另一个可能存在或可能不存在的子集合；那么它应该触发最后的组删除（这似乎不起作用）

function checkForInvitesAndDelete(groupId) {
  const promisesInvitesAndDelete = [];
  return admin.firestore().collection('groups').doc(groupId).collection('invitations').get()
    .then(groupInvitations => {
        console.log("delete open Group Invitations");
        groupInvitations.forEach(groupInvite => {
            promisesInvitesAndDelete.push(deleteGroupInvite(groupId, groupInvite.id));
        });
        Promise.all(promisesInvitesAndDelete)
            .then(() => {
                deleteGroup(groupId)
            })
            .catch(errPromisesInvitesAndDelete => {
                console.log("an error occured during the processing of deleting group invites");
                console.log(errPromisesInvitesAndDelete, errPromisesInvitesAndDelete.code);
                return "error";
            });
    })
    .catch(() => {
        console.log("no open invitations");
        deleteGroup(groupId);
    });
}

F) 删除组函数

function deleteGroup(groupId) {
  return admin.firestore().collection('groups').doc(groupId).delete();
}

我对编程相对陌生，尤其是 Firebase 函数，因此任何帮助将不胜感激！

谢谢你！

Answer 1

您没有return在应该在的地方到处使用该关键字。如果你执行一项async任务，你必须以return某种方式“”它。

一些例子：

示例A：添加return在前面Promise.all(promises)

...B：添加return在前面Promise.all(promisesUserData)

... C：添加return在前面checkForOthers(groupId)

...D：添加return在前面checkForInvitesAndDelete(groupId)

... E:return在Promise.all(promisesInvitesAndDelete)and之前添加deleteGroup(groupId)