fix: replace all async foreach callbacks (#10157)

Co-authored-by: zomars <[email protected]>

Author: nicktrn

apps/web/playwright/booking-pages.e2e.ts

@@ -158,9 +158,10 @@ test.describe("pro user", () => {
 
     await expect(page.locator("[data-testid=success-page]")).toBeVisible();
 
-    additionalGuests.forEach(async (email) => {
+    const promises = additionalGuests.map(async (email) => {
       await expect(page.locator(`[data-testid="attendee-email-${email}"]`)).toHaveText(email);
     });
+    await Promise.all(promises);
   });
 
   test("Time slots should be reserved when selected", async ({ context, page }) => {

packages/app-store/vital/lib/reschedule.ts

@@ -121,18 +121,21 @@ const Reschedule = async (bookingUid: string, cancellationReason: string) => {
     const bookingRefsFiltered: BookingReference[] = bookingToReschedule.references.filter(
       (ref) => !!credentialsMap.get(ref.type)
     );
+
+    const promises = bookingRefsFiltered.map(async (bookingRef) => {
+      if (!bookingRef.uid) return;
+
+      if (bookingRef.type.endsWith("_calendar")) {
+        const calendar = await getCalendar(credentialsMap.get(bookingRef.type));
+        return calendar?.deleteEvent(bookingRef.uid, builder.calendarEvent);
+      } else if (bookingRef.type.endsWith("_video")) {
+        return deleteMeeting(credentialsMap.get(bookingRef.type), bookingRef.uid);
+      }
+    });
     try {
-      bookingRefsFiltered.forEach(async (bookingRef) => {
-        if (bookingRef.uid) {
-          if (bookingRef.type.endsWith("_calendar")) {
-            const calendar = await getCalendar(credentialsMap.get(bookingRef.type));
-            return calendar?.deleteEvent(bookingRef.uid, builder.calendarEvent);
-          } else if (bookingRef.type.endsWith("_video")) {
-            return deleteMeeting(credentialsMap.get(bookingRef.type), bookingRef.uid);
-          }
-        }
-      });
+      await Promise.all(promises);
     } catch (error) {
+      // FIXME: error logging - non-Error type errors are currently discarded
       if (error instanceof Error) {
         logger.error(error.message);
       }

packages/app-store/wipemycalother/lib/reschedule.ts

@@ -121,17 +121,19 @@ const Reschedule = async (bookingUid: string, cancellationReason: string) => {
     const bookingRefsFiltered: BookingReference[] = bookingToReschedule.references.filter(
       (ref) => !!credentialsMap.get(ref.type)
     );
+
+    const promises = bookingRefsFiltered.map(async (bookingRef) => {
+      if (!bookingRef.uid) return;
+
+      if (bookingRef.type.endsWith("_calendar")) {
+        const calendar = await getCalendar(credentialsMap.get(bookingRef.type));
+        return calendar?.deleteEvent(bookingRef.uid, builder.calendarEvent);
+      } else if (bookingRef.type.endsWith("_video")) {
+        return deleteMeeting(credentialsMap.get(bookingRef.type), bookingRef.uid);
+      }
+    });
     try {
-      bookingRefsFiltered.forEach(async (bookingRef) => {
-        if (bookingRef.uid) {
-          if (bookingRef.type.endsWith("_calendar")) {
-            const calendar = await getCalendar(credentialsMap.get(bookingRef.type));
-            return calendar?.deleteEvent(bookingRef.uid, builder.calendarEvent);
-          } else if (bookingRef.type.endsWith("_video")) {
-            return deleteMeeting(credentialsMap.get(bookingRef.type), bookingRef.uid);
-          }
-        }
-      });
+      await Promise.all(promises);
     } catch (error) {
       if (error instanceof Error) {
         logger.error(error.message);

packages/app-store/zapier/lib/nodeScheduler.ts

@@ -10,6 +10,7 @@ export async function scheduleTrigger(
 ) {
   try {
     //schedule job to call subscriber url at the end of meeting
+    // FIXME: in-process scheduling - job will vanish on server crash / restart
     const job = schedule.scheduleJob(
       `${subscriber.appId}_${subscriber.id}`,
       booking.endTime,
@@ -57,38 +58,39 @@ export async function cancelScheduledJobs(
   appId?: string | null,
   isReschedule?: boolean
 ) {
-  try {
-    let scheduledJobs = booking.scheduledJobs || [];
+  if (!booking.scheduledJobs) return;
 
-    if (booking.scheduledJobs) {
-      booking.scheduledJobs.forEach(async (scheduledJob) => {
-        if (appId) {
-          if (scheduledJob.startsWith(appId)) {
-            if (schedule.scheduledJobs[scheduledJob]) {
-              schedule.scheduledJobs[scheduledJob].cancel();
-            }
-            scheduledJobs = scheduledJobs?.filter((job) => scheduledJob !== job) || [];
-          }
-        } else {
-          //if no specific appId given, delete all scheduled jobs of booking
-          if (schedule.scheduledJobs[scheduledJob]) {
-            schedule.scheduledJobs[scheduledJob].cancel();
-          }
-          scheduledJobs = [];
+  let scheduledJobs = booking.scheduledJobs || [];
+  const promises = booking.scheduledJobs.map(async (scheduledJob) => {
+    if (appId) {
+      if (scheduledJob.startsWith(appId)) {
+        if (schedule.scheduledJobs[scheduledJob]) {
+          schedule.scheduledJobs[scheduledJob].cancel();
         }
+        scheduledJobs = scheduledJobs?.filter((job) => scheduledJob !== job) || [];
+      }
+    } else {
+      //if no specific appId given, delete all scheduled jobs of booking
+      if (schedule.scheduledJobs[scheduledJob]) {
+        schedule.scheduledJobs[scheduledJob].cancel();
+      }
+      scheduledJobs = [];
+    }
 
-        if (!isReschedule) {
-          await prisma.booking.update({
-            where: {
-              uid: booking.uid,
-            },
-            data: {
-              scheduledJobs: scheduledJobs,
-            },
-          });
-        }
+    if (!isReschedule) {
+      await prisma.booking.update({
+        where: {
+          uid: booking.uid,
+        },
+        data: {
+          scheduledJobs: scheduledJobs,
+        },
       });
     }
+  });
+
+  try {
+    await Promise.all(promises);
   } catch (error) {
     console.error("Error cancelling scheduled jobs", error);
   }

packages/atoms/build.mjs

@@ -12,7 +12,7 @@ const libraries = [
   },
 ];
 
-libraries.forEach(async (lib) => {
+const promises = libraries.map(async (lib) => {
   await build({
     build: {
       outDir: `./dist/${lib.fileName}`,
@@ -29,3 +29,4 @@ libraries.forEach(async (lib) => {
     },
   });
 });
+await Promise.all(promises);

packages/features/bookings/lib/handleCancelBooking.ts

@@ -430,9 +430,9 @@ async function handler(req: CustomRequest) {
           bookingToDelete.recurringEventId &&
           allRemainingBookings
         ) {
-          bookingToDelete.user.credentials
+          const promises = bookingToDelete.user.credentials
             .filter((credential) => credential.type.endsWith("_calendar"))
-            .forEach(async (credential) => {
+            .map(async (credential) => {
               const calendar = await getCalendar(credential);
               for (const updBooking of updatedBookings) {
                 const bookingRef = updBooking.references.find((ref) => ref.type.includes("_calendar"));
@@ -443,6 +443,13 @@ async function handler(req: CustomRequest) {
                 }
               }
             });
+          try {
+            await Promise.all(promises);
+          } catch (error) {
+            if (error instanceof Error) {
+              logger.error(error.message);
+            }
+          }
         } else {
           apiDeletes.push(calendar?.deleteEvent(uid, evt, externalCalendarId) as Promise<unknown>);
         }
@@ -603,11 +610,13 @@ async function handler(req: CustomRequest) {
   });
 
   // delete scheduled jobs of cancelled bookings
+  // FIXME: async calls into ether
   updatedBookings.forEach((booking) => {
     cancelScheduledJobs(booking);
   });
 
   //Workflows - cancel all reminders for cancelled bookings
+  // FIXME: async calls into ether
   updatedBookings.forEach((booking) => {
     booking.workflowReminders.forEach((reminder) => {
       if (reminder.method === WorkflowMethods.EMAIL) {
@@ -622,11 +631,14 @@ async function handler(req: CustomRequest) {
 
   const prismaPromises: Promise<unknown>[] = [bookingReferenceDeletes];
 
-  // @TODO: find a way in the future if a promise fails don't stop the rest of the promises
-  // Also if emails fails try to requeue them
   try {
-    await Promise.all(prismaPromises.concat(apiDeletes));
+    const settled = await Promise.allSettled(prismaPromises.concat(apiDeletes));
+    const rejected = settled.filter(({ status }) => status === "rejected") as PromiseRejectedResult[];
+    if (rejected.length) {
+      throw new Error(`Reasons: ${rejected.map(({ reason }) => reason)}`);
+    }
 
+    // TODO: if emails fail try to requeue them
     await sendCancelledEmails(evt, { eventName: bookingToDelete?.eventType?.eventName });
   } catch (error) {
     console.error("Error deleting event", error);