Zapier Trigger: After Meeting ends (#3827)

* add new trigger with first simple job scheduling

* fix DB update

* use array to save scheduled jobs in booking

* cancel scheduled jobs when zap disabled or zapier disconnected

* schedule jobs only for confirmed bookings

* schedule jobs for already existing bookings

* fix bug to create workflow reminders when confirming recurring events

* delete remove all zapier webhooks when api key is deleted

* schedule job for all confirmed recurring bookings

* fix zapier trigger and workflow reminders when cancelling recurring events

* code clean up

* code clean up

* add migration

* add type package for node-schedule

* remove nodescheduler

* add updated nodescheduler

* move code to app-store

* add meeting ended to webhook constants

* udpate zapier README.md

* implement QA suggestions

* add default handler and fix imports

* Type fix

Co-authored-by: CarinaWolli <wollencarina@gmail.com>
Co-authored-by: kodiakhq[bot] <49736102+kodiakhq[bot]@users.noreply.github.com>
Co-authored-by: Omar López <zomars@me.com>

Author: 4 people

apps/web/lib/webhooks/constants.ts

@@ -7,11 +7,12 @@ export const WEBHOOK_TRIGGER_EVENTS_GROUPED_BY_APP = {
     WebhookTriggerEvents.BOOKING_CANCELLED,
     WebhookTriggerEvents.BOOKING_CREATED,
     WebhookTriggerEvents.BOOKING_RESCHEDULED,
-  ] as ["BOOKING_CANCELLED", "BOOKING_CREATED", "BOOKING_RESCHEDULED"],
+    WebhookTriggerEvents.MEETING_ENDED,
+  ] as const,
   routing_forms: [WebhookTriggerEvents.FORM_SUBMITTED] as ["FORM_SUBMITTED"],
 };
 
 export const WEBHOOK_TRIGGER_EVENTS = [
   ...WEBHOOK_TRIGGER_EVENTS_GROUPED_BY_APP.core,
   ...WEBHOOK_TRIGGER_EVENTS_GROUPED_BY_APP.routing_forms,
-] as ["BOOKING_CANCELLED", "BOOKING_CREATED", "BOOKING_RESCHEDULED", "FORM_SUBMITTED"];
+] as const;

apps/web/lib/webhooks/subscriptions.tsx

@@ -30,6 +30,7 @@ const getWebhooks = async (options: GetSubscriberOptions) => {
       },
     },
     select: {
+      id: true,
       subscriberUrl: true,
       payloadTemplate: true,
       appId: true,

apps/web/pages/api/book/confirm.ts

@@ -1,8 +1,19 @@
-import { Booking, BookingStatus, Prisma, SchedulingType, User } from "@prisma/client";
+import {
+  Booking,
+  BookingStatus,
+  Prisma,
+  SchedulingType,
+  User,
+  WebhookTriggerEvents,
+  Workflow,
+  WorkflowsOnEventTypes,
+  WorkflowStep,
+} from "@prisma/client";
 import type { NextApiRequest } from "next";
 import { z } from "zod";
 
 import { refund } from "@calcom/app-store/stripepayment/lib/server";
+import { scheduleTrigger } from "@calcom/app-store/zapier/lib/nodeScheduler";
 import EventManager from "@calcom/core/EventManager";
 import { sendDeclinedEmails, sendScheduledEmails } from "@calcom/emails";
 import { scheduleWorkflowReminders } from "@calcom/features/ee/workflows/lib/reminders/reminderScheduler";
@@ -14,6 +25,7 @@ import type { AdditionalInformation, CalendarEvent } from "@calcom/types/Calenda
 
 import { getSession } from "@lib/auth";
 import { HttpError } from "@lib/core/http/error";
+import getSubscribers from "@lib/webhooks/subscriptions";
 
 import { getTranslation } from "@server/lib/i18n";
 
@@ -30,6 +42,7 @@ const authorized = async (
       id: booking.eventTypeId || undefined,
     },
     select: {
+      id: true,
       schedulingType: true,
       users: true,
     },
@@ -129,6 +142,7 @@ async function patchHandler(req: NextApiRequest) {
       recurringEventId: true,
       status: true,
       smsReminderNumber: true,
+      scheduledJobs: true,
     },
   });
 
