@blackcode_sa/metaestetics-api 1.12.27 → 1.12.28

package/src/services/patient/patient.service.ts

@@ -5,13 +5,9 @@ import {
   updateDoc,
   arrayUnion,
   serverTimestamp,
-} from "firebase/firestore";
-import { BaseService } from "../base.service";
-import {
-  MediaService,
-  MediaAccessLevel,
-  MediaResource,
-} from "../media/media.service";
+} from 'firebase/firestore';
+import { BaseService } from '../base.service';
+import { MediaService, MediaAccessLevel, MediaResource } from '../media/media.service';
 import {
   PatientProfile,
   PatientSensitiveInfo,
@@ -38,11 +34,11 @@ import {
   RequesterInfo,
   PatientProfileForDoctor,
   CreateManualPatientData,
-} from "../../types/patient";
-import { Auth } from "firebase/auth";
-import { Firestore } from "firebase/firestore";
-import { FirebaseApp } from "firebase/app";
-import { Timestamp } from "firebase/firestore";
+} from '../../types/patient';
+import { Auth } from 'firebase/auth';
+import { Firestore } from 'firebase/firestore';
+import { FirebaseApp } from 'firebase/app';
+import { Timestamp } from 'firebase/firestore';
 
 // Importujemo utility funkcije
 import {
@@ -63,6 +59,7 @@ import {
   createSensitiveInfoUtil,
   getSensitiveInfoUtil,
   updateSensitiveInfoUtil,
+  claimPatientSensitiveInfoUtil,
   createMedicalInfoUtil,
   getMedicalInfoUtil,
   updateVitalStatsUtil,
@@ -94,12 +91,9 @@ import {
   markPatientTokenAsUsedUtil,
   getActiveInviteTokensByClinicUtil,
   getActiveInviteTokensByPatientUtil,
-} from "./utils";
+} from './utils';
 
-import {
-  CreatePatientTokenData,
-  PatientToken,
-} from "../../types/patient/token.types";
+import { CreatePatientTokenData, PatientToken } from '../../types/patient/token.types';
 
 export class PatientService extends BaseService {
   private mediaService: MediaService;
@@ -110,9 +104,7 @@ export class PatientService extends BaseService {
   }
 
   // Metode za rad sa profilom pacijenta
-  async createPatientProfile(
-    data: CreatePatientProfileData
-  ): Promise<PatientProfile> {
+  async createPatientProfile(data: CreatePatientProfileData): Promise<PatientProfile> {
     return createPatientProfileUtil(this.db, data, () => this.generateId());
   }
 
@@ -131,21 +123,21 @@ export class PatientService extends BaseService {
    */
   async createManualPatient(
     data: CreateManualPatientData,
-    requester: RequesterInfo
+    requester: RequesterInfo,
   ): Promise<PatientProfile> {
     console.log(
       `[PatientService.createManualPatient] Attempting to create manual patient by requester:`,
-      requester
+      requester,
     );
 
     // Security Check: Ensure the requester is a clinic admin
     if (
-      requester.role !== "clinic_admin" ||
+      requester.role !== 'clinic_admin' ||
       !requester.associatedClinicId ||
       requester.associatedClinicId !== data.clinicId
     ) {
       throw new Error(
-        "Unauthorized: Requester must be a clinic admin and can only add patients to their own clinic."
+        'Unauthorized: Requester must be a clinic admin and can only add patients to their own clinic.',
       );
     }
 
@@ -184,7 +176,7 @@ export class PatientService extends BaseService {
 
     // 2. Create Patient Sensitive Info
     const sensitiveInfoRef = getSensitiveInfoDocRef(this.db, patientId);
-    const newSensitiveInfo: Omit<PatientSensitiveInfo, "photoUrl"> = {
+    const newSensitiveInfo: Omit<PatientSensitiveInfo, 'photoUrl'> = {
       patientId,
       firstName: data.firstName,
       lastName: data.lastName,
@@ -208,7 +200,7 @@ export class PatientService extends BaseService {
       contraindications: [],
       allergies: [],
       currentMedications: [],
-      emergencyNotes: "",
+      emergencyNotes: '',
       lastUpdated: now,
       updatedBy: requester.id, // The admin who created the record
     };
@@ -217,15 +209,13 @@ export class PatientService extends BaseService {
     await batch.commit();
 
     console.log(
-      `[PatientService.createManualPatient] Successfully created manual patient with ID: ${patientId}`
+      `[PatientService.createManualPatient] Successfully created manual patient with ID: ${patientId}`,
     );
 
     return newProfile;
   }
 
-  async getPatientProfileByUserRef(
-    userRef: string
-  ): Promise<PatientProfile | null> {
+  async getPatientProfileByUserRef(userRef: string): Promise<PatientProfile | null> {
     return getPatientProfileByUserRefUtil(this.db, userRef);
   }
 
@@ -233,7 +223,7 @@ export class PatientService extends BaseService {
   async updatePatientLocation(
     patientId: string,
     latitude: number,
-    longitude: number
+    longitude: number,
   ): Promise<void> {
     await updatePatientLocationUtil(this.db, patientId, latitude, longitude);
   }
@@ -241,30 +231,30 @@ export class PatientService extends BaseService {
   async updatePatientLocationByUserRef(
     userRef: string,
     latitude: number,
-    longitude: number
+    longitude: number,
   ): Promise<void> {
     const profile = await this.getPatientProfileByUserRef(userRef);
-    if (!profile) throw new Error("Patient profile not found");
+    if (!profile) throw new Error('Patient profile not found');
     await this.updatePatientLocation(profile.id, latitude, longitude);
   }
 
   async createLocationInfo(
     data: CreatePatientLocationInfoData,
-    requesterId: string
+    requesterId: string,
   ): Promise<PatientLocationInfo> {
     return createLocationInfoUtil(this.db, data, requesterId);
   }
 
   async getLocationInfo(
     patientId: string,
-    requesterId: string
+    requesterId: string,
   ): Promise<PatientLocationInfo | null> {
     return getLocationInfoUtil(this.db, patientId, requesterId);
   }
 
   async getLocationInfoByUserRef(
     userRef: string,
-    requesterId: string
+    requesterId: string,
   ): Promise<PatientLocationInfo | null> {
     const profile = await this.getPatientProfileByUserRef(userRef);
     if (!profile) return null;
@@ -274,7 +264,7 @@ export class PatientService extends BaseService {
   async updateLocationInfo(
     patientId: string,
     data: UpdatePatientLocationInfoData,
-    requesterId: string
+    requesterId: string,
   ): Promise<PatientLocationInfo> {
     return updateLocationInfoUtil(this.db, patientId, data, requesterId);
   }
@@ -282,11 +272,11 @@ export class PatientService extends BaseService {
   // Metode za rad sa osetljivim informacijama
   async createSensitiveInfo(
     data: CreatePatientSensitiveInfoData,
-    requesterUserId: string
+    requesterUserId: string,
   ): Promise<PatientSensitiveInfo> {
     const currentUser = await this.getCurrentUser();
     if (currentUser.uid !== requesterUserId) {
-      throw new Error("Requester does not match authenticated user.");
+      throw new Error('Requester does not match authenticated user.');
     }
 
     return createSensitiveInfoUtil(
@@ -294,30 +284,25 @@ export class PatientService extends BaseService {
       data,
       requesterUserId,
       currentUser.roles,
-      this.mediaService
+      this.mediaService,
     );
   }
 
   async getSensitiveInfo(
     patientId: string,
-    requesterUserId: string
+    requesterUserId: string,
   ): Promise<PatientSensitiveInfo | null> {
     const currentUser = await this.getCurrentUser();
     if (currentUser.uid !== requesterUserId) {
       // Allow for read-only access if authorized, but for now we check identity
       // This could be expanded later based on practitioner/admin roles
     }
-    return getSensitiveInfoUtil(
-      this.db,
-      patientId,
-      requesterUserId,
-      currentUser.roles
-    );
+    return getSensitiveInfoUtil(this.db, patientId, requesterUserId, currentUser.roles);
   }
 
   async getSensitiveInfoByUserRef(
     userRef: string,
-    requesterUserId: string
+    requesterUserId: string,
   ): Promise<PatientSensitiveInfo | null> {
     const profile = await this.getPatientProfileByUserRef(userRef);
     if (!profile) return null;
@@ -328,11 +313,11 @@ export class PatientService extends BaseService {
   async updateSensitiveInfo(
     patientId: string,
     data: UpdatePatientSensitiveInfoData,
-    requesterUserId: string
+    requesterUserId: string,
   ): Promise<PatientSensitiveInfo> {
     const currentUser = await this.getCurrentUser();
     if (currentUser.uid !== requesterUserId) {
-      throw new Error("Requester does not match authenticated user.");
+      throw new Error('Requester does not match authenticated user.');
     }
     return updateSensitiveInfoUtil(
       this.db,
@@ -340,219 +325,122 @@ export class PatientService extends BaseService {
       data,
       requesterUserId,
       currentUser.roles,
-      this.mediaService
+      this.mediaService,
     );
   }
 
-  // Metode za rad sa medicinskim informacijama
-  async createMedicalInfo(
+  async claimPatientSensitiveInfo(
     patientId: string,
-    data: CreatePatientMedicalInfoData
-  ): Promise<void> {
+    userId: string,
+  ): Promise<PatientSensitiveInfo> {
+    return claimPatientSensitiveInfoUtil(this.db, patientId, userId);
+  }
+
+  // Metode za rad sa medicinskim informacijama
+  async createMedicalInfo(patientId: string, data: CreatePatientMedicalInfoData): Promise<void> {
     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: string): Promise<PatientMedicalInfo> {
     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: string): Promise<PatientMedicalInfo> {
     const profile = await this.getPatientProfileByUserRef(userRef);
-    if (!profile) throw new Error("Patient profile not found");
+    if (!profile) throw new Error('Patient profile not found');
     return this.getMedicalInfo(profile.id);
   }
 
   // Metode za rad sa vitalnim statistikama
-  async updateVitalStats(
-    patientId: string,
-    data: UpdateVitalStatsData
-  ): Promise<void> {
+  async updateVitalStats(patientId: string, data: UpdateVitalStatsData): Promise<void> {
     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: string, data: AddAllergyData): Promise<void> {
     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: string,
-    data: UpdateAllergyData
-  ): Promise<void> {
+  async updateAllergy(patientId: string, data: UpdateAllergyData): Promise<void> {
     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: string, allergyIndex: number): Promise<void> {
     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: string,
-    data: AddBlockingConditionData
-  ): Promise<void> {
+  async addBlockingCondition(patientId: string, data: AddBlockingConditionData): Promise<void> {
     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: string,
-    data: UpdateBlockingConditionData
+    data: UpdateBlockingConditionData,
   ): Promise<void> {
     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: string,
-    conditionIndex: number
-  ): Promise<void> {
+  async removeBlockingCondition(patientId: string, conditionIndex: number): Promise<void> {
     const currentUser = await this.getCurrentUser();
     await removeBlockingConditionUtil(
       this.db,
       patientId,
       conditionIndex,
       currentUser.uid,
-      currentUser.roles
+      currentUser.roles,
     );
   }
 
   // Metode za rad sa kontraindikacijama
-  async addContraindication(
-    patientId: string,
-    data: AddContraindicationData
-  ): Promise<void> {
+  async addContraindication(patientId: string, data: AddContraindicationData): Promise<void> {
     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: string,
-    data: UpdateContraindicationData
-  ): Promise<void> {
+  async updateContraindication(patientId: string, data: UpdateContraindicationData): Promise<void> {
     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: string,
-    contraindicationIndex: number
-  ): Promise<void> {
+  async removeContraindication(patientId: string, contraindicationIndex: number): Promise<void> {
     const currentUser = await this.getCurrentUser();
     await removeContraindicationUtil(
       this.db,
       patientId,
       contraindicationIndex,
       currentUser.uid,
-      currentUser.roles
+      currentUser.roles,
     );
   }
 
   // Metode za rad sa medikacijama
-  async addMedication(
-    patientId: string,
-    data: AddMedicationData
-  ): Promise<void> {
+  async addMedication(patientId: string, data: AddMedicationData): Promise<void> {
     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: string,
-    data: UpdateMedicationData
-  ): Promise<void> {
+  async updateMedication(patientId: string, data: UpdateMedicationData): Promise<void> {
     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: string,
-    medicationIndex: number
-  ): Promise<void> {
+  async removeMedication(patientId: string, medicationIndex: number): Promise<void> {
     const currentUser = await this.getCurrentUser();
     await removeMedicationUtil(
       this.db,
       patientId,
       medicationIndex,
       currentUser.uid,
-      currentUser.roles
+      currentUser.roles,
     );
   }
 
@@ -563,7 +451,7 @@ export class PatientService extends BaseService {
 
   async addExpoTokenByUserRef(userRef: string, token: string): Promise<void> {
     const profile = await this.getPatientProfileByUserRef(userRef);
-    if (!profile) throw new Error("Patient profile not found");
+    if (!profile) throw new Error('Patient profile not found');
     await this.addExpoToken(profile.id, token);
   }
 
@@ -571,12 +459,9 @@ export class PatientService extends BaseService {
     await removeExpoTokenUtil(this.db, patientId, token);
   }
 
-  async removeExpoTokenByUserRef(
-    userRef: string,
-    token: string
-  ): Promise<void> {
+  async removeExpoTokenByUserRef(userRef: string, token: string): Promise<void> {
     const profile = await this.getPatientProfileByUserRef(userRef);
-    if (!profile) throw new Error("Patient profile not found");
+    if (!profile) throw new Error('Patient profile not found');
     await this.removeExpoToken(profile.id, token);
   }
 
@@ -586,19 +471,17 @@ export class PatientService extends BaseService {
 
   async addPointsByUserRef(userRef: string, points: number): Promise<void> {
     const profile = await this.getPatientProfileByUserRef(userRef);
-    if (!profile) throw new Error("Patient profile not found");
+    if (!profile) throw new Error('Patient profile not found');
     await this.addPoints(profile.id, points);
   }
 
   private async getCurrentUser(): Promise<any> {
     if (!this.auth.currentUser) {
-      throw new Error("No authenticated user");
+      throw new Error('No authenticated user');
     }
-    const userDoc = await getDoc(
-      doc(this.db, "users", this.auth.currentUser.uid)
-    );
+    const userDoc = await getDoc(doc(this.db, 'users', this.auth.currentUser.uid));
     if (!userDoc.exists()) {
-      throw new Error("User not found");
+      throw new Error('User not found');
     }
     return userDoc.data();
   }
@@ -651,20 +534,15 @@ export class PatientService extends BaseService {
    * @param file - File or Blob to upload
    * @returns URL of the uploaded photo
    */
-  async uploadProfilePhoto(
-    patientId: string,
-    file: File | Blob
-  ): Promise<string> {
-    console.log(
-      `[PatientService] Uploading profile photo for patient ${patientId}`
-    );
+  async uploadProfilePhoto(patientId: string, file: File | Blob): Promise<string> {
+    console.log(`[PatientService] Uploading profile photo for patient ${patientId}`);
 
     const mediaMetadata = await this.mediaService.uploadMedia(
       file,
       patientId, // Using patientId as ownerId
       MediaAccessLevel.PRIVATE, // Profile photos should be private
-      "patient_profile_photos",
-      file instanceof File ? file.name : `profile_photo_${patientId}`
+      'patient_profile_photos',
+      file instanceof File ? file.name : `profile_photo_${patientId}`,
     );
 
     // Update the patient sensitive info with the new photo URL
@@ -682,38 +560,26 @@ export class PatientService extends BaseService {
    * @param file - New file or Blob to upload
    * @returns URL of the new uploaded photo
    */
-  async updateProfilePhoto(
-    patientId: string,
-    file: File | Blob
-  ): Promise<string> {
-    console.log(
-      `[PatientService] Updating profile photo for patient ${patientId}`
-    );
+  async updateProfilePhoto(patientId: string, file: File | Blob): Promise<string> {
+    console.log(`[PatientService] Updating profile photo for patient ${patientId}`);
 
     // Get current patient sensitive info to check for existing photo
     const currentUser = await this.getCurrentUser();
-    const currentSensitiveInfo = await this.getSensitiveInfo(
-      patientId,
-      currentUser.uid
-    );
+    const currentSensitiveInfo = await this.getSensitiveInfo(patientId, currentUser.uid);
 
     // Delete old photo if it exists and is managed by our MediaService
-    if (
-      currentSensitiveInfo?.photoUrl &&
-      typeof currentSensitiveInfo.photoUrl === "string"
-    ) {
+    if (currentSensitiveInfo?.photoUrl && typeof currentSensitiveInfo.photoUrl === 'string') {
       try {
-        const existingMediaMetadata =
-          await this.mediaService.getMediaMetadataByUrl(
-            currentSensitiveInfo.photoUrl
-          );
+        const existingMediaMetadata = await this.mediaService.getMediaMetadataByUrl(
+          currentSensitiveInfo.photoUrl,
+        );
         if (existingMediaMetadata) {
           await this.mediaService.deleteMedia(existingMediaMetadata.id);
         }
       } catch (error) {
         console.warn(
           `[PatientService] Could not delete old profile photo for patient ${patientId}:`,
-          error
+          error,
         );
         // Continue with upload even if deletion fails
       }
@@ -728,33 +594,24 @@ export class PatientService extends BaseService {
    * @param patientId - ID of the patient
    */
   async deleteProfilePhoto(patientId: string): Promise<void> {
-    console.log(
-      `[PatientService] Deleting profile photo for patient ${patientId}`
-    );
+    console.log(`[PatientService] Deleting profile photo for patient ${patientId}`);
 
     // Get current patient sensitive info to find the photo URL
     const currentUser = await this.getCurrentUser();
-    const currentSensitiveInfo = await this.getSensitiveInfo(
-      patientId,
-      currentUser.uid
-    );
+    const currentSensitiveInfo = await this.getSensitiveInfo(patientId, currentUser.uid);
 
-    if (
-      currentSensitiveInfo?.photoUrl &&
-      typeof currentSensitiveInfo.photoUrl === "string"
-    ) {
+    if (currentSensitiveInfo?.photoUrl && typeof currentSensitiveInfo.photoUrl === 'string') {
       try {
-        const existingMediaMetadata =
-          await this.mediaService.getMediaMetadataByUrl(
-            currentSensitiveInfo.photoUrl
-          );
+        const existingMediaMetadata = await this.mediaService.getMediaMetadataByUrl(
+          currentSensitiveInfo.photoUrl,
+        );
         if (existingMediaMetadata) {
           await this.mediaService.deleteMedia(existingMediaMetadata.id);
         }
       } catch (error) {
         console.warn(
           `[PatientService] Could not delete profile photo for patient ${patientId}:`,
-          error
+          error,
         );
       }
 
@@ -774,14 +631,14 @@ export class PatientService extends BaseService {
    */
   private async handleProfilePhotoUpload(
     photoUrl: MediaResource | undefined,
-    patientId: string
+    patientId: string,
   ): Promise<string | undefined> {
     if (!photoUrl) {
       return undefined;
     }
 
     // If it's already a URL string, return it as is
-    if (typeof photoUrl === "string") {
+    if (typeof photoUrl === 'string') {
       return photoUrl;
     }
 
@@ -796,14 +653,14 @@ export class PatientService extends BaseService {
   // Metode za ažuriranje profila
   async updatePatientProfile(
     patientId: string,
-    data: Partial<Omit<PatientProfile, "id" | "createdAt" | "updatedAt">>
+    data: Partial<Omit<PatientProfile, 'id' | 'createdAt' | 'updatedAt'>>,
   ): Promise<PatientProfile> {
     return updatePatientProfileUtil(this.db, patientId, data);
   }
 
   async updatePatientProfileByUserRef(
     userRef: string,
-    data: Partial<Omit<PatientProfile, "id" | "createdAt" | "updatedAt">>
+    data: Partial<Omit<PatientProfile, 'id' | 'createdAt' | 'updatedAt'>>,
   ): Promise<PatientProfile> {
     return updatePatientProfileByUserRefUtil(this.db, userRef, data);
   }
@@ -818,7 +675,7 @@ export class PatientService extends BaseService {
    */
   async searchPatients(
     params: SearchPatientsParams,
-    requester: RequesterInfo
+    requester: RequesterInfo,
   ): Promise<PatientProfile[]> {
     // We can potentially add more service-level logic here in the future,
     // like fetching additional data or enriching the results.
@@ -827,7 +684,7 @@ export class PatientService extends BaseService {
       `[PatientService.searchPatients] Initiating search with params:`,
       params,
       `by requester:`,
-      requester
+      requester,
     );
 
     // The utility function already handles validation and security checks.
@@ -846,10 +703,7 @@ export class PatientService extends BaseService {
     limit?: number;
     startAfter?: string;
   }): Promise<PatientProfile[]> {
-    console.log(
-      `[PatientService.getAllPatients] Fetching patients with options:`,
-      options
-    );
+    console.log(`[PatientService.getAllPatients] Fetching patients with options:`, options);
     return getAllPatientsUtil(this.db, options);
   }
 
@@ -867,10 +721,10 @@ export class PatientService extends BaseService {
     options?: {
       limit?: number;
       startAfter?: string;
-    }
+    },
   ): Promise<PatientProfile[]> {
     console.log(
-      `[PatientService.getPatientsByPractitioner] Fetching patients for practitioner: ${practitionerId}`
+      `[PatientService.getPatientsByPractitioner] Fetching patients for practitioner: ${practitionerId}`,
     );
     return getPatientsByPractitionerUtil(this.db, practitionerId, options);
   }
@@ -889,16 +743,12 @@ export class PatientService extends BaseService {
     options?: {
       limit?: number;
       startAfter?: string;
-    }
+    },
   ): Promise<PatientProfileForDoctor[]> {
     console.log(
-      `[PatientService.getPatientsByPractitionerWithDetails] Fetching detailed patient profiles for practitioner: ${practitionerId}`
-    );
-    return getPatientsByPractitionerWithDetailsUtil(
-      this.db,
-      practitionerId,
-      options
+      `[PatientService.getPatientsByPractitionerWithDetails] Fetching detailed patient profiles for practitioner: ${practitionerId}`,
     );
+    return getPatientsByPractitionerWithDetailsUtil(this.db, practitionerId, options);
   }
 
   /**
@@ -915,11 +765,9 @@ export class PatientService extends BaseService {
     options?: {
       limit?: number;
       startAfter?: string;
-    }
+    },
   ): Promise<PatientProfile[]> {
-    console.log(
-      `[PatientService.getPatientsByClinic] Fetching patients for clinic: ${clinicId}`
-    );
+    console.log(`[PatientService.getPatientsByClinic] Fetching patients for clinic: ${clinicId}`);
     return getPatientsByClinicUtil(this.db, clinicId, options);
   }
 
@@ -930,17 +778,14 @@ export class PatientService extends BaseService {
    * @param {string} createdBy - ID of the admin user creating the token.
    * @returns {Promise<PatientToken>} The created token.
    */
-  async createPatientToken(
-    data: CreatePatientTokenData,
-    createdBy: string
-  ): Promise<PatientToken> {
+  async createPatientToken(data: CreatePatientTokenData, createdBy: string): Promise<PatientToken> {
     // We assume the 'createdBy' user is validated to be a clinic admin
     // in the calling context (e.g., a cloud function or API endpoint).
     return createPatientTokenUtil(
       this.db,
       data,
       createdBy,
-      () => this.generateId() // Pass the ID generation function
+      () => this.generateId(), // Pass the ID generation function
     );
   }
 
@@ -950,9 +795,7 @@ export class PatientService extends BaseService {
    * @param {string} tokenString - The token string to validate.
    * @returns {Promise<PatientToken | null>} The token if found and valid, otherwise null.
    */
-  async validatePatientToken(
-    tokenString: string
-  ): Promise<PatientToken | null> {
+  async validatePatientToken(tokenString: string): Promise<PatientToken | null> {
     return validatePatientTokenUtil(this.db, tokenString);
   }
 
@@ -964,11 +807,7 @@ export class PatientService extends BaseService {
    * @param {string} userId - The ID of the user who is using the token.
    * @returns {Promise<void>}
    */
-  async markPatientTokenAsUsed(
-    tokenId: string,
-    patientId: string,
-    userId: string
-  ): Promise<void> {
+  async markPatientTokenAsUsed(tokenId: string, patientId: string, userId: string): Promise<void> {
     return markPatientTokenAsUsedUtil(this.db, tokenId, patientId, userId);
   }
 
@@ -979,9 +818,7 @@ export class PatientService extends BaseService {
    * @param {string} clinicId - The ID of the clinic.
    * @returns {Promise<PatientToken[]>} An array of active tokens for the clinic.
    */
-  async getActiveInviteTokensByClinic(
-    clinicId: string
-  ): Promise<PatientToken[]> {
+  async getActiveInviteTokensByClinic(clinicId: string): Promise<PatientToken[]> {
     return getActiveInviteTokensByClinicUtil(this.db, clinicId);
   }
 
@@ -992,9 +829,7 @@ export class PatientService extends BaseService {
    * @param {string} patientId - The ID of the patient.
    * @returns {Promise<PatientToken[]>} An array of active tokens for the patient.
    */
-  async getActiveInviteTokensByPatient(
-    patientId: string
-  ): Promise<PatientToken[]> {
+  async getActiveInviteTokensByPatient(patientId: string): Promise<PatientToken[]> {
     // Security check should be done in the calling context to ensure
     // the admin has permission to view this patient's tokens.
     return getActiveInviteTokensByPatientUtil(this.db, patientId);