@blackcode_sa/metaestetics-api 1.6.17 → 1.6.18

package/dist/admin/index.js

@@ -3383,10 +3383,8 @@ var AppointmentAggregationService = class {
             status: "pendingNotification" /* PENDING_NOTIFICATION */,
             originalNotifyAtValue: notifyAtValue,
             originalTimeframeUnit: template.timeframe.unit,
-            updatedAt: admin10.firestore.Timestamp.now(),
+            updatedAt: admin10.firestore.Timestamp.now()
             // Use current server timestamp
-            notificationId: void 0,
-            actionTakenAt: void 0
           };
           return instructionObject;
         });

package/dist/admin/index.mjs

@@ -3328,10 +3328,8 @@ var AppointmentAggregationService = class {
             status: "pendingNotification" /* PENDING_NOTIFICATION */,
             originalNotifyAtValue: notifyAtValue,
             originalTimeframeUnit: template.timeframe.unit,
-            updatedAt: admin10.firestore.Timestamp.now(),
+            updatedAt: admin10.firestore.Timestamp.now()
             // Use current server timestamp
-            notificationId: void 0,
-            actionTakenAt: void 0
           };
           return instructionObject;
         });

package/dist/index.d.mts

@@ -5,6 +5,7 @@ import { FirebaseApp } from 'firebase/app';
 import { Auth, User as User$1 } from 'firebase/auth';
 import { Analytics } from 'firebase/analytics';
 import { FirebaseStorage } from 'firebase/storage';
+import { Functions } from 'firebase/functions';
 
 /**
  * Review system type definitions
@@ -5042,6 +5043,8 @@ interface FirebaseInstance {
     db: Firestore;
     auth: Auth;
     analytics: Analytics | null;
+    storage: FirebaseStorage;
+    functions: Functions;
 }
 declare const initializeFirebase: (config: {
     apiKey: string;

package/dist/index.d.ts

@@ -5,6 +5,7 @@ import { FirebaseApp } from 'firebase/app';
 import { Auth, User as User$1 } from 'firebase/auth';
 import { Analytics } from 'firebase/analytics';
 import { FirebaseStorage } from 'firebase/storage';
+import { Functions } from 'firebase/functions';
 
 /**
  * Review system type definitions
@@ -5042,6 +5043,8 @@ interface FirebaseInstance {
     db: Firestore;
     auth: Auth;
     analytics: Analytics | null;
+    storage: FirebaseStorage;
+    functions: Functions;
 }
 declare const initializeFirebase: (config: {
     apiKey: string;

package/dist/index.js

@@ -705,17 +705,21 @@ var import_firestore = require("firebase/firestore");
 var import_auth = require("firebase/auth");
 var import_analytics = require("firebase/analytics");
 var import_react_native = require("react-native");
+var import_storage = require("firebase/storage");
+var import_functions = require("firebase/functions");
 var firebaseInstance = null;
 var initializeFirebase = (config) => {
   if (!firebaseInstance) {
     const app = (0, import_app.initializeApp)(config);
     const db = (0, import_firestore.getFirestore)(app);
     const auth = (0, import_auth.getAuth)(app);
+    const storage = (0, import_storage.getStorage)(app);
+    const functions = (0, import_functions.getFunctions)(app);
     let analytics = null;
     if (typeof window !== "undefined" && import_react_native.Platform.OS === "web") {
       analytics = (0, import_analytics.getAnalytics)(app);
     }
-    firebaseInstance = { app, db, auth, analytics };
+    firebaseInstance = { app, db, auth, analytics, storage, functions };
   }
   return firebaseInstance;
 };
@@ -1061,13 +1065,13 @@ var FirebaseErrorCode = /* @__PURE__ */ ((FirebaseErrorCode2) => {
 })(FirebaseErrorCode || {});
 
 // src/services/base.service.ts
-var import_storage = require("firebase/storage");
+var import_storage2 = require("firebase/storage");
 var BaseService = class {
   constructor(db, auth, app) {
     this.db = db;
     this.auth = auth;
     this.app = app;
-    this.storage = (0, import_storage.getStorage)(app);
+    this.storage = (0, import_storage2.getStorage)(app);
   }
   /**
    * Generiše jedinstveni ID za dokumente
@@ -1188,7 +1192,7 @@ var import_firestore11 = require("firebase/firestore");
 
 // src/services/patient/utils/profile.utils.ts
 var import_firestore6 = require("firebase/firestore");
-var import_storage2 = require("firebase/storage");
+var import_storage3 = require("firebase/storage");
 var import_zod8 = require("zod");
 
 // src/types/patient/medical-info.types.ts
@@ -2116,9 +2120,9 @@ var updatePatientProfileByUserRefUtil = async (db, userRef, data) => {
   }
 };
 var uploadProfilePhotoUtil = async (storage, patientId, file) => {
-  const photoRef = (0, import_storage2.ref)(storage, `patient-photos/${patientId}/profile-photo`);
-  await (0, import_storage2.uploadBytes)(photoRef, file);
-  return (0, import_storage2.getDownloadURL)(photoRef);
+  const photoRef = (0, import_storage3.ref)(storage, `patient-photos/${patientId}/profile-photo`);
+  await (0, import_storage3.uploadBytes)(photoRef, file);
+  return (0, import_storage3.getDownloadURL)(photoRef);
 };
 var updateProfilePhotoUtil = async (storage, db, patientId, file) => {
   const patientDoc = await (0, import_firestore6.getDoc)(getPatientDocRef(db, patientId));
@@ -2126,8 +2130,8 @@ var updateProfilePhotoUtil = async (storage, db, patientId, file) => {
   const patientData = patientDoc.data();
   if (patientData.profilePhoto) {
     try {
-      const oldPhotoRef = (0, import_storage2.ref)(storage, patientData.profilePhoto);
-      await (0, import_storage2.deleteObject)(oldPhotoRef);
+      const oldPhotoRef = (0, import_storage3.ref)(storage, patientData.profilePhoto);
+      await (0, import_storage3.deleteObject)(oldPhotoRef);
     } catch (error) {
       console.warn("Failed to delete old profile photo:", error);
     }
@@ -2145,8 +2149,8 @@ var deleteProfilePhotoUtil = async (storage, db, patientId) => {
   const patientData = patientDoc.data();
   if (patientData.profilePhoto) {
     try {
-      const photoRef = (0, import_storage2.ref)(storage, patientData.profilePhoto);
-      await (0, import_storage2.deleteObject)(photoRef);
+      const photoRef = (0, import_storage3.ref)(storage, patientData.profilePhoto);
+      await (0, import_storage3.deleteObject)(photoRef);
     } catch (error) {
       console.warn("Failed to delete profile photo:", error);
     }
@@ -5130,7 +5134,7 @@ var import_geofire_common3 = require("geofire-common");
 var import_zod16 = require("zod");
 
 // src/services/clinic/utils/photos.utils.ts
-var import_storage3 = require("firebase/storage");
+var import_storage4 = require("firebase/storage");
 async function uploadPhoto(photo, entityType, entityId, photoType, app, fileName) {
   if (!photo || typeof photo !== "string" || !photo.startsWith("data:")) {
     return photo;
@@ -5139,9 +5143,9 @@ async function uploadPhoto(photo, entityType, entityId, photoType, app, fileName
     console.log(
       `[PHOTO_UTILS] Uploading ${photoType} for ${entityType}/${entityId}`
     );
-    const storage = (0, import_storage3.getStorage)(app);
+    const storage = (0, import_storage4.getStorage)(app);
     const storageFileName = fileName || `${photoType}-${Date.now()}`;
-    const storageRef = (0, import_storage3.ref)(
+    const storageRef = (0, import_storage4.ref)(
       storage,
       `${entityType}/${entityId}/${storageFileName}`
     );
@@ -5153,8 +5157,8 @@ async function uploadPhoto(photo, entityType, entityId, photoType, app, fileName
       byteArrays.push(byteCharacters.charCodeAt(i));
     }
     const blob = new Blob([new Uint8Array(byteArrays)], { type: contentType });
-    await (0, import_storage3.uploadBytes)(storageRef, blob, { contentType });
-    const downloadUrl = await (0, import_storage3.getDownloadURL)(storageRef);
+    await (0, import_storage4.uploadBytes)(storageRef, blob, { contentType });
+    const downloadUrl = await (0, import_storage4.getDownloadURL)(storageRef);
     console.log(`[PHOTO_UTILS] ${photoType} uploaded successfully`, {
       downloadUrl
     });
@@ -12163,7 +12167,7 @@ var ReviewService = class extends BaseService {
 
 // src/services/appointment/appointment.service.ts
 var import_firestore40 = require("firebase/firestore");
-var import_functions = require("firebase/functions");
+var import_functions2 = require("firebase/functions");
 
 // src/services/appointment/utils/appointment.utils.ts
 var import_firestore39 = require("firebase/firestore");
@@ -12377,7 +12381,7 @@ var AppointmentService = class extends BaseService {
     this.practitionerService = practitionerService;
     this.clinicService = clinicService;
     this.filledDocumentService = filledDocumentService;
-    this.functions = (0, import_functions.getFunctions)(app, "europe-west6");
+    this.functions = (0, import_functions2.getFunctions)(app, "europe-west6");
   }
   /**
    * Gets available booking slots for a specific clinic, practitioner, and procedure using HTTP request.

package/dist/index.mjs

@@ -471,17 +471,21 @@ import { getFirestore } from "firebase/firestore";
 import { getAuth } from "firebase/auth";
 import { getAnalytics } from "firebase/analytics";
 import { Platform } from "react-native";
+import { getStorage } from "firebase/storage";
+import { getFunctions } from "firebase/functions";
 var firebaseInstance = null;
 var initializeFirebase = (config) => {
   if (!firebaseInstance) {
     const app = initializeApp(config);
     const db = getFirestore(app);
     const auth = getAuth(app);
+    const storage = getStorage(app);
+    const functions = getFunctions(app);
     let analytics = null;
     if (typeof window !== "undefined" && Platform.OS === "web") {
       analytics = getAnalytics(app);
     }
-    firebaseInstance = { app, db, auth, analytics };
+    firebaseInstance = { app, db, auth, analytics, storage, functions };
   }
   return firebaseInstance;
 };
@@ -846,13 +850,13 @@ var FirebaseErrorCode = /* @__PURE__ */ ((FirebaseErrorCode2) => {
 })(FirebaseErrorCode || {});
 
 // src/services/base.service.ts
-import { getStorage } from "firebase/storage";
+import { getStorage as getStorage2 } from "firebase/storage";
 var BaseService = class {
   constructor(db, auth, app) {
     this.db = db;
     this.auth = auth;
     this.app = app;
-    this.storage = getStorage(app);
+    this.storage = getStorage2(app);
   }
   /**
    * Generiše jedinstveni ID za dokumente
@@ -5036,7 +5040,7 @@ import { z as z16 } from "zod";
 
 // src/services/clinic/utils/photos.utils.ts
 import {
-  getStorage as getStorage2,
+  getStorage as getStorage3,
   ref as ref2,
   uploadBytes as uploadBytes2,
   getDownloadURL as getDownloadURL2,
@@ -5050,7 +5054,7 @@ async function uploadPhoto(photo, entityType, entityId, photoType, app, fileName
     console.log(
       `[PHOTO_UTILS] Uploading ${photoType} for ${entityType}/${entityId}`
     );
-    const storage = getStorage2(app);
+    const storage = getStorage3(app);
     const storageFileName = fileName || `${photoType}-${Date.now()}`;
     const storageRef = ref2(
       storage,
@@ -12258,7 +12262,7 @@ import {
   startAfter as startAfter11,
   getDocs as getDocs26
 } from "firebase/firestore";
-import { getFunctions } from "firebase/functions";
+import { getFunctions as getFunctions2 } from "firebase/functions";
 
 // src/services/appointment/utils/appointment.utils.ts
 import {
@@ -12486,7 +12490,7 @@ var AppointmentService = class extends BaseService {
     this.practitionerService = practitionerService;
     this.clinicService = clinicService;
     this.filledDocumentService = filledDocumentService;
-    this.functions = getFunctions(app, "europe-west6");
+    this.functions = getFunctions2(app, "europe-west6");
   }
   /**
    * Gets available booking slots for a specific clinic, practitioner, and procedure using HTTP request.

package/package.json

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

package/src/admin/aggregation/appointment/appointment.aggregation.service.ts

@@ -566,8 +566,6 @@ export class AppointmentAggregationService {
             originalNotifyAtValue: notifyAtValue,
             originalTimeframeUnit: template.timeframe.unit,
             updatedAt: admin.firestore.Timestamp.now() as any, // Use current server timestamp
-            notificationId: undefined,
-            actionTakenAt: undefined,
           };
           return instructionObject;
         });

package/src/admin/users/user-profile.admin.ts

@@ -0,0 +1,404 @@
+import * as admin from "firebase-admin";
+import { User, UserRole, USERS_COLLECTION } from "../../types";
+import {
+  PatientProfile,
+  PATIENTS_COLLECTION,
+  CreatePatientProfileData,
+  PatientSensitiveInfo,
+  PATIENT_SENSITIVE_INFO_COLLECTION,
+  CreatePatientSensitiveInfoData,
+  Gender,
+  PatientMedicalInfo,
+  PATIENT_MEDICAL_INFO_COLLECTION,
+} from "../../types/patient";
+
+/**
+ * @class UserProfileAdminService
+ * @description Handles user profile management operations for admin tasks
+ */
+export class UserProfileAdminService {
+  private db: admin.firestore.Firestore;
+
+  /**
+   * Constructor for UserProfileAdminService
+   * @param firestore Optional Firestore instance. If not provided, uses the default admin SDK instance.
+   */
+  constructor(firestore?: admin.firestore.Firestore) {
+    this.db = firestore || admin.firestore();
+  }
+
+  /**
+   * Creates a blank user profile with minimal information
+   * @param authUserData Basic user data from Firebase Auth
+   * @returns The created user document
+   */
+  async createBlankUserProfile(authUserData: {
+    uid: string;
+    email: string | null;
+    isAnonymous: boolean;
+  }): Promise<User> {
+    console.log(
+      `[UserProfileAdminService] Creating blank user profile for user ${authUserData.uid}`
+    );
+
+    const userData: User = {
+      uid: authUserData.uid,
+      email: authUserData.email,
+      roles: [], // Empty roles array as requested
+      isAnonymous: authUserData.isAnonymous,
+      createdAt: admin.firestore.FieldValue.serverTimestamp(),
+      updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      lastLoginAt: admin.firestore.FieldValue.serverTimestamp(),
+    };
+
+    try {
+      const userRef = this.db
+        .collection(USERS_COLLECTION)
+        .doc(authUserData.uid);
+      await userRef.set(userData);
+
+      // Fetch the created document to return with server timestamps
+      const userDoc = await userRef.get();
+      return userDoc.data() as User;
+    } catch (error) {
+      console.error(
+        `[UserProfileAdminService] Error creating blank user profile for ${authUserData.uid}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Initializes patient role for a user and creates all required patient documents
+   * Creates patient profile, sensitive info, and medical info in one operation
+   *
+   * @param userId The user ID to initialize with patient role
+   * @param options Optional data for different aspects of patient initialization
+   * @returns Object containing the updated user and all created patient documents
+   */
+  async initializePatientRole(
+    userId: string,
+    options?: {
+      profileData?: Partial<CreatePatientProfileData>;
+      sensitiveData?: Partial<CreatePatientSensitiveInfoData>;
+    }
+  ): Promise<{
+    user: User;
+    patientProfile: PatientProfile;
+    patientSensitiveInfo: PatientSensitiveInfo;
+    patientMedicalInfo: PatientMedicalInfo;
+  }> {
+    console.log(
+      `[UserProfileAdminService] Initializing complete patient role for user ${userId}`
+    );
+
+    try {
+      // Get user document
+      const userRef = this.db.collection(USERS_COLLECTION).doc(userId);
+      const userDoc = await userRef.get();
+
+      if (!userDoc.exists) {
+        throw new Error(`User ${userId} not found`);
+      }
+
+      const userData = userDoc.data() as User;
+      let patientProfileId: string | undefined = userData.patientProfile;
+
+      // Create patient profile if it doesn't exist
+      let patientProfile: PatientProfile;
+      if (!patientProfileId) {
+        // Create patient profile
+        const patientProfileRef = this.db.collection(PATIENTS_COLLECTION).doc();
+        patientProfileId = patientProfileRef.id;
+
+        // Set default profile data
+        const defaultProfileData: CreatePatientProfileData = {
+          userRef: userId,
+          displayName: "Patient", // Default display name
+          expoTokens: [],
+          gamification: {
+            level: 1,
+            points: 0,
+          },
+          isActive: true,
+          isVerified: false,
+          doctors: [],
+          clinics: [],
+          doctorIds: [],
+          clinicIds: [],
+        };
+
+        // Merge with any provided profile data
+        const mergedProfileData = {
+          ...defaultProfileData,
+          ...options?.profileData,
+        };
+
+        // Create the patient profile document with explicit properties
+        const patientProfileData = {
+          id: patientProfileId,
+          userRef: mergedProfileData.userRef,
+          displayName: mergedProfileData.displayName,
+          profilePhoto: null,
+          gamification: mergedProfileData.gamification || {
+            level: 1,
+            points: 0,
+          },
+          expoTokens: mergedProfileData.expoTokens || [],
+          isActive: mergedProfileData.isActive,
+          isVerified: mergedProfileData.isVerified,
+          doctors: mergedProfileData.doctors || [],
+          clinics: mergedProfileData.clinics || [],
+          doctorIds: mergedProfileData.doctorIds || [],
+          clinicIds: mergedProfileData.clinicIds || [],
+          createdAt: admin.firestore.FieldValue.serverTimestamp(),
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        };
+
+        // Store the document
+        await patientProfileRef.set(patientProfileData);
+
+        // For returning to the client, use type assertions
+        patientProfile = {
+          ...patientProfileData,
+          createdAt: null as any,
+          updatedAt: null as any,
+        } as unknown as PatientProfile;
+
+        console.log(
+          `[UserProfileAdminService] Creating patient profile with ID ${patientProfileId}`
+        );
+      } else {
+        // Get existing patient profile
+        const patientProfileRef = this.db
+          .collection(PATIENTS_COLLECTION)
+          .doc(patientProfileId);
+        const patientProfileDoc = await patientProfileRef.get();
+
+        if (!patientProfileDoc.exists) {
+          throw new Error(
+            `Patient profile ${patientProfileId} exists in user but not in patients collection`
+          );
+        }
+
+        patientProfile = patientProfileDoc.data() as PatientProfile;
+      }
+
+      // Create sensitive information document
+      const sensitiveInfoRef = this.db
+        .collection(PATIENTS_COLLECTION)
+        .doc(patientProfileId)
+        .collection(PATIENT_SENSITIVE_INFO_COLLECTION)
+        .doc("info"); // Use 'info' as standard document ID for subcollection
+
+      // Check if sensitive info document already exists
+      const sensitiveInfoDoc = await sensitiveInfoRef.get();
+      let patientSensitiveInfo: PatientSensitiveInfo;
+
+      if (!sensitiveInfoDoc.exists) {
+        // Create default sensitive info data
+        const defaultSensitiveData: CreatePatientSensitiveInfoData = {
+          patientId: patientProfileId,
+          userRef: userId,
+          firstName: "",
+          lastName: "",
+          dateOfBirth: null,
+          gender: Gender.PREFER_NOT_TO_SAY,
+        };
+
+        // Merge with provided data
+        const mergedSensitiveData = {
+          ...defaultSensitiveData,
+          ...options?.sensitiveData,
+        };
+
+        // Create sensitive info
+        const sensitiveInfoData = {
+          ...mergedSensitiveData,
+          createdAt: admin.firestore.FieldValue.serverTimestamp(),
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+          // Leave dateOfBirth as is
+        };
+
+        // Store the document
+        await sensitiveInfoRef.set(sensitiveInfoData);
+
+        // Convert for client return with type assertions
+        patientSensitiveInfo = {
+          ...sensitiveInfoData,
+          createdAt: null as any,
+          updatedAt: null as any,
+        } as unknown as PatientSensitiveInfo;
+
+        console.log(
+          `[UserProfileAdminService] Creating sensitive info in subcollection for patient ${patientProfileId}`
+        );
+      } else {
+        patientSensitiveInfo = sensitiveInfoDoc.data() as PatientSensitiveInfo;
+      }
+
+      // Create medical info document as a subcollection
+      const medicalInfoRef = this.db
+        .collection(PATIENTS_COLLECTION)
+        .doc(patientProfileId)
+        .collection(PATIENT_MEDICAL_INFO_COLLECTION)
+        .doc("info"); // Use 'info' as standard document ID for subcollection
+
+      // Check if medical info document already exists
+      const medicalInfoDoc = await medicalInfoRef.get();
+      let patientMedicalInfo: PatientMedicalInfo;
+
+      if (!medicalInfoDoc.exists) {
+        // Create medical info
+        const medicalInfoData = {
+          patientId: patientProfileId,
+          vitalStats: {},
+          blockingConditions: [],
+          contraindications: [],
+          allergies: [],
+          currentMedications: [],
+          lastUpdated: admin.firestore.FieldValue.serverTimestamp(),
+          updatedBy: userId,
+        };
+
+        // Store the document
+        await medicalInfoRef.set(medicalInfoData);
+
+        // Convert for client return with type assertions
+        patientMedicalInfo = {
+          ...medicalInfoData,
+          lastUpdated: null as any,
+        } as unknown as PatientMedicalInfo;
+
+        console.log(
+          `[UserProfileAdminService] Creating medical info in subcollection for patient ${patientProfileId}`
+        );
+      } else {
+        patientMedicalInfo = medicalInfoDoc.data() as PatientMedicalInfo;
+      }
+
+      // Update user document with patient role and profile reference
+      const batch = this.db.batch();
+
+      // Add patient role if not already present
+      if (!userData.roles.includes(UserRole.PATIENT)) {
+        batch.update(userRef, {
+          roles: admin.firestore.FieldValue.arrayUnion(UserRole.PATIENT),
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      }
+
+      // Add patient profile reference if not already set
+      if (!userData.patientProfile) {
+        batch.update(userRef, {
+          patientProfile: patientProfileId,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      }
+
+      await batch.commit();
+
+      // Get updated user document
+      const updatedUserDoc = await userRef.get();
+      const updatedUser = updatedUserDoc.data() as User;
+
+      console.log(
+        `[UserProfileAdminService] Successfully initialized patient role for user ${userId}`
+      );
+
+      return {
+        user: updatedUser,
+        patientProfile,
+        patientSensitiveInfo,
+        patientMedicalInfo,
+      };
+    } catch (error) {
+      console.error(
+        `[UserProfileAdminService] Error initializing patient role for user ${userId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Initializes clinic admin role for a user
+   * @param userId The user ID to initialize with clinic admin role
+   * @returns The updated user document
+   */
+  async initializeClinicAdminRole(userId: string): Promise<User> {
+    console.log(
+      `[UserProfileAdminService] Initializing clinic admin role for user ${userId}`
+    );
+
+    try {
+      const userRef = this.db.collection(USERS_COLLECTION).doc(userId);
+      const userDoc = await userRef.get();
+
+      if (!userDoc.exists) {
+        throw new Error(`User ${userId} not found`);
+      }
+
+      const userData = userDoc.data() as User;
+
+      // Only add the role if it doesn't already exist
+      if (!userData.roles.includes(UserRole.CLINIC_ADMIN)) {
+        await userRef.update({
+          roles: admin.firestore.FieldValue.arrayUnion(UserRole.CLINIC_ADMIN),
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      }
+
+      // Return the updated user document
+      const updatedUserDoc = await userRef.get();
+      return updatedUserDoc.data() as User;
+    } catch (error) {
+      console.error(
+        `[UserProfileAdminService] Error initializing clinic admin role for user ${userId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Initializes practitioner role for a user
+   * @param userId The user ID to initialize with practitioner role
+   * @returns The updated user document
+   */
+  async initializePractitionerRole(userId: string): Promise<User> {
+    console.log(
+      `[UserProfileAdminService] Initializing practitioner role for user ${userId}`
+    );
+
+    try {
+      const userRef = this.db.collection(USERS_COLLECTION).doc(userId);
+      const userDoc = await userRef.get();
+
+      if (!userDoc.exists) {
+        throw new Error(`User ${userId} not found`);
+      }
+
+      const userData = userDoc.data() as User;
+
+      // Only add the role if it doesn't already exist
+      if (!userData.roles.includes(UserRole.PRACTITIONER)) {
+        await userRef.update({
+          roles: admin.firestore.FieldValue.arrayUnion(UserRole.PRACTITIONER),
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      }
+
+      // Return the updated user document
+      const updatedUserDoc = await userRef.get();
+      return updatedUserDoc.data() as User;
+    } catch (error) {
+      console.error(
+        `[UserProfileAdminService] Error initializing practitioner role for user ${userId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+}