@blackcode_sa/metaestetics-api 1.7.31 → 1.7.33

package/dist/index.js

@@ -5548,7 +5548,7 @@ var PractitionerService = class extends BaseService {
       if (!practitioner) {
         throw new Error(`Practitioner ${practitionerId} not found`);
       }
-      if (!practitioner.isActive || practitioner.status !== "active" /* ACTIVE */) {
+      if (!practitioner.isActive) {
         throw new Error(`Practitioner ${practitionerId} is not active`);
       }
       const clinic = await this.getClinicService().getClinic(clinicId);

package/dist/index.mjs

@@ -5452,7 +5452,7 @@ var PractitionerService = class extends BaseService {
       if (!practitioner) {
         throw new Error(`Practitioner ${practitionerId} not found`);
       }
-      if (!practitioner.isActive || practitioner.status !== "active" /* ACTIVE */) {
+      if (!practitioner.isActive) {
         throw new Error(`Practitioner ${practitionerId} is not active`);
       }
       const clinic = await this.getClinicService().getClinic(clinicId);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.7.31",
+  "version": "1.7.33",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/admin/aggregation/practitioner-invite/practitioner-invite.aggregation.service.ts

@@ -0,0 +1,576 @@
+import * as admin from "firebase-admin";
+import {
+  PractitionerInvite,
+  PractitionerInviteStatus,
+  PRACTITIONER_INVITES_COLLECTION,
+} from "../../../types/clinic/practitioner-invite.types";
+import { DoctorInfo } from "../../../types/clinic";
+import {
+  Practitioner,
+  PRACTITIONERS_COLLECTION,
+  PractitionerClinicWorkingHours,
+} from "../../../types/practitioner";
+import { CLINICS_COLLECTION, Clinic } from "../../../types/clinic";
+import { ClinicInfo } from "../../../types/profile";
+import { Logger } from "../../logger";
+
+/**
+ * @class PractitionerInviteAggregationService
+ * @description Handles aggregation tasks and side effects related to practitioner invite lifecycle events.
+ * This service is intended to be used primarily by background functions (e.g., Cloud Functions)
+ * triggered by changes in the practitioner-invites collection.
+ */
+export class PractitionerInviteAggregationService {
+  private db: admin.firestore.Firestore;
+
+  /**
+   * Constructor for PractitionerInviteAggregationService.
+   * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
+   */
+  constructor(firestore?: admin.firestore.Firestore) {
+    this.db = firestore || admin.firestore();
+    Logger.info("[PractitionerInviteAggregationService] Initialized.");
+  }
+
+  /**
+   * Handles side effects when a practitioner invite is first created.
+   * This function would typically be called by a Firestore onCreate trigger.
+   * @param {PractitionerInvite} invite - The newly created PractitionerInvite object.
+   * @returns {Promise<void>}
+   */
+  async handleInviteCreate(invite: PractitionerInvite): Promise<void> {
+    Logger.info(
+      `[PractitionerInviteAggService] Handling CREATE for invite: ${invite.id}, practitioner: ${invite.practitionerId}, clinic: ${invite.clinicId}, status: ${invite.status}`
+    );
+
+    try {
+      // TODO: Add any side effects needed when an invite is created
+      // For example: Send notification emails, update counters, etc.
+      // Currently, the main email sending is handled by the mailing service
+
+      Logger.info(
+        `[PractitionerInviteAggService] Successfully processed CREATE for invite: ${invite.id}`
+      );
+    } catch (error) {
+      Logger.error(
+        `[PractitionerInviteAggService] Error in handleInviteCreate for invite ${invite.id}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Handles side effects when a practitioner invite is updated.
+   * This function would typically be called by a Firestore onUpdate trigger.
+   * @param {PractitionerInvite} before - The PractitionerInvite object before the update.
+   * @param {PractitionerInvite} after - The PractitionerInvite object after the update.
+   * @returns {Promise<void>}
+   */
+  async handleInviteUpdate(
+    before: PractitionerInvite,
+    after: PractitionerInvite
+  ): Promise<void> {
+    Logger.info(
+      `[PractitionerInviteAggService] Handling UPDATE for invite: ${after.id}. Status ${before.status} -> ${after.status}`
+    );
+
+    try {
+      const statusChanged = before.status !== after.status;
+
+      if (statusChanged) {
+        Logger.info(
+          `[PractitionerInviteAggService] Status changed for invite ${after.id}: ${before.status} -> ${after.status}`
+        );
+
+        // Handle PENDING -> ACCEPTED
+        if (
+          before.status === PractitionerInviteStatus.PENDING &&
+          after.status === PractitionerInviteStatus.ACCEPTED
+        ) {
+          Logger.info(
+            `[PractitionerInviteAggService] Invite ${after.id} PENDING -> ACCEPTED. Adding practitioner to clinic.`
+          );
+          await this.handleInviteAccepted(after);
+        }
+
+        // Handle PENDING -> REJECTED
+        else if (
+          before.status === PractitionerInviteStatus.PENDING &&
+          after.status === PractitionerInviteStatus.REJECTED
+        ) {
+          Logger.info(
+            `[PractitionerInviteAggService] Invite ${after.id} PENDING -> REJECTED.`
+          );
+          await this.handleInviteRejected(after);
+        }
+
+        // Handle PENDING -> CANCELLED
+        else if (
+          before.status === PractitionerInviteStatus.PENDING &&
+          after.status === PractitionerInviteStatus.CANCELLED
+        ) {
+          Logger.info(
+            `[PractitionerInviteAggService] Invite ${after.id} PENDING -> CANCELLED.`
+          );
+          await this.handleInviteCancelled(after);
+        }
+      }
+
+      Logger.info(
+        `[PractitionerInviteAggService] Successfully processed UPDATE for invite: ${after.id}`
+      );
+    } catch (error) {
+      Logger.error(
+        `[PractitionerInviteAggService] Error in handleInviteUpdate for invite ${after.id}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Handles side effects when a practitioner invite is deleted.
+   * @param deletedInvite - The PractitionerInvite object that was deleted.
+   * @returns {Promise<void>}
+   */
+  async handleInviteDelete(deletedInvite: PractitionerInvite): Promise<void> {
+    Logger.info(
+      `[PractitionerInviteAggService] Handling DELETE for invite: ${deletedInvite.id}`
+    );
+
+    try {
+      // TODO: Add cleanup logic if needed
+      // For now, deleting an invite doesn't require additional aggregation actions
+      // since the practitioner-clinic relationship would already be established if the invite was accepted
+
+      Logger.info(
+        `[PractitionerInviteAggService] Successfully processed DELETE for invite: ${deletedInvite.id}`
+      );
+    } catch (error) {
+      Logger.error(
+        `[PractitionerInviteAggService] Error in handleInviteDelete for invite ${deletedInvite.id}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  // --- Private Helper Methods ---
+
+  /**
+   * Handles the business logic when a practitioner accepts an invite.
+   * This includes adding the practitioner to the clinic and the clinic to the practitioner.
+   * @param {PractitionerInvite} invite - The accepted invite
+   * @returns {Promise<void>}
+   */
+  private async handleInviteAccepted(
+    invite: PractitionerInvite
+  ): Promise<void> {
+    Logger.info(
+      `[PractitionerInviteAggService] Processing accepted invite ${invite.id} for practitioner ${invite.practitionerId} and clinic ${invite.clinicId}`
+    );
+
+    try {
+      // Fetch the current practitioner and clinic data to ensure they exist
+      const [practitioner, clinic] = await Promise.all([
+        this.fetchPractitionerById(invite.practitionerId),
+        this.fetchClinicById(invite.clinicId),
+      ]);
+
+      if (!practitioner) {
+        throw new Error(
+          `Practitioner ${invite.practitionerId} not found during invite acceptance`
+        );
+      }
+
+      if (!clinic) {
+        throw new Error(
+          `Clinic ${invite.clinicId} not found during invite acceptance`
+        );
+      }
+
+      // Create DoctorInfo object for aggregation
+      const doctorInfo: DoctorInfo = {
+        id: practitioner.id,
+        name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+        description: practitioner.basicInfo.bio || undefined,
+        photo:
+          typeof practitioner.basicInfo.profileImageUrl === "object" &&
+          practitioner.basicInfo.profileImageUrl !== null
+            ? (practitioner.basicInfo.profileImageUrl as any)?.url || null
+            : typeof practitioner.basicInfo.profileImageUrl === "string"
+            ? practitioner.basicInfo.profileImageUrl
+            : null,
+        rating: practitioner.reviewInfo?.averageRating || 0,
+        services: practitioner.proceduresInfo?.map((proc) => proc.name) || [], // Use procedure names as services
+      };
+
+      // Create ClinicInfo object for aggregation
+      const clinicInfo: ClinicInfo = {
+        id: clinic.id,
+        featuredPhoto:
+          typeof clinic.coverPhoto === "object" && clinic.coverPhoto !== null
+            ? (clinic.coverPhoto as any)?.url || ""
+            : typeof clinic.coverPhoto === "string"
+            ? clinic.coverPhoto
+            : "",
+        name: clinic.name,
+        description: clinic.description || null,
+        location: clinic.location,
+        contactInfo: clinic.contactInfo,
+      };
+
+      // Check if practitioner is already associated with the clinic
+      const isPractitionerInClinic = clinic.doctors.includes(practitioner.id);
+      const isClinicInPractitioner = practitioner.clinics.includes(clinic.id);
+
+      // Add practitioner to clinic if not already there
+      if (!isPractitionerInClinic) {
+        Logger.info(
+          `[PractitionerInviteAggService] Adding practitioner ${practitioner.id} to clinic ${clinic.id}`
+        );
+        await this.addPractitionerToClinic(clinic.id, doctorInfo);
+      } else {
+        Logger.info(
+          `[PractitionerInviteAggService] Practitioner ${practitioner.id} already in clinic ${clinic.id}, updating info`
+        );
+        await this.updatePractitionerInfoInClinic(clinic.id, doctorInfo);
+      }
+
+      // Add clinic to practitioner if not already there
+      if (!isClinicInPractitioner) {
+        Logger.info(
+          `[PractitionerInviteAggService] Adding clinic ${clinic.id} to practitioner ${practitioner.id}`
+        );
+        await this.addClinicToPractitioner(practitioner.id, clinicInfo, invite);
+      } else {
+        Logger.info(
+          `[PractitionerInviteAggService] Clinic ${clinic.id} already in practitioner ${practitioner.id}, updating working hours`
+        );
+        await this.updatePractitionerWorkingHours(practitioner.id, invite);
+      }
+
+      Logger.info(
+        `[PractitionerInviteAggService] Successfully processed accepted invite ${invite.id}`
+      );
+    } catch (error) {
+      Logger.error(
+        `[PractitionerInviteAggService] Error processing accepted invite ${invite.id}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Handles the business logic when a practitioner rejects an invite.
+   * @param {PractitionerInvite} invite - The rejected invite
+   * @returns {Promise<void>}
+   */
+  private async handleInviteRejected(
+    invite: PractitionerInvite
+  ): Promise<void> {
+    Logger.info(
+      `[PractitionerInviteAggService] Processing rejected invite ${invite.id}`
+    );
+
+    try {
+      // TODO: Add any side effects for rejected invites
+      // For example: Update counters, send notifications, etc.
+
+      Logger.info(
+        `[PractitionerInviteAggService] Successfully processed rejected invite ${invite.id}`
+      );
+    } catch (error) {
+      Logger.error(
+        `[PractitionerInviteAggService] Error processing rejected invite ${invite.id}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Handles the business logic when an invite is cancelled by admin.
+   * @param {PractitionerInvite} invite - The cancelled invite
+   * @returns {Promise<void>}
+   */
+  private async handleInviteCancelled(
+    invite: PractitionerInvite
+  ): Promise<void> {
+    Logger.info(
+      `[PractitionerInviteAggService] Processing cancelled invite ${invite.id}`
+    );
+
+    try {
+      // TODO: Add any side effects for cancelled invites
+      // For example: Update counters, send notifications, etc.
+
+      Logger.info(
+        `[PractitionerInviteAggService] Successfully processed cancelled invite ${invite.id}`
+      );
+    } catch (error) {
+      Logger.error(
+        `[PractitionerInviteAggService] Error processing cancelled invite ${invite.id}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Adds practitioner information to a clinic when an invite is accepted.
+   * @param clinicId - ID of the clinic to update
+   * @param doctorInfo - Doctor information to add to the clinic
+   * @returns {Promise<void>}
+   */
+  private async addPractitionerToClinic(
+    clinicId: string,
+    doctorInfo: DoctorInfo
+  ): Promise<void> {
+    Logger.info(
+      `[PractitionerInviteAggService] Adding practitioner ${doctorInfo.id} to clinic ${clinicId}`
+    );
+
+    try {
+      const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(clinicId);
+
+      await clinicRef.update({
+        doctors: admin.firestore.FieldValue.arrayUnion(doctorInfo.id),
+        doctorsInfo: admin.firestore.FieldValue.arrayUnion(doctorInfo),
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      });
+
+      Logger.info(
+        `[PractitionerInviteAggService] Successfully added practitioner ${doctorInfo.id} to clinic ${clinicId}`
+      );
+    } catch (error) {
+      Logger.error(
+        `[PractitionerInviteAggService] Error adding practitioner ${doctorInfo.id} to clinic ${clinicId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Updates practitioner information in a clinic.
+   * @param clinicId - ID of the clinic to update
+   * @param doctorInfo - Updated doctor information
+   * @returns {Promise<void>}
+   */
+  private async updatePractitionerInfoInClinic(
+    clinicId: string,
+    doctorInfo: DoctorInfo
+  ): Promise<void> {
+    Logger.info(
+      `[PractitionerInviteAggService] Updating practitioner ${doctorInfo.id} info in clinic ${clinicId}`
+    );
+
+    try {
+      const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(clinicId);
+
+      // Get current clinic data to filter doctorsInfo manually
+      const clinicDoc = await clinicRef.get();
+      if (clinicDoc.exists) {
+        const clinicData = clinicDoc.data() as Clinic;
+        const currentDoctorsInfo = clinicData?.doctorsInfo || [];
+
+        // Filter out the doctor info with matching ID
+        const filteredDoctorsInfo = currentDoctorsInfo.filter(
+          (doctor: any) => doctor.id !== doctorInfo.id
+        );
+
+        // Add the updated doctor info to the filtered array
+        const updatedDoctorsInfo = [...filteredDoctorsInfo, doctorInfo];
+
+        // Update with the complete new array
+        await clinicRef.update({
+          doctorsInfo: updatedDoctorsInfo,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+
+        Logger.info(
+          `[PractitionerInviteAggService] Successfully updated practitioner ${doctorInfo.id} info in clinic ${clinicId}`
+        );
+      } else {
+        Logger.warn(
+          `[PractitionerInviteAggService] Clinic ${clinicId} not found for doctor info update`
+        );
+      }
+    } catch (error) {
+      Logger.error(
+        `[PractitionerInviteAggService] Error updating practitioner ${doctorInfo.id} info in clinic ${clinicId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Adds a clinic to a practitioner's profile with working hours from the invite.
+   * @param {string} practitionerId - The practitioner ID
+   * @param {ClinicInfo} clinicInfo - The clinic information
+   * @param {PractitionerInvite} invite - The accepted invite containing working hours
+   * @returns {Promise<void>}
+   */
+  private async addClinicToPractitioner(
+    practitionerId: string,
+    clinicInfo: ClinicInfo,
+    invite: PractitionerInvite
+  ): Promise<void> {
+    Logger.info(
+      `[PractitionerInviteAggService] Adding clinic ${clinicInfo.id} to practitioner ${practitionerId}`
+    );
+
+    try {
+      const practitionerRef = this.db
+        .collection(PRACTITIONERS_COLLECTION)
+        .doc(practitionerId);
+
+      // Create working hours object from the invite's proposed working hours
+      const workingHours: PractitionerClinicWorkingHours = {
+        clinicId: clinicInfo.id,
+        workingHours: invite.proposedWorkingHours,
+        isActive: true,
+        createdAt: admin.firestore.Timestamp.now() as any,
+        updatedAt: admin.firestore.Timestamp.now() as any,
+      };
+
+      // Update practitioner document with new clinic and working hours
+      await practitionerRef.update({
+        clinics: admin.firestore.FieldValue.arrayUnion(clinicInfo.id),
+        clinicsInfo: admin.firestore.FieldValue.arrayUnion(clinicInfo),
+        clinicWorkingHours: admin.firestore.FieldValue.arrayUnion(workingHours),
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      });
+
+      Logger.info(
+        `[PractitionerInviteAggService] Successfully added clinic ${clinicInfo.id} to practitioner ${practitionerId}`
+      );
+    } catch (error) {
+      Logger.error(
+        `[PractitionerInviteAggService] Error adding clinic to practitioner:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Updates the working hours for an existing practitioner-clinic relationship.
+   * @param {string} practitionerId - The practitioner ID
+   * @param {PractitionerInvite} invite - The accepted invite containing new working hours
+   * @returns {Promise<void>}
+   */
+  private async updatePractitionerWorkingHours(
+    practitionerId: string,
+    invite: PractitionerInvite
+  ): Promise<void> {
+    Logger.info(
+      `[PractitionerInviteAggService] Updating working hours for practitioner ${practitionerId} at clinic ${invite.clinicId}`
+    );
+
+    try {
+      const practitionerRef = this.db
+        .collection(PRACTITIONERS_COLLECTION)
+        .doc(practitionerId);
+
+      // Get current practitioner data
+      const practitionerDoc = await practitionerRef.get();
+      if (!practitionerDoc.exists) {
+        throw new Error(`Practitioner ${practitionerId} not found`);
+      }
+
+      const practitionerData = practitionerDoc.data() as Practitioner;
+      const currentWorkingHours = practitionerData.clinicWorkingHours || [];
+
+      // Find and update the working hours for this clinic
+      const updatedWorkingHours = currentWorkingHours.map((wh) => {
+        if (wh.clinicId === invite.clinicId) {
+          return {
+            ...wh,
+            workingHours: invite.proposedWorkingHours,
+            isActive: true,
+            updatedAt: admin.firestore.Timestamp.now() as any,
+          };
+        }
+        return wh;
+      });
+
+      // If working hours for this clinic don't exist, add them
+      if (!updatedWorkingHours.some((wh) => wh.clinicId === invite.clinicId)) {
+        updatedWorkingHours.push({
+          clinicId: invite.clinicId,
+          workingHours: invite.proposedWorkingHours,
+          isActive: true,
+          createdAt: admin.firestore.Timestamp.now() as any,
+          updatedAt: admin.firestore.Timestamp.now() as any,
+        });
+      }
+
+      // Update the practitioner document
+      await practitionerRef.update({
+        clinicWorkingHours: updatedWorkingHours,
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      });
+
+      Logger.info(
+        `[PractitionerInviteAggService] Successfully updated working hours for practitioner ${practitionerId} at clinic ${invite.clinicId}`
+      );
+    } catch (error) {
+      Logger.error(
+        `[PractitionerInviteAggService] Error updating practitioner working hours:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  // --- Data Fetching Helpers ---
+
+  /**
+   * Fetches a practitioner by ID.
+   * @param practitionerId The practitioner ID.
+   * @returns {Promise<Practitioner | null>} The practitioner or null if not found.
+   */
+  private async fetchPractitionerById(
+    practitionerId: string
+  ): Promise<Practitioner | null> {
+    try {
+      const doc = await this.db
+        .collection(PRACTITIONERS_COLLECTION)
+        .doc(practitionerId)
+        .get();
+      return doc.exists ? (doc.data() as Practitioner) : null;
+    } catch (error) {
+      Logger.error(
+        `[PractitionerInviteAggService] Error fetching practitioner ${practitionerId}:`,
+        error
+      );
+      return null;
+    }
+  }
+
+  /**
+   * Fetches a clinic by ID.
+   * @param clinicId The clinic ID.
+   * @returns {Promise<Clinic | null>} The clinic or null if not found.
+   */
+  private async fetchClinicById(clinicId: string): Promise<Clinic | null> {
+    try {
+      const doc = await this.db
+        .collection(CLINICS_COLLECTION)
+        .doc(clinicId)
+        .get();
+      return doc.exists ? (doc.data() as Clinic) : null;
+    } catch (error) {
+      Logger.error(
+        `[PractitionerInviteAggService] Error fetching clinic ${clinicId}:`,
+        error
+      );
+      return null;
+    }
+  }
+}

package/src/admin/index.ts

@@ -11,6 +11,10 @@ import {
   PractitionerToken,
   PractitionerTokenStatus,
 } from "../types/practitioner";
+import {
+  PractitionerInvite,
+  PractitionerInviteStatus,
+} from "../types/clinic/practitioner-invite.types";
 import { DoctorInfo } from "../types/clinic";
 import { Procedure, ProcedureSummaryInfo } from "../types/procedure";
 import { PatientProfile } from "../types/patient";
@@ -19,6 +23,7 @@ import { Appointment, AppointmentStatus } from "../types/appointment";
 // Explicitly import the services to re-export them by name
 import { ClinicAggregationService } from "./aggregation/clinic/clinic.aggregation.service";
 import { PractitionerAggregationService } from "./aggregation/practitioner/practitioner.aggregation.service";
+import { PractitionerInviteAggregationService } from "./aggregation/practitioner-invite/practitioner-invite.aggregation.service";
 import { ProcedureAggregationService } from "./aggregation/procedure/procedure.aggregation.service";
 import { PatientAggregationService } from "./aggregation/patient/patient.aggregation.service";
 import { AppointmentAggregationService } from "./aggregation/appointment/appointment.aggregation.service";
@@ -48,6 +53,7 @@ export type {
 export type { Clinic, ClinicLocation } from "../types/clinic";
 export type { ClinicInfo } from "../types/profile";
 export type { Practitioner, PractitionerToken } from "../types/practitioner";
+export type { PractitionerInvite } from "../types/clinic/practitioner-invite.types";
 export type { DoctorInfo } from "../types/clinic";
 export type { Procedure, ProcedureSummaryInfo } from "../types/procedure";
 export type { PatientProfile as Patient } from "../types/patient";
@@ -63,6 +69,7 @@ export {
 } from "../types/notifications";
 export { UserRole } from "../types";
 export { PractitionerTokenStatus } from "../types/practitioner";
+export { PractitionerInviteStatus } from "../types/clinic/practitioner-invite.types";
 export { AppointmentStatus } from "../types/appointment";
 
 // Export admin classes/services explicitly by name
@@ -70,6 +77,7 @@ export {
   NotificationsAdmin,
   ClinicAggregationService,
   PractitionerAggregationService,
+  PractitionerInviteAggregationService,
   ProcedureAggregationService,
   PatientAggregationService,
   AppointmentAggregationService,

package/src/services/practitioner/practitioner.service.ts

@@ -1226,10 +1226,7 @@ export class PractitionerService extends BaseService {
         throw new Error(`Practitioner ${practitionerId} not found`);
       }
 
-      if (
-        !practitioner.isActive ||
-        practitioner.status !== PractitionerStatus.ACTIVE
-      ) {
+      if (!practitioner.isActive) {
         throw new Error(`Practitioner ${practitionerId} is not active`);
       }
 

package/src/types/calendar/index.ts

@@ -233,11 +233,11 @@ export interface SearchCalendarEventsParams {
  */
 export interface CreateBlockingEventParams {
   entityType: "practitioner" | "clinic";
-  entityId: string;
+  entityId: string; // Profile ID of clinic or practitioner, not userRef
   eventName: string;
   eventTime: CalendarEventTime;
   eventType:
-    | CalendarEventType.BLOCKING
+    | CalendarEventType.BLOCKING // Let's only use this enum for doctor's app, then handle more information through description (eg  "Holiday", "Break", "Free Day", "Other")
     | CalendarEventType.BREAK
     | CalendarEventType.FREE_DAY
     | CalendarEventType.OTHER;