@blackcode_sa/metaestetics-api 1.5.28 → 1.5.30

package/src/admin/aggregation/patient/patient.aggregation.service.ts

@@ -0,0 +1,141 @@
+import * as admin from "firebase-admin";
+
+const CALENDAR_SUBCOLLECTION_ID = "calendar";
+
+/**
+ * @class PatientAggregationService
+ * @description Handles aggregation tasks related to patient data updates/deletions.
+ */
+export class PatientAggregationService {
+  private db: admin.firestore.Firestore;
+
+  constructor(firestore?: admin.firestore.Firestore) {
+    this.db = firestore || admin.firestore();
+  }
+
+  // --- Methods for Patient Creation --- >
+  // No specific aggregations defined for patient creation in the plan.
+
+  // --- Methods for Patient Update --- >
+  /**
+   * Updates patient information in calendar events
+   * @param patientId - ID of the patient
+   * @param patientInfo - Updated patient information
+   * @returns {Promise<void>}
+   */
+  async updatePatientInfoInCalendarEvents(
+    patientId: string,
+    patientInfo: any
+  ): Promise<void> {
+    if (!patientId || !patientInfo) {
+      console.log(
+        "[PatientAggregationService] Missing patientId or patientInfo for calendar update. Skipping."
+      );
+      return;
+    }
+
+    console.log(
+      `[PatientAggregationService] Querying upcoming calendar events for patient ${patientId} to update patient info.`
+    );
+
+    const now = admin.firestore.Timestamp.now();
+    // Use a Collection Group query
+    const calendarEventsQuery = this.db
+      .collectionGroup(CALENDAR_SUBCOLLECTION_ID)
+      .where("patientId", "==", patientId)
+      .where("eventTime.start", ">", now);
+
+    try {
+      const snapshot = await calendarEventsQuery.get();
+      if (snapshot.empty) {
+        console.log(
+          `[PatientAggregationService] No upcoming calendar events found for patient ${patientId}. No patient info updates needed.`
+        );
+        return;
+      }
+
+      const batch = this.db.batch();
+      snapshot.docs.forEach((doc) => {
+        console.log(
+          `[PatientAggregationService] Updating patient info for calendar event ${doc.ref.path}`
+        );
+        batch.update(doc.ref, {
+          patientInfo: patientInfo,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      });
+
+      await batch.commit();
+      console.log(
+        `[PatientAggregationService] Successfully updated patient info in ${snapshot.size} upcoming calendar events for patient ${patientId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[PatientAggregationService] Error updating patient info in calendar events for patient ${patientId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  // --- Methods for Patient Deletion --- >
+  /**
+   * Cancels all upcoming calendar events associated with a deleted patient
+   * @param patientId - ID of the deleted patient
+   * @returns {Promise<void>}
+   */
+  async cancelUpcomingCalendarEventsForPatient(
+    patientId: string
+  ): Promise<void> {
+    if (!patientId) {
+      console.log(
+        "[PatientAggregationService] Missing patientId for canceling calendar events. Skipping."
+      );
+      return;
+    }
+
+    console.log(
+      `[PatientAggregationService] Querying upcoming calendar events for patient ${patientId} to cancel.`
+    );
+
+    const now = admin.firestore.Timestamp.now();
+    // Use a Collection Group query
+    const calendarEventsQuery = this.db
+      .collectionGroup(CALENDAR_SUBCOLLECTION_ID)
+      .where("patientId", "==", patientId)
+      .where("eventTime.start", ">", now);
+
+    try {
+      const snapshot = await calendarEventsQuery.get();
+      if (snapshot.empty) {
+        console.log(
+          `[PatientAggregationService] No upcoming calendar events found for patient ${patientId}. No events to cancel.`
+        );
+        return;
+      }
+
+      const batch = this.db.batch();
+      snapshot.docs.forEach((doc) => {
+        console.log(
+          `[PatientAggregationService] Canceling calendar event ${doc.ref.path}`
+        );
+        batch.update(doc.ref, {
+          status: "CANCELED",
+          cancelReason: "Patient deleted",
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      });
+
+      await batch.commit();
+      console.log(
+        `[PatientAggregationService] Successfully canceled ${snapshot.size} upcoming calendar events for patient ${patientId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[PatientAggregationService] Error canceling calendar events for patient ${patientId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+}

package/src/admin/aggregation/practitioner/README.md

@@ -0,0 +1,42 @@
+# Practitioner Aggregation Service (Admin)
+
+This service centralizes the logic for updating aggregated data in various Firestore collections _when a practitioner is created, updated, or deleted_. It is designed primarily for use by Cloud Functions triggered by changes in the `practitioners` collection.
+
+## `PractitionerAggregationService` Class
+
+### Constructor
+
+```typescript
+constructor(firestore?: admin.firestore.Firestore)
+```
+
+Initializes the service with an Admin Firestore instance. Uses the default instance if none is provided.
+
+### Methods Triggered by Practitioner **Creation**
+
+- **`addPractitionerToClinic(clinicId: string, doctorInfo: DoctorInfo): Promise<void>`**
+  - Adds the `practitionerId` (from `doctorInfo.id`) and the `doctorInfo` object to the `doctors` and `doctorsInfo` arrays respectively in the specified `Clinic` document.
+  - Typically called for each clinic the new practitioner is associated with.
+
+### Methods Triggered by Practitioner **Update**
+
+- **`updatePractitionerInfoInClinics(clinicIds: string[], doctorInfo: DoctorInfo): Promise<void>`**
+  - Updates the aggregated `doctorsInfo` array within multiple `Clinic` documents associated with the practitioner.
+  - Uses a batch write to first remove the old `DoctorInfo` (matching by `id`) and then add the updated `doctorInfo`.
+- **`updatePractitionerInfoInProcedures(procedureIds: string[], doctorInfo: DoctorInfo): Promise<void>`**
+  - Updates the embedded `doctorInfo` object within multiple `Procedure` documents associated with the updated practitioner.
+- **`updatePractitionerInfoInCalendarEvents(practitionerId: string, practitionerInfo: DoctorInfo): Promise<void>`**
+  - Uses a Collection Group query (`calendar` subcollection) to find all _upcoming_ calendar events associated with the `practitionerId`.
+  - Updates the embedded `practitionerInfo` object in these calendar events.
+
+### Methods Triggered by Practitioner **Deletion**
+
+- **`removePractitionerFromClinics(clinicIds: string[], practitionerId: string): Promise<void>`**
+  - Removes the `practitionerId` from the `doctors` array and the corresponding `DoctorInfo` object (matching by `id`) from the `doctorsInfo` array in multiple `Clinic` documents.
+- **`cancelUpcomingCalendarEventsForPractitioner(practitionerId: string): Promise<void>`**
+  - Uses a Collection Group query (`calendar` subcollection) to find all _upcoming_ calendar events associated with the `practitionerId`.
+  - Sets the `status` of these events to `CANCELED` and adds a `cancelReason` ("Practitioner deleted").
+- **`removePractitionerFromPatients(patientIds: string[], practitionerId: string): Promise<void>`**
+  - Removes the `practitionerId` from the `doctorIds` array in multiple `Patient` documents.
+- **`inactivateProceduresForPractitioner(procedureIds: string[]): Promise<void>`**
+  - Sets the `isActive` flag to `false` for multiple `Procedure` documents associated with the deleted practitioner.

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

@@ -0,0 +1,433 @@
+import * as admin from "firebase-admin";
+import { DoctorInfo } from "../../../types/clinic";
+import { PROCEDURES_COLLECTION } from "../../../types/procedure";
+import { PRACTITIONERS_COLLECTION } from "../../../types/practitioner";
+import { PATIENTS_COLLECTION } from "../../../types/patient";
+import { CLINICS_COLLECTION } from "../../../types/clinic";
+
+const CALENDAR_SUBCOLLECTION_ID = "calendar";
+
+/**
+ * @class PractitionerAggregationService
+ * @description Handles aggregation tasks related to practitioner data updates/deletions.
+ */
+export class PractitionerAggregationService {
+  private db: admin.firestore.Firestore;
+
+  constructor(firestore?: admin.firestore.Firestore) {
+    this.db = firestore || admin.firestore();
+  }
+
+  /**
+   * Adds practitioner information to a clinic when a new practitioner is created
+   * @param clinicId - ID of the clinic to update
+   * @param doctorInfo - Doctor information to add to the clinic
+   * @returns {Promise<void>}
+   */
+  async addPractitionerToClinic(
+    clinicId: string,
+    doctorInfo: DoctorInfo
+  ): Promise<void> {
+    if (!clinicId || !doctorInfo) {
+      console.log(
+        "[PractitionerAggregationService] Missing clinicId or doctorInfo for adding practitioner to clinic. Skipping."
+      );
+      return;
+    }
+
+    const practitionerId = doctorInfo.id;
+    console.log(
+      `[PractitionerAggregationService] Adding practitioner ${practitionerId} to clinic ${clinicId}.`
+    );
+
+    const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(clinicId);
+
+    try {
+      await clinicRef.update({
+        doctors: admin.firestore.FieldValue.arrayUnion(practitionerId),
+        doctorsInfo: admin.firestore.FieldValue.arrayUnion(doctorInfo),
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      });
+
+      console.log(
+        `[PractitionerAggregationService] Successfully added practitioner ${practitionerId} to clinic ${clinicId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[PractitionerAggregationService] Error adding practitioner ${practitionerId} to clinic ${clinicId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Updates practitioner information in associated clinics
+   * @param clinicIds - IDs of clinics associated with the practitioner
+   * @param doctorInfo - Updated doctor information
+   * @returns {Promise<void>}
+   */
+  async updatePractitionerInfoInClinics(
+    clinicIds: string[],
+    doctorInfo: DoctorInfo
+  ): Promise<void> {
+    if (!clinicIds || clinicIds.length === 0 || !doctorInfo) {
+      console.log(
+        "[PractitionerAggregationService] Missing clinicIds or doctorInfo for updating practitioner in clinics. Skipping."
+      );
+      return;
+    }
+
+    const batch = this.db.batch();
+    const practitionerId = doctorInfo.id;
+
+    console.log(
+      `[PractitionerAggregationService] Starting batch update of practitioner ${practitionerId} in ${clinicIds.length} clinics.`
+    );
+
+    for (const clinicId of clinicIds) {
+      const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(clinicId);
+
+      // Remove old doctor info based on ID matcher
+      batch.update(clinicRef, {
+        doctorsInfo: admin.firestore.FieldValue.arrayRemove({
+          id: practitionerId,
+        }),
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      });
+      // Add updated doctor info
+      batch.update(clinicRef, {
+        doctorsInfo: admin.firestore.FieldValue.arrayUnion(doctorInfo),
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      });
+    }
+
+    try {
+      await batch.commit();
+      console.log(
+        `[PractitionerAggregationService] Successfully updated practitioner ${practitionerId} info in ${clinicIds.length} clinics.`
+      );
+    } catch (error) {
+      console.error(
+        `[PractitionerAggregationService] Error updating practitioner ${practitionerId} info in clinics:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Updates practitioner information in associated procedures
+   * @param procedureIds - IDs of procedures associated with the practitioner
+   * @param doctorInfo - Updated doctor information
+   * @returns {Promise<void>}
+   */
+  async updatePractitionerInfoInProcedures(
+    procedureIds: string[],
+    doctorInfo: DoctorInfo
+  ): Promise<void> {
+    if (!procedureIds || procedureIds.length === 0 || !doctorInfo) {
+      console.log(
+        "[PractitionerAggregationService] Missing procedureIds or doctorInfo for updating practitioner in procedures. Skipping."
+      );
+      return;
+    }
+
+    const batch = this.db.batch();
+    const practitionerId = doctorInfo.id;
+
+    console.log(
+      `[PractitionerAggregationService] Starting batch update of practitioner ${practitionerId} in ${procedureIds.length} procedures.`
+    );
+
+    for (const procedureId of procedureIds) {
+      const procedureRef = this.db
+        .collection(PROCEDURES_COLLECTION)
+        .doc(procedureId);
+
+      // Update the embedded doctorInfo object directly
+      batch.update(procedureRef, {
+        doctorInfo: doctorInfo,
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      });
+    }
+
+    try {
+      await batch.commit();
+      console.log(
+        `[PractitionerAggregationService] Successfully updated practitioner ${practitionerId} info in ${procedureIds.length} procedures.`
+      );
+    } catch (error) {
+      console.error(
+        `[PractitionerAggregationService] Error updating practitioner ${practitionerId} info in procedures:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Updates practitioner information in calendar events
+   * @param practitionerId - ID of the practitioner
+   * @param practitionerInfo - Updated practitioner information
+   * @returns {Promise<void>}
+   */
+  async updatePractitionerInfoInCalendarEvents(
+    practitionerId: string,
+    practitionerInfo: DoctorInfo
+  ): Promise<void> {
+    if (!practitionerId || !practitionerInfo) {
+      console.log(
+        "[PractitionerAggregationService] Missing practitionerId or practitionerInfo for calendar update. Skipping."
+      );
+      return;
+    }
+
+    console.log(
+      `[PractitionerAggregationService] Querying upcoming calendar events for practitioner ${practitionerId} to update practitioner info.`
+    );
+
+    const now = admin.firestore.Timestamp.now();
+    // Use a Collection Group query
+    const calendarEventsQuery = this.db
+      .collectionGroup(CALENDAR_SUBCOLLECTION_ID)
+      .where("practitionerId", "==", practitionerId)
+      .where("eventTime.start", ">", now);
+
+    try {
+      const snapshot = await calendarEventsQuery.get();
+      if (snapshot.empty) {
+        console.log(
+          `[PractitionerAggregationService] No upcoming calendar events found for practitioner ${practitionerId}. No doctor info updates needed.`
+        );
+        return;
+      }
+
+      const batch = this.db.batch();
+      snapshot.docs.forEach((doc) => {
+        console.log(
+          `[PractitionerAggregationService] Updating practitioner info for calendar event ${doc.ref.path}`
+        );
+        batch.update(doc.ref, {
+          practitionerInfo: practitionerInfo,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      });
+
+      await batch.commit();
+      console.log(
+        `[PractitionerAggregationService] Successfully updated practitioner info in ${snapshot.size} upcoming calendar events for practitioner ${practitionerId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[PractitionerAggregationService] Error updating practitioner info in calendar events for practitioner ${practitionerId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Removes practitioner from clinics when a practitioner is deleted
+   * @param clinicIds - IDs of clinics associated with the practitioner
+   * @param practitionerId - ID of the deleted practitioner
+   * @returns {Promise<void>}
+   */
+  async removePractitionerFromClinics(
+    clinicIds: string[],
+    practitionerId: string
+  ): Promise<void> {
+    if (!clinicIds || clinicIds.length === 0 || !practitionerId) {
+      console.log(
+        "[PractitionerAggregationService] Missing clinicIds or practitionerId for removing practitioner from clinics. Skipping."
+      );
+      return;
+    }
+
+    const batch = this.db.batch();
+
+    console.log(
+      `[PractitionerAggregationService] Starting batch removal of practitioner ${practitionerId} from ${clinicIds.length} clinics.`
+    );
+
+    for (const clinicId of clinicIds) {
+      const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(clinicId);
+
+      // Remove doctor ID from doctors array
+      batch.update(clinicRef, {
+        doctors: admin.firestore.FieldValue.arrayRemove(practitionerId),
+        // Remove all doctor info objects where id matches the practitioner ID
+        doctorsInfo: admin.firestore.FieldValue.arrayRemove({
+          id: practitionerId,
+        }),
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      });
+    }
+
+    try {
+      await batch.commit();
+      console.log(
+        `[PractitionerAggregationService] Successfully removed practitioner ${practitionerId} from ${clinicIds.length} clinics.`
+      );
+    } catch (error) {
+      console.error(
+        `[PractitionerAggregationService] Error removing practitioner ${practitionerId} from clinics:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Cancels all upcoming calendar events for a deleted practitioner
+   * @param practitionerId - ID of the deleted practitioner
+   * @returns {Promise<void>}
+   */
+  async cancelUpcomingCalendarEventsForPractitioner(
+    practitionerId: string
+  ): Promise<void> {
+    if (!practitionerId) {
+      console.log(
+        "[PractitionerAggregationService] Missing practitionerId for canceling calendar events. Skipping."
+      );
+      return;
+    }
+
+    console.log(
+      `[PractitionerAggregationService] Querying upcoming calendar events for practitioner ${practitionerId} to cancel.`
+    );
+
+    const now = admin.firestore.Timestamp.now();
+    // Use a Collection Group query
+    const calendarEventsQuery = this.db
+      .collectionGroup(CALENDAR_SUBCOLLECTION_ID)
+      .where("practitionerId", "==", practitionerId)
+      .where("eventTime.start", ">", now);
+
+    try {
+      const snapshot = await calendarEventsQuery.get();
+      if (snapshot.empty) {
+        console.log(
+          `[PractitionerAggregationService] No upcoming calendar events found for practitioner ${practitionerId}. No events to cancel.`
+        );
+        return;
+      }
+
+      const batch = this.db.batch();
+      snapshot.docs.forEach((doc) => {
+        console.log(
+          `[PractitionerAggregationService] Canceling calendar event ${doc.ref.path}`
+        );
+        batch.update(doc.ref, {
+          status: "CANCELED",
+          cancelReason: "Practitioner deleted",
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      });
+
+      await batch.commit();
+      console.log(
+        `[PractitionerAggregationService] Successfully canceled ${snapshot.size} upcoming calendar events for practitioner ${practitionerId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[PractitionerAggregationService] Error canceling calendar events for practitioner ${practitionerId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Removes practitioner from patients when a practitioner is deleted
+   * @param patientIds - IDs of patients associated with the practitioner
+   * @param practitionerId - ID of the deleted practitioner
+   * @returns {Promise<void>}
+   */
+  async removePractitionerFromPatients(
+    patientIds: string[],
+    practitionerId: string
+  ): Promise<void> {
+    if (!patientIds || patientIds.length === 0 || !practitionerId) {
+      console.log(
+        "[PractitionerAggregationService] Missing patientIds or practitionerId for removing practitioner from patients. Skipping."
+      );
+      return;
+    }
+
+    const batch = this.db.batch();
+
+    console.log(
+      `[PractitionerAggregationService] Starting batch removal of practitioner ${practitionerId} from ${patientIds.length} patients.`
+    );
+
+    for (const patientId of patientIds) {
+      const patientRef = this.db.collection(PATIENTS_COLLECTION).doc(patientId);
+
+      // Remove doctor ID from doctorIds array
+      batch.update(patientRef, {
+        doctorIds: admin.firestore.FieldValue.arrayRemove(practitionerId),
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      });
+    }
+
+    try {
+      await batch.commit();
+      console.log(
+        `[PractitionerAggregationService] Successfully removed practitioner ${practitionerId} from ${patientIds.length} patients.`
+      );
+    } catch (error) {
+      console.error(
+        `[PractitionerAggregationService] Error removing practitioner ${practitionerId} from patients:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Inactivates all procedures associated with a deleted practitioner
+   * @param procedureIds - IDs of procedures provided by the practitioner
+   * @returns {Promise<void>}
+   */
+  async inactivateProceduresForPractitioner(
+    procedureIds: string[]
+  ): Promise<void> {
+    if (!procedureIds || procedureIds.length === 0) {
+      console.log(
+        "[PractitionerAggregationService] No procedure IDs provided for inactivation. Skipping."
+      );
+      return;
+    }
+
+    const batch = this.db.batch();
+
+    console.log(
+      `[PractitionerAggregationService] Starting inactivation of ${procedureIds.length} procedures.`
+    );
+
+    for (const procedureId of procedureIds) {
+      const procedureRef = this.db
+        .collection(PROCEDURES_COLLECTION)
+        .doc(procedureId);
+
+      batch.update(procedureRef, {
+        isActive: false,
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      });
+    }
+
+    try {
+      await batch.commit();
+      console.log(
+        `[PractitionerAggregationService] Successfully inactivated ${procedureIds.length} procedures.`
+      );
+    } catch (error) {
+      console.error(
+        `[PractitionerAggregationService] Error committing batch inactivation of procedures:`,
+        error
+      );
+      throw error;
+    }
+  }
+}

package/src/admin/aggregation/procedure/README.md

@@ -0,0 +1,43 @@
+# Procedure Aggregation Service (Admin)
+
+This service centralizes the logic for updating aggregated data in various Firestore collections _when a procedure is created, updated, or deleted/inactivated_. It is designed primarily for use by Cloud Functions triggered by changes in the `procedures` collection.
+
+## `ProcedureAggregationService` Class
+
+### Constructor
+
+```typescript
+constructor(firestore?: admin.firestore.Firestore)
+```
+
+Initializes the service with an Admin Firestore instance. Uses the default instance if none is provided.
+
+### Methods Triggered by Procedure **Creation**
+
+- **`addProcedureToPractitioner(practitionerId: string, procedureSummary: ProcedureSummaryInfo): Promise<void>`**
+  - Adds the `procedureId` (from `procedureSummary.id`) and the `procedureSummary` object to the `procedureIds` and `proceduresInfo` arrays respectively in the specified `Practitioner` document.
+- **`addProcedureToClinic(clinicId: string, procedureSummary: ProcedureSummaryInfo): Promise<void>`**
+  - Adds the `procedureId` (from `procedureSummary.id`) and the `procedureSummary` object to the `procedures` and `proceduresInfo` arrays respectively in the specified `Clinic` document.
+
+### Methods Triggered by Procedure **Update**
+
+- **`updateProcedureInfoInPractitioner(practitionerId: string, procedureSummary: ProcedureSummaryInfo): Promise<void>`**
+  - Updates the `proceduresInfo` array within the specified `Practitioner` document.
+  - Uses a transaction to read the existing array, filter out the old summary (matching by `id`), add the updated `procedureSummary`, and write the modified array back. This prevents race conditions.
+- **`updateProcedureInfoInClinic(clinicId: string, procedureSummary: ProcedureSummaryInfo): Promise<void>`**
+  - Updates the `proceduresInfo` array within the specified `Clinic` document using the same transaction-based read-modify-write pattern as above.
+- **`updateProcedureInfoInCalendarEvents(procedureId: string, procedureInfo: any): Promise<void>`**
+  - Uses a Collection Group query (`calendar` subcollection) to find all _upcoming_ calendar events associated with the `procedureId`.
+  - Updates the embedded `procedureInfo` object in these calendar events with the provided `procedureInfo`.
+
+### Methods Triggered by Procedure **Deletion / Deactivation**
+
+- **`cancelUpcomingCalendarEventsForProcedure(procedureId: string): Promise<void>`**
+  - Uses a Collection Group query (`calendar` subcollection) to find all _upcoming_ calendar events associated with the `procedureId`.
+  - Sets the `status` of these events to `CANCELED` and adds a `cancelReason` ("Procedure deleted or inactivated").
+- **`removeProcedureFromPractitioner(practitionerId: string, procedureId: string): Promise<void>`**
+  - Removes the `procedureId` from the `procedureIds` array and the corresponding `ProcedureSummaryInfo` object (matching by `id`) from the `proceduresInfo` array in the specified `Practitioner` document.
+  - Uses a transaction-based read-modify-write pattern.
+- **`removeProcedureFromClinic(clinicId: string, procedureId: string): Promise<void>`**
+  - Removes the `procedureId` from the `procedures` array and the corresponding `ProcedureSummaryInfo` object (matching by `id`) from the `proceduresInfo` array in the specified `Clinic` document.
+  - Uses a transaction-based read-modify-write pattern.