@blackcode_sa/metaestetics-api 1.13.3 → 1.13.5

package/src/services/calendar/synced-calendars.service.ts

@@ -1,743 +1,743 @@
-import { Auth } from "firebase/auth";
-import { Firestore, Timestamp } from "firebase/firestore";
-import { FirebaseApp } from "firebase/app";
-import { BaseService } from "../base.service";
-import {
-  SyncedCalendar,
-  SyncedCalendarProvider,
-  CreateSyncedCalendarData,
-  UpdateSyncedCalendarData,
-  SYNCED_CALENDARS_COLLECTION,
-} from "../../types/calendar/synced-calendar.types";
-import {
-  CalendarEvent,
-  CalendarEventStatus,
-  CalendarSyncStatus,
-} from "../../types/calendar";
-
-// Import utility functions
-import {
-  createPractitionerSyncedCalendarUtil,
-  createPatientSyncedCalendarUtil,
-  createClinicSyncedCalendarUtil,
-  getPractitionerSyncedCalendarUtil,
-  getPractitionerSyncedCalendarsUtil,
-  getPatientSyncedCalendarUtil,
-  getPatientSyncedCalendarsUtil,
-  getClinicSyncedCalendarUtil,
-  getClinicSyncedCalendarsUtil,
-  updatePractitionerSyncedCalendarUtil,
-  updatePatientSyncedCalendarUtil,
-  updateClinicSyncedCalendarUtil,
-  deletePractitionerSyncedCalendarUtil,
-  deletePatientSyncedCalendarUtil,
-  deleteClinicSyncedCalendarUtil,
-  updateLastSyncedTimestampUtil,
-} from "./utils/synced-calendar.utils";
-
-// Import Google Calendar utilities
-import {
-  authenticateWithGoogleCalendarUtil,
-  refreshGoogleCalendarTokenUtil,
-  listGoogleCalendarsUtil,
-  syncEventsToGoogleCalendarUtil,
-  fetchEventsFromGoogleCalendarUtil,
-  convertGoogleEventToCalendarEventUtil,
-  deleteGoogleCalendarEventUtil,
-  getGoogleCalendarOAuthUrlUtil,
-  GOOGLE_CALENDAR_API_URL,
-  makeRequest,
-} from "./utils/google-calendar.utils";
-
-/**
- * Service for managing synced calendars and calendar synchronization
- */
-export class SyncedCalendarsService extends BaseService {
-  /**
-   * Creates a new SyncedCalendarsService instance
-   * @param db - Firestore instance
-   * @param auth - Firebase Auth instance
-   * @param app - Firebase App instance
-   */
-  constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
-    super(db, auth, app);
-  }
-
-  // ===== Practitioner Synced Calendars =====
-
-  /**
-   * Creates a synced calendar for a practitioner
-   * @param practitionerId - ID of the practitioner
-   * @param calendarData - Synced calendar data
-   * @returns Created synced calendar
-   */
-  async createPractitionerSyncedCalendar(
-    practitionerId: string,
-    calendarData: Omit<
-      CreateSyncedCalendarData,
-      "id" | "createdAt" | "updatedAt"
-    >
-  ): Promise<SyncedCalendar> {
-    return createPractitionerSyncedCalendarUtil(
-      this.db,
-      practitionerId,
-      calendarData,
-      this.generateId.bind(this)
-    );
-  }
-
-  /**
-   * Gets a synced calendar for a practitioner
-   * @param practitionerId - ID of the practitioner
-   * @param calendarId - ID of the synced calendar
-   * @returns Synced calendar or null if not found
-   */
-  async getPractitionerSyncedCalendar(
-    practitionerId: string,
-    calendarId: string
-  ): Promise<SyncedCalendar | null> {
-    return getPractitionerSyncedCalendarUtil(
-      this.db,
-      practitionerId,
-      calendarId
-    );
-  }
-
-  /**
-   * Gets all synced calendars for a practitioner
-   * @param practitionerId - ID of the practitioner
-   * @returns Array of synced calendars
-   */
-  async getPractitionerSyncedCalendars(
-    practitionerId: string
-  ): Promise<SyncedCalendar[]> {
-    return getPractitionerSyncedCalendarsUtil(this.db, practitionerId);
-  }
-
-  /**
-   * Updates a synced calendar for a practitioner
-   * @param practitionerId - ID of the practitioner
-   * @param calendarId - ID of the synced calendar
-   * @param updateData - Data to update
-   * @returns Updated synced calendar
-   */
-  async updatePractitionerSyncedCalendar(
-    practitionerId: string,
-    calendarId: string,
-    updateData: Omit<UpdateSyncedCalendarData, "updatedAt">
-  ): Promise<SyncedCalendar> {
-    return updatePractitionerSyncedCalendarUtil(
-      this.db,
-      practitionerId,
-      calendarId,
-      updateData
-    );
-  }
-
-  /**
-   * Deletes a synced calendar for a practitioner
-   * @param practitionerId - ID of the practitioner
-   * @param calendarId - ID of the synced calendar
-   */
-  async deletePractitionerSyncedCalendar(
-    practitionerId: string,
-    calendarId: string
-  ): Promise<void> {
-    return deletePractitionerSyncedCalendarUtil(
-      this.db,
-      practitionerId,
-      calendarId
-    );
-  }
-
-  // ===== Patient Synced Calendars =====
-
-  /**
-   * Creates a synced calendar for a patient
-   * @param patientId - ID of the patient
-   * @param calendarData - Synced calendar data
-   * @returns Created synced calendar
-   */
-  async createPatientSyncedCalendar(
-    patientId: string,
-    calendarData: Omit<
-      CreateSyncedCalendarData,
-      "id" | "createdAt" | "updatedAt"
-    >
-  ): Promise<SyncedCalendar> {
-    return createPatientSyncedCalendarUtil(
-      this.db,
-      patientId,
-      calendarData,
-      this.generateId.bind(this)
-    );
-  }
-
-  /**
-   * Gets a synced calendar for a patient
-   * @param patientId - ID of the patient
-   * @param calendarId - ID of the synced calendar
-   * @returns Synced calendar or null if not found
-   */
-  async getPatientSyncedCalendar(
-    patientId: string,
-    calendarId: string
-  ): Promise<SyncedCalendar | null> {
-    return getPatientSyncedCalendarUtil(this.db, patientId, calendarId);
-  }
-
-  /**
-   * Gets all synced calendars for a patient
-   * @param patientId - ID of the patient
-   * @returns Array of synced calendars
-   */
-  async getPatientSyncedCalendars(
-    patientId: string
-  ): Promise<SyncedCalendar[]> {
-    return getPatientSyncedCalendarsUtil(this.db, patientId);
-  }
-
-  /**
-   * Updates a synced calendar for a patient
-   * @param patientId - ID of the patient
-   * @param calendarId - ID of the synced calendar
-   * @param updateData - Data to update
-   * @returns Updated synced calendar
-   */
-  async updatePatientSyncedCalendar(
-    patientId: string,
-    calendarId: string,
-    updateData: Omit<UpdateSyncedCalendarData, "updatedAt">
-  ): Promise<SyncedCalendar> {
-    return updatePatientSyncedCalendarUtil(
-      this.db,
-      patientId,
-      calendarId,
-      updateData
-    );
-  }
-
-  /**
-   * Deletes a synced calendar for a patient
-   * @param patientId - ID of the patient
-   * @param calendarId - ID of the synced calendar
-   */
-  async deletePatientSyncedCalendar(
-    patientId: string,
-    calendarId: string
-  ): Promise<void> {
-    return deletePatientSyncedCalendarUtil(this.db, patientId, calendarId);
-  }
-
-  // ===== Clinic Synced Calendars =====
-
-  /**
-   * Creates a synced calendar for a clinic
-   * @param clinicId - ID of the clinic
-   * @param calendarData - Synced calendar data
-   * @returns Created synced calendar
-   */
-  async createClinicSyncedCalendar(
-    clinicId: string,
-    calendarData: Omit<
-      CreateSyncedCalendarData,
-      "id" | "createdAt" | "updatedAt"
-    >
-  ): Promise<SyncedCalendar> {
-    return createClinicSyncedCalendarUtil(
-      this.db,
-      clinicId,
-      calendarData,
-      this.generateId.bind(this)
-    );
-  }
-
-  /**
-   * Gets a synced calendar for a clinic
-   * @param clinicId - ID of the clinic
-   * @param calendarId - ID of the synced calendar
-   * @returns Synced calendar or null if not found
-   */
-  async getClinicSyncedCalendar(
-    clinicId: string,
-    calendarId: string
-  ): Promise<SyncedCalendar | null> {
-    return getClinicSyncedCalendarUtil(this.db, clinicId, calendarId);
-  }
-
-  /**
-   * Gets all synced calendars for a clinic
-   * @param clinicId - ID of the clinic
-   * @returns Array of synced calendars
-   */
-  async getClinicSyncedCalendars(clinicId: string): Promise<SyncedCalendar[]> {
-    return getClinicSyncedCalendarsUtil(this.db, clinicId);
-  }
-
-  /**
-   * Updates a synced calendar for a clinic
-   * @param clinicId - ID of the clinic
-   * @param calendarId - ID of the synced calendar
-   * @param updateData - Data to update
-   * @returns Updated synced calendar
-   */
-  async updateClinicSyncedCalendar(
-    clinicId: string,
-    calendarId: string,
-    updateData: Omit<UpdateSyncedCalendarData, "updatedAt">
-  ): Promise<SyncedCalendar> {
-    return updateClinicSyncedCalendarUtil(
-      this.db,
-      clinicId,
-      calendarId,
-      updateData
-    );
-  }
-
-  /**
-   * Deletes a synced calendar for a clinic
-   * @param clinicId - ID of the clinic
-   * @param calendarId - ID of the synced calendar
-   */
-  async deleteClinicSyncedCalendar(
-    clinicId: string,
-    calendarId: string
-  ): Promise<void> {
-    return deleteClinicSyncedCalendarUtil(this.db, clinicId, calendarId);
-  }
-
-  // ===== Google Calendar Integration =====
-
-  /**
-   * Gets the OAuth URL for Google Calendar
-   * @param scopes - OAuth scopes to request
-   * @returns OAuth URL
-   */
-  getGoogleCalendarOAuthUrl(
-    scopes: string[] = ["https://www.googleapis.com/auth/calendar"]
-  ): string {
-    return getGoogleCalendarOAuthUrlUtil(scopes);
-  }
-
-  /**
-   * Authenticates with Google Calendar using an authorization code
-   * @param authCode - Authorization code from Google OAuth
-   * @returns Access token, refresh token, and expiration time
-   */
-  async authenticateWithGoogleCalendar(
-    authCode: string
-  ): Promise<{ accessToken: string; refreshToken: string; expiresIn: number }> {
-    return authenticateWithGoogleCalendarUtil(authCode);
-  }
-
-  /**
-   * Lists available Google Calendars for a user
-   * @param accessToken - Google API access token
-   * @returns List of available calendars
-   */
-  async listGoogleCalendars(
-    accessToken: string
-  ): Promise<Array<{ id: string; name: string }>> {
-    return listGoogleCalendarsUtil(accessToken);
-  }
-
-  /**
-   * Syncs events from our system to Google Calendar for a practitioner
-   * @param practitionerId - ID of the practitioner
-   * @param calendarId - ID of the synced calendar
-   * @param events - Events to sync
-   * @param existingSyncId - Optional existing sync ID for updating an event
-   * @returns Result of the sync operation
-   */
-  async syncPractitionerEventsToGoogleCalendar(
-    practitionerId: string,
-    calendarId: string,
-    events: CalendarEvent[],
-    existingSyncId?: string
-  ): Promise<{
-    success: boolean;
-    syncedEvents: number;
-    errors: any[];
-    eventIds: string[];
-  }> {
-    const syncedCalendar = await this.getPractitionerSyncedCalendar(
-      practitionerId,
-      calendarId
-    );
-
-    if (!syncedCalendar) {
-      throw new Error("Synced calendar not found");
-    }
-
-    return syncEventsToGoogleCalendarUtil(
-      this.db,
-      "practitioner",
-      practitionerId,
-      syncedCalendar,
-      events,
-      existingSyncId
-    );
-  }
-
-  /**
-   * Syncs events from our system to Google Calendar for a patient
-   * @param patientId - ID of the patient
-   * @param calendarId - ID of the synced calendar
-   * @param events - Events to sync
-   * @param existingSyncId - Optional existing sync ID for updating an event
-   * @returns Result of the sync operation
-   */
-  async syncPatientEventsToGoogleCalendar(
-    patientId: string,
-    calendarId: string,
-    events: CalendarEvent[],
-    existingSyncId?: string
-  ): Promise<{
-    success: boolean;
-    syncedEvents: number;
-    errors: any[];
-    eventIds: string[];
-  }> {
-    const syncedCalendar = await this.getPatientSyncedCalendar(
-      patientId,
-      calendarId
-    );
-
-    if (!syncedCalendar) {
-      throw new Error("Synced calendar not found");
-    }
-
-    return syncEventsToGoogleCalendarUtil(
-      this.db,
-      "patient",
-      patientId,
-      syncedCalendar,
-      events,
-      existingSyncId
-    );
-  }
-
-  /**
-   * Syncs events from our system to Google Calendar for a clinic
-   * @param clinicId - ID of the clinic
-   * @param calendarId - ID of the synced calendar
-   * @param events - Events to sync
-   * @returns Result of the sync operation
-   */
-  async syncClinicEventsToGoogleCalendar(
-    clinicId: string,
-    calendarId: string,
-    events: CalendarEvent[]
-  ): Promise<{ success: boolean; syncedEvents: number; errors: any[] }> {
-    const syncedCalendar = await this.getClinicSyncedCalendar(
-      clinicId,
-      calendarId
-    );
-
-    if (!syncedCalendar) {
-      throw new Error("Synced calendar not found");
-    }
-
-    return syncEventsToGoogleCalendarUtil(
-      this.db,
-      "clinic",
-      clinicId,
-      syncedCalendar,
-      events
-    );
-  }
-
-  /**
-   * Fetches events from Google Calendar for a practitioner
-   * @param practitionerId - ID of the practitioner
-   * @param calendarId - ID of the synced calendar
-   * @param startDate - Start date for fetching events
-   * @param endDate - End date for fetching events
-   * @returns Events fetched from Google Calendar
-   */
-  async fetchEventsFromPractitionerGoogleCalendar(
-    practitionerId: string,
-    calendarId: string,
-    startDate: Date,
-    endDate: Date
-  ): Promise<any[]> {
-    const syncedCalendar = await this.getPractitionerSyncedCalendar(
-      practitionerId,
-      calendarId
-    );
-
-    if (!syncedCalendar) {
-      throw new Error("Synced calendar not found");
-    }
-
-    return fetchEventsFromGoogleCalendarUtil(
-      this.db,
-      "practitioner",
-      practitionerId,
-      syncedCalendar,
-      startDate,
-      endDate
-    );
-  }
-
-  /**
-   * Fetches events from Google Calendar for a patient
-   * @param patientId - ID of the patient
-   * @param calendarId - ID of the synced calendar
-   * @param startDate - Start date for fetching events
-   * @param endDate - End date for fetching events
-   * @returns Events fetched from Google Calendar
-   */
-  async fetchEventsFromPatientGoogleCalendar(
-    patientId: string,
-    calendarId: string,
-    startDate: Date,
-    endDate: Date
-  ): Promise<any[]> {
-    const syncedCalendar = await this.getPatientSyncedCalendar(
-      patientId,
-      calendarId
-    );
-
-    if (!syncedCalendar) {
-      throw new Error("Synced calendar not found");
-    }
-
-    return fetchEventsFromGoogleCalendarUtil(
-      this.db,
-      "patient",
-      patientId,
-      syncedCalendar,
-      startDate,
-      endDate
-    );
-  }
-
-  /**
-   * Fetches events from Google Calendar for a clinic
-   * @param clinicId - ID of the clinic
-   * @param calendarId - ID of the synced calendar
-   * @param startDate - Start date for fetching events
-   * @param endDate - End date for fetching events
-   * @returns Events fetched from Google Calendar
-   */
-  async fetchEventsFromClinicGoogleCalendar(
-    clinicId: string,
-    calendarId: string,
-    startDate: Date,
-    endDate: Date
-  ): Promise<any[]> {
-    const syncedCalendar = await this.getClinicSyncedCalendar(
-      clinicId,
-      calendarId
-    );
-
-    if (!syncedCalendar) {
-      throw new Error("Synced calendar not found");
-    }
-
-    return fetchEventsFromGoogleCalendarUtil(
-      this.db,
-      "clinic",
-      clinicId,
-      syncedCalendar,
-      startDate,
-      endDate
-    );
-  }
-
-  /**
-   * Deletes an event from Google Calendar for a practitioner
-   * @param practitionerId - ID of the practitioner
-   * @param calendarId - ID of the synced calendar
-   * @param eventId - ID of the event in Google Calendar
-   * @returns Success status
-   */
-  async deletePractitionerGoogleCalendarEvent(
-    practitionerId: string,
-    calendarId: string,
-    eventId: string
-  ): Promise<boolean> {
-    const syncedCalendar = await this.getPractitionerSyncedCalendar(
-      practitionerId,
-      calendarId
-    );
-
-    if (!syncedCalendar) {
-      throw new Error("Synced calendar not found");
-    }
-
-    return deleteGoogleCalendarEventUtil(
-      this.db,
-      "practitioner",
-      practitionerId,
-      syncedCalendar,
-      eventId
-    );
-  }
-
-  /**
-   * Deletes an event from Google Calendar for a patient
-   * @param patientId - ID of the patient
-   * @param calendarId - ID of the synced calendar
-   * @param eventId - ID of the event in Google Calendar
-   * @returns Success status
-   */
-  async deletePatientGoogleCalendarEvent(
-    patientId: string,
-    calendarId: string,
-    eventId: string
-  ): Promise<boolean> {
-    const syncedCalendar = await this.getPatientSyncedCalendar(
-      patientId,
-      calendarId
-    );
-
-    if (!syncedCalendar) {
-      throw new Error("Synced calendar not found");
-    }
-
-    return deleteGoogleCalendarEventUtil(
-      this.db,
-      "patient",
-      patientId,
-      syncedCalendar,
-      eventId
-    );
-  }
-
-  /**
-   * Deletes an event from Google Calendar for a clinic
-   * @param clinicId - ID of the clinic
-   * @param calendarId - ID of the synced calendar
-   * @param eventId - ID of the event in Google Calendar
-   * @returns Success status
-   */
-  async deleteClinicGoogleCalendarEvent(
-    clinicId: string,
-    calendarId: string,
-    eventId: string
-  ): Promise<boolean> {
-    const syncedCalendar = await this.getClinicSyncedCalendar(
-      clinicId,
-      calendarId
-    );
-
-    if (!syncedCalendar) {
-      throw new Error("Synced calendar not found");
-    }
-
-    return deleteGoogleCalendarEventUtil(
-      this.db,
-      "clinic",
-      clinicId,
-      syncedCalendar,
-      eventId
-    );
-  }
-
-  /**
-   * Converts Google Calendar events to our system's format for a practitioner
-   * @param practitionerId - ID of the practitioner
-   * @param googleEvents - Google Calendar events
-   * @returns Converted calendar events
-   */
-  convertGoogleEventsToPractitionerEvents(
-    practitionerId: string,
-    googleEvents: any[]
-  ): Partial<CalendarEvent>[] {
-    return googleEvents.map((event) =>
-      convertGoogleEventToCalendarEventUtil(
-        event,
-        practitionerId,
-        "practitioner"
-      )
-    );
-  }
-
-  /**
-   * Converts Google Calendar events to our system's format for a patient
-   * @param patientId - ID of the patient
-   * @param googleEvents - Google Calendar events
-   * @returns Converted calendar events
-   */
-  convertGoogleEventsToPatientEvents(
-    patientId: string,
-    googleEvents: any[]
-  ): Partial<CalendarEvent>[] {
-    return googleEvents.map((event) =>
-      convertGoogleEventToCalendarEventUtil(event, patientId, "patient")
-    );
-  }
-
-  /**
-   * Converts Google Calendar events to our system's format for a clinic
-   * @param clinicId - ID of the clinic
-   * @param googleEvents - Google Calendar events
-   * @returns Converted calendar events
-   */
-  convertGoogleEventsToClinicEvents(
-    clinicId: string,
-    googleEvents: any[]
-  ): Partial<CalendarEvent>[] {
-    return googleEvents.map((event) =>
-      convertGoogleEventToCalendarEventUtil(event, clinicId, "clinic")
-    );
-  }
-
-  /**
-   * Fetches a single event from Google Calendar for a practitioner
-   * @param practitionerId - ID of the practitioner
-   * @param calendarId - ID of the synced calendar
-   * @param eventId - ID of the event in Google Calendar
-   * @returns The event data or null if not found
-   */
-  async fetchEventFromPractitionerGoogleCalendar(
-    practitionerId: string,
-    calendarId: string,
-    eventId: string
-  ): Promise<any | null> {
-    const syncedCalendar = await this.getPractitionerSyncedCalendar(
-      practitionerId,
-      calendarId
-    );
-
-    if (!syncedCalendar) {
-      throw new Error("Synced calendar not found");
-    }
-
-    try {
-      // Refresh token if needed
-      const { accessToken } = await refreshGoogleCalendarTokenUtil(
-        syncedCalendar.refreshToken
-      );
-
-      // Call Google Calendar API to fetch the single event
-      const response = await makeRequest(
-        "get",
-        `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events/${eventId}`,
-        { Authorization: `Bearer ${accessToken}` }
-      );
-
-      // Update the last synced timestamp
-      await updateLastSyncedTimestampUtil(
-        this.db,
-        "practitioner",
-        practitionerId,
-        syncedCalendar.id
-      );
-
-      return response;
-    } catch (error) {
-      // If the event was not found (404), return null
-      if ((error as any).response?.status === 404) {
-        return null;
-      }
-
-      console.error(
-        `Error fetching event from Google Calendar: ${(error as Error).message}`
-      );
-      throw error;
-    }
-  }
-}
+import { Auth } from "firebase/auth";
+import { Firestore, Timestamp } from "firebase/firestore";
+import { FirebaseApp } from "firebase/app";
+import { BaseService } from "../base.service";
+import {
+  SyncedCalendar,
+  SyncedCalendarProvider,
+  CreateSyncedCalendarData,
+  UpdateSyncedCalendarData,
+  SYNCED_CALENDARS_COLLECTION,
+} from "../../types/calendar/synced-calendar.types";
+import {
+  CalendarEvent,
+  CalendarEventStatus,
+  CalendarSyncStatus,
+} from "../../types/calendar";
+
+// Import utility functions
+import {
+  createPractitionerSyncedCalendarUtil,
+  createPatientSyncedCalendarUtil,
+  createClinicSyncedCalendarUtil,
+  getPractitionerSyncedCalendarUtil,
+  getPractitionerSyncedCalendarsUtil,
+  getPatientSyncedCalendarUtil,
+  getPatientSyncedCalendarsUtil,
+  getClinicSyncedCalendarUtil,
+  getClinicSyncedCalendarsUtil,
+  updatePractitionerSyncedCalendarUtil,
+  updatePatientSyncedCalendarUtil,
+  updateClinicSyncedCalendarUtil,
+  deletePractitionerSyncedCalendarUtil,
+  deletePatientSyncedCalendarUtil,
+  deleteClinicSyncedCalendarUtil,
+  updateLastSyncedTimestampUtil,
+} from "./utils/synced-calendar.utils";
+
+// Import Google Calendar utilities
+import {
+  authenticateWithGoogleCalendarUtil,
+  refreshGoogleCalendarTokenUtil,
+  listGoogleCalendarsUtil,
+  syncEventsToGoogleCalendarUtil,
+  fetchEventsFromGoogleCalendarUtil,
+  convertGoogleEventToCalendarEventUtil,
+  deleteGoogleCalendarEventUtil,
+  getGoogleCalendarOAuthUrlUtil,
+  GOOGLE_CALENDAR_API_URL,
+  makeRequest,
+} from "./utils/google-calendar.utils";
+
+/**
+ * Service for managing synced calendars and calendar synchronization
+ */
+export class SyncedCalendarsService extends BaseService {
+  /**
+   * Creates a new SyncedCalendarsService instance
+   * @param db - Firestore instance
+   * @param auth - Firebase Auth instance
+   * @param app - Firebase App instance
+   */
+  constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
+    super(db, auth, app);
+  }
+
+  // ===== Practitioner Synced Calendars =====
+
+  /**
+   * Creates a synced calendar for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param calendarData - Synced calendar data
+   * @returns Created synced calendar
+   */
+  async createPractitionerSyncedCalendar(
+    practitionerId: string,
+    calendarData: Omit<
+      CreateSyncedCalendarData,
+      "id" | "createdAt" | "updatedAt"
+    >
+  ): Promise<SyncedCalendar> {
+    return createPractitionerSyncedCalendarUtil(
+      this.db,
+      practitionerId,
+      calendarData,
+      this.generateId.bind(this)
+    );
+  }
+
+  /**
+   * Gets a synced calendar for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param calendarId - ID of the synced calendar
+   * @returns Synced calendar or null if not found
+   */
+  async getPractitionerSyncedCalendar(
+    practitionerId: string,
+    calendarId: string
+  ): Promise<SyncedCalendar | null> {
+    return getPractitionerSyncedCalendarUtil(
+      this.db,
+      practitionerId,
+      calendarId
+    );
+  }
+
+  /**
+   * Gets all synced calendars for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @returns Array of synced calendars
+   */
+  async getPractitionerSyncedCalendars(
+    practitionerId: string
+  ): Promise<SyncedCalendar[]> {
+    return getPractitionerSyncedCalendarsUtil(this.db, practitionerId);
+  }
+
+  /**
+   * Updates a synced calendar for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param calendarId - ID of the synced calendar
+   * @param updateData - Data to update
+   * @returns Updated synced calendar
+   */
+  async updatePractitionerSyncedCalendar(
+    practitionerId: string,
+    calendarId: string,
+    updateData: Omit<UpdateSyncedCalendarData, "updatedAt">
+  ): Promise<SyncedCalendar> {
+    return updatePractitionerSyncedCalendarUtil(
+      this.db,
+      practitionerId,
+      calendarId,
+      updateData
+    );
+  }
+
+  /**
+   * Deletes a synced calendar for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param calendarId - ID of the synced calendar
+   */
+  async deletePractitionerSyncedCalendar(
+    practitionerId: string,
+    calendarId: string
+  ): Promise<void> {
+    return deletePractitionerSyncedCalendarUtil(
+      this.db,
+      practitionerId,
+      calendarId
+    );
+  }
+
+  // ===== Patient Synced Calendars =====
+
+  /**
+   * Creates a synced calendar for a patient
+   * @param patientId - ID of the patient
+   * @param calendarData - Synced calendar data
+   * @returns Created synced calendar
+   */
+  async createPatientSyncedCalendar(
+    patientId: string,
+    calendarData: Omit<
+      CreateSyncedCalendarData,
+      "id" | "createdAt" | "updatedAt"
+    >
+  ): Promise<SyncedCalendar> {
+    return createPatientSyncedCalendarUtil(
+      this.db,
+      patientId,
+      calendarData,
+      this.generateId.bind(this)
+    );
+  }
+
+  /**
+   * Gets a synced calendar for a patient
+   * @param patientId - ID of the patient
+   * @param calendarId - ID of the synced calendar
+   * @returns Synced calendar or null if not found
+   */
+  async getPatientSyncedCalendar(
+    patientId: string,
+    calendarId: string
+  ): Promise<SyncedCalendar | null> {
+    return getPatientSyncedCalendarUtil(this.db, patientId, calendarId);
+  }
+
+  /**
+   * Gets all synced calendars for a patient
+   * @param patientId - ID of the patient
+   * @returns Array of synced calendars
+   */
+  async getPatientSyncedCalendars(
+    patientId: string
+  ): Promise<SyncedCalendar[]> {
+    return getPatientSyncedCalendarsUtil(this.db, patientId);
+  }
+
+  /**
+   * Updates a synced calendar for a patient
+   * @param patientId - ID of the patient
+   * @param calendarId - ID of the synced calendar
+   * @param updateData - Data to update
+   * @returns Updated synced calendar
+   */
+  async updatePatientSyncedCalendar(
+    patientId: string,
+    calendarId: string,
+    updateData: Omit<UpdateSyncedCalendarData, "updatedAt">
+  ): Promise<SyncedCalendar> {
+    return updatePatientSyncedCalendarUtil(
+      this.db,
+      patientId,
+      calendarId,
+      updateData
+    );
+  }
+
+  /**
+   * Deletes a synced calendar for a patient
+   * @param patientId - ID of the patient
+   * @param calendarId - ID of the synced calendar
+   */
+  async deletePatientSyncedCalendar(
+    patientId: string,
+    calendarId: string
+  ): Promise<void> {
+    return deletePatientSyncedCalendarUtil(this.db, patientId, calendarId);
+  }
+
+  // ===== Clinic Synced Calendars =====
+
+  /**
+   * Creates a synced calendar for a clinic
+   * @param clinicId - ID of the clinic
+   * @param calendarData - Synced calendar data
+   * @returns Created synced calendar
+   */
+  async createClinicSyncedCalendar(
+    clinicId: string,
+    calendarData: Omit<
+      CreateSyncedCalendarData,
+      "id" | "createdAt" | "updatedAt"
+    >
+  ): Promise<SyncedCalendar> {
+    return createClinicSyncedCalendarUtil(
+      this.db,
+      clinicId,
+      calendarData,
+      this.generateId.bind(this)
+    );
+  }
+
+  /**
+   * Gets a synced calendar for a clinic
+   * @param clinicId - ID of the clinic
+   * @param calendarId - ID of the synced calendar
+   * @returns Synced calendar or null if not found
+   */
+  async getClinicSyncedCalendar(
+    clinicId: string,
+    calendarId: string
+  ): Promise<SyncedCalendar | null> {
+    return getClinicSyncedCalendarUtil(this.db, clinicId, calendarId);
+  }
+
+  /**
+   * Gets all synced calendars for a clinic
+   * @param clinicId - ID of the clinic
+   * @returns Array of synced calendars
+   */
+  async getClinicSyncedCalendars(clinicId: string): Promise<SyncedCalendar[]> {
+    return getClinicSyncedCalendarsUtil(this.db, clinicId);
+  }
+
+  /**
+   * Updates a synced calendar for a clinic
+   * @param clinicId - ID of the clinic
+   * @param calendarId - ID of the synced calendar
+   * @param updateData - Data to update
+   * @returns Updated synced calendar
+   */
+  async updateClinicSyncedCalendar(
+    clinicId: string,
+    calendarId: string,
+    updateData: Omit<UpdateSyncedCalendarData, "updatedAt">
+  ): Promise<SyncedCalendar> {
+    return updateClinicSyncedCalendarUtil(
+      this.db,
+      clinicId,
+      calendarId,
+      updateData
+    );
+  }
+
+  /**
+   * Deletes a synced calendar for a clinic
+   * @param clinicId - ID of the clinic
+   * @param calendarId - ID of the synced calendar
+   */
+  async deleteClinicSyncedCalendar(
+    clinicId: string,
+    calendarId: string
+  ): Promise<void> {
+    return deleteClinicSyncedCalendarUtil(this.db, clinicId, calendarId);
+  }
+
+  // ===== Google Calendar Integration =====
+
+  /**
+   * Gets the OAuth URL for Google Calendar
+   * @param scopes - OAuth scopes to request
+   * @returns OAuth URL
+   */
+  getGoogleCalendarOAuthUrl(
+    scopes: string[] = ["https://www.googleapis.com/auth/calendar"]
+  ): string {
+    return getGoogleCalendarOAuthUrlUtil(scopes);
+  }
+
+  /**
+   * Authenticates with Google Calendar using an authorization code
+   * @param authCode - Authorization code from Google OAuth
+   * @returns Access token, refresh token, and expiration time
+   */
+  async authenticateWithGoogleCalendar(
+    authCode: string
+  ): Promise<{ accessToken: string; refreshToken: string; expiresIn: number }> {
+    return authenticateWithGoogleCalendarUtil(authCode);
+  }
+
+  /**
+   * Lists available Google Calendars for a user
+   * @param accessToken - Google API access token
+   * @returns List of available calendars
+   */
+  async listGoogleCalendars(
+    accessToken: string
+  ): Promise<Array<{ id: string; name: string }>> {
+    return listGoogleCalendarsUtil(accessToken);
+  }
+
+  /**
+   * Syncs events from our system to Google Calendar for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param calendarId - ID of the synced calendar
+   * @param events - Events to sync
+   * @param existingSyncId - Optional existing sync ID for updating an event
+   * @returns Result of the sync operation
+   */
+  async syncPractitionerEventsToGoogleCalendar(
+    practitionerId: string,
+    calendarId: string,
+    events: CalendarEvent[],
+    existingSyncId?: string
+  ): Promise<{
+    success: boolean;
+    syncedEvents: number;
+    errors: any[];
+    eventIds: string[];
+  }> {
+    const syncedCalendar = await this.getPractitionerSyncedCalendar(
+      practitionerId,
+      calendarId
+    );
+
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+
+    return syncEventsToGoogleCalendarUtil(
+      this.db,
+      "practitioner",
+      practitionerId,
+      syncedCalendar,
+      events,
+      existingSyncId
+    );
+  }
+
+  /**
+   * Syncs events from our system to Google Calendar for a patient
+   * @param patientId - ID of the patient
+   * @param calendarId - ID of the synced calendar
+   * @param events - Events to sync
+   * @param existingSyncId - Optional existing sync ID for updating an event
+   * @returns Result of the sync operation
+   */
+  async syncPatientEventsToGoogleCalendar(
+    patientId: string,
+    calendarId: string,
+    events: CalendarEvent[],
+    existingSyncId?: string
+  ): Promise<{
+    success: boolean;
+    syncedEvents: number;
+    errors: any[];
+    eventIds: string[];
+  }> {
+    const syncedCalendar = await this.getPatientSyncedCalendar(
+      patientId,
+      calendarId
+    );
+
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+
+    return syncEventsToGoogleCalendarUtil(
+      this.db,
+      "patient",
+      patientId,
+      syncedCalendar,
+      events,
+      existingSyncId
+    );
+  }
+
+  /**
+   * Syncs events from our system to Google Calendar for a clinic
+   * @param clinicId - ID of the clinic
+   * @param calendarId - ID of the synced calendar
+   * @param events - Events to sync
+   * @returns Result of the sync operation
+   */
+  async syncClinicEventsToGoogleCalendar(
+    clinicId: string,
+    calendarId: string,
+    events: CalendarEvent[]
+  ): Promise<{ success: boolean; syncedEvents: number; errors: any[] }> {
+    const syncedCalendar = await this.getClinicSyncedCalendar(
+      clinicId,
+      calendarId
+    );
+
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+
+    return syncEventsToGoogleCalendarUtil(
+      this.db,
+      "clinic",
+      clinicId,
+      syncedCalendar,
+      events
+    );
+  }
+
+  /**
+   * Fetches events from Google Calendar for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param calendarId - ID of the synced calendar
+   * @param startDate - Start date for fetching events
+   * @param endDate - End date for fetching events
+   * @returns Events fetched from Google Calendar
+   */
+  async fetchEventsFromPractitionerGoogleCalendar(
+    practitionerId: string,
+    calendarId: string,
+    startDate: Date,
+    endDate: Date
+  ): Promise<any[]> {
+    const syncedCalendar = await this.getPractitionerSyncedCalendar(
+      practitionerId,
+      calendarId
+    );
+
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+
+    return fetchEventsFromGoogleCalendarUtil(
+      this.db,
+      "practitioner",
+      practitionerId,
+      syncedCalendar,
+      startDate,
+      endDate
+    );
+  }
+
+  /**
+   * Fetches events from Google Calendar for a patient
+   * @param patientId - ID of the patient
+   * @param calendarId - ID of the synced calendar
+   * @param startDate - Start date for fetching events
+   * @param endDate - End date for fetching events
+   * @returns Events fetched from Google Calendar
+   */
+  async fetchEventsFromPatientGoogleCalendar(
+    patientId: string,
+    calendarId: string,
+    startDate: Date,
+    endDate: Date
+  ): Promise<any[]> {
+    const syncedCalendar = await this.getPatientSyncedCalendar(
+      patientId,
+      calendarId
+    );
+
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+
+    return fetchEventsFromGoogleCalendarUtil(
+      this.db,
+      "patient",
+      patientId,
+      syncedCalendar,
+      startDate,
+      endDate
+    );
+  }
+
+  /**
+   * Fetches events from Google Calendar for a clinic
+   * @param clinicId - ID of the clinic
+   * @param calendarId - ID of the synced calendar
+   * @param startDate - Start date for fetching events
+   * @param endDate - End date for fetching events
+   * @returns Events fetched from Google Calendar
+   */
+  async fetchEventsFromClinicGoogleCalendar(
+    clinicId: string,
+    calendarId: string,
+    startDate: Date,
+    endDate: Date
+  ): Promise<any[]> {
+    const syncedCalendar = await this.getClinicSyncedCalendar(
+      clinicId,
+      calendarId
+    );
+
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+
+    return fetchEventsFromGoogleCalendarUtil(
+      this.db,
+      "clinic",
+      clinicId,
+      syncedCalendar,
+      startDate,
+      endDate
+    );
+  }
+
+  /**
+   * Deletes an event from Google Calendar for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param calendarId - ID of the synced calendar
+   * @param eventId - ID of the event in Google Calendar
+   * @returns Success status
+   */
+  async deletePractitionerGoogleCalendarEvent(
+    practitionerId: string,
+    calendarId: string,
+    eventId: string
+  ): Promise<boolean> {
+    const syncedCalendar = await this.getPractitionerSyncedCalendar(
+      practitionerId,
+      calendarId
+    );
+
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+
+    return deleteGoogleCalendarEventUtil(
+      this.db,
+      "practitioner",
+      practitionerId,
+      syncedCalendar,
+      eventId
+    );
+  }
+
+  /**
+   * Deletes an event from Google Calendar for a patient
+   * @param patientId - ID of the patient
+   * @param calendarId - ID of the synced calendar
+   * @param eventId - ID of the event in Google Calendar
+   * @returns Success status
+   */
+  async deletePatientGoogleCalendarEvent(
+    patientId: string,
+    calendarId: string,
+    eventId: string
+  ): Promise<boolean> {
+    const syncedCalendar = await this.getPatientSyncedCalendar(
+      patientId,
+      calendarId
+    );
+
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+
+    return deleteGoogleCalendarEventUtil(
+      this.db,
+      "patient",
+      patientId,
+      syncedCalendar,
+      eventId
+    );
+  }
+
+  /**
+   * Deletes an event from Google Calendar for a clinic
+   * @param clinicId - ID of the clinic
+   * @param calendarId - ID of the synced calendar
+   * @param eventId - ID of the event in Google Calendar
+   * @returns Success status
+   */
+  async deleteClinicGoogleCalendarEvent(
+    clinicId: string,
+    calendarId: string,
+    eventId: string
+  ): Promise<boolean> {
+    const syncedCalendar = await this.getClinicSyncedCalendar(
+      clinicId,
+      calendarId
+    );
+
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+
+    return deleteGoogleCalendarEventUtil(
+      this.db,
+      "clinic",
+      clinicId,
+      syncedCalendar,
+      eventId
+    );
+  }
+
+  /**
+   * Converts Google Calendar events to our system's format for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param googleEvents - Google Calendar events
+   * @returns Converted calendar events
+   */
+  convertGoogleEventsToPractitionerEvents(
+    practitionerId: string,
+    googleEvents: any[]
+  ): Partial<CalendarEvent>[] {
+    return googleEvents.map((event) =>
+      convertGoogleEventToCalendarEventUtil(
+        event,
+        practitionerId,
+        "practitioner"
+      )
+    );
+  }
+
+  /**
+   * Converts Google Calendar events to our system's format for a patient
+   * @param patientId - ID of the patient
+   * @param googleEvents - Google Calendar events
+   * @returns Converted calendar events
+   */
+  convertGoogleEventsToPatientEvents(
+    patientId: string,
+    googleEvents: any[]
+  ): Partial<CalendarEvent>[] {
+    return googleEvents.map((event) =>
+      convertGoogleEventToCalendarEventUtil(event, patientId, "patient")
+    );
+  }
+
+  /**
+   * Converts Google Calendar events to our system's format for a clinic
+   * @param clinicId - ID of the clinic
+   * @param googleEvents - Google Calendar events
+   * @returns Converted calendar events
+   */
+  convertGoogleEventsToClinicEvents(
+    clinicId: string,
+    googleEvents: any[]
+  ): Partial<CalendarEvent>[] {
+    return googleEvents.map((event) =>
+      convertGoogleEventToCalendarEventUtil(event, clinicId, "clinic")
+    );
+  }
+
+  /**
+   * Fetches a single event from Google Calendar for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param calendarId - ID of the synced calendar
+   * @param eventId - ID of the event in Google Calendar
+   * @returns The event data or null if not found
+   */
+  async fetchEventFromPractitionerGoogleCalendar(
+    practitionerId: string,
+    calendarId: string,
+    eventId: string
+  ): Promise<any | null> {
+    const syncedCalendar = await this.getPractitionerSyncedCalendar(
+      practitionerId,
+      calendarId
+    );
+
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+
+    try {
+      // Refresh token if needed
+      const { accessToken } = await refreshGoogleCalendarTokenUtil(
+        syncedCalendar.refreshToken
+      );
+
+      // Call Google Calendar API to fetch the single event
+      const response = await makeRequest(
+        "get",
+        `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events/${eventId}`,
+        { Authorization: `Bearer ${accessToken}` }
+      );
+
+      // Update the last synced timestamp
+      await updateLastSyncedTimestampUtil(
+        this.db,
+        "practitioner",
+        practitionerId,
+        syncedCalendar.id
+      );
+
+      return response;
+    } catch (error) {
+      // If the event was not found (404), return null
+      if ((error as any).response?.status === 404) {
+        return null;
+      }
+
+      console.error(
+        `Error fetching event from Google Calendar: ${(error as Error).message}`
+      );
+      throw error;
+    }
+  }
+}