@blackcode_sa/metaestetics-api 1.12.8 → 1.12.10

package/src/services/auth/auth.service.ts

@@ -6,8 +6,6 @@ import {
   signInAnonymously as firebaseSignInAnonymously,
   signOut as firebaseSignOut,
   GoogleAuthProvider,
-  FacebookAuthProvider,
-  OAuthProvider,
   signInWithPopup,
   signInWithRedirect,
   getRedirectResult,
@@ -18,7 +16,8 @@ import {
   verifyPasswordResetCode,
   confirmPasswordReset,
   fetchSignInMethodsForEmail,
-} from "firebase/auth";
+  signInWithCredential,
+} from 'firebase/auth';
 import {
   getFirestore,
   collection,
@@ -36,21 +35,17 @@ import {
   Timestamp,
   runTransaction,
   Firestore,
-} from "firebase/firestore";
-import { FirebaseApp } from "firebase/app";
-import { User, UserRole, USERS_COLLECTION } from "../../types";
-import { z } from "zod";
-import {
-  emailSchema,
-  passwordSchema,
-  userRoleSchema,
-} from "../../validations/schemas";
-import { AuthError, AUTH_ERRORS } from "../../errors/auth.errors";
-import { FirebaseErrorCode } from "../../errors/firebase.errors";
-import { FirebaseError } from "../../errors/firebase.errors";
-import { BaseService } from "../base.service";
-import { UserService } from "../user/user.service";
-import { throws } from "assert";
+} from 'firebase/firestore';
+import { FirebaseApp } from 'firebase/app';
+import { User, UserRole, USERS_COLLECTION } from '../../types';
+import { z } from 'zod';
+import { emailSchema, passwordSchema, userRoleSchema } from '../../validations/schemas';
+import { AuthError, AUTH_ERRORS } from '../../errors/auth.errors';
+import { FirebaseErrorCode } from '../../errors/firebase.errors';
+import { FirebaseError } from '../../errors/firebase.errors';
+import { BaseService } from '../base.service';
+import { UserService } from '../user/user.service';
+import { throws } from 'assert';
 import {
   ClinicGroup,
   AdminToken,
@@ -62,22 +57,22 @@ import {
   SubscriptionModel,
   CLINIC_GROUPS_COLLECTION,
   ClinicAdmin,
-} from "../../types/clinic";
-import { clinicAdminSignupSchema } from "../../validations/clinic.schema";
-import { ClinicGroupService } from "../clinic/clinic-group.service";
-import { ClinicAdminService } from "../clinic/clinic-admin.service";
-import { ClinicService } from "../clinic/clinic.service";
+} from '../../types/clinic';
+import { clinicAdminSignupSchema } from '../../validations/clinic.schema';
+import { ClinicGroupService } from '../clinic/clinic-group.service';
+import { ClinicAdminService } from '../clinic/clinic-admin.service';
+import { ClinicService } from '../clinic/clinic.service';
 import {
   Practitioner,
   CreatePractitionerData,
   PractitionerStatus,
   PractitionerBasicInfo,
   PractitionerCertification,
-} from "../../types/practitioner";
-import { PractitionerService } from "../practitioner/practitioner.service";
-import { practitionerSignupSchema } from "../../validations/practitioner.schema";
-import { CertificationLevel } from "../../backoffice/types/static/certification.types";
-import { MediaService } from "../media/media.service";
+} from '../../types/practitioner';
+import { PractitionerService } from '../practitioner/practitioner.service';
+import { practitionerSignupSchema } from '../../validations/practitioner.schema';
+import { CertificationLevel } from '../../backoffice/types/static/certification.types';
+import { MediaService } from '../media/media.service';
 // Import utility functions
 import {
   checkEmailExists,
@@ -86,20 +81,13 @@ import {
   handleSignupError,
   buildPractitionerData,
   validatePractitionerProfileData,
-} from "./utils";
+} from './utils';
 
 export class AuthService extends BaseService {
   private googleProvider = new GoogleAuthProvider();
-  private facebookProvider = new FacebookAuthProvider();
-  private appleProvider = new OAuthProvider("apple.com");
   private userService: UserService;
 
-  constructor(
-    db: Firestore,
-    auth: Auth,
-    app: FirebaseApp,
-    userService: UserService
-  ) {
+  constructor(db: Firestore, auth: Auth, app: FirebaseApp, userService: UserService) {
     super(db, auth, app);
     this.userService = userService || new UserService(db, auth, app);
   }
@@ -113,13 +101,9 @@ export class AuthService extends BaseService {
     initialRole: UserRole = UserRole.PATIENT,
     options?: {
       patientInviteToken?: string;
-    }
+    },
   ): Promise<User> {
-    const { user: firebaseUser } = await createUserWithEmailAndPassword(
-      this.auth,
-      email,
-      password
-    );
+    const { user: firebaseUser } = await createUserWithEmailAndPassword(this.auth, email, password);
 
     return this.userService.createUser(firebaseUser, [initialRole], options);
   }
@@ -137,56 +121,45 @@ export class AuthService extends BaseService {
     clinicAdmin: ClinicAdmin;
   }> {
     try {
-      console.log("[AUTH] Starting clinic admin signup process", {
+      console.log('[AUTH] Starting clinic admin signup process', {
         email: data.email,
       });
 
       // Validate data
       try {
         await clinicAdminSignupSchema.parseAsync(data);
-        console.log("[AUTH] Clinic admin signup data validation passed");
+        console.log('[AUTH] Clinic admin signup data validation passed');
       } catch (validationError) {
-        console.error(
-          "[AUTH] Validation error in signUpClinicAdmin:",
-          validationError
-        );
+        console.error('[AUTH] Validation error in signUpClinicAdmin:', validationError);
         throw validationError;
       }
 
       // Create Firebase user
-      console.log("[AUTH] Creating Firebase user");
+      console.log('[AUTH] Creating Firebase user');
       let firebaseUser;
       try {
-        const result = await createUserWithEmailAndPassword(
-          this.auth,
-          data.email,
-          data.password
-        );
+        const result = await createUserWithEmailAndPassword(this.auth, data.email, data.password);
         firebaseUser = result.user;
-        console.log("[AUTH] Firebase user created successfully", {
+        console.log('[AUTH] Firebase user created successfully', {
           uid: firebaseUser.uid,
         });
       } catch (firebaseError) {
-        console.error("[AUTH] Firebase user creation failed:", firebaseError);
+        console.error('[AUTH] Firebase user creation failed:', firebaseError);
         throw handleFirebaseError(firebaseError);
       }
 
       // Create user with CLINIC_ADMIN role
-      console.log("[AUTH] Creating user with CLINIC_ADMIN role");
+      console.log('[AUTH] Creating user with CLINIC_ADMIN role');
       let user;
       try {
-        user = await this.userService.createUser(
-          firebaseUser,
-          [UserRole.CLINIC_ADMIN],
-          {
-            skipProfileCreation: true,
-          }
-        );
-        console.log("[AUTH] User with CLINIC_ADMIN role created successfully", {
+        user = await this.userService.createUser(firebaseUser, [UserRole.CLINIC_ADMIN], {
+          skipProfileCreation: true,
+        });
+        console.log('[AUTH] User with CLINIC_ADMIN role created successfully', {
           userId: user.uid,
         });
       } catch (userCreationError) {
-        console.error("[AUTH] User creation failed:", userCreationError);
+        console.error('[AUTH] User creation failed:', userCreationError);
         throw userCreationError;
       }
 
@@ -198,20 +171,16 @@ export class AuthService extends BaseService {
         email: data.email,
         phoneNumber: data.phoneNumber,
       };
-      console.log("[AUTH] Contact person object created");
+      console.log('[AUTH] Contact person object created');
 
       // Initialize services
-      console.log("[AUTH] Initializing clinic services");
-      const clinicAdminService = new ClinicAdminService(
-        this.db,
-        this.auth,
-        this.app
-      );
+      console.log('[AUTH] Initializing clinic services');
+      const clinicAdminService = new ClinicAdminService(this.db, this.auth, this.app);
       const clinicGroupService = new ClinicGroupService(
         this.db,
         this.auth,
         this.app,
-        clinicAdminService
+        clinicAdminService,
       );
       const mediaService = new MediaService(this.db, this.auth, this.app);
       const clinicService = new ClinicService(
@@ -220,30 +189,26 @@ export class AuthService extends BaseService {
         this.app,
         clinicGroupService,
         clinicAdminService,
-        mediaService
+        mediaService,
       );
 
       // Set services to resolve circular dependencies
       clinicAdminService.setServices(clinicGroupService, clinicService);
-      console.log(
-        "[AUTH] Services initialized and circular dependencies resolved"
-      );
+      console.log('[AUTH] Services initialized and circular dependencies resolved');
 
       let clinicGroup: ClinicGroup | null = null;
       let adminProfile: ClinicAdmin | null = null;
 
       if (data.isCreatingNewGroup) {
-        console.log("[AUTH] Creating new clinic group flow");
+        console.log('[AUTH] Creating new clinic group flow');
         // Create new clinic group
         if (!data.clinicGroupData) {
-          console.error("[AUTH] Clinic group data is missing");
-          throw new Error(
-            "Clinic group data is required when creating a new group"
-          );
+          console.error('[AUTH] Clinic group data is missing');
+          throw new Error('Clinic group data is required when creating a new group');
         }
 
         // First create the clinic admin without a group
-        console.log("[AUTH] Creating clinic admin first (without group)");
+        console.log('[AUTH] Creating clinic admin first (without group)');
         const createClinicAdminData: CreateClinicAdminData = {
           userRef: firebaseUser.uid,
           isGroupOwner: true,
@@ -255,34 +220,24 @@ export class AuthService extends BaseService {
         };
 
         try {
-          adminProfile = await clinicAdminService.createClinicAdmin(
-            createClinicAdminData
-          );
-          console.log("[AUTH] Clinic admin created successfully", {
+          adminProfile = await clinicAdminService.createClinicAdmin(createClinicAdminData);
+          console.log('[AUTH] Clinic admin created successfully', {
             adminId: adminProfile.id,
           });
         } catch (adminCreationError) {
-          console.error(
-            "[AUTH] Clinic admin creation failed:",
-            adminCreationError
-          );
+          console.error('[AUTH] Clinic admin creation failed:', adminCreationError);
           throw adminCreationError;
         }
 
         // Update user document with admin profile reference
         try {
-          console.log("[AUTH] Updating user with admin profile reference");
+          console.log('[AUTH] Updating user with admin profile reference');
           user = await this.userService.updateUser(firebaseUser.uid, {
             adminProfile: adminProfile.id,
           });
-          console.log(
-            "[AUTH] User updated with admin profile reference successfully"
-          );
+          console.log('[AUTH] User updated with admin profile reference successfully');
         } catch (userUpdateError) {
-          console.error(
-            "[AUTH] Failed to update user with admin profile:",
-            userUpdateError
-          );
+          console.error('[AUTH] Failed to update user with admin profile:', userUpdateError);
           throw userUpdateError;
         }
 
@@ -296,14 +251,13 @@ export class AuthService extends BaseService {
           isActive: true,
           logo: data.clinicGroupData.logo || null,
           subscriptionModel:
-            data.clinicGroupData.subscriptionModel ||
-            SubscriptionModel.NO_SUBSCRIPTION,
+            data.clinicGroupData.subscriptionModel || SubscriptionModel.NO_SUBSCRIPTION,
           onboarding: {
             completed: false,
             step: 1,
           },
         };
-        console.log("[AUTH] Clinic group data prepared", {
+        console.log('[AUTH] Clinic group data prepared', {
           groupName: createClinicGroupData.name,
         });
 
@@ -312,46 +266,39 @@ export class AuthService extends BaseService {
           clinicGroup = await clinicGroupService.createClinicGroup(
             createClinicGroupData,
             adminProfile.id, // Use admin profile ID, not user UID
-            false // This is not a default group since we're providing complete data
+            false, // This is not a default group since we're providing complete data
           );
-          console.log("[AUTH] Clinic group created successfully", {
+          console.log('[AUTH] Clinic group created successfully', {
             groupId: clinicGroup.id,
           });
 
           // Now update the admin with the group ID
-          console.log("[AUTH] Updating admin with clinic group ID");
+          console.log('[AUTH] Updating admin with clinic group ID');
           await clinicAdminService.updateClinicAdmin(adminProfile.id, {
             // Use admin profile ID, not user UID
             clinicGroupId: clinicGroup.id,
           });
-          console.log("[AUTH] Admin updated with clinic group ID successfully");
+          console.log('[AUTH] Admin updated with clinic group ID successfully');
 
           // Get the updated admin profile
-          adminProfile = await clinicAdminService.getClinicAdmin(
-            adminProfile.id
-          );
+          adminProfile = await clinicAdminService.getClinicAdmin(adminProfile.id);
         } catch (groupCreationError) {
-          console.error(
-            "[AUTH] Clinic group creation failed:",
-            groupCreationError
-          );
+          console.error('[AUTH] Clinic group creation failed:', groupCreationError);
           throw groupCreationError;
         }
       } else {
-        console.log("[AUTH] Joining existing clinic group flow");
+        console.log('[AUTH] Joining existing clinic group flow');
         // Join existing clinic group with token
         if (!data.inviteToken) {
-          console.error("[AUTH] Invite token is missing");
-          throw new Error(
-            "Invite token is required when joining an existing group"
-          );
+          console.error('[AUTH] Invite token is missing');
+          throw new Error('Invite token is required when joining an existing group');
         }
-        console.log("[AUTH] Invite token provided", {
+        console.log('[AUTH] Invite token provided', {
           token: data.inviteToken,
         });
 
         // Find the token in the database
-        console.log("[AUTH] Searching for token in clinic groups");
+        console.log('[AUTH] Searching for token in clinic groups');
         const groupsRef = collection(this.db, CLINIC_GROUPS_COLLECTION);
         const q = query(groupsRef);
         const querySnapshot = await getDocs(q);
@@ -359,26 +306,22 @@ export class AuthService extends BaseService {
         let foundGroup: ClinicGroup | null = null;
         let foundToken: AdminToken | null = null;
 
-        console.log(
-          "[AUTH] Found",
-          querySnapshot.size,
-          "clinic groups to check"
-        );
+        console.log('[AUTH] Found', querySnapshot.size, 'clinic groups to check');
         for (const docSnapshot of querySnapshot.docs) {
           const group = docSnapshot.data() as ClinicGroup;
-          console.log("[AUTH] Checking group", {
+          console.log('[AUTH] Checking group', {
             groupId: group.id,
             groupName: group.name,
           });
 
           // Find the token in the group's tokens
-          const token = group.adminTokens.find((t) => {
+          const token = group.adminTokens.find(t => {
             const isMatch =
               t.token === data.inviteToken &&
               t.status === AdminTokenStatus.ACTIVE &&
               new Date(t.expiresAt.toDate()) > new Date();
 
-            console.log("[AUTH] Checking token", {
+            console.log('[AUTH] Checking token', {
               tokenId: t.id,
               tokenMatch: t.token === data.inviteToken,
               tokenStatus: t.status,
@@ -394,7 +337,7 @@ export class AuthService extends BaseService {
           if (token) {
             foundGroup = group;
             foundToken = token;
-            console.log("[AUTH] Found matching token in group", {
+            console.log('[AUTH] Found matching token in group', {
               groupId: group.id,
               tokenId: token.id,
             });
@@ -403,14 +346,14 @@ export class AuthService extends BaseService {
         }
 
         if (!foundGroup || !foundToken) {
-          console.error("[AUTH] No valid token found in any clinic group");
-          throw new Error("Invalid or expired invite token");
+          console.error('[AUTH] No valid token found in any clinic group');
+          throw new Error('Invalid or expired invite token');
         }
 
         clinicGroup = foundGroup;
 
         // Create clinic admin
-        console.log("[AUTH] Creating clinic admin");
+        console.log('[AUTH] Creating clinic admin');
         const createClinicAdminData: CreateClinicAdminData = {
           userRef: firebaseUser.uid,
           clinicGroupId: foundGroup.id,
@@ -422,17 +365,12 @@ export class AuthService extends BaseService {
         };
 
         try {
-          adminProfile = await clinicAdminService.createClinicAdmin(
-            createClinicAdminData
-          );
-          console.log("[AUTH] Clinic admin created successfully", {
+          adminProfile = await clinicAdminService.createClinicAdmin(createClinicAdminData);
+          console.log('[AUTH] Clinic admin created successfully', {
             adminId: adminProfile.id,
           });
         } catch (adminCreationError) {
-          console.error(
-            "[AUTH] Clinic admin creation failed:",
-            adminCreationError
-          );
+          console.error('[AUTH] Clinic admin creation failed:', adminCreationError);
           throw adminCreationError;
         }
 
@@ -441,26 +379,24 @@ export class AuthService extends BaseService {
           await clinicGroupService.verifyAndUseAdminToken(
             foundGroup.id,
             data.inviteToken,
-            firebaseUser.uid
+            firebaseUser.uid,
           );
-          console.log("[AUTH] Token marked as used successfully");
+          console.log('[AUTH] Token marked as used successfully');
         } catch (tokenUseError) {
-          console.error("[AUTH] Failed to mark token as used:", tokenUseError);
+          console.error('[AUTH] Failed to mark token as used:', tokenUseError);
           throw tokenUseError;
         }
       }
 
-      console.log("[AUTH] Clinic admin signup completed successfully", {
+      console.log('[AUTH] Clinic admin signup completed successfully', {
         userId: user.uid,
         clinicGroupId: clinicGroup.id,
-        clinicAdminId: adminProfile?.id || "unknown",
+        clinicAdminId: adminProfile?.id || 'unknown',
       });
 
       // Ensure we have all required data before returning
       if (!clinicGroup || !adminProfile) {
-        throw new Error(
-          "Failed to create or retrieve clinic group or admin profile"
-        );
+        throw new Error('Failed to create or retrieve clinic group or admin profile');
       }
 
       return {
@@ -471,19 +407,19 @@ export class AuthService extends BaseService {
     } catch (error) {
       if (error instanceof z.ZodError) {
         console.error(
-          "[AUTH] Zod validation error in signUpClinicAdmin:",
-          JSON.stringify(error.errors, null, 2)
+          '[AUTH] Zod validation error in signUpClinicAdmin:',
+          JSON.stringify(error.errors, null, 2),
         );
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
 
       const firebaseError = error as FirebaseError;
       if (firebaseError.code === FirebaseErrorCode.EMAIL_ALREADY_IN_USE) {
-        console.error("[AUTH] Email already in use:", data.email);
+        console.error('[AUTH] Email already in use:', data.email);
         throw AUTH_ERRORS.EMAIL_ALREADY_EXISTS;
       }
 
-      console.error("[AUTH] Unhandled error in signUpClinicAdmin:", error);
+      console.error('[AUTH] Unhandled error in signUpClinicAdmin:', error);
       throw error;
     }
   }
@@ -492,11 +428,7 @@ export class AuthService extends BaseService {
    * Prijavljuje korisnika sa email-om i lozinkom
    */
   async signIn(email: string, password: string): Promise<User> {
-    const { user: firebaseUser } = await signInWithEmailAndPassword(
-      this.auth,
-      email,
-      password
-    );
+    const { user: firebaseUser } = await signInWithEmailAndPassword(this.auth, email, password);
 
     return this.userService.getOrCreateUser(firebaseUser);
   }
@@ -511,7 +443,7 @@ export class AuthService extends BaseService {
    */
   async signInClinicAdmin(
     email: string,
-    password: string
+    password: string,
   ): Promise<{
     user: User;
     clinicAdmin: ClinicAdmin;
@@ -519,16 +451,12 @@ export class AuthService extends BaseService {
   }> {
     try {
       // Initialize required services
-      const clinicAdminService = new ClinicAdminService(
-        this.db,
-        this.auth,
-        this.app
-      );
+      const clinicAdminService = new ClinicAdminService(this.db, this.auth, this.app);
       const clinicGroupService = new ClinicGroupService(
         this.db,
         this.auth,
         this.app,
-        clinicAdminService
+        clinicAdminService,
       );
       const mediaService = new MediaService(this.db, this.auth, this.app);
       const clinicService = new ClinicService(
@@ -537,52 +465,41 @@ export class AuthService extends BaseService {
         this.app,
         clinicGroupService,
         clinicAdminService,
-        mediaService
+        mediaService,
       );
 
       // Set services to resolve circular dependencies
       clinicAdminService.setServices(clinicGroupService, clinicService);
 
       // Sign in with email/password
-      const { user: firebaseUser } = await signInWithEmailAndPassword(
-        this.auth,
-        email,
-        password
-      );
+      const { user: firebaseUser } = await signInWithEmailAndPassword(this.auth, email, password);
 
       // Get or create user
       const user = await this.userService.getOrCreateUser(firebaseUser);
 
       // Check if user has clinic_admin role
       if (!user.roles?.includes(UserRole.CLINIC_ADMIN)) {
-        console.error("[AUTH] User is not a clinic admin:", user.uid);
+        console.error('[AUTH] User is not a clinic admin:', user.uid);
         throw AUTH_ERRORS.INVALID_ROLE;
       }
 
       // Check and get admin profile
       if (!user.adminProfile) {
-        console.error("[AUTH] User has no admin profile:", user.uid);
+        console.error('[AUTH] User has no admin profile:', user.uid);
         throw AUTH_ERRORS.NOT_FOUND;
       }
 
       // Get clinic admin profile
-      const adminProfile = await clinicAdminService.getClinicAdmin(
-        user.adminProfile
-      );
+      const adminProfile = await clinicAdminService.getClinicAdmin(user.adminProfile);
       if (!adminProfile) {
-        console.error("[AUTH] Admin profile not found:", user.adminProfile);
+        console.error('[AUTH] Admin profile not found:', user.adminProfile);
         throw AUTH_ERRORS.NOT_FOUND;
       }
 
       // Get clinic group
-      const clinicGroup = await clinicGroupService.getClinicGroup(
-        adminProfile.clinicGroupId
-      );
+      const clinicGroup = await clinicGroupService.getClinicGroup(adminProfile.clinicGroupId);
       if (!clinicGroup) {
-        console.error(
-          "[AUTH] Clinic group not found:",
-          adminProfile.clinicGroupId
-        );
+        console.error('[AUTH] Clinic group not found:', adminProfile.clinicGroupId);
         throw AUTH_ERRORS.NOT_FOUND;
       }
 
@@ -592,56 +509,11 @@ export class AuthService extends BaseService {
         clinicGroup,
       };
     } catch (error) {
-      console.error("[AUTH] Error in signInClinicAdmin:", error);
+      console.error('[AUTH] Error in signInClinicAdmin:', error);
       throw error;
     }
   }
 
-  /**
-   * Prijavljuje korisnika sa Facebook-om
-   */
-  async signInWithFacebook(): Promise<User> {
-    const provider = new FacebookAuthProvider();
-    const { user: firebaseUser } = await signInWithPopup(this.auth, provider);
-
-    return this.userService.getOrCreateUser(firebaseUser);
-  }
-
-  /**
-   * Prijavljuje korisnika sa Google nalogom
-   */
-  async signInWithGoogle(
-    initialRole: UserRole = UserRole.PATIENT,
-    options?: {
-      patientInviteToken?: string;
-    }
-  ): Promise<User> {
-    const { user: firebaseUser } = await signInWithPopup(
-      this.auth,
-      this.googleProvider
-    );
-
-    const existingUser = await this.userService.getUserByEmail(
-      firebaseUser.email!
-    );
-    if (existingUser) {
-      await this.userService.updateUserLoginTimestamp(existingUser.uid);
-      return existingUser;
-    }
-
-    return this.userService.createUser(firebaseUser, [initialRole], options);
-  }
-
-  /**
-   * Prijavljuje korisnika sa Apple-om
-   */
-  async signInWithApple(): Promise<User> {
-    const provider = new OAuthProvider("apple.com");
-    const { user: firebaseUser } = await signInWithPopup(this.auth, provider);
-
-    return this.userService.getOrCreateUser(firebaseUser);
-  }
-
   /**
    * Prijavljuje korisnika anonimno
    */
@@ -685,20 +557,13 @@ export class AuthService extends BaseService {
         throw AUTH_ERRORS.NOT_AUTHENTICATED;
       }
       if (!currentUser.isAnonymous) {
-        throw new AuthError(
-          "User is not anonymous",
-          "AUTH/NOT_ANONYMOUS_USER",
-          400
-        );
+        throw new AuthError('User is not anonymous', 'AUTH/NOT_ANONYMOUS_USER', 400);
       }
 
       const credential = EmailAuthProvider.credential(email, password);
       await linkWithCredential(currentUser, credential);
 
-      return await this.userService.upgradeAnonymousUser(
-        currentUser.uid,
-        email
-      );
+      return await this.userService.upgradeAnonymousUser(currentUser.uid, email);
     } catch (error) {
       if (error instanceof z.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
@@ -711,118 +576,6 @@ export class AuthService extends BaseService {
     }
   }
 
-  /**
-   * Upgrades an anonymous user to a regular user by signing in with a Google account.
-   *
-   * @throws {AuthError} If the user is not anonymous.
-   * @throws {AuthError} If the user is not authenticated.
-   * @throws {AuthError} If the popup window is closed by the user.
-   * @throws {FirebaseError} If any other Firebase error occurs.
-   *
-   * @returns {Promise<User>} The upgraded user.
-   */
-  async upgradeAnonymousUserWithGoogle(): Promise<User> {
-    try {
-      const currentUser = this.auth.currentUser;
-      if (!currentUser) {
-        throw AUTH_ERRORS.NOT_AUTHENTICATED;
-      }
-      if (!currentUser.isAnonymous) {
-        throw new AuthError(
-          "User is not anonymous",
-          "AUTH/NOT_ANONYMOUS_USER",
-          400
-        );
-      }
-
-      const userCredential = await signInWithPopup(
-        this.auth,
-        this.googleProvider
-      );
-      if (!userCredential) throw AUTH_ERRORS.INVALID_CREDENTIAL;
-
-      return await this.userService.upgradeAnonymousUser(
-        currentUser.uid,
-        userCredential.user.email!
-      );
-    } catch (error: unknown) {
-      const firebaseError = error as FirebaseError;
-      if (firebaseError.code === FirebaseErrorCode.POPUP_CLOSED_BY_USER) {
-        throw AUTH_ERRORS.POPUP_CLOSED;
-      }
-      throw error;
-    }
-  }
-
-  async upgradeAnonymousUserWithFacebook(): Promise<User> {
-    try {
-      const currentUser = this.auth.currentUser;
-      if (!currentUser) {
-        throw AUTH_ERRORS.NOT_AUTHENTICATED;
-      }
-      if (!currentUser.isAnonymous) {
-        throw new AuthError(
-          "User is not anonymous",
-          "AUTH/NOT_ANONYMOUS_USER",
-          400
-        );
-      }
-
-      this.facebookProvider.addScope("email");
-      const userCredential = await signInWithPopup(
-        this.auth,
-        this.facebookProvider
-      );
-      if (!userCredential) throw AUTH_ERRORS.INVALID_CREDENTIAL;
-
-      return await this.userService.upgradeAnonymousUser(
-        currentUser.uid,
-        userCredential.user.email!
-      );
-    } catch (error: unknown) {
-      const firebaseError = error as FirebaseError;
-      if (firebaseError.code === FirebaseErrorCode.POPUP_CLOSED_BY_USER) {
-        throw AUTH_ERRORS.POPUP_CLOSED;
-      }
-      throw error;
-    }
-  }
-
-  async upgradeAnonymousUserWithApple(): Promise<User> {
-    try {
-      const currentUser = this.auth.currentUser;
-      if (!currentUser) {
-        throw AUTH_ERRORS.NOT_AUTHENTICATED;
-      }
-      if (!currentUser.isAnonymous) {
-        throw new AuthError(
-          "User is not anonymous",
-          "AUTH/NOT_ANONYMOUS_USER",
-          400
-        );
-      }
-
-      this.appleProvider.addScope("email");
-      this.appleProvider.addScope("name");
-      const userCredential = await signInWithPopup(
-        this.auth,
-        this.appleProvider
-      );
-      if (!userCredential) throw AUTH_ERRORS.INVALID_CREDENTIAL;
-
-      return await this.userService.upgradeAnonymousUser(
-        currentUser.uid,
-        userCredential.user.email!
-      );
-    } catch (error: unknown) {
-      const firebaseError = error as FirebaseError;
-      if (firebaseError.code === FirebaseErrorCode.POPUP_CLOSED_BY_USER) {
-        throw AUTH_ERRORS.POPUP_CLOSED;
-      }
-      throw error;
-    }
-  }
-
   /**
    * Šalje email za resetovanje lozinke korisniku
    * @param email Email adresa korisnika
@@ -875,10 +628,7 @@ export class AuthService extends BaseService {
    * @param newPassword Nova lozinka
    * @returns Promise koji se razrešava kada je lozinka promenjena
    */
-  async confirmPasswordReset(
-    oobCode: string,
-    newPassword: string
-  ): Promise<void> {
+  async confirmPasswordReset(oobCode: string, newPassword: string): Promise<void> {
     try {
       await passwordSchema.parseAsync(newPassword);
 
@@ -923,7 +673,7 @@ export class AuthService extends BaseService {
     let firebaseUser: any = null;
 
     try {
-      console.log("[AUTH] Starting atomic practitioner signup process", {
+      console.log('[AUTH] Starting atomic practitioner signup process', {
         email: data.email,
         hasToken: !!data.token,
       });
@@ -932,95 +682,69 @@ export class AuthService extends BaseService {
       await this.validateSignupData(data);
 
       // Step 2: Create Firebase user (outside transaction - can't be easily rolled back)
-      console.log("[AUTH] Creating Firebase user");
+      console.log('[AUTH] Creating Firebase user');
       try {
-        const result = await createUserWithEmailAndPassword(
-          this.auth,
-          data.email,
-          data.password
-        );
+        const result = await createUserWithEmailAndPassword(this.auth, data.email, data.password);
         firebaseUser = result.user;
-        console.log("[AUTH] Firebase user created successfully", {
+        console.log('[AUTH] Firebase user created successfully', {
           uid: firebaseUser.uid,
         });
       } catch (firebaseError) {
-        console.error("[AUTH] Firebase user creation failed:", firebaseError);
+        console.error('[AUTH] Firebase user creation failed:', firebaseError);
         throw handleFirebaseError(firebaseError);
       }
 
       // Step 3: Execute all database operations in a single transaction
-      console.log("[AUTH] Starting Firestore transaction");
-      const transactionResult = await runTransaction(
-        this.db,
-        async (transaction) => {
-          console.log(
-            "[AUTH] Transaction started - creating user and practitioner"
-          );
+      console.log('[AUTH] Starting Firestore transaction');
+      const transactionResult = await runTransaction(this.db, async transaction => {
+        console.log('[AUTH] Transaction started - creating user and practitioner');
 
-          // Initialize services
-          const practitionerService = new PractitionerService(
-            this.db,
-            this.auth,
-            this.app
-          );
+        // Initialize services
+        const practitionerService = new PractitionerService(this.db, this.auth, this.app);
 
-          // Create user document using existing method (not in transaction for now)
-          console.log("[AUTH] Creating user document");
-          const user = await this.userService.createUser(
-            firebaseUser,
-            [UserRole.PRACTITIONER],
-            { skipProfileCreation: true }
-          );
+        // Create user document using existing method (not in transaction for now)
+        console.log('[AUTH] Creating user document');
+        const user = await this.userService.createUser(firebaseUser, [UserRole.PRACTITIONER], {
+          skipProfileCreation: true,
+        });
 
-          let practitioner: Practitioner;
-
-          // Handle practitioner profile creation/claiming
-          if (data.token) {
-            console.log(
-              "[AUTH] Claiming existing practitioner profile with token"
-            );
-            const claimedPractitioner =
-              await practitionerService.validateTokenAndClaimProfile(
-                data.token,
-                firebaseUser.uid
-              );
-            if (!claimedPractitioner) {
-              throw new Error("Invalid or expired invitation token");
-            }
-            practitioner = claimedPractitioner;
-          } else {
-            console.log("[AUTH] Creating new practitioner profile");
-            const practitionerData = buildPractitionerData(
-              data,
-              firebaseUser.uid
-            );
-            practitioner = await practitionerService.createPractitioner(
-              practitionerData
-            );
+        let practitioner: Practitioner;
+
+        // Handle practitioner profile creation/claiming
+        if (data.token) {
+          console.log('[AUTH] Claiming existing practitioner profile with token');
+          const claimedPractitioner = await practitionerService.validateTokenAndClaimProfile(
+            data.token,
+            firebaseUser.uid,
+          );
+          if (!claimedPractitioner) {
+            throw new Error('Invalid or expired invitation token');
           }
+          practitioner = claimedPractitioner;
+        } else {
+          console.log('[AUTH] Creating new practitioner profile');
+          const practitionerData = buildPractitionerData(data, firebaseUser.uid);
+          practitioner = await practitionerService.createPractitioner(practitionerData);
+        }
 
-          // Link practitioner to user
-          console.log("[AUTH] Linking practitioner to user");
-          await this.userService.updateUser(firebaseUser.uid, {
-            practitionerProfile: practitioner.id,
-          });
+        // Link practitioner to user
+        console.log('[AUTH] Linking practitioner to user');
+        await this.userService.updateUser(firebaseUser.uid, {
+          practitionerProfile: practitioner.id,
+        });
 
-          console.log("[AUTH] Transaction operations completed successfully");
-          return { user, practitioner };
-        }
-      );
+        console.log('[AUTH] Transaction operations completed successfully');
+        return { user, practitioner };
+      });
 
-      console.log("[AUTH] Atomic practitioner signup completed successfully", {
+      console.log('[AUTH] Atomic practitioner signup completed successfully', {
         userId: transactionResult.user.uid,
         practitionerId: transactionResult.practitioner.id,
       });
 
       return transactionResult;
     } catch (error) {
-      console.error(
-        "[AUTH] Atomic signup failed, initiating cleanup...",
-        error
-      );
+      console.error('[AUTH] Atomic signup failed, initiating cleanup...', error);
 
       // Cleanup Firebase user if transaction failed
       if (firebaseUser) {
@@ -1043,47 +767,41 @@ export class AuthService extends BaseService {
     token?: string;
     profileData?: Partial<CreatePractitionerData>;
   }): Promise<void> {
-    console.log("[AUTH] Pre-validating signup data");
+    console.log('[AUTH] Pre-validating signup data');
 
     try {
       // 1. Schema validation
       await practitionerSignupSchema.parseAsync(data);
-      console.log("[AUTH] Schema validation passed");
+      console.log('[AUTH] Schema validation passed');
 
       // 2. Check if email already exists (before creating Firebase user)
       const emailExists = await checkEmailExists(this.auth, data.email);
       if (emailExists) {
-        console.log("[AUTH] Email already exists:", data.email);
+        console.log('[AUTH] Email already exists:', data.email);
         throw AUTH_ERRORS.EMAIL_ALREADY_EXISTS;
       }
-      console.log("[AUTH] Email availability confirmed");
+      console.log('[AUTH] Email availability confirmed');
 
       // 3. Validate token if provided
       if (data.token) {
-        const practitionerService = new PractitionerService(
-          this.db,
-          this.auth,
-          this.app
-        );
-        const isValidToken = await practitionerService.validateToken(
-          data.token
-        );
+        const practitionerService = new PractitionerService(this.db, this.auth, this.app);
+        const isValidToken = await practitionerService.validateToken(data.token);
         if (!isValidToken) {
-          console.log("[AUTH] Invalid token provided:", data.token);
-          throw new Error("Invalid or expired invitation token");
+          console.log('[AUTH] Invalid token provided:', data.token);
+          throw new Error('Invalid or expired invitation token');
         }
-        console.log("[AUTH] Token validation passed");
+        console.log('[AUTH] Token validation passed');
       }
 
       // 4. Validate profile data structure if provided
       if (data.profileData) {
         await validatePractitionerProfileData(data.profileData);
-        console.log("[AUTH] Profile data validation passed");
+        console.log('[AUTH] Profile data validation passed');
       }
 
-      console.log("[AUTH] All pre-validation checks passed");
+      console.log('[AUTH] All pre-validation checks passed');
     } catch (error) {
-      console.error("[AUTH] Pre-validation failed:", error);
+      console.error('[AUTH] Pre-validation failed:', error);
       throw error;
     }
   }
@@ -1098,59 +816,46 @@ export class AuthService extends BaseService {
    */
   async signInPractitioner(
     email: string,
-    password: string
+    password: string,
   ): Promise<{
     user: User;
     practitioner: Practitioner;
   }> {
     try {
-      console.log("[AUTH] Starting practitioner signin process", {
+      console.log('[AUTH] Starting practitioner signin process', {
         email: email,
       });
 
       // Initialize required service
-      const practitionerService = new PractitionerService(
-        this.db,
-        this.auth,
-        this.app
-      );
+      const practitionerService = new PractitionerService(this.db, this.auth, this.app);
 
       // Sign in with email/password
-      const { user: firebaseUser } = await signInWithEmailAndPassword(
-        this.auth,
-        email,
-        password
-      );
+      const { user: firebaseUser } = await signInWithEmailAndPassword(this.auth, email, password);
 
       // Get or create user
       const user = await this.userService.getOrCreateUser(firebaseUser);
-      console.log("[AUTH] User retrieved", { uid: user.uid });
+      console.log('[AUTH] User retrieved', { uid: user.uid });
 
       // Check if user has practitioner role
       if (!user.roles?.includes(UserRole.PRACTITIONER)) {
-        console.error("[AUTH] User is not a practitioner:", user.uid);
+        console.error('[AUTH] User is not a practitioner:', user.uid);
         throw AUTH_ERRORS.INVALID_ROLE;
       }
 
       // Check and get practitioner profile
       if (!user.practitionerProfile) {
-        console.error("[AUTH] User has no practitioner profile:", user.uid);
+        console.error('[AUTH] User has no practitioner profile:', user.uid);
         throw AUTH_ERRORS.NOT_FOUND;
       }
 
       // Get practitioner profile
-      const practitioner = await practitionerService.getPractitioner(
-        user.practitionerProfile
-      );
+      const practitioner = await practitionerService.getPractitioner(user.practitionerProfile);
       if (!practitioner) {
-        console.error(
-          "[AUTH] Practitioner profile not found:",
-          user.practitionerProfile
-        );
+        console.error('[AUTH] Practitioner profile not found:', user.practitionerProfile);
         throw AUTH_ERRORS.NOT_FOUND;
       }
 
-      console.log("[AUTH] Practitioner signin completed successfully", {
+      console.log('[AUTH] Practitioner signin completed successfully', {
         userId: user.uid,
         practitionerId: practitioner.id,
       });
@@ -1160,8 +865,80 @@ export class AuthService extends BaseService {
         practitioner,
       };
     } catch (error) {
-      console.error("[AUTH] Error in signInPractitioner:", error);
+      console.error('[AUTH] Error in signInPractitioner:', error);
       throw error;
     }
   }
+
+  /**
+   * Signs in a user with a Google ID token from a mobile client.
+   * If the user does not exist, a new user is created.
+   * @param idToken - The Google ID token obtained from the mobile app.
+   * @param initialRole - The role to assign to the user if they are being created.
+   * @returns The signed-in or newly created user.
+   */
+  async signInWithGoogleIdToken(
+    idToken: string,
+    initialRole: UserRole = UserRole.PATIENT,
+  ): Promise<User> {
+    try {
+      console.log('[AUTH] Signing in with Google ID Token');
+      const credential = GoogleAuthProvider.credential(idToken);
+      const { user: firebaseUser } = await signInWithCredential(this.auth, credential);
+      console.log('[AUTH] Firebase user signed in:', firebaseUser.uid);
+
+      // Check if the user already has a profile in our database
+      const existingUser = await this.userService.getUserById(firebaseUser.uid);
+      if (existingUser) {
+        console.log('[AUTH] Existing user found, returning profile:', existingUser.uid);
+        return existingUser;
+      }
+
+      // If no profile exists, create a new one
+      console.log('[AUTH] No existing user found, creating new profile for:', firebaseUser.uid);
+      return this.userService.createUser(firebaseUser, [initialRole]);
+    } catch (error) {
+      console.error('[AUTH] Error in signInWithGoogleIdToken:', error);
+      throw handleFirebaseError(error);
+    }
+  }
+
+  /**
+   * Links a Google account to the currently signed-in user using an ID token.
+   * This is used to upgrade an anonymous user or to allow an existing user
+   * to sign in with Google in the future.
+   * @param idToken - The Google ID token obtained from the mobile app.
+   * @returns The updated user profile.
+   */
+  async linkGoogleAccount(idToken: string): Promise<User> {
+    try {
+      console.log('[AUTH] Linking Google account with ID Token');
+      const currentUser = this.auth.currentUser;
+      if (!currentUser) {
+        throw AUTH_ERRORS.NOT_AUTHENTICATED;
+      }
+
+      const wasAnonymous = currentUser.isAnonymous;
+      console.log(`[AUTH] Current user is ${wasAnonymous ? 'anonymous' : 'not anonymous'}`);
+
+      const credential = GoogleAuthProvider.credential(idToken);
+      const userCredential = await linkWithCredential(currentUser, credential);
+      const linkedFirebaseUser = userCredential.user;
+      console.log('[AUTH] Google account linked successfully to user:', linkedFirebaseUser.uid);
+
+      if (wasAnonymous) {
+        console.log('[AUTH] Upgrading anonymous user profile');
+        return await this.userService.upgradeAnonymousUser(
+          linkedFirebaseUser.uid,
+          linkedFirebaseUser.email!,
+        );
+      }
+
+      // If the user was not anonymous, just return their updated profile
+      return (await this.userService.getUserById(linkedFirebaseUser.uid))!;
+    } catch (error) {
+      console.error('[AUTH] Error in linkGoogleAccount:', error);
+      throw handleFirebaseError(error);
+    }
+  }
 }