@blackcode_sa/metaestetics-api 1.14.79 → 1.15.3

package/package.json

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

package/src/services/appointment/appointment.service.ts

@@ -1855,7 +1855,12 @@ export class AppointmentService extends BaseService {
         throw new Error('No zone data available for billing calculation');
       }
 
-      const finalbilling = calculateFinalBilling(zonesData, taxRate);
+      // Preserve existing discount when recalculating
+      const existingDiscount = appointment.metadata?.finalbilling?.discount;
+      const discountParam = existingDiscount
+        ? { type: existingDiscount.type, value: existingDiscount.value }
+        : undefined;
+      const finalbilling = calculateFinalBilling(zonesData, taxRate, discountParam);
 
       const currentMetadata = appointment.metadata || {
         selectedZones: null,
@@ -1909,6 +1914,78 @@ export class AppointmentService extends BaseService {
     }
   }
 
+  /**
+   * Applies or removes an overall discount on the appointment total
+   * @param appointmentId ID of the appointment
+   * @param discount Discount to apply (null to remove)
+   * @param taxRate Optional tax rate override
+   * @returns The updated appointment
+   */
+  async applyOverallDiscount(
+    appointmentId: string,
+    discount: { type: 'percentage' | 'fixed'; value: number } | null,
+    taxRate?: number,
+  ): Promise<Appointment> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Applying overall discount for appointment ${appointmentId}`,
+        discount,
+      );
+
+      const appointment = await this.getAppointmentById(appointmentId);
+      if (!appointment) {
+        throw new Error(`Appointment with ID ${appointmentId} not found`);
+      }
+
+      const zonesData = appointment.metadata?.zonesData;
+      if (!zonesData || Object.keys(zonesData).length === 0) {
+        throw new Error('No zone data available for billing calculation');
+      }
+
+      const finalbilling = calculateFinalBilling(zonesData, taxRate, discount);
+
+      const currentMetadata = appointment.metadata || {
+        selectedZones: null,
+        zonePhotos: null,
+        zonesData: null,
+        appointmentProducts: [],
+        extendedProcedures: [],
+        recommendedProcedures: [],
+        finalbilling: null,
+        finalizationNotesShared: null,
+        finalizationNotesInternal: null,
+        finalizationNotes: null,
+      };
+
+      const updateData: UpdateAppointmentData = {
+        metadata: {
+          selectedZones: currentMetadata.selectedZones,
+          zonePhotos: currentMetadata.zonePhotos,
+          zonesData: currentMetadata.zonesData,
+          appointmentProducts: currentMetadata.appointmentProducts || [],
+          extendedProcedures: currentMetadata.extendedProcedures || [],
+          recommendedProcedures: currentMetadata.recommendedProcedures || [],
+          ...(currentMetadata.zoneBilling !== undefined && {
+            zoneBilling: currentMetadata.zoneBilling,
+          }),
+          finalbilling,
+          finalizationNotesShared: currentMetadata.finalizationNotesShared ?? null,
+          finalizationNotesInternal: currentMetadata.finalizationNotesInternal ?? null,
+          finalizationNotes:
+            currentMetadata.finalizationNotes ??
+            currentMetadata.finalizationNotesShared ??
+            null,
+        },
+        updatedAt: serverTimestamp(),
+      };
+
+      return await this.updateAppointment(appointmentId, updateData);
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error applying overall discount:`, error);
+      throw error;
+    }
+  }
+
   /**
    * Adds a recommended procedure to an appointment
    * Multiple recommendations of the same procedure are allowed (e.g., touch-up in 2 weeks, full treatment in 3 months)

package/src/services/appointment/utils/appointment.utils.ts

@@ -31,6 +31,7 @@ import { ClinicInfo, PatientProfileInfo, PractitionerProfileInfo } from '../../.
 import { PRACTITIONERS_COLLECTION } from '../../../types/practitioner';
 import { PATIENTS_COLLECTION } from '../../../types/patient';
 import { CLINICS_COLLECTION } from '../../../types/clinic';
+import { getSensitiveInfoDocRef } from '../../patient/utils/docs.utils';
 import { BlockingCondition } from '../../../backoffice/types/static/blocking-condition.types';
 import { Requirement } from '../../../backoffice/types/requirement.types';
 import { PROCEDURES_COLLECTION } from '../../../types/procedure';
@@ -64,13 +65,15 @@ export async function fetchAggregatedInfoUtil(
   postProcedureRequirements: Requirement[];
 }> {
   try {
-    // Fetch all data in parallel for efficiency
-    const [clinicDoc, practitionerDoc, patientDoc, procedureDoc] = await Promise.all([
-      getDoc(doc(db, CLINICS_COLLECTION, clinicId)),
-      getDoc(doc(db, PRACTITIONERS_COLLECTION, practitionerId)),
-      getDoc(doc(db, PATIENTS_COLLECTION, patientId)),
-      getDoc(doc(db, PROCEDURES_COLLECTION, procedureId)),
-    ]);
+    // Fetch all data in parallel for efficiency (including patient sensitive-info for PII)
+    const [clinicDoc, practitionerDoc, patientDoc, patientSensitiveDoc, procedureDoc] =
+      await Promise.all([
+        getDoc(doc(db, CLINICS_COLLECTION, clinicId)),
+        getDoc(doc(db, PRACTITIONERS_COLLECTION, practitionerId)),
+        getDoc(doc(db, PATIENTS_COLLECTION, patientId)),
+        getDoc(getSensitiveInfoDocRef(db, patientId)),
+        getDoc(doc(db, PROCEDURES_COLLECTION, procedureId)),
+      ]);
 
     // Check if all required entities exist
     if (!clinicDoc.exists()) {
@@ -89,6 +92,9 @@ export async function fetchAggregatedInfoUtil(
     const clinicData = clinicDoc.data();
     const practitionerData = practitionerDoc.data();
     const patientData = patientDoc.data();
+    const patientSensitiveData = patientSensitiveDoc.exists()
+      ? (patientSensitiveDoc.data() as { firstName?: string; lastName?: string; email?: string; phoneNumber?: string; dateOfBirth?: any; gender?: string })
+      : null;
     const procedureData = procedureDoc.data();
 
     // Extract relevant info for ClinicInfo
@@ -114,14 +120,17 @@ export async function fetchAggregatedInfoUtil(
     };
 
     // Extract relevant info for PatientProfileInfo
-    // Note: This may need adjustment depending on how patient data is structured
+    // Prefer sensitive-info (patient PII) over profile; profile is fallback for displayName from manual creation
     const patientInfo: PatientProfileInfo = {
       id: patientId,
-      fullName: patientData.displayName || '',
-      email: patientData.email || '',
-      phone: patientData.phoneNumber || null,
-      dateOfBirth: patientData.dateOfBirth || Timestamp.now(),
-      gender: patientData.gender || 'other',
+      fullName:
+        patientSensitiveData?.firstName && patientSensitiveData?.lastName
+          ? `${patientSensitiveData.firstName} ${patientSensitiveData.lastName}`.trim()
+          : patientData.displayName || '',
+      email: patientSensitiveData?.email ?? patientData.email ?? '',
+      phone: patientSensitiveData?.phoneNumber ?? patientData.phoneNumber ?? null,
+      dateOfBirth: patientSensitiveData?.dateOfBirth ?? patientData.dateOfBirth ?? Timestamp.now(),
+      gender: patientSensitiveData?.gender ?? patientData.gender ?? 'other',
     };
 
     // Extract procedureInfo from the procedure document

package/src/services/appointment/utils/zone-management.utils.ts

@@ -9,6 +9,15 @@ import {
 import { getAppointmentByIdUtil } from './appointment.utils';
 import { doc } from 'firebase/firestore';
 
+/**
+ * Swiss 5-centime rounding (nearest 0.05 CHF)
+ * @param value Amount to round
+ * @returns Rounded amount
+ */
+export function swissRound(value: number): number {
+  return Math.round(value / 0.05) * 0.05;
+}
+
 /**
  * Validates that a zone key follows the category.zone format
  * @param zoneKey Zone key to validate
@@ -49,11 +58,13 @@ export function calculateItemSubtotal(item: Partial<ZoneItemData>): number {
  * Recalculates final billing based on all zone items
  * @param zonesData Zone items data
  * @param taxRate Tax rate (e.g., 0.20 for 20%)
+ * @param discount Optional overall discount to apply
  * @returns Calculated final billing
  */
 export function calculateFinalBilling(
   zonesData: Record<string, ZoneItemData[]>,
   taxRate: number = 0.081,
+  discount?: { type: 'percentage' | 'fixed'; value: number } | null,
 ): FinalBilling {
   let subtotalAll = 0;
 
@@ -66,9 +77,6 @@ export function calculateFinalBilling(
     });
   });
 
