calendar/packages/features/webhooks/lib/service/WebhookTaskConsumer.ts

import type { BookingForCalEventBuilder } from "@calcom/features/CalendarEventBuilder";
import { WebhookTriggerEvents } from "@calcom/prisma/enums";
import type { CalendarEvent } from "@calcom/types/Calendar";
import type { WebhookEventDTO, WebhookSubscriber } from "../dto/types";
import type { PayloadBuilderFactory } from "../factory/versioned/PayloadBuilderFactory";
import type { IWebhookDataFetcher } from "../interface/IWebhookDataFetcher";
import type { IWebhookRepository } from "../interface/IWebhookRepository";
import { DEFAULT_WEBHOOK_VERSION } from "../interface/IWebhookRepository";
import type { ILogger } from "../interface/infrastructure";
import type { IWebhookService } from "../interface/services";
import type {
  BookingWebhookTaskPayload,
  PaymentWebhookTaskPayload,
  WebhookTaskPayload,
} from "../types/webhookTask";

export class WebhookTaskConsumer {
  private readonly log: ILogger;

  constructor(
    private readonly webhookRepository: IWebhookRepository,
    private readonly dataFetchers: IWebhookDataFetcher[],
    private readonly payloadBuilderFactory: PayloadBuilderFactory,
    private readonly webhookService: IWebhookService,
    logger: ILogger
  ) {
    this.log = logger.getSubLogger({ prefix: ["[WebhookTaskConsumer]"] });
  }

  /**
   * Main entry point for processing webhook delivery tasks.
   */
  async processWebhookTask(payload: WebhookTaskPayload, taskId: string): Promise<void> {
    this.log.debug("Processing webhook delivery task", {
      operationId: payload.operationId,
      taskId,
      triggerEvent: payload.triggerEvent,
    });

    try {
      const fetcher = this.getDataFetcher(payload.triggerEvent);

      if (!fetcher) {
        this.log.error("No data fetcher found for trigger event", {
          operationId: payload.operationId,
          triggerEvent: payload.triggerEvent,
        });
        throw new Error(`No data fetcher registered for trigger event: ${payload.triggerEvent}`);
      }

      const subscriberContext = fetcher.getSubscriberContext(payload);
      const subscribers = await this.webhookRepository.getSubscribers(subscriberContext);

      if (subscribers.length === 0) {
        this.log.debug("No webhook subscribers found", { operationId: payload.operationId });
        return;
      }

      this.log.debug(`Found ${subscribers.length} webhook subscriber(s)`, {
        operationId: payload.operationId,
      });

      const eventData = await fetcher.fetchEventData(payload);

      if (!eventData) {
        this.log.warn("Event data not found", {
          operationId: payload.operationId,
          triggerEvent: payload.triggerEvent,
        });
        return;
      }

      await this.sendWebhooksToSubscribers(subscribers, eventData, payload);

      this.log.debug("Webhook delivery task completed", {
        operationId: payload.operationId,
        subscriberCount: subscribers.length,
      });
    } catch (error) {
      this.log.error("Failed to process webhook delivery task", {
        operationId: payload.operationId,
        taskId,
        error: error instanceof Error ? error.message : String(error),
      });
      throw error;
    }
  }

  /**
   * Get the appropriate data fetcher for the trigger event.
   *
   * Uses polymorphism via canHandle() method - each fetcher knows which events it handles.
   */
  private getDataFetcher(triggerEvent: string): IWebhookDataFetcher | null {
    return this.dataFetchers.find((fetcher) => fetcher.canHandle(triggerEvent as never)) || null;
  }

  /**
   * Build webhook payloads and send to each subscriber via WebhookService.
   * Uses WebhookService.processWebhooks() for HTTP delivery.
   */
  private async sendWebhooksToSubscribers(
    subscribers: WebhookSubscriber[],
    eventData: Record<string, unknown>,
    payload: WebhookTaskPayload
  ): Promise<void> {
    if (subscribers.length === 0) {
      this.log.debug("No subscribers to send webhooks to");
      return;
    }

    try {
      const dto = this.buildDTO(eventData, payload);

      if (!dto) {
        this.log.warn("Failed to build DTO for webhook", {
          triggerEvent: payload.triggerEvent,
          operationId: payload.operationId,
        });
        return;
      }

      const builder = this.payloadBuilderFactory.getBuilder(DEFAULT_WEBHOOK_VERSION, dto.triggerEvent);
      const webhookPayload = builder.build(dto);

      await this.webhookService.processWebhooks(dto.triggerEvent, webhookPayload, subscribers);

      this.log.debug("Webhook sending completed", {
        subscriberCount: subscribers.length,
        triggerEvent: payload.triggerEvent,
        operationId: payload.operationId,
      });
    } catch (error) {
      this.log.error("Error in sendWebhooksToSubscribers", {
        error: error instanceof Error ? error.message : String(error),
        triggerEvent: payload.triggerEvent,
      });
      throw error;
    }
  }
  /**
   * Build WebhookEventDTO from fetched event data.
   *
   * This method maps the data fetched from DB into the DTO structure
   * expected by PayloadBuilders.
   */
  private buildDTO(eventData: Record<string, unknown>, payload: WebhookTaskPayload): WebhookEventDTO | null {
    const { triggerEvent, timestamp } = payload;

    const calendarEvent = eventData.calendarEvent as CalendarEvent | undefined;
    const booking = eventData.booking as BookingForCalEventBuilder | undefined;
    const eventType = booking?.eventType;

    if (!calendarEvent || !booking || !eventType) {
      this.log.warn("Missing required data to build DTO", {
        hasCalendarEvent: !!calendarEvent,
        hasBooking: !!booking,
        hasEventType: !!eventType,
      });
      return null;
    }

    const eventTypeInfo = {
      id: eventType.id,
      eventTitle: eventType.title,
      eventDescription: eventType.description,
      requiresConfirmation: eventType.requiresConfirmation,
      price: eventType.price,
      currency: eventType.currency,
      length: eventType.length,
    };

    const bookingPayload = payload as BookingWebhookTaskPayload;
    const baseDTO = {
      createdAt: timestamp,
      bookingId: booking.id,
      eventTypeId: eventType.id,
      userId: booking.user?.id ?? null,
      teamId: bookingPayload.teamId ?? null,
      orgId: bookingPayload.orgId,
      platformClientId: bookingPayload.platformClientId ?? bookingPayload.oAuthClientId,
      evt: calendarEvent,
      eventType: eventTypeInfo,
      booking: {
        id: booking.id,
        eventTypeId: booking.eventTypeId,
        userId: booking.userId,
        startTime: booking.startTime,
        smsReminderNumber: booking.smsReminderNumber,
        iCalSequence: booking.iCalSequence,
        // Raw assignmentReason from DB for legacy format [{ reasonEnum, reasonString }]
        assignmentReason: booking.assignmentReason,
      },
    };

    switch (triggerEvent) {
      case WebhookTriggerEvents.BOOKING_REQUESTED:
        return {
          ...baseDTO,
          triggerEvent,
          metadata: {
            ...(typeof booking.metadata === "object" &&
            booking.metadata !== null &&
            !Array.isArray(booking.metadata)
              ? booking.metadata
              : {}),
            ...(bookingPayload.metadata ?? {}),
          },
        } as WebhookEventDTO;
      default:
        this.log.warn("Unsupported trigger event for DTO building", { triggerEvent });
        return null;
    }
  }
}