@blackcode_sa/metaestetics-api 1.12.62 → 1.12.64

package/src/services/calendar/utils/synced-calendar.utils.ts

@@ -1,472 +1,472 @@
-import {
-  Firestore,
-  collection,
-  doc,
-  getDoc,
-  getDocs,
-  setDoc,
-  updateDoc,
-  deleteDoc,
-  query,
-  where,
-  orderBy,
-  Timestamp,
-  serverTimestamp,
-} from "firebase/firestore";
-import {
-  SyncedCalendar,
-  SyncedCalendarProvider,
-  CreateSyncedCalendarData,
-  UpdateSyncedCalendarData,
-  SYNCED_CALENDARS_COLLECTION,
-} from "../../../types/calendar/synced-calendar.types";
-import {
-  getPractitionerSyncedCalendarDocRef,
-  getPatientSyncedCalendarDocRef,
-  getClinicSyncedCalendarDocRef,
-} from "./docs.utils";
-
-/**
- * Creates a synced calendar for a practitioner
- * @param db - Firestore instance
- * @param practitionerId - ID of the practitioner
- * @param calendarData - Synced calendar data
- * @param generateId - Function to generate a unique ID
- * @returns Created synced calendar
- */
-export async function createPractitionerSyncedCalendarUtil(
-  db: Firestore,
-  practitionerId: string,
-  calendarData: Omit<
-    CreateSyncedCalendarData,
-    "id" | "createdAt" | "updatedAt"
-  >,
-  generateId: () => string
-): Promise<SyncedCalendar> {
-  const calendarId = generateId();
-  const calendarRef = getPractitionerSyncedCalendarDocRef(
-    db,
-    practitionerId,
-    calendarId
-  );
-
-  const newCalendar: CreateSyncedCalendarData = {
-    id: calendarId,
-    ...calendarData,
-    createdAt: serverTimestamp(),
-    updatedAt: serverTimestamp(),
-  };
-
-  await setDoc(calendarRef, newCalendar);
-
-  // Convert server timestamp to Timestamp for return value
-  return {
-    ...newCalendar,
-    createdAt: Timestamp.now(),
-    updatedAt: Timestamp.now(),
-  } as SyncedCalendar;
-}
-
-/**
- * Creates a synced calendar for a patient
- * @param db - Firestore instance
- * @param patientId - ID of the patient
- * @param calendarData - Synced calendar data
- * @param generateId - Function to generate a unique ID
- * @returns Created synced calendar
- */
-export async function createPatientSyncedCalendarUtil(
-  db: Firestore,
-  patientId: string,
-  calendarData: Omit<
-    CreateSyncedCalendarData,
-    "id" | "createdAt" | "updatedAt"
-  >,
-  generateId: () => string
-): Promise<SyncedCalendar> {
-  const calendarId = generateId();
-  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
-
-  const newCalendar: CreateSyncedCalendarData = {
-    id: calendarId,
-    ...calendarData,
-    createdAt: serverTimestamp(),
-    updatedAt: serverTimestamp(),
-  };
-
-  await setDoc(calendarRef, newCalendar);
-
-  // Convert server timestamp to Timestamp for return value
-  return {
-    ...newCalendar,
-    createdAt: Timestamp.now(),
-    updatedAt: Timestamp.now(),
-  } as SyncedCalendar;
-}
-
-/**
- * Creates a synced calendar for a clinic
- * @param db - Firestore instance
- * @param clinicId - ID of the clinic
- * @param calendarData - Synced calendar data
- * @param generateId - Function to generate a unique ID
- * @returns Created synced calendar
- */
-export async function createClinicSyncedCalendarUtil(
-  db: Firestore,
-  clinicId: string,
-  calendarData: Omit<
-    CreateSyncedCalendarData,
-    "id" | "createdAt" | "updatedAt"
-  >,
-  generateId: () => string
-): Promise<SyncedCalendar> {
-  const calendarId = generateId();
-  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
-
-  const newCalendar: CreateSyncedCalendarData = {
-    id: calendarId,
-    ...calendarData,
-    createdAt: serverTimestamp(),
-    updatedAt: serverTimestamp(),
-  };
-
-  await setDoc(calendarRef, newCalendar);
-
-  // Convert server timestamp to Timestamp for return value
-  return {
-    ...newCalendar,
-    createdAt: Timestamp.now(),
-    updatedAt: Timestamp.now(),
-  } as SyncedCalendar;
-}
-
-/**
- * Gets a synced calendar for a practitioner
- * @param db - Firestore instance
- * @param practitionerId - ID of the practitioner
- * @param calendarId - ID of the synced calendar
- * @returns Synced calendar or null if not found
- */
-export async function getPractitionerSyncedCalendarUtil(
-  db: Firestore,
-  practitionerId: string,
-  calendarId: string
-): Promise<SyncedCalendar | null> {
-  const calendarRef = getPractitionerSyncedCalendarDocRef(
-    db,
-    practitionerId,
-    calendarId
-  );
-  const calendarDoc = await getDoc(calendarRef);
-
-  if (!calendarDoc.exists()) {
-    return null;
-  }
-
-  return calendarDoc.data() as SyncedCalendar;
-}
-
-/**
- * Gets all synced calendars for a practitioner
- * @param db - Firestore instance
- * @param practitionerId - ID of the practitioner
- * @returns Array of synced calendars
- */
-export async function getPractitionerSyncedCalendarsUtil(
-  db: Firestore,
-  practitionerId: string
-): Promise<SyncedCalendar[]> {
-  const calendarsRef = collection(
-    db,
-    `practitioners/${practitionerId}/${SYNCED_CALENDARS_COLLECTION}`
-  );
-
-  const q = query(calendarsRef, orderBy("createdAt", "desc"));
-  const querySnapshot = await getDocs(q);
-
-  return querySnapshot.docs.map((doc) => doc.data() as SyncedCalendar);
-}
-
-/**
- * Gets a synced calendar for a patient
- * @param db - Firestore instance
- * @param patientId - ID of the patient
- * @param calendarId - ID of the synced calendar
- * @returns Synced calendar or null if not found
- */
-export async function getPatientSyncedCalendarUtil(
-  db: Firestore,
-  patientId: string,
-  calendarId: string
-): Promise<SyncedCalendar | null> {
-  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
-  const calendarDoc = await getDoc(calendarRef);
-
-  if (!calendarDoc.exists()) {
-    return null;
-  }
-
-  return calendarDoc.data() as SyncedCalendar;
-}
-
-/**
- * Gets all synced calendars for a patient
- * @param db - Firestore instance
- * @param patientId - ID of the patient
- * @returns Array of synced calendars
- */
-export async function getPatientSyncedCalendarsUtil(
-  db: Firestore,
-  patientId: string
-): Promise<SyncedCalendar[]> {
-  const calendarsRef = collection(
-    db,
-    `patients/${patientId}/${SYNCED_CALENDARS_COLLECTION}`
-  );
-
-  const q = query(calendarsRef, orderBy("createdAt", "desc"));
-  const querySnapshot = await getDocs(q);
-
-  return querySnapshot.docs.map((doc) => doc.data() as SyncedCalendar);
-}
-
-/**
- * Gets a synced calendar for a clinic
- * @param db - Firestore instance
- * @param clinicId - ID of the clinic
- * @param calendarId - ID of the synced calendar
- * @returns Synced calendar or null if not found
- */
-export async function getClinicSyncedCalendarUtil(
-  db: Firestore,
-  clinicId: string,
-  calendarId: string
-): Promise<SyncedCalendar | null> {
-  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
-  const calendarDoc = await getDoc(calendarRef);
-
-  if (!calendarDoc.exists()) {
-    return null;
-  }
-
-  return calendarDoc.data() as SyncedCalendar;
-}
-
-/**
- * Gets all synced calendars for a clinic
- * @param db - Firestore instance
- * @param clinicId - ID of the clinic
- * @returns Array of synced calendars
- */
-export async function getClinicSyncedCalendarsUtil(
-  db: Firestore,
-  clinicId: string
-): Promise<SyncedCalendar[]> {
-  const calendarsRef = collection(
-    db,
-    `clinics/${clinicId}/${SYNCED_CALENDARS_COLLECTION}`
-  );
-
-  const q = query(calendarsRef, orderBy("createdAt", "desc"));
-  const querySnapshot = await getDocs(q);
-
-  return querySnapshot.docs.map((doc) => doc.data() as SyncedCalendar);
-}
-
-/**
- * Updates a synced calendar for a practitioner
- * @param db - Firestore instance
- * @param practitionerId - ID of the practitioner
- * @param calendarId - ID of the synced calendar
- * @param updateData - Data to update
- * @returns Updated synced calendar
- */
-export async function updatePractitionerSyncedCalendarUtil(
-  db: Firestore,
-  practitionerId: string,
-  calendarId: string,
-  updateData: Omit<UpdateSyncedCalendarData, "updatedAt">
-): Promise<SyncedCalendar> {
-  const calendarRef = getPractitionerSyncedCalendarDocRef(
-    db,
-    practitionerId,
-    calendarId
-  );
-
-  const updates: UpdateSyncedCalendarData = {
-    ...updateData,
-    updatedAt: serverTimestamp(),
-  };
-
-  await updateDoc(calendarRef, updates as any);
-
-  // Get the updated document
-  const updatedDoc = await getDoc(calendarRef);
-
-  if (!updatedDoc.exists()) {
-    throw new Error("Synced calendar not found after update");
-  }
-
-  return updatedDoc.data() as SyncedCalendar;
-}
-
-/**
- * Updates a synced calendar for a patient
- * @param db - Firestore instance
- * @param patientId - ID of the patient
- * @param calendarId - ID of the synced calendar
- * @param updateData - Data to update
- * @returns Updated synced calendar
- */
-export async function updatePatientSyncedCalendarUtil(
-  db: Firestore,
-  patientId: string,
-  calendarId: string,
-  updateData: Omit<UpdateSyncedCalendarData, "updatedAt">
-): Promise<SyncedCalendar> {
-  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
-
-  const updates: UpdateSyncedCalendarData = {
-    ...updateData,
-    updatedAt: serverTimestamp(),
-  };
-
-  await updateDoc(calendarRef, updates as any);
-
-  // Get the updated document
-  const updatedDoc = await getDoc(calendarRef);
-
-  if (!updatedDoc.exists()) {
-    throw new Error("Synced calendar not found after update");
-  }
-
-  return updatedDoc.data() as SyncedCalendar;
-}
-
-/**
- * Updates a synced calendar for a clinic
- * @param db - Firestore instance
- * @param clinicId - ID of the clinic
- * @param calendarId - ID of the synced calendar
- * @param updateData - Data to update
- * @returns Updated synced calendar
- */
-export async function updateClinicSyncedCalendarUtil(
-  db: Firestore,
-  clinicId: string,
-  calendarId: string,
-  updateData: Omit<UpdateSyncedCalendarData, "updatedAt">
-): Promise<SyncedCalendar> {
-  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
-
-  const updates: UpdateSyncedCalendarData = {
-    ...updateData,
-    updatedAt: serverTimestamp(),
-  };
-
-  await updateDoc(calendarRef, updates as any);
-
-  // Get the updated document
-  const updatedDoc = await getDoc(calendarRef);
-
-  if (!updatedDoc.exists()) {
-    throw new Error("Synced calendar not found after update");
-  }
-
-  return updatedDoc.data() as SyncedCalendar;
-}
-
-/**
- * Deletes a synced calendar for a practitioner
- * @param db - Firestore instance
- * @param practitionerId - ID of the practitioner
- * @param calendarId - ID of the synced calendar
- */
-export async function deletePractitionerSyncedCalendarUtil(
-  db: Firestore,
-  practitionerId: string,
-  calendarId: string
-): Promise<void> {
-  const calendarRef = getPractitionerSyncedCalendarDocRef(
-    db,
-    practitionerId,
-    calendarId
-  );
-  await deleteDoc(calendarRef);
-}
-
-/**
- * Deletes a synced calendar for a patient
- * @param db - Firestore instance
- * @param patientId - ID of the patient
- * @param calendarId - ID of the synced calendar
- */
-export async function deletePatientSyncedCalendarUtil(
-  db: Firestore,
-  patientId: string,
-  calendarId: string
-): Promise<void> {
-  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
-  await deleteDoc(calendarRef);
-}
-
-/**
- * Deletes a synced calendar for a clinic
- * @param db - Firestore instance
- * @param clinicId - ID of the clinic
- * @param calendarId - ID of the synced calendar
- */
-export async function deleteClinicSyncedCalendarUtil(
-  db: Firestore,
-  clinicId: string,
-  calendarId: string
-): Promise<void> {
-  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
-  await deleteDoc(calendarRef);
-}
-
-/**
- * Updates the last synced timestamp for a synced calendar
- * @param db - Firestore instance
- * @param entityType - Type of entity (practitioner, patient, clinic)
- * @param entityId - ID of the entity
- * @param calendarId - ID of the synced calendar
- * @returns Updated synced calendar
- */
-export async function updateLastSyncedTimestampUtil(
-  db: Firestore,
-  entityType: "practitioner" | "patient" | "clinic",
-  entityId: string,
-  calendarId: string
-): Promise<SyncedCalendar> {
-  const updateData: Omit<UpdateSyncedCalendarData, "updatedAt"> = {
-    lastSyncedAt: Timestamp.now(),
-  };
-
-  switch (entityType) {
-    case "practitioner":
-      return updatePractitionerSyncedCalendarUtil(
-        db,
-        entityId,
-        calendarId,
-        updateData
-      );
-    case "patient":
-      return updatePatientSyncedCalendarUtil(
-        db,
-        entityId,
-        calendarId,
-        updateData
-      );
-    case "clinic":
-      return updateClinicSyncedCalendarUtil(
-        db,
-        entityId,
-        calendarId,
-        updateData
-      );
-    default:
-      throw new Error(`Invalid entity type: ${entityType}`);
-  }
-}
+import {
+  Firestore,
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  setDoc,
+  updateDoc,
+  deleteDoc,
+  query,
+  where,
+  orderBy,
+  Timestamp,
+  serverTimestamp,
+} from "firebase/firestore";
+import {
+  SyncedCalendar,
+  SyncedCalendarProvider,
+  CreateSyncedCalendarData,
+  UpdateSyncedCalendarData,
+  SYNCED_CALENDARS_COLLECTION,
+} from "../../../types/calendar/synced-calendar.types";
+import {
+  getPractitionerSyncedCalendarDocRef,
+  getPatientSyncedCalendarDocRef,
+  getClinicSyncedCalendarDocRef,
+} from "./docs.utils";
+
+/**
+ * Creates a synced calendar for a practitioner
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @param calendarData - Synced calendar data
+ * @param generateId - Function to generate a unique ID
+ * @returns Created synced calendar
+ */
+export async function createPractitionerSyncedCalendarUtil(
+  db: Firestore,
+  practitionerId: string,
+  calendarData: Omit<
+    CreateSyncedCalendarData,
+    "id" | "createdAt" | "updatedAt"
+  >,
+  generateId: () => string
+): Promise<SyncedCalendar> {
+  const calendarId = generateId();
+  const calendarRef = getPractitionerSyncedCalendarDocRef(
+    db,
+    practitionerId,
+    calendarId
+  );
+
+  const newCalendar: CreateSyncedCalendarData = {
+    id: calendarId,
+    ...calendarData,
+    createdAt: serverTimestamp(),
+    updatedAt: serverTimestamp(),
+  };
+
+  await setDoc(calendarRef, newCalendar);
+
+  // Convert server timestamp to Timestamp for return value
+  return {
+    ...newCalendar,
+    createdAt: Timestamp.now(),
+    updatedAt: Timestamp.now(),
+  } as SyncedCalendar;
+}
+
+/**
+ * Creates a synced calendar for a patient
+ * @param db - Firestore instance
+ * @param patientId - ID of the patient
+ * @param calendarData - Synced calendar data
+ * @param generateId - Function to generate a unique ID
+ * @returns Created synced calendar
+ */
+export async function createPatientSyncedCalendarUtil(
+  db: Firestore,
+  patientId: string,
+  calendarData: Omit<
+    CreateSyncedCalendarData,
+    "id" | "createdAt" | "updatedAt"
+  >,
+  generateId: () => string
+): Promise<SyncedCalendar> {
+  const calendarId = generateId();
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+
+  const newCalendar: CreateSyncedCalendarData = {
+    id: calendarId,
+    ...calendarData,
+    createdAt: serverTimestamp(),
+    updatedAt: serverTimestamp(),
+  };
+
+  await setDoc(calendarRef, newCalendar);
+
+  // Convert server timestamp to Timestamp for return value
+  return {
+    ...newCalendar,
+    createdAt: Timestamp.now(),
+    updatedAt: Timestamp.now(),
+  } as SyncedCalendar;
+}
+
+/**
+ * Creates a synced calendar for a clinic
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @param calendarData - Synced calendar data
+ * @param generateId - Function to generate a unique ID
+ * @returns Created synced calendar
+ */
+export async function createClinicSyncedCalendarUtil(
+  db: Firestore,
+  clinicId: string,
+  calendarData: Omit<
+    CreateSyncedCalendarData,
+    "id" | "createdAt" | "updatedAt"
+  >,
+  generateId: () => string
+): Promise<SyncedCalendar> {
+  const calendarId = generateId();
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+
+  const newCalendar: CreateSyncedCalendarData = {
+    id: calendarId,
+    ...calendarData,
+    createdAt: serverTimestamp(),
+    updatedAt: serverTimestamp(),
+  };
+
+  await setDoc(calendarRef, newCalendar);
+
+  // Convert server timestamp to Timestamp for return value
+  return {
+    ...newCalendar,
+    createdAt: Timestamp.now(),
+    updatedAt: Timestamp.now(),
+  } as SyncedCalendar;
+}
+
+/**
+ * Gets a synced calendar for a practitioner
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @param calendarId - ID of the synced calendar
+ * @returns Synced calendar or null if not found
+ */
+export async function getPractitionerSyncedCalendarUtil(
+  db: Firestore,
+  practitionerId: string,
+  calendarId: string
+): Promise<SyncedCalendar | null> {
+  const calendarRef = getPractitionerSyncedCalendarDocRef(
+    db,
+    practitionerId,
+    calendarId
+  );
+  const calendarDoc = await getDoc(calendarRef);
+
+  if (!calendarDoc.exists()) {
+    return null;
+  }
+
+  return calendarDoc.data() as SyncedCalendar;
+}
+
+/**
+ * Gets all synced calendars for a practitioner
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @returns Array of synced calendars
+ */
+export async function getPractitionerSyncedCalendarsUtil(
+  db: Firestore,
+  practitionerId: string
+): Promise<SyncedCalendar[]> {
+  const calendarsRef = collection(
+    db,
+    `practitioners/${practitionerId}/${SYNCED_CALENDARS_COLLECTION}`
+  );
+
+  const q = query(calendarsRef, orderBy("createdAt", "desc"));
+  const querySnapshot = await getDocs(q);
+
+  return querySnapshot.docs.map((doc) => doc.data() as SyncedCalendar);
+}
+
+/**
+ * Gets a synced calendar for a patient
+ * @param db - Firestore instance
+ * @param patientId - ID of the patient
+ * @param calendarId - ID of the synced calendar
+ * @returns Synced calendar or null if not found
+ */
+export async function getPatientSyncedCalendarUtil(
+  db: Firestore,
+  patientId: string,
+  calendarId: string
+): Promise<SyncedCalendar | null> {
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+  const calendarDoc = await getDoc(calendarRef);
+
+  if (!calendarDoc.exists()) {
+    return null;
+  }
+
+  return calendarDoc.data() as SyncedCalendar;
+}
+
+/**
+ * Gets all synced calendars for a patient
+ * @param db - Firestore instance
+ * @param patientId - ID of the patient
+ * @returns Array of synced calendars
+ */
+export async function getPatientSyncedCalendarsUtil(
+  db: Firestore,
+  patientId: string
+): Promise<SyncedCalendar[]> {
+  const calendarsRef = collection(
+    db,
+    `patients/${patientId}/${SYNCED_CALENDARS_COLLECTION}`
+  );
+
+  const q = query(calendarsRef, orderBy("createdAt", "desc"));
+  const querySnapshot = await getDocs(q);
+
+  return querySnapshot.docs.map((doc) => doc.data() as SyncedCalendar);
+}
+
+/**
+ * Gets a synced calendar for a clinic
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @param calendarId - ID of the synced calendar
+ * @returns Synced calendar or null if not found
+ */
+export async function getClinicSyncedCalendarUtil(
+  db: Firestore,
+  clinicId: string,
+  calendarId: string
+): Promise<SyncedCalendar | null> {
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+  const calendarDoc = await getDoc(calendarRef);
+
+  if (!calendarDoc.exists()) {
+    return null;
+  }
+
+  return calendarDoc.data() as SyncedCalendar;
+}
+
+/**
+ * Gets all synced calendars for a clinic
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @returns Array of synced calendars
+ */
+export async function getClinicSyncedCalendarsUtil(
+  db: Firestore,
+  clinicId: string
+): Promise<SyncedCalendar[]> {
+  const calendarsRef = collection(
+    db,
+    `clinics/${clinicId}/${SYNCED_CALENDARS_COLLECTION}`
+  );
+
+  const q = query(calendarsRef, orderBy("createdAt", "desc"));
+  const querySnapshot = await getDocs(q);
+
+  return querySnapshot.docs.map((doc) => doc.data() as SyncedCalendar);
+}
+
+/**
+ * Updates a synced calendar for a practitioner
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @param calendarId - ID of the synced calendar
+ * @param updateData - Data to update
+ * @returns Updated synced calendar
+ */
+export async function updatePractitionerSyncedCalendarUtil(
+  db: Firestore,
+  practitionerId: string,
+  calendarId: string,
+  updateData: Omit<UpdateSyncedCalendarData, "updatedAt">
+): Promise<SyncedCalendar> {
+  const calendarRef = getPractitionerSyncedCalendarDocRef(
+    db,
+    practitionerId,
+    calendarId
+  );
+
+  const updates: UpdateSyncedCalendarData = {
+    ...updateData,
+    updatedAt: serverTimestamp(),
+  };
+
+  await updateDoc(calendarRef, updates as any);
+
+  // Get the updated document
+  const updatedDoc = await getDoc(calendarRef);
+
+  if (!updatedDoc.exists()) {
+    throw new Error("Synced calendar not found after update");
+  }
+
+  return updatedDoc.data() as SyncedCalendar;
+}
+
+/**
+ * Updates a synced calendar for a patient
+ * @param db - Firestore instance
+ * @param patientId - ID of the patient
+ * @param calendarId - ID of the synced calendar
+ * @param updateData - Data to update
+ * @returns Updated synced calendar
+ */
+export async function updatePatientSyncedCalendarUtil(
+  db: Firestore,
+  patientId: string,
+  calendarId: string,
+  updateData: Omit<UpdateSyncedCalendarData, "updatedAt">
+): Promise<SyncedCalendar> {
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+
+  const updates: UpdateSyncedCalendarData = {
+    ...updateData,
+    updatedAt: serverTimestamp(),
+  };
+
+  await updateDoc(calendarRef, updates as any);
+
+  // Get the updated document
+  const updatedDoc = await getDoc(calendarRef);
+
+  if (!updatedDoc.exists()) {
+    throw new Error("Synced calendar not found after update");
+  }
+
+  return updatedDoc.data() as SyncedCalendar;
+}
+
+/**
+ * Updates a synced calendar for a clinic
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @param calendarId - ID of the synced calendar
+ * @param updateData - Data to update
+ * @returns Updated synced calendar
+ */
+export async function updateClinicSyncedCalendarUtil(
+  db: Firestore,
+  clinicId: string,
+  calendarId: string,
+  updateData: Omit<UpdateSyncedCalendarData, "updatedAt">
+): Promise<SyncedCalendar> {
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+
+  const updates: UpdateSyncedCalendarData = {
+    ...updateData,
+    updatedAt: serverTimestamp(),
+  };
+
+  await updateDoc(calendarRef, updates as any);
+
+  // Get the updated document
+  const updatedDoc = await getDoc(calendarRef);
+
+  if (!updatedDoc.exists()) {
+    throw new Error("Synced calendar not found after update");
+  }
+
+  return updatedDoc.data() as SyncedCalendar;
+}
+
+/**
+ * Deletes a synced calendar for a practitioner
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @param calendarId - ID of the synced calendar
+ */
+export async function deletePractitionerSyncedCalendarUtil(
+  db: Firestore,
+  practitionerId: string,
+  calendarId: string
+): Promise<void> {
+  const calendarRef = getPractitionerSyncedCalendarDocRef(
+    db,
+    practitionerId,
+    calendarId
+  );
+  await deleteDoc(calendarRef);
+}
+
+/**
+ * Deletes a synced calendar for a patient
+ * @param db - Firestore instance
+ * @param patientId - ID of the patient
+ * @param calendarId - ID of the synced calendar
+ */
+export async function deletePatientSyncedCalendarUtil(
+  db: Firestore,
+  patientId: string,
+  calendarId: string
+): Promise<void> {
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+  await deleteDoc(calendarRef);
+}
+
+/**
+ * Deletes a synced calendar for a clinic
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @param calendarId - ID of the synced calendar
+ */
+export async function deleteClinicSyncedCalendarUtil(
+  db: Firestore,
+  clinicId: string,
+  calendarId: string
+): Promise<void> {
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+  await deleteDoc(calendarRef);
+}
+
+/**
+ * Updates the last synced timestamp for a synced calendar
+ * @param db - Firestore instance
+ * @param entityType - Type of entity (practitioner, patient, clinic)
+ * @param entityId - ID of the entity
+ * @param calendarId - ID of the synced calendar
+ * @returns Updated synced calendar
+ */
+export async function updateLastSyncedTimestampUtil(
+  db: Firestore,
+  entityType: "practitioner" | "patient" | "clinic",
+  entityId: string,
+  calendarId: string
+): Promise<SyncedCalendar> {
+  const updateData: Omit<UpdateSyncedCalendarData, "updatedAt"> = {
+    lastSyncedAt: Timestamp.now(),
+  };
+
+  switch (entityType) {
+    case "practitioner":
+      return updatePractitionerSyncedCalendarUtil(
+        db,
+        entityId,
+        calendarId,
+        updateData
+      );
+    case "patient":
+      return updatePatientSyncedCalendarUtil(
+        db,
+        entityId,
+        calendarId,
+        updateData
+      );
+    case "clinic":
+      return updateClinicSyncedCalendarUtil(
+        db,
+        entityId,
+        calendarId,
+        updateData
+      );
+    default:
+      throw new Error(`Invalid entity type: ${entityType}`);
+  }
+}