-  const taxPrice = subtotalAll * taxRate;
-  const finalPrice = subtotalAll + taxPrice;
-
   // Get currency from first item (assuming all same currency)
   let currency: any = 'CHF'; // Default
 
@@ -80,6 +88,39 @@ export function calculateFinalBilling(
     }
   }
 
+  // Apply overall discount if provided
+  if (discount && discount.value > 0) {
+    let discountAmount: number;
+    if (discount.type === 'percentage') {
+      discountAmount = subtotalAll * (discount.value / 100);
+    } else {
+      discountAmount = discount.value;
+    }
+    // Cap discount at subtotal (can't go negative)
+    discountAmount = Math.min(discountAmount, subtotalAll);
+
+    const discountedSubtotal = subtotalAll - discountAmount;
+    const taxPrice = discountedSubtotal * taxRate;
+    const finalPrice = swissRound(discountedSubtotal + taxPrice);
+
+    return {
+      subtotalAll,
+      discount: {
+        type: discount.type,
+        value: discount.value,
+        amount: discountAmount,
+      },
+      discountedSubtotal,
+      taxRate,
+      taxPrice,
+      finalPrice,
+      currency,
+    };
+  }
+
+  const taxPrice = subtotalAll * taxRate;
+  const finalPrice = swissRound(subtotalAll + taxPrice);
+
   return {
     subtotalAll,
     taxRate,
@@ -183,8 +224,12 @@ export async function addItemToZoneUtil(
   // Add item to zone
   zonesData[zoneId].push(itemWithSubtotal);
 
-  // Recalculate final billing with Swiss tax rate (8.1%)
-  const finalbilling = calculateFinalBilling(zonesData, 0.081);
+  // Recalculate final billing with Swiss tax rate (8.1%), preserving existing discount
+  const existingDiscount = metadata.finalbilling?.discount;
+  const discountParam = existingDiscount
+    ? { type: existingDiscount.type, value: existingDiscount.value }
+    : undefined;
+  const finalbilling = calculateFinalBilling(zonesData, 0.081, discountParam);
 
   // Update appointment
   const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
@@ -234,8 +279,12 @@ export async function removeItemFromZoneUtil(
     delete metadata.zonesData[zoneId];
   }
 
-  // Recalculate final billing with Swiss tax rate (8.1%)
-  const finalbilling = calculateFinalBilling(metadata.zonesData, 0.081);
+  // Recalculate final billing with Swiss tax rate (8.1%), preserving existing discount
+  const existingDiscount = metadata.finalbilling?.discount;
+  const discountParam = existingDiscount
+    ? { type: existingDiscount.type, value: existingDiscount.value }
+    : undefined;
+  const finalbilling = calculateFinalBilling(metadata.zonesData, 0.081, discountParam);
 
   // Update appointment
   const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
@@ -327,8 +376,12 @@ export async function updateZoneItemUtil(
     newSubtotal: items[itemIndex].subtotal,
   });
 
-  // Recalculate final billing with Swiss tax rate (8.1%)
-  const finalbilling = calculateFinalBilling(metadata.zonesData, 0.081);
+  // Recalculate final billing with Swiss tax rate (8.1%), preserving existing discount
+  const existingDiscount = metadata.finalbilling?.discount;
+  const discountParam = existingDiscount
+    ? { type: existingDiscount.type, value: existingDiscount.value }
+    : undefined;
+  const finalbilling = calculateFinalBilling(metadata.zonesData, 0.081, discountParam);
 
   // Log what we're about to save to Firestore
   console.log(`[updateZoneItemUtil] Saving to Firestore:`, {

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

@@ -103,8 +103,40 @@ import {
   AestheticAnalysis,
   CreateAestheticAnalysisData,
   UpdateAestheticAnalysisData,
+  SkinQualityAssessment,
+  CreateSkinQualityAssessmentData,
+  UpdateSkinQualityAssessmentData,
+  BodyAssessment,
+  CreateBodyAssessmentData,
+  UpdateBodyAssessmentData,
+  HairScalpAssessment,
+  CreateHairScalpAssessmentData,
+  UpdateHairScalpAssessmentData,
+  PreSurgicalAssessment,
+  CreatePreSurgicalAssessmentData,
+  UpdatePreSurgicalAssessmentData,
 } from '../../types/patient';
 
+import {
+  getSkinQualityAssessmentUtil,
+  createOrUpdateSkinQualityAssessmentUtil,
+} from './utils/skin-quality-assessment.utils';
+
+import {
+  getBodyAssessmentUtil,
+  createOrUpdateBodyAssessmentUtil,
+} from './utils/body-assessment.utils';
+
+import {
+  getHairScalpAssessmentUtil,
+  createOrUpdateHairScalpAssessmentUtil,
+} from './utils/hair-scalp-assessment.utils';
+
+import {
+  getPreSurgicalAssessmentUtil,
+  createOrUpdatePreSurgicalAssessmentUtil,
+} from './utils/pre-surgical-assessment.utils';
+
 import { CreatePatientTokenData, PatientToken } from '../../types/patient/token.types';
 
 export class PatientService extends BaseService {
@@ -882,4 +914,108 @@ export class PatientService extends BaseService {
       true
     );
   }
+
+  // Skin Quality Assessment methods
+  async getSkinQualityAssessment(patientId: string): Promise<SkinQualityAssessment | null> {
+    const currentUser = await this.getCurrentUser();
+    return getSkinQualityAssessmentUtil(this.db, patientId, currentUser.uid, currentUser.roles);
+  }
+
+  async createSkinQualityAssessment(
+    patientId: string,
+    data: CreateSkinQualityAssessmentData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdateSkinQualityAssessmentUtil(
+      this.db, patientId, data, currentUser.uid, currentUser.roles, false
+    );
+  }
+
+  async updateSkinQualityAssessment(
+    patientId: string,
+    data: UpdateSkinQualityAssessmentData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdateSkinQualityAssessmentUtil(
+      this.db, patientId, data, currentUser.uid, currentUser.roles, true
+    );
+  }
+
+  // Body Assessment methods
+  async getBodyAssessment(patientId: string): Promise<BodyAssessment | null> {
+    const currentUser = await this.getCurrentUser();
+    return getBodyAssessmentUtil(this.db, patientId, currentUser.uid, currentUser.roles);
+  }
+
+  async createBodyAssessment(
+    patientId: string,
+    data: CreateBodyAssessmentData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdateBodyAssessmentUtil(
+      this.db, patientId, data, currentUser.uid, currentUser.roles, false
+    );
+  }
+
+  async updateBodyAssessment(
+    patientId: string,
+    data: UpdateBodyAssessmentData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdateBodyAssessmentUtil(
+      this.db, patientId, data, currentUser.uid, currentUser.roles, true
+    );
+  }
+
+  // Hair & Scalp Assessment methods
+  async getHairScalpAssessment(patientId: string): Promise<HairScalpAssessment | null> {
+    const currentUser = await this.getCurrentUser();
+    return getHairScalpAssessmentUtil(this.db, patientId, currentUser.uid, currentUser.roles);
+  }
+
+  async createHairScalpAssessment(
+    patientId: string,
+    data: CreateHairScalpAssessmentData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdateHairScalpAssessmentUtil(
+      this.db, patientId, data, currentUser.uid, currentUser.roles, false
+    );
+  }
+
+  async updateHairScalpAssessment(
+    patientId: string,
+    data: UpdateHairScalpAssessmentData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdateHairScalpAssessmentUtil(
+      this.db, patientId, data, currentUser.uid, currentUser.roles, true
+    );
+  }
+
+  // Pre-Surgical Assessment methods
+  async getPreSurgicalAssessment(patientId: string): Promise<PreSurgicalAssessment | null> {
+    const currentUser = await this.getCurrentUser();
+    return getPreSurgicalAssessmentUtil(this.db, patientId, currentUser.uid, currentUser.roles);
+  }
+
+  async createPreSurgicalAssessment(
+    patientId: string,
+    data: CreatePreSurgicalAssessmentData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdatePreSurgicalAssessmentUtil(
+      this.db, patientId, data, currentUser.uid, currentUser.roles, false
+    );
+  }
+
+  async updatePreSurgicalAssessment(
+    patientId: string,
+    data: UpdatePreSurgicalAssessmentData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdatePreSurgicalAssessmentUtil(
+      this.db, patientId, data, currentUser.uid, currentUser.roles, true
+    );
+  }
 }

package/src/services/patient/utils/body-assessment.utils.ts

@@ -0,0 +1,159 @@
+import { getDoc, updateDoc, setDoc, serverTimestamp, Firestore, doc } from 'firebase/firestore';
+import {
+  BodyAssessment,
+  CreateBodyAssessmentData,
+  UpdateBodyAssessmentData,
+  BODY_ASSESSMENT_COLLECTION,
+  PATIENTS_COLLECTION,
+  BodyAssessmentStatus,
+} from '../../../types/patient';
+import { UserRole } from '../../../types';
+import {
+  createBodyAssessmentSchema,
+  updateBodyAssessmentSchema,
+  bodyAssessmentSchema,
+} from '../../../validations/patient/body-assessment.schema';
+import { getPatientDocRef } from './docs.utils';
+import { AuthError } from '../../../errors/auth.errors';
+import { getPractitionerProfileByUserRef } from './practitioner.utils';
+import { getClinicAdminByUserRef } from '../../clinic/utils/admin.utils';
+
+export const getBodyAssessmentDocRef = (db: Firestore, patientId: string) => {
+  return doc(db, PATIENTS_COLLECTION, patientId, BODY_ASSESSMENT_COLLECTION, patientId);
+};
+
+const checkBodyAssessmentAccessUtil = async (
+  db: Firestore,
+  patientId: string,
+  requesterId: string,
+  requesterRoles: UserRole[]
+): Promise<void> => {
+  const patientDoc = await getDoc(getPatientDocRef(db, patientId));
+  if (!patientDoc.exists()) {
+    throw new Error('Patient profile not found');
+  }
+  const patientData = patientDoc.data() as any;
+
+  if (patientData.userRef && patientData.userRef === requesterId) {
+    return;
+  }
+
+  if (requesterRoles.includes(UserRole.PRACTITIONER)) {
+    const practitionerProfile = await getPractitionerProfileByUserRef(db, requesterId);
+    if (practitionerProfile && patientData.doctorIds?.includes(practitionerProfile.id)) {
+      return;
+    }
+  }
+
+  if (requesterRoles.includes(UserRole.CLINIC_ADMIN)) {
+    const adminProfile = await getClinicAdminByUserRef(db, requesterId);
+    if (adminProfile && adminProfile.clinicsManaged) {
+      const hasAccess = adminProfile.clinicsManaged.some((managedClinicId) =>
+        patientData.clinicIds?.includes(managedClinicId)
+      );
+      if (hasAccess) {
+        return;
+      }
+    }
+  }
+
+  throw new AuthError(
+    'Unauthorized access to body assessment.',
+    'AUTH/UNAUTHORIZED_ACCESS',
+    403
+  );
+};
+
+export const calculateBodyAssessmentCompletionPercentage = (data: Partial<BodyAssessment>): number => {
+  let completed = 0;
+  const total = 4;
+
+  if (data.selectedZones && data.selectedZones.length > 0) completed++;
+  if (data.zoneAssessments && data.zoneAssessments.length > 0) completed++;
+  if (data.composition && (data.composition.bmi || data.composition.bodyFatPercentage || data.composition.waistHipRatio)) completed++;
+  if ((data.measurements && data.measurements.waist) || (data.symmetry && data.symmetry.overallSymmetry)) completed++;
+
+  return Math.round((completed / total) * 100);
+};
+
+export const determineBodyAssessmentStatus = (completionPercentage: number): BodyAssessmentStatus => {
+  if (completionPercentage < 50) return 'incomplete';
+  if (completionPercentage >= 50) return 'ready_for_planning';
+  return 'incomplete';
+};
+
+export const getBodyAssessmentUtil = async (
+  db: Firestore,
+  patientId: string,
+  requesterId: string,
+  requesterRoles: UserRole[]
+): Promise<BodyAssessment | null> => {
+  await checkBodyAssessmentAccessUtil(db, patientId, requesterId, requesterRoles);
+
+  const docRef = getBodyAssessmentDocRef(db, patientId);
+  const snapshot = await getDoc(docRef);
+
+  if (!snapshot.exists()) {
+    return null;
+  }
+
+  const data = snapshot.data();
+  return bodyAssessmentSchema.parse({
+    ...data,
+    id: patientId,
+  });
+};
+
+export const createOrUpdateBodyAssessmentUtil = async (
+  db: Firestore,
+  patientId: string,
+  data: CreateBodyAssessmentData | UpdateBodyAssessmentData,
+  requesterId: string,
+  requesterRoles: UserRole[],
+  isUpdate: boolean = false
+): Promise<void> => {
+  await checkBodyAssessmentAccessUtil(db, patientId, requesterId, requesterRoles);
+
+  const validatedData = isUpdate
+    ? updateBodyAssessmentSchema.parse(data)
+    : createBodyAssessmentSchema.parse(data);
+
+  const docRef = getBodyAssessmentDocRef(db, patientId);
+  const snapshot = await getDoc(docRef);
+
+  const requesterRole = requesterRoles.includes(UserRole.PRACTITIONER) ? 'PRACTITIONER' : 'PATIENT';
+
+  const existingData = snapshot.exists() ? snapshot.data() : null;
+  const mergedData: any = {
+    ...(existingData || {}),
+    ...validatedData,
+  };
+
+  const completionPercentage = calculateBodyAssessmentCompletionPercentage(mergedData);
+  const status = determineBodyAssessmentStatus(completionPercentage);
+
+  if (!snapshot.exists()) {
+    await setDoc(docRef, {
+      id: patientId,
+      patientId,
+      selectedZones: [],
+      zoneAssessments: [],
+      ...validatedData,
+      completionPercentage,
+      status,
+      lastUpdatedBy: requesterId,
+      lastUpdatedByRole: requesterRole,
+      createdAt: serverTimestamp(),
+      updatedAt: serverTimestamp(),
+    });
+  } else {
+    await updateDoc(docRef, {
+      ...validatedData,
+      completionPercentage,
+      status,
+      lastUpdatedBy: requesterId,
+      lastUpdatedByRole: requesterRole,
+      updatedAt: serverTimestamp(),
+    });
+  }
+};

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

@@ -120,13 +120,13 @@ export const getPatientsByClinicWithDetailsUtil = async (
             ? (sensitiveInfoDoc.data() as PatientSensitiveInfo)
             : null;
 
-          // Merge sensitive info into profile (sensitive info takes precedence)
+          // Merge sensitive info into profile (sensitive-info is source of truth for PII)
           return {
             ...profile,
-            // Merge phoneNumber from sensitive info if not in profile
-            phoneNumber: profile.phoneNumber || sensitiveInfo?.phoneNumber || null,
-            // Merge dateOfBirth from sensitive info if not in profile
-            dateOfBirth: profile.dateOfBirth || sensitiveInfo?.dateOfBirth || null,
+            // Prefer phoneNumber from sensitive-info (patient self-updated); fallback to profile (manual creation)
+            phoneNumber: sensitiveInfo?.phoneNumber ?? profile.phoneNumber ?? null,
+            // Prefer dateOfBirth from sensitive-info
+            dateOfBirth: sensitiveInfo?.dateOfBirth ?? profile.dateOfBirth ?? null,
             // Merge photoUrl from sensitive info if available
             photoUrl: sensitiveInfo?.photoUrl || null,
           } as PatientProfile & { photoUrl?: string | null };