@blackcode_sa/metaestetics-api 1.12.26 → 1.12.28

package/dist/index.mjs

@@ -2905,12 +2905,7 @@ import {
 } from "firebase/firestore";
 
 // src/services/patient/utils/sensitive.utils.ts
-import {
-  getDoc as getDoc6,
-  updateDoc as updateDoc4,
-  setDoc as setDoc4,
-  serverTimestamp as serverTimestamp4
-} from "firebase/firestore";
+import { getDoc as getDoc6, updateDoc as updateDoc4, setDoc as setDoc4, serverTimestamp as serverTimestamp4 } from "firebase/firestore";
 
 // src/validations/patient.schema.ts
 import { z as z7 } from "zod";
@@ -4211,10 +4206,7 @@ var checkSensitiveAccessUtil = async (db, patientId, requesterId, requesterRoles
     return;
   }
   if (requesterRoles.includes("practitioner" /* PRACTITIONER */)) {
-    const practitionerProfile = await getPractitionerProfileByUserRef(
-      db,
-      requesterId
-    );
+    const practitionerProfile = await getPractitionerProfileByUserRef(db, requesterId);
     if (practitionerProfile && ((_a = patientData.doctorIds) == null ? void 0 : _a.includes(practitionerProfile.id))) {
       return;
     }
@@ -4262,16 +4254,9 @@ var handlePhotoUrlUpload = async (photoUrl, patientId, mediaService) => {
 };
 var createSensitiveInfoUtil = async (db, data, requesterId, requesterRoles, mediaService) => {
   try {
-    await checkSensitiveAccessUtil(
-      db,
-      data.patientId,
-      requesterId,
-      requesterRoles
-    );
+    await checkSensitiveAccessUtil(db, data.patientId, requesterId, requesterRoles);
     const validatedData = createPatientSensitiveInfoSchema.parse(data);
-    const sensitiveDoc = await getDoc6(
-      getSensitiveInfoDocRef(db, data.patientId)
-    );
+    const sensitiveDoc = await getDoc6(getSensitiveInfoDocRef(db, data.patientId));
     if (sensitiveDoc.exists()) {
       throw new Error("Sensitive information already exists for this patient");
     }
@@ -4316,11 +4301,7 @@ var updateSensitiveInfoUtil = async (db, patientId, data, requesterId, requester
   let processedPhotoUrl = void 0;
   if (data.photoUrl !== void 0) {
     if (mediaService) {
-      processedPhotoUrl = await handlePhotoUrlUpload(
-        data.photoUrl,
-        patientId,
-        mediaService
-      );
+      processedPhotoUrl = await handlePhotoUrlUpload(data.photoUrl, patientId, mediaService);
     } else if (typeof data.photoUrl === "string" || data.photoUrl === null) {
       processedPhotoUrl = data.photoUrl;
     } else {
@@ -4339,6 +4320,36 @@ var updateSensitiveInfoUtil = async (db, patientId, data, requesterId, requester
   }
   return updatedDoc.data();
 };
+var claimPatientSensitiveInfoUtil = async (db, patientId, userId) => {
+  const patientDoc = await getDoc6(getPatientDocRef(db, patientId));
+  if (!patientDoc.exists()) {
+    throw new Error("Patient profile not found");
+  }
+  const patientData = patientDoc.data();
+  if (!patientData.isManual) {
+    throw new Error("Only manually created patient profiles can be claimed");
+  }
+  if (patientData.userRef) {
+    throw new Error("Patient profile has already been claimed");
+  }
+  const sensitiveDoc = await getDoc6(getSensitiveInfoDocRef(db, patientId));
+  if (!sensitiveDoc.exists()) {
+    throw new Error("Patient sensitive information not found");
+  }
+  const sensitiveData = sensitiveDoc.data();
+  if (sensitiveData.userRef) {
+    throw new Error("Patient sensitive information has already been claimed");
+  }
+  await updateDoc4(getSensitiveInfoDocRef(db, patientId), {
+    userRef: userId,
+    updatedAt: serverTimestamp4()
+  });
+  const updatedDoc = await getDoc6(getSensitiveInfoDocRef(db, patientId));
+  if (!updatedDoc.exists()) {
+    throw new Error("Failed to retrieve updated sensitive information");
+  }
+  return updatedDoc.data();
+};
 
 // src/services/patient/utils/docs.utils.ts
 var getPatientDocRef = (db, patientId) => {
@@ -5524,12 +5535,7 @@ var PatientService = class extends BaseService {
     const currentUser = await this.getCurrentUser();
     if (currentUser.uid !== requesterUserId) {
     }
-    return getSensitiveInfoUtil(
-      this.db,
-      patientId,
-      requesterUserId,
-      currentUser.roles
-    );
+    return getSensitiveInfoUtil(this.db, patientId, requesterUserId, currentUser.roles);
   }
   async getSensitiveInfoByUserRef(userRef, requesterUserId) {
     const profile = await this.getPatientProfileByUserRef(userRef);
@@ -5550,25 +5556,17 @@ var PatientService = class extends BaseService {
       this.mediaService
     );
   }
+  async claimPatientSensitiveInfo(patientId, userId) {
+    return claimPatientSensitiveInfoUtil(this.db, patientId, userId);
+  }
   // Metode za rad sa medicinskim informacijama
   async createMedicalInfo(patientId, data) {
     const currentUser = await this.getCurrentUser();
-    await createMedicalInfoUtil(
-      this.db,
-      patientId,
-      data,
-      currentUser.uid,
-      currentUser.roles
-    );
+    await createMedicalInfoUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
   }
   async getMedicalInfo(patientId) {
     const currentUser = await this.getCurrentUser();
-    return getMedicalInfoUtil(
-      this.db,
-      patientId,
-      currentUser.uid,
-      currentUser.roles
-    );
+    return getMedicalInfoUtil(this.db, patientId, currentUser.uid, currentUser.roles);
   }
   async getMedicalInfoByUserRef(userRef) {
     const profile = await this.getPatientProfileByUserRef(userRef);
@@ -5578,65 +5576,29 @@ var PatientService = class extends BaseService {
   // Metode za rad sa vitalnim statistikama
   async updateVitalStats(patientId, data) {
     const currentUser = await this.getCurrentUser();
-    await updateVitalStatsUtil(
-      this.db,
-      patientId,
-      data,
-      currentUser.uid,
-      currentUser.roles
-    );
+    await updateVitalStatsUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
   }
   // Metode za rad sa alergijama
   async addAllergy(patientId, data) {
     const currentUser = await this.getCurrentUser();
-    await addAllergyUtil(
-      this.db,
-      patientId,
-      data,
-      currentUser.uid,
-      currentUser.roles
-    );
+    await addAllergyUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
   }
   async updateAllergy(patientId, data) {
     const currentUser = await this.getCurrentUser();
-    await updateAllergyUtil(
-      this.db,
-      patientId,
-      data,
-      currentUser.uid,
-      currentUser.roles
-    );
+    await updateAllergyUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
   }
   async removeAllergy(patientId, allergyIndex) {
     const currentUser = await this.getCurrentUser();
-    await removeAllergyUtil(
-      this.db,
-      patientId,
-      allergyIndex,
-      currentUser.uid,
-      currentUser.roles
-    );
+    await removeAllergyUtil(this.db, patientId, allergyIndex, currentUser.uid, currentUser.roles);
   }
   // Metode za rad sa blocking conditions
   async addBlockingCondition(patientId, data) {
     const currentUser = await this.getCurrentUser();
-    await addBlockingConditionUtil(
-      this.db,
-      patientId,
-      data,
-      currentUser.uid,
-      currentUser.roles
-    );
+    await addBlockingConditionUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
   }
   async updateBlockingCondition(patientId, data) {
     const currentUser = await this.getCurrentUser();
-    await updateBlockingConditionUtil(
-      this.db,
-      patientId,
-      data,
-      currentUser.uid,
-      currentUser.roles
-    );
+    await updateBlockingConditionUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
   }
   async removeBlockingCondition(patientId, conditionIndex) {
     const currentUser = await this.getCurrentUser();
@@ -5651,23 +5613,11 @@ var PatientService = class extends BaseService {
   // Metode za rad sa kontraindikacijama
   async addContraindication(patientId, data) {
     const currentUser = await this.getCurrentUser();
-    await addContraindicationUtil(
-      this.db,
-      patientId,
-      data,
-      currentUser.uid,
-      currentUser.roles
-    );
+    await addContraindicationUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
   }
   async updateContraindication(patientId, data) {
     const currentUser = await this.getCurrentUser();
-    await updateContraindicationUtil(
-      this.db,
-      patientId,
-      data,
-      currentUser.uid,
-      currentUser.roles
-    );
+    await updateContraindicationUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
   }
   async removeContraindication(patientId, contraindicationIndex) {
     const currentUser = await this.getCurrentUser();
@@ -5682,23 +5632,11 @@ var PatientService = class extends BaseService {
   // Metode za rad sa medikacijama
   async addMedication(patientId, data) {
     const currentUser = await this.getCurrentUser();
-    await addMedicationUtil(
-      this.db,
-      patientId,
-      data,
-      currentUser.uid,
-      currentUser.roles
-    );
+    await addMedicationUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
   }
   async updateMedication(patientId, data) {
     const currentUser = await this.getCurrentUser();
-    await updateMedicationUtil(
-      this.db,
-      patientId,
-      data,
-      currentUser.uid,
-      currentUser.roles
-    );
+    await updateMedicationUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
   }
   async removeMedication(patientId, medicationIndex) {
     const currentUser = await this.getCurrentUser();
@@ -5739,9 +5677,7 @@ var PatientService = class extends BaseService {
     if (!this.auth.currentUser) {
       throw new Error("No authenticated user");
     }
-    const userDoc = await getDoc13(
-      doc10(this.db, "users", this.auth.currentUser.uid)
-    );
+    const userDoc = await getDoc13(doc10(this.db, "users", this.auth.currentUser.uid));
     if (!userDoc.exists()) {
       throw new Error("User not found");
     }
@@ -5782,9 +5718,7 @@ var PatientService = class extends BaseService {
    * @returns URL of the uploaded photo
    */
   async uploadProfilePhoto(patientId, file) {
-    console.log(
-      `[PatientService] Uploading profile photo for patient ${patientId}`
-    );
+    console.log(`[PatientService] Uploading profile photo for patient ${patientId}`);
     const mediaMetadata = await this.mediaService.uploadMedia(
       file,
       patientId,
@@ -5807,14 +5741,9 @@ var PatientService = class extends BaseService {
    * @returns URL of the new uploaded photo
    */
   async updateProfilePhoto(patientId, file) {
-    console.log(
-      `[PatientService] Updating profile photo for patient ${patientId}`
-    );
+    console.log(`[PatientService] Updating profile photo for patient ${patientId}`);
     const currentUser = await this.getCurrentUser();
-    const currentSensitiveInfo = await this.getSensitiveInfo(
-      patientId,
-      currentUser.uid
-    );
+    const currentSensitiveInfo = await this.getSensitiveInfo(patientId, currentUser.uid);
     if ((currentSensitiveInfo == null ? void 0 : currentSensitiveInfo.photoUrl) && typeof currentSensitiveInfo.photoUrl === "string") {
       try {
         const existingMediaMetadata = await this.mediaService.getMediaMetadataByUrl(
@@ -5837,14 +5766,9 @@ var PatientService = class extends BaseService {
    * @param patientId - ID of the patient
    */
   async deleteProfilePhoto(patientId) {
-    console.log(
-      `[PatientService] Deleting profile photo for patient ${patientId}`
-    );
+    console.log(`[PatientService] Deleting profile photo for patient ${patientId}`);
     const currentUser = await this.getCurrentUser();
-    const currentSensitiveInfo = await this.getSensitiveInfo(
-      patientId,
-      currentUser.uid
-    );
+    const currentSensitiveInfo = await this.getSensitiveInfo(patientId, currentUser.uid);
     if ((currentSensitiveInfo == null ? void 0 : currentSensitiveInfo.photoUrl) && typeof currentSensitiveInfo.photoUrl === "string") {
       try {
         const existingMediaMetadata = await this.mediaService.getMediaMetadataByUrl(
@@ -5916,10 +5840,7 @@ var PatientService = class extends BaseService {
    * @returns {Promise<PatientProfile[]>} A promise resolving to an array of all patient profiles.
    */
   async getAllPatients(options) {
-    console.log(
-      `[PatientService.getAllPatients] Fetching patients with options:`,
-      options
-    );
+    console.log(`[PatientService.getAllPatients] Fetching patients with options:`, options);
     return getAllPatientsUtil(this.db, options);
   }
   /**
@@ -5950,11 +5871,7 @@ var PatientService = class extends BaseService {
     console.log(
       `[PatientService.getPatientsByPractitionerWithDetails] Fetching detailed patient profiles for practitioner: ${practitionerId}`
     );
-    return getPatientsByPractitionerWithDetailsUtil(
-      this.db,
-      practitionerId,
-      options
-    );
+    return getPatientsByPractitionerWithDetailsUtil(this.db, practitionerId, options);
   }
   /**
    * Gets all patients associated with a specific clinic.
@@ -5966,9 +5883,7 @@ var PatientService = class extends BaseService {
    * @returns {Promise<PatientProfile[]>} A promise resolving to an array of patient profiles
    */
   async getPatientsByClinic(clinicId, options) {
-    console.log(
-      `[PatientService.getPatientsByClinic] Fetching patients for clinic: ${clinicId}`
-    );
+    console.log(`[PatientService.getPatientsByClinic] Fetching patients for clinic: ${clinicId}`);
     return getPatientsByClinicUtil(this.db, clinicId, options);
   }
   /**
@@ -7680,11 +7595,15 @@ var UserService = class extends BaseService {
             if ((await this.getUserById(userId)).patientProfile || patientProfile2.userRef) {
               throw new Error("User already has a patient profile.");
             }
-            const sensitiveInfo = await patientService.getSensitiveInfo(patientProfile2.id, userId);
+            const sensitiveInfo = await patientService.claimPatientSensitiveInfo(
+              patientProfile2.id,
+              userId
+            );
             const fullDisplayName = sensitiveInfo ? `${sensitiveInfo.firstName} ${sensitiveInfo.lastName}` : patientProfile2.displayName;
             await patientService.updatePatientProfile(patientProfile2.id, {
               userRef: userId,
               isManual: false,
+              isVerified: true,
               displayName: fullDisplayName
             });
             await patientService.markPatientTokenAsUsed(token.id, token.patientId, userId);

package/package.json

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

package/src/admin/booking/booking.admin.ts

@@ -339,22 +339,33 @@ export class BookingAdmin {
         endTime: end.toDate().toISOString(),
       });
 
+      const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1000;
+      const queryStart = admin.firestore.Timestamp.fromMillis(
+        start.toMillis() - MAX_EVENT_DURATION_MS
+      );
+
       const eventsRef = this.db
         .collection(`clinics/${clinicId}/calendar`)
-        .where("eventTime.start", ">=", start)
-        .where("eventTime.start", "<=", end);
+        .where("eventTime.start", ">=", queryStart)
+        .where("eventTime.start", "<", end)
+        .orderBy("eventTime.start");
 
       const snapshot = await eventsRef.get();
 
-      const events = snapshot.docs.map((doc) => ({
-        ...doc.data(),
-        id: doc.id,
-      }));
+      const events = snapshot.docs
+        .map((doc) => ({
+          ...doc.data(),
+          id: doc.id,
+        }))
+        .filter((event: any) => {
+          return event.eventTime.end.toMillis() > start.toMillis();
+        });
 
       Logger.debug("[BookingAdmin] Retrieved clinic calendar events", {
         clinicId,
         eventsCount: events.length,
         eventsTypes: this.summarizeEventTypes(events),
+        queryStartTime: queryStart.toDate().toISOString(),
       });
 
       return events;
@@ -392,22 +403,33 @@ export class BookingAdmin {
         endTime: end.toDate().toISOString(),
       });
 
+      const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1000;
+      const queryStart = admin.firestore.Timestamp.fromMillis(
+        start.toMillis() - MAX_EVENT_DURATION_MS
+      );
+
       const eventsRef = this.db
         .collection(`practitioners/${practitionerId}/calendar`)
-        .where("eventTime.start", ">=", start)
-        .where("eventTime.start", "<=", end);
+        .where("eventTime.start", ">=", queryStart)
+        .where("eventTime.start", "<", end)
+        .orderBy("eventTime.start");
 
       const snapshot = await eventsRef.get();
 
-      const events = snapshot.docs.map((doc) => ({
-        ...doc.data(),
-        id: doc.id,
-      }));
+      const events = snapshot.docs
+        .map((doc) => ({
+          ...doc.data(),
+          id: doc.id,
+        }))
+        .filter((event: any) => {
+          return event.eventTime.end.toMillis() > start.toMillis();
+        });
 
       Logger.debug("[BookingAdmin] Retrieved practitioner calendar events", {
         practitionerId,
         eventsCount: events.length,
         eventsTypes: this.summarizeEventTypes(events),
+        queryStartTime: queryStart.toDate().toISOString(),
       });
 
       return events;

package/src/admin/booking/booking.calculator.ts

@@ -96,7 +96,8 @@ export class BookingAvailabilityCalculator {
     const availableSlots = this.generateAvailableSlots(
       availableIntervals,
       schedulingIntervalMinutes,
-      procedureDurationMinutes
+      procedureDurationMinutes,
+      tz
     );
 
     return { availableSlots };
@@ -469,16 +470,18 @@ export class BookingAvailabilityCalculator {
    * @param intervals - Final available intervals
    * @param intervalMinutes - Scheduling interval in minutes
    * @param durationMinutes - Procedure duration in minutes
+   * @param tz - IANA timezone of the clinic
    * @returns Array of available booking slots
    */
   private static generateAvailableSlots(
     intervals: TimeInterval[],
     intervalMinutes: number,
-    durationMinutes: number
+    durationMinutes: number,
+    tz: string
   ): AvailableSlot[] {
     const slots: AvailableSlot[] = [];
     console.log(
-      `Generating slots with ${intervalMinutes}min intervals for ${durationMinutes}min procedure`
+      `Generating slots with ${intervalMinutes}min intervals for ${durationMinutes}min procedure in timezone ${tz}`
     );
 
     // Convert duration to milliseconds
@@ -492,8 +495,8 @@ export class BookingAvailabilityCalculator {
       const intervalStart = interval.start.toDate();
       const intervalEnd = interval.end.toDate();
 
-      // Start at the beginning of the interval
-      let slotStart = DateTime.fromJSDate(intervalStart);
+      // Start at the beginning of the interval IN CLINIC TIMEZONE
+      let slotStart = DateTime.fromMillis(intervalStart.getTime(), { zone: tz });
 
       // Adjust slotStart to the nearest interval boundary if needed
       const minutesIntoDay = slotStart.hour * 60 + slotStart.minute;
@@ -511,7 +514,7 @@ export class BookingAvailabilityCalculator {
         const slotEnd = slotStart.plus({ minutes: durationMinutes });
 
         // Check if this slot fits entirely within one of our available intervals
-        if (this.isSlotFullyAvailable(slotStart, slotEnd, intervals)) {
+        if (this.isSlotFullyAvailable(slotStart, slotEnd, intervals, tz)) {
           slots.push({
             start: Timestamp.fromMillis(slotStart.toMillis()),
           });
@@ -532,17 +535,19 @@ export class BookingAvailabilityCalculator {
    * @param slotStart - Start time of the slot
    * @param slotEnd - End time of the slot
    * @param intervals - Available intervals
+   * @param tz - IANA timezone of the clinic
    * @returns True if the slot is fully contained within an available interval
    */
   private static isSlotFullyAvailable(
     slotStart: DateTime,
     slotEnd: DateTime,
-    intervals: TimeInterval[]
+    intervals: TimeInterval[],
+    tz: string
   ): boolean {
     // Check if the slot is fully contained in any of the available intervals
     return intervals.some((interval) => {
-      const intervalStart = DateTime.fromMillis(interval.start.toMillis());
-      const intervalEnd = DateTime.fromMillis(interval.end.toMillis());
+      const intervalStart = DateTime.fromMillis(interval.start.toMillis(), { zone: tz });
+      const intervalEnd = DateTime.fromMillis(interval.end.toMillis(), { zone: tz });
 
       return slotStart >= intervalStart && slotEnd <= intervalEnd;
     });

package/src/admin/booking/timezones-problem.md

@@ -122,11 +122,55 @@ Alignment expectation:
   - Interval sizes that don’t divide 60 (e.g., 20 min), and variable procedure durations.
 
 ### Actionable checklist
-- Make all DateTime constructions in slot generation and containment checks use `{ zone: tz }`.
-- Replace `fromJSDate` with `fromMillis` in calculator paths.
-- Update event fetching to include overlaps with the timeframe; union queries or adjust model.
-- Re-assert the type contract: calculator receives only client `Timestamp` + `tz`.
-- Document UI responsibility to convert wall-clock (clinic `tz`) → UTC Timestamp exactly once.
+- ✅ Make all DateTime constructions in slot generation and containment checks use `{ zone: tz }`.
+- ✅ Replace `fromJSDate` with `fromMillis` in calculator paths.
+- ✅ Update event fetching to include overlaps with the timeframe; union queries or adjust model.
+- ⏳ Re-assert the type contract: calculator receives only client `Timestamp` + `tz`.
+- ⏳ Document UI responsibility to convert wall-clock (clinic `tz`) → UTC Timestamp exactly once.
+
+### PHASE 1 COMPLETED: Backend Calculator Fixes ✅
+
+**Date Completed:** October 1, 2025
+
+**Changes Made:**
+
+1. **booking.calculator.ts - generateAvailableSlots()**
+   - Added `tz: string` parameter
+   - Changed `DateTime.fromJSDate(intervalStart)` → `DateTime.fromMillis(intervalStart.getTime(), { zone: tz })`
+   - Now explicitly creates DateTime in clinic timezone for all slot calculations
+   
+2. **booking.calculator.ts - isSlotFullyAvailable()**
+   - Added `tz: string` parameter
+   - Changed `DateTime.fromMillis(interval.start.toMillis())` → `DateTime.fromMillis(interval.start.toMillis(), { zone: tz })`
+   - Interval boundary checks now use clinic timezone context
+
+3. **booking.calculator.ts - calculateSlots()**
+   - Updated call to `generateAvailableSlots()` to pass `tz` parameter
+   - Updated call to `isSlotFullyAvailable()` to pass `tz` parameter
+
+4. **booking.admin.ts - getClinicCalendarEvents()**
+   - Fixed event overlap logic with bounded query
+   - Added lower bound: `queryStart = start - 24 hours` to prevent querying all historical events
+   - Query: `eventTime.start >= queryStart AND eventTime.start < end`
+   - Added post-filter: `eventTime.end > start` to catch all overlapping events
+   - Prevents missing events that start before window but overlap into it
+   - Performance optimized: only queries ~24-48 hours of events instead of entire history
+
+5. **booking.admin.ts - getPractitionerCalendarEvents()**
+   - Applied same overlap fix with 24-hour lookback window
+   - Ensures busy time subtraction includes all conflicting events
+   - Efficient: assumes no appointments longer than 24 hours
+
+**Impact:**
+- Slot generation now correctly happens in clinic timezone
+- Slots are properly converted to UTC for storage/transmission
+- Event blocking now catches all overlapping events, not just those starting within window
+- Fixes timezone display issues for users in different timezones
+
+**Next Steps:**
+- Phase 2: Mobile app fixes (use original UTC timestamp from slots)
+- Phase 3: ClinicApp fixes (same as Mobile)
+- Phase 4: Testing across multiple timezones and DST boundaries
 
 ### Known risks
 - DST transitions can produce days with 23/25 hours; rounding/iteration must not assume 24h.

package/src/services/clinic/clinic.service.ts

@@ -17,7 +17,7 @@ import {
   arrayUnion,
   arrayRemove,
 } from "firebase/firestore";
-import { getFunctions, httpsCallable, connectFunctionsEmulator } from "firebase/functions";
+import { getFunctions, httpsCallable } from "firebase/functions";
 import { BaseService } from "../base.service";
 import {
   Clinic,