cal.diy/packages/features/bookings/lib/onBookingEvents/BookingEventHandlerService.ts

import type { ISimpleLogger } from "@calcom/features/di/shared/services/logger.service";
import type { HashedLinkService } from "@calcom/features/hashedLink/lib/service/HashedLinkService";
import { safeStringify } from "@calcom/lib/safeStringify";
import type { BookingCreatedPayload, BookingRescheduledPayload } from "./types";

interface BookingEventHandlerDeps {
  log: ISimpleLogger;
  hashedLinkService: HashedLinkService;
}

interface OnBookingCreatedParams {
  payload: BookingCreatedPayload;
}

interface OnBookingRescheduledParams {
  payload: BookingRescheduledPayload;
}

export class BookingEventHandlerService {
  private readonly log: BookingEventHandlerDeps["log"];

  constructor(private readonly deps: BookingEventHandlerDeps) {
    this.log = deps.log;
  }

  async onBookingCreated(params: OnBookingCreatedParams) {
    const { payload } = params;
    this.log.debug("onBookingCreated", safeStringify(payload));
    if (payload.config.isDryRun) {
      return;
    }
    await this.onBookingCreatedOrRescheduled(payload);
  }

  async onBookingRescheduled(params: OnBookingRescheduledParams) {
    const { payload } = params;
    this.log.debug("onBookingRescheduled", safeStringify(payload));
    if (payload.config.isDryRun) {
      return;
    }
    await this.onBookingCreatedOrRescheduled(payload);
  }

  private async onBookingCreatedOrRescheduled(payload: BookingCreatedPayload | BookingRescheduledPayload) {
    const results = await Promise.allSettled([
      this.updatePrivateLinkUsage(payload.bookingFormData.hashedLink),
    ]);
    results.forEach((result) => {
      if (result.status === "rejected") {
        this.log.error(
          "Error while executing onBookingCreatedOrRescheduled task",
          safeStringify(result.reason)
        );
      }
    });
  }

  private async updatePrivateLinkUsage(hashedLink: string | null) {
    try {
      if (hashedLink) {
        await this.deps.hashedLinkService.validateAndIncrementUsage(hashedLink);
      }
    } catch (error) {
      this.log.error("Error while updating hashed link", safeStringify(error));
    }
  }
}