@@ -237,6 +251,21 @@ async function patchHandler(req: NextApiRequest) {
         log.error(error);
       }
     }
+    let updatedBookings: {
+      scheduledJobs: string[];
+      id: number;
+      startTime: Date;
+      endTime: Date;
+      uid: string;
+      smsReminderNumber: string | null;
+      eventType: {
+        workflows: (WorkflowsOnEventTypes & {
+          workflow: Workflow & {
+            steps: WorkflowStep[];
+          };
+        })[];
+      } | null;
+    }[] = [];
 
     if (recurringEventId) {
       // The booking to confirm is a recurring event and comes from /booking/recurring, proceeding to mark all related
@@ -247,8 +276,9 @@ async function patchHandler(req: NextApiRequest) {
           status: BookingStatus.PENDING,
         },
       });
-      unconfirmedRecurringBookings.map(async (recurringBooking) => {
-        await prisma.booking.update({
+
+      const updateBookingsPromise = unconfirmedRecurringBookings.map((recurringBooking) => {
+        return prisma.booking.update({
           where: {
             id: recurringBooking.id,
           },
@@ -258,12 +288,35 @@ async function patchHandler(req: NextApiRequest) {
               create: scheduleResult.referencesToCreate,
             },
           },
+          select: {
+            eventType: {
+              select: {
+                workflows: {
+                  include: {
+                    workflow: {
+                      include: {
+                        steps: true,
+                      },
+                    },
+                  },
+                },
+              },
+            },
+            uid: true,
+            startTime: true,
+            endTime: true,
+            smsReminderNumber: true,
+            id: true,
+            scheduledJobs: true,
+          },
         });
       });
+      const updatedBookingsResult = await Promise.all(updateBookingsPromise);
+      updatedBookings = updatedBookings.concat(updatedBookingsResult);
     } else {
       // @NOTE: be careful with this as if any error occurs before this booking doesn't get confirmed
       // Should perform update on booking (confirm) -> then trigger the rest handlers
-      await prisma.booking.update({
+      const updatedBooking = await prisma.booking.update({
         where: {
           id: bookingId,
         },
@@ -273,13 +326,62 @@ async function patchHandler(req: NextApiRequest) {
             create: scheduleResult.referencesToCreate,
           },
         },
+        select: {
+          eventType: {
+            select: {
+              workflows: {
+                include: {
+                  workflow: {
+                    include: {
+                      steps: true,
+                    },
+                  },
+                },
+              },
+            },
+          },
+          uid: true,
+          startTime: true,
+          endTime: true,
+          smsReminderNumber: true,
+          id: true,
+          scheduledJobs: true,
+        },
       });
+      updatedBookings.push(updatedBooking);
     }
 
     //Workflows - set reminders for confirmed events
-    if (booking.eventType?.workflows) {
-      await scheduleWorkflowReminders(booking.eventType.workflows, booking.smsReminderNumber, evt, false);
+    for (const updatedBooking of updatedBookings) {
+      if (updatedBooking.eventType?.workflows) {
+        const evtOfBooking = evt;
+        evtOfBooking.startTime = updatedBooking.startTime.toISOString();
+        evtOfBooking.endTime = updatedBooking.endTime.toISOString();
+        evtOfBooking.uid = updatedBooking.uid;
+
+        await scheduleWorkflowReminders(
+          updatedBooking.eventType.workflows,
+          updatedBooking.smsReminderNumber,
+          evtOfBooking,
+          false
+        );
+      }
     }
+
+    // schedule job for zapier trigger 'when meeting ends'
+    const subscriberOptionsMeetingEnded = {
+      userId: booking.userId || 0,
+      eventTypeId: booking.eventTypeId || 0,
+      triggerEvent: WebhookTriggerEvents.MEETING_ENDED,
+    };
+
+    const subscribersMeetingEnded = await getSubscribers(subscriberOptionsMeetingEnded);
+
+    subscribersMeetingEnded.forEach((subscriber) => {
+      updatedBookings.forEach((booking) => {
+        scheduleTrigger(booking, subscriber.subscriberUrl, subscriber);
+      });
+    });
   } else {
     evt.rejectionReason = rejectionReason;
     if (recurringEventId) {

apps/web/pages/api/book/event.ts

@@ -6,6 +6,7 @@ import short from "short-uuid";
 import { v5 as uuidv5 } from "uuid";
 
 import { handlePayment } from "@calcom/app-store/stripepayment/lib/server";
+import { cancelScheduledJobs, scheduleTrigger } from "@calcom/app-store/zapier/lib/nodeScheduler";
 import EventManager from "@calcom/core/EventManager";
 import { getUserAvailability } from "@calcom/core/getUserAvailability";
 import dayjs from "@calcom/dayjs";
@@ -791,13 +792,32 @@ async function handler(req: NextApiRequest) {
 
   log.debug(`Booking ${organizerUser.username} completed`);
 
-  const eventTrigger: WebhookTriggerEvents = rescheduleUid ? "BOOKING_RESCHEDULED" : "BOOKING_CREATED";
+  const eventTrigger: WebhookTriggerEvents = rescheduleUid
+    ? WebhookTriggerEvents.BOOKING_RESCHEDULED
+    : WebhookTriggerEvents.BOOKING_CREATED;
   const subscriberOptions = {
     userId: organizerUser.id,
     eventTypeId,
     triggerEvent: eventTrigger,
   };
 
+  const subscriberOptionsMeetingEnded = {
+    userId: organizerUser.id,
+    eventTypeId,
+    triggerEvent: WebhookTriggerEvents.MEETING_ENDED,
+  };
+
+  const subscribersMeetingEnded = await getSubscribers(subscriberOptionsMeetingEnded);
+
+  subscribersMeetingEnded.forEach((subscriber) => {
+    if (rescheduleUid && originalRescheduledBooking) {
+      cancelScheduledJobs(originalRescheduledBooking);
+    }
+    if (booking && booking.status === BookingStatus.ACCEPTED) {
+      scheduleTrigger(booking, subscriber.subscriberUrl, subscriber);
+    }
+  });
+
   // Send Webhook call if hooked to BOOKING_CREATED & BOOKING_RESCHEDULED
   const subscribers = await getSubscribers(subscriberOptions);
   console.log("evt:", {

apps/web/pages/api/cancel.ts

@@ -1,10 +1,18 @@
-import { BookingStatus, Prisma, PrismaPromise, WebhookTriggerEvents, WorkflowMethods } from "@prisma/client";
+import {
+  BookingStatus,
+  Prisma,
+  PrismaPromise,
+  WebhookTriggerEvents,
+  WorkflowMethods,
+  WorkflowReminder,
+} from "@prisma/client";
 import { NextApiRequest, NextApiResponse } from "next";
 import z from "zod";
 
 import { getCalendar } from "@calcom/app-store/_utils/getCalendar";
 import { FAKE_DAILY_CREDENTIAL } from "@calcom/app-store/dailyvideo/lib/VideoApiAdapter";
 import { refund } from "@calcom/app-store/stripepayment/lib/server";
+import { cancelScheduledJobs } from "@calcom/app-store/zapier/lib/nodeScheduler";
 import { deleteMeeting } from "@calcom/core/videoClient";
 import dayjs from "@calcom/dayjs";
 import { sendCancelledEmails } from "@calcom/emails";
@@ -82,6 +90,7 @@ async function handler(req: NextApiRequest, res: NextApiResponse) {
       destinationCalendar: true,
       smsReminderNumber: true,
       workflowReminders: true,
+      scheduledJobs: true,
     },
   });
 
@@ -164,6 +173,21 @@ async function handler(req: NextApiRequest, res: NextApiResponse) {
   );
   await Promise.all(promises);
 
+  //Workflows - schedule reminders
+  if (bookingToDelete.eventType?.workflows) {
+    await sendCancelledReminders(
+      bookingToDelete.eventType?.workflows,
+      bookingToDelete.smsReminderNumber,
+      evt
+    );
+  }
+
+  let updatedBookings: {
+    uid: string;
+    workflowReminders: WorkflowReminder[];
+    scheduledJobs: string[];
+  }[] = [];
+
   // by cancelling first, and blocking whilst doing so; we can ensure a cancel
   // action always succeeds even if subsequent integrations fail cancellation.
   if (bookingToDelete.eventType?.recurringEvent && bookingToDelete.recurringEventId && allRemainingBookings) {
@@ -181,16 +205,36 @@ async function handler(req: NextApiRequest, res: NextApiResponse) {
         cancellationReason: cancellationReason,
       },
     });
+    const allUpdatedBookings = await prisma.booking.findMany({
+      where: {
+        recurringEventId: bookingToDelete.recurringEventId,
+        startTime: {
+          gte: new Date(),
+        },
+      },
+      select: {
+        workflowReminders: true,
+        uid: true,
+        scheduledJobs: true,
+      },
+    });
+    updatedBookings = updatedBookings.concat(allUpdatedBookings);
   } else {
-    await prisma.booking.update({
+    const updatedBooking = await prisma.booking.update({
       where: {
         uid,
       },
       data: {
         status: BookingStatus.CANCELLED,
         cancellationReason: cancellationReason,
       },
+      select: {
+        workflowReminders: true,
+        uid: true,
+        scheduledJobs: true,
+      },
     });
+    updatedBookings.push(updatedBooking);
   }
 
   /** TODO: Remove this without breaking functionality */
@@ -299,37 +343,35 @@ async function handler(req: NextApiRequest, res: NextApiResponse) {
     },
   });
 
-  //Workflows - delete all reminders for that booking
+  // delete scheduled jobs of cancelled bookings
+  updatedBookings.forEach((booking) => {
+    cancelScheduledJobs(booking);
+  });
+
+  //Workflows - delete all reminders for bookings
   const remindersToDelete: PrismaPromise<Prisma.BatchPayload>[] = [];
-  bookingToDelete.workflowReminders.forEach((reminder) => {
-    if (reminder.scheduled && reminder.referenceId) {
-      if (reminder.method === WorkflowMethods.EMAIL) {
-        deleteScheduledEmailReminder(reminder.referenceId);
-      } else if (reminder.method === WorkflowMethods.SMS) {
-        deleteScheduledSMSReminder(reminder.referenceId);
+  updatedBookings.forEach((booking) => {
+    booking.workflowReminders.forEach((reminder) => {
+      if (reminder.scheduled && reminder.referenceId) {
+        if (reminder.method === WorkflowMethods.EMAIL) {
+          deleteScheduledEmailReminder(reminder.referenceId);
+        } else if (reminder.method === WorkflowMethods.SMS) {
+          deleteScheduledSMSReminder(reminder.referenceId);
+        }
       }
-    }
-    const reminderToDelete = prisma.workflowReminder.deleteMany({
-      where: {
-        id: reminder.id,
-      },
+      const reminderToDelete = prisma.workflowReminder.deleteMany({
+        where: {
+          id: reminder.id,
+        },
+      });
+      remindersToDelete.push(reminderToDelete);
     });
-    remindersToDelete.push(reminderToDelete);
   });
 
   await Promise.all([apiDeletes, attendeeDeletes, bookingReferenceDeletes].concat(remindersToDelete));
 
   await sendCancelledEmails(evt);
 
-  //Workflows - schedule reminders
-  if (bookingToDelete.eventType?.workflows) {
-    await sendCancelledReminders(
-      bookingToDelete.eventType?.workflows,
-      bookingToDelete.smsReminderNumber,
-      evt
-    );
-  }
-
   res.status(204).end();
 }