@blackcode_sa/metaestetics-api 1.5.17 → 1.5.18

package/src/services/patient/utils/profile.utils.ts

@@ -13,15 +13,12 @@ import {
   where,
   getDocs,
   QueryConstraint,
-} from "firebase/firestore";
-import {
-  ref,
-  uploadBytes,
-  getDownloadURL,
-  deleteObject,
-  FirebaseStorage,
-} from "firebase/storage";
-import { z } from "zod";
+  limit,
+  startAfter,
+  doc,
+} from 'firebase/firestore';
+import { ref, uploadBytes, getDownloadURL, deleteObject, FirebaseStorage } from 'firebase/storage';
+import { z } from 'zod';
 import {
   PatientProfile,
   CreatePatientProfileData,
@@ -29,36 +26,36 @@ import {
   SearchPatientsParams,
   RequesterInfo,
   PATIENTS_COLLECTION,
-} from "../../../types/patient";
+} from '../../../types/patient';
 import {
   patientProfileSchema,
   createPatientProfileSchema,
   searchPatientsSchema,
   requesterInfoSchema,
-} from "../../../validations/patient.schema";
+} from '../../../validations/patient.schema';
 import {
   getPatientDocRef,
   getPatientDocRefByUserRef,
   initSensitiveInfoDocIfNotExists,
   getSensitiveInfoDocRef,
   getMedicalInfoDocRef,
-} from "./docs.utils";
-import { ensureMedicalInfoExists } from "./medical.utils";
-import { DEFAULT_MEDICAL_INFO } from "../../../types/patient/medical-info.types";
+} from './docs.utils';
+import { ensureMedicalInfoExists } from './medical.utils';
+import { DEFAULT_MEDICAL_INFO } from '../../../types/patient/medical-info.types';
 
 // Funkcije za rad sa profilom
 export const createPatientProfileUtil = async (
   db: Firestore,
   data: CreatePatientProfileData,
-  generateId: () => string
+  generateId: () => string,
 ): Promise<PatientProfile> => {
   try {
-    console.log("[createPatientProfileUtil] Starting patient profile creation");
+    console.log('[createPatientProfileUtil] Starting patient profile creation');
     const validatedData = createPatientProfileSchema.parse(data);
     const patientId = generateId();
     console.log(`[createPatientProfileUtil] Generated patientId: ${patientId}`);
 
-    const patientData: Omit<PatientProfile, "createdAt" | "updatedAt"> & {
+    const patientData: Omit<PatientProfile, 'createdAt' | 'updatedAt'> & {
       createdAt: ReturnType<typeof serverTimestamp>;
       updatedAt: ReturnType<typeof serverTimestamp>;
     } = {
@@ -96,21 +93,16 @@ export const createPatientProfileUtil = async (
       const sensitiveInfoCreated = await initSensitiveInfoDocIfNotExists(
         db,
         patientId,
-        validatedData.userRef
+        validatedData.userRef,
       );
       console.log(
         `[createPatientProfileUtil] Sensitive info document creation result: ${
-          sensitiveInfoCreated
-            ? "Document already existed"
-            : "New document created"
-        }`
+          sensitiveInfoCreated ? 'Document already existed' : 'New document created'
+        }`,
       );
       sensitiveInfoSuccess = true;
     } catch (sensitiveError) {
-      console.error(
-        `[createPatientProfileUtil] Error creating sensitive info:`,
-        sensitiveError
-      );
+      console.error(`[createPatientProfileUtil] Error creating sensitive info:`, sensitiveError);
       // Don't throw the error, we'll try the direct method
     }
 
@@ -119,33 +111,21 @@ export const createPatientProfileUtil = async (
     let medicalInfoSuccess = false;
     try {
       await ensureMedicalInfoExists(db, patientId, validatedData.userRef);
-      console.log(
-        `[createPatientProfileUtil] Medical info document created successfully`
-      );
+      console.log(`[createPatientProfileUtil] Medical info document created successfully`);
       medicalInfoSuccess = true;
     } catch (medicalError) {
-      console.error(
-        `[createPatientProfileUtil] Error creating medical info:`,
-        medicalError
-      );
+      console.error(`[createPatientProfileUtil] Error creating medical info:`, medicalError);
       // Don't throw the error, we'll try the direct method
     }
 
     // If either utility function failed, try the direct method
     if (!sensitiveInfoSuccess || !medicalInfoSuccess) {
-      console.log(
-        `[createPatientProfileUtil] Using fallback method to create documents`
-      );
+      console.log(`[createPatientProfileUtil] Using fallback method to create documents`);
       try {
         await testCreateSubDocuments(db, patientId, validatedData.userRef);
-        console.log(
-          `[createPatientProfileUtil] Fallback method completed successfully`
-        );
+        console.log(`[createPatientProfileUtil] Fallback method completed successfully`);
       } catch (fallbackError) {
-        console.error(
-          `[createPatientProfileUtil] Fallback method failed:`,
-          fallbackError
-        );
+        console.error(`[createPatientProfileUtil] Fallback method failed:`, fallbackError);
         // Still continue to return the patient profile
       }
     }
@@ -153,23 +133,16 @@ export const createPatientProfileUtil = async (
     console.log(`[createPatientProfileUtil] Verifying patient document exists`);
     const patientDoc = await getDoc(getPatientDocRef(db, patientId));
     if (!patientDoc.exists()) {
-      console.error(
-        `[createPatientProfileUtil] Patient document not found after creation`
-      );
-      throw new Error("Failed to create patient profile");
+      console.error(`[createPatientProfileUtil] Patient document not found after creation`);
+      throw new Error('Failed to create patient profile');
     }
 
-    console.log(
-      `[createPatientProfileUtil] Patient profile creation completed successfully`
-    );
+    console.log(`[createPatientProfileUtil] Patient profile creation completed successfully`);
     return patientDoc.data() as PatientProfile;
   } catch (error) {
-    console.error(
-      `[createPatientProfileUtil] Error in patient profile creation:`,
-      error
-    );
+    console.error(`[createPatientProfileUtil] Error in patient profile creation:`, error);
     if (error instanceof z.ZodError) {
-      throw new Error("Invalid patient data: " + error.message);
+      throw new Error('Invalid patient data: ' + error.message);
     }
     throw error;
   }
@@ -177,7 +150,7 @@ export const createPatientProfileUtil = async (
 
 export const getPatientProfileUtil = async (
   db: Firestore,
-  patientId: string
+  patientId: string,
 ): Promise<PatientProfile | null> => {
   const patientDoc = await getDoc(getPatientDocRef(db, patientId));
   return patientDoc.exists() ? (patientDoc.data() as PatientProfile) : null;
@@ -185,7 +158,7 @@ export const getPatientProfileUtil = async (
 
 export const getPatientProfileByUserRefUtil = async (
   db: Firestore,
-  userRef: string
+  userRef: string,
 ): Promise<PatientProfile | null> => {
   try {
     const docRef = await getPatientDocRefByUserRef(db, userRef);
@@ -200,7 +173,7 @@ export const getPatientProfileByUserRefUtil = async (
 export const addExpoTokenUtil = async (
   db: Firestore,
   patientId: string,
-  token: string
+  token: string,
 ): Promise<void> => {
   await updateDoc(getPatientDocRef(db, patientId), {
     expoTokens: arrayUnion(token),
@@ -211,7 +184,7 @@ export const addExpoTokenUtil = async (
 export const removeExpoTokenUtil = async (
   db: Firestore,
   patientId: string,
-  token: string
+  token: string,
 ): Promise<void> => {
   await updateDoc(getPatientDocRef(db, patientId), {
     expoTokens: arrayRemove(token),
@@ -222,10 +195,10 @@ export const removeExpoTokenUtil = async (
 export const addPointsUtil = async (
   db: Firestore,
   patientId: string,
-  points: number
+  points: number,
 ): Promise<void> => {
   await updateDoc(getPatientDocRef(db, patientId), {
-    "gamification.points": increment(points),
+    'gamification.points': increment(points),
     updatedAt: serverTimestamp(),
   });
 };
@@ -233,7 +206,7 @@ export const addPointsUtil = async (
 export const updatePatientProfileUtil = async (
   db: Firestore,
   patientId: string,
-  data: Partial<Omit<PatientProfile, "id" | "createdAt" | "updatedAt">>
+  data: Partial<Omit<PatientProfile, 'id' | 'createdAt' | 'updatedAt'>>,
 ): Promise<PatientProfile> => {
   try {
     const updateData = {
@@ -245,7 +218,7 @@ export const updatePatientProfileUtil = async (
 
     const updatedDoc = await getDoc(getPatientDocRef(db, patientId));
     if (!updatedDoc.exists()) {
-      throw new Error("Patient profile not found after update");
+      throw new Error('Patient profile not found after update');
     }
 
     return updatedDoc.data() as PatientProfile;
@@ -258,23 +231,21 @@ export const updatePatientProfileUtil = async (
 export const updatePatientProfileByUserRefUtil = async (
   db: Firestore,
   userRef: string,
-  data: Partial<Omit<PatientProfile, "id" | "createdAt" | "updatedAt">>
+  data: Partial<Omit<PatientProfile, 'id' | 'createdAt' | 'updatedAt'>>,
 ): Promise<PatientProfile> => {
   try {
     const docRef = await getPatientDocRefByUserRef(db, userRef);
     const patientDoc = await getDoc(docRef);
 
     if (!patientDoc.exists()) {
-      throw new Error("Patient profile not found");
+      throw new Error('Patient profile not found');
     }
 
     const patientData = patientDoc.data() as PatientProfile;
     return updatePatientProfileUtil(db, patientData.id, data);
   } catch (error: unknown) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `Failed to update patient profile by user ref: ${errorMessage}`
-    );
+    throw new Error(`Failed to update patient profile by user ref: ${errorMessage}`);
   }
 };
 
@@ -282,7 +253,7 @@ export const updatePatientProfileByUserRefUtil = async (
 export const uploadProfilePhotoUtil = async (
   storage: FirebaseStorage,
   patientId: string,
-  file: File
+  file: File,
 ): Promise<string> => {
   const photoRef = ref(storage, `patient-photos/${patientId}/profile-photo`);
   await uploadBytes(photoRef, file);
@@ -293,11 +264,11 @@ export const updateProfilePhotoUtil = async (
   storage: FirebaseStorage,
   db: Firestore,
   patientId: string,
-  file: File
+  file: File,
 ): Promise<string> => {
   // Prvo obrišemo staru sliku ako postoji
   const patientDoc = await getDoc(getPatientDocRef(db, patientId));
-  if (!patientDoc.exists()) throw new Error("Patient profile not found");
+  if (!patientDoc.exists()) throw new Error('Patient profile not found');
 
   const patientData = patientDoc.data() as PatientProfile;
   if (patientData.profilePhoto) {
@@ -305,7 +276,7 @@ export const updateProfilePhotoUtil = async (
       const oldPhotoRef = ref(storage, patientData.profilePhoto);
       await deleteObject(oldPhotoRef);
     } catch (error) {
-      console.warn("Failed to delete old profile photo:", error);
+      console.warn('Failed to delete old profile photo:', error);
     }
   }
 
@@ -324,10 +295,10 @@ export const updateProfilePhotoUtil = async (
 export const deleteProfilePhotoUtil = async (
   storage: FirebaseStorage,
   db: Firestore,
-  patientId: string
+  patientId: string,
 ): Promise<void> => {
   const patientDoc = await getDoc(getPatientDocRef(db, patientId));
-  if (!patientDoc.exists()) throw new Error("Patient profile not found");
+  if (!patientDoc.exists()) throw new Error('Patient profile not found');
 
   const patientData = patientDoc.data() as PatientProfile;
   if (patientData.profilePhoto) {
@@ -335,7 +306,7 @@ export const deleteProfilePhotoUtil = async (
       const photoRef = ref(storage, patientData.profilePhoto);
       await deleteObject(photoRef);
     } catch (error) {
-      console.warn("Failed to delete profile photo:", error);
+      console.warn('Failed to delete profile photo:', error);
     }
   }
 
@@ -352,45 +323,39 @@ export const deleteProfilePhotoUtil = async (
 export const testCreateSubDocuments = async (
   db: Firestore,
   patientId: string,
-  userRef: string
+  userRef: string,
 ): Promise<void> => {
   console.log(
-    `[testCreateSubDocuments] Starting test for patientId: ${patientId}, userRef: ${userRef}`
+    `[testCreateSubDocuments] Starting test for patientId: ${patientId}, userRef: ${userRef}`,
   );
 
   try {
     // Test sensitive info creation
     console.log(`[testCreateSubDocuments] Testing sensitive info creation`);
     const sensitiveInfoRef = getSensitiveInfoDocRef(db, patientId);
-    console.log(
-      `[testCreateSubDocuments] Sensitive info path: ${sensitiveInfoRef.path}`
-    );
+    console.log(`[testCreateSubDocuments] Sensitive info path: ${sensitiveInfoRef.path}`);
 
     const defaultSensitiveInfo = {
       patientId,
       userRef,
-      photoUrl: "",
-      firstName: "Name",
-      lastName: "Surname",
+      photoUrl: '',
+      firstName: 'Name',
+      lastName: 'Surname',
       dateOfBirth: Timestamp.now(),
       gender: Gender.PREFER_NOT_TO_SAY,
-      email: "test@example.com",
-      phoneNumber: "",
+      email: 'test@example.com',
+      phoneNumber: '',
       createdAt: Timestamp.now(),
       updatedAt: Timestamp.now(),
     };
 
     await setDoc(sensitiveInfoRef, defaultSensitiveInfo);
-    console.log(
-      `[testCreateSubDocuments] Sensitive info document created directly`
-    );
+    console.log(`[testCreateSubDocuments] Sensitive info document created directly`);
 
     // Test medical info creation
     console.log(`[testCreateSubDocuments] Testing medical info creation`);
     const medicalInfoRef = getMedicalInfoDocRef(db, patientId);
-    console.log(
-      `[testCreateSubDocuments] Medical info path: ${medicalInfoRef.path}`
-    );
+    console.log(`[testCreateSubDocuments] Medical info path: ${medicalInfoRef.path}`);
 
     const defaultMedicalInfo = {
       ...DEFAULT_MEDICAL_INFO,
@@ -400,9 +365,7 @@ export const testCreateSubDocuments = async (
     };
 
     await setDoc(medicalInfoRef, defaultMedicalInfo);
-    console.log(
-      `[testCreateSubDocuments] Medical info document created directly`
-    );
+    console.log(`[testCreateSubDocuments] Medical info document created directly`);
 
     console.log(`[testCreateSubDocuments] Test completed successfully`);
   } catch (error) {
@@ -423,7 +386,7 @@ export const testCreateSubDocuments = async (
 export const searchPatientsUtil = async (
   db: Firestore,
   params: SearchPatientsParams,
-  requester: RequesterInfo
+  requester: RequesterInfo,
 ): Promise<PatientProfile[]> => {
   // Validate input
   searchPatientsSchema.parse(params);
@@ -434,65 +397,52 @@ export const searchPatientsUtil = async (
 
   // --- Security Checks & Initial Filtering ---
 
-  if (requester.role === "clinic_admin") {
+  if (requester.role === 'clinic_admin') {
     // Clinic admin can only search within their own clinic
     if (!requester.associatedClinicId) {
-      throw new Error(
-        "Associated clinic ID is required for clinic admin search."
-      );
+      throw new Error('Associated clinic ID is required for clinic admin search.');
     }
     // If the search params specify a different clinic, it's an invalid request for this admin.
     if (params.clinicId && params.clinicId !== requester.associatedClinicId) {
       console.warn(
-        `Clinic admin (${requester.id}) attempted to search outside their associated clinic (${requester.associatedClinicId})`
+        `Clinic admin (${requester.id}) attempted to search outside their associated clinic (${requester.associatedClinicId})`,
       );
       return []; // Or throw an error
     }
 
     // **Mandatory filter**: Ensure patients belong to the admin's clinic.
-    constraints.push(
-      where("clinicIds", "array-contains", requester.associatedClinicId)
-    );
+    constraints.push(where('clinicIds', 'array-contains', requester.associatedClinicId));
 
     // Optional filter: If practitionerId is also provided, filter by that practitioner *within the admin's clinic*.
     if (params.practitionerId) {
-      constraints.push(
-        where("doctorIds", "array-contains", params.practitionerId)
-      );
+      constraints.push(where('doctorIds', 'array-contains', params.practitionerId));
       // We might need an additional check here if the practitioner MUST work at the admin's clinic.
       // This would require fetching practitioner data or having denormalized clinic IDs on the practitioner.
     }
-  } else if (requester.role === "practitioner") {
+  } else if (requester.role === 'practitioner') {
     // Practitioner can only search for their own patients.
     if (!requester.associatedPractitionerId) {
-      throw new Error(
-        "Associated practitioner ID is required for practitioner search."
-      );
+      throw new Error('Associated practitioner ID is required for practitioner search.');
     }
     // If the search params specify a different practitioner, it's invalid.
-    if (
-      params.practitionerId &&
-      params.practitionerId !== requester.associatedPractitionerId
-    ) {
+    if (params.practitionerId && params.practitionerId !== requester.associatedPractitionerId) {
       console.warn(
-        `Practitioner (${requester.id}) attempted to search for patients of another practitioner (${params.practitionerId})`
+        `Practitioner (${requester.id}) attempted to search for patients of another practitioner (${params.practitionerId})`,
       );
       return []; // Or throw an error
     }
 
     // **Mandatory filter**: Ensure patients are associated with this practitioner.
-    constraints.push(
-      where("doctorIds", "array-contains", requester.associatedPractitionerId)
-    );
+    constraints.push(where('doctorIds', 'array-contains', requester.associatedPractitionerId));
 
     // Optional filter: If clinicId is provided, filter by patients of this practitioner *at that specific clinic*.
     if (params.clinicId) {
-      constraints.push(where("clinicIds", "array-contains", params.clinicId));
+      constraints.push(where('clinicIds', 'array-contains', params.clinicId));
       // Similar to above, we might need to check if the practitioner actually works at this clinic.
     }
   } else {
     // Should not happen due to validation, but good practice to handle.
-    throw new Error("Invalid requester role.");
+    throw new Error('Invalid requester role.');
   }
 
   // --- Execute Query ---
@@ -500,17 +450,63 @@ export const searchPatientsUtil = async (
     const finalQuery = query(patientsCollectionRef, ...constraints);
     const querySnapshot = await getDocs(finalQuery);
 
-    const patients = querySnapshot.docs.map(
-      (doc) => doc.data() as PatientProfile
-    );
+    const patients = querySnapshot.docs.map((doc) => doc.data() as PatientProfile);
 
-    console.log(
-      `[searchPatientsUtil] Found ${patients.length} patients matching criteria.`
-    );
+    console.log(`[searchPatientsUtil] Found ${patients.length} patients matching criteria.`);
     return patients;
   } catch (error) {
-    console.error("[searchPatientsUtil] Error searching patients:", error);
+    console.error('[searchPatientsUtil] Error searching patients:', error);
     // Consider logging more details or re-throwing a specific error type
     return []; // Return empty array on error
   }
 };
+
+/**
+ * Retrieves all patient profiles from the database.
+ *
+ * @param {Firestore} db - Firestore instance
+ * @param {Object} options - Optional parameters for pagination
+ * @param {number} options.limit - Maximum number of profiles to return
+ * @param {string} options.startAfter - The ID of the document to start after (for pagination)
+ * @returns {Promise<PatientProfile[]>} A promise resolving to an array of all patient profiles
+ */
+export const getAllPatientsUtil = async (
+  db: Firestore,
+  options?: { limit?: number; startAfter?: string },
+): Promise<PatientProfile[]> => {
+  try {
+    console.log(`[getAllPatientsUtil] Fetching patients with options:`, options);
+
+    const patientsCollection = collection(db, PATIENTS_COLLECTION);
+
+    let q = query(patientsCollection);
+
+    // Apply pagination if needed
+    if (options?.limit) {
+      q = query(q, limit(options.limit));
+    }
+
+    // If startAfter is provided, get that document and use it for pagination
+    if (options?.startAfter) {
+      const startAfterDoc = await getDoc(doc(db, PATIENTS_COLLECTION, options.startAfter));
+      if (startAfterDoc.exists()) {
+        q = query(q, startAfter(startAfterDoc));
+      }
+    }
+
+    const patientsSnapshot = await getDocs(q);
+
+    const patients: PatientProfile[] = [];
+    patientsSnapshot.forEach((doc) => {
+      patients.push(doc.data() as PatientProfile);
+    });
+
+    console.log(`[getAllPatientsUtil] Found ${patients.length} patients`);
+    return patients;
+  } catch (error) {
+    console.error(`[getAllPatientsUtil] Error fetching patients:`, error);
+    throw new Error(
+      `Failed to retrieve patients: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+};