@blackcode_sa/metaestetics-api 1.14.16 → 1.14.18

package/dist/index.d.mts

@@ -8321,6 +8321,23 @@ declare class AuthService extends BaseService {
     private googleProvider;
     private userService;
     constructor(db: Firestore, auth: Auth, app: FirebaseApp, userService: UserService);
+    /**
+     * Waits for Firebase Auth state to settle after sign-in.
+     *
+     * In React Native with AsyncStorage persistence, there's a critical issue:
+     * 1. signInWithCredential() sets auth.currentUser in memory immediately
+     * 2. But AsyncStorage persistence happens asynchronously
+     * 3. If AsyncStorage reads an old NULL value, it can OVERWRITE the current auth state
+     * 4. This causes auth.currentUser to become NULL even after it was set
+     *
+     * This method uses onAuthStateChanged to wait for the auth state to be SET and STABLE.
+     * It ensures the auth state persists through AsyncStorage operations.
+     *
+     * @param expectedUid - The UID we expect to see in auth.currentUser
+     * @param timeoutMs - Maximum time to wait (default 5 seconds)
+     * @returns Promise that resolves when auth state is ready and stable
+     */
+    private waitForAuthStateToSettle;
     /**
      * Registruje novog korisnika sa email-om i lozinkom
      */

package/dist/index.d.ts

@@ -8321,6 +8321,23 @@ declare class AuthService extends BaseService {
     private googleProvider;
     private userService;
     constructor(db: Firestore, auth: Auth, app: FirebaseApp, userService: UserService);
+    /**
+     * Waits for Firebase Auth state to settle after sign-in.
+     *
+     * In React Native with AsyncStorage persistence, there's a critical issue:
+     * 1. signInWithCredential() sets auth.currentUser in memory immediately
+     * 2. But AsyncStorage persistence happens asynchronously
+     * 3. If AsyncStorage reads an old NULL value, it can OVERWRITE the current auth state
+     * 4. This causes auth.currentUser to become NULL even after it was set
+     *
+     * This method uses onAuthStateChanged to wait for the auth state to be SET and STABLE.
+     * It ensures the auth state persists through AsyncStorage operations.
+     *
+     * @param expectedUid - The UID we expect to see in auth.currentUser
+     * @param timeoutMs - Maximum time to wait (default 5 seconds)
+     * @returns Promise that resolves when auth state is ready and stable
+     */
+    private waitForAuthStateToSettle;
     /**
      * Registruje novog korisnika sa email-om i lozinkom
      */

package/dist/index.js

@@ -15402,6 +15402,73 @@ ${stackTrace}`);
     console.log("[AUTH] AuthService initialized");
     console.log("[AUTH] Initial auth.currentUser:", ((_a = this.auth.currentUser) == null ? void 0 : _a.uid) || "NULL");
   }
+  /**
+   * Waits for Firebase Auth state to settle after sign-in.
+   * 
+   * In React Native with AsyncStorage persistence, there's a critical issue:
+   * 1. signInWithCredential() sets auth.currentUser in memory immediately
+   * 2. But AsyncStorage persistence happens asynchronously
+   * 3. If AsyncStorage reads an old NULL value, it can OVERWRITE the current auth state
+   * 4. This causes auth.currentUser to become NULL even after it was set
+   * 
+   * This method uses onAuthStateChanged to wait for the auth state to be SET and STABLE.
+   * It ensures the auth state persists through AsyncStorage operations.
+   * 
+   * @param expectedUid - The UID we expect to see in auth.currentUser
+   * @param timeoutMs - Maximum time to wait (default 5 seconds)
+   * @returns Promise that resolves when auth state is ready and stable
+   */
+  async waitForAuthStateToSettle(expectedUid, timeoutMs = 5e3) {
+    var _a, _b, _c;
+    if (((_a = this.auth.currentUser) == null ? void 0 : _a.uid) === expectedUid) {
+      console.log("[AUTH] Auth state appears set, waiting for stability...");
+      await new Promise((resolve) => setTimeout(resolve, 200));
+      if (((_b = this.auth.currentUser) == null ? void 0 : _b.uid) === expectedUid) {
+        console.log("[AUTH] \u2705 Auth state stable for:", expectedUid);
+        return;
+      }
+    }
+    console.log("[AUTH] Waiting for auth state to settle for:", expectedUid);
+    console.log("[AUTH] Current auth.currentUser:", ((_c = this.auth.currentUser) == null ? void 0 : _c.uid) || "NULL");
+    return new Promise((resolve, reject) => {
+      const startTime = Date.now();
+      let resolved = false;
+      const unsubscribe = (0, import_auth8.onAuthStateChanged)(this.auth, (user) => {
+        if (resolved) return;
+        const currentUid = (user == null ? void 0 : user.uid) || null;
+        console.log("[AUTH] onAuthStateChanged fired:", currentUid || "NULL");
+        if (currentUid === expectedUid) {
+          setTimeout(() => {
+            var _a2;
+            if (resolved) return;
+            if (((_a2 = this.auth.currentUser) == null ? void 0 : _a2.uid) === expectedUid) {
+              resolved = true;
+              unsubscribe();
+              clearTimeout(timeout);
+              const elapsed = Date.now() - startTime;
+              console.log(`[AUTH] \u2705 Auth state settled and stable after ${elapsed}ms for:`, expectedUid);
+              resolve();
+            } else {
+              console.warn("[AUTH] \u26A0\uFE0F Auth state became NULL after being set, waiting more...");
+            }
+          }, 300);
+        } else if (currentUid === null && Date.now() - startTime > 1e3) {
+          console.error("[AUTH] \u274C Auth state became NULL after being set!");
+          console.error("[AUTH] This indicates AsyncStorage persistence issue");
+        }
+      });
+      const timeout = setTimeout(() => {
+        var _a2, _b2;
+        if (resolved) return;
+        resolved = true;
+        unsubscribe();
+        console.error("[AUTH] \u274C Timeout waiting for auth state to settle");
+        console.error("[AUTH] Expected UID:", expectedUid);
+        console.error("[AUTH] Actual auth.currentUser:", ((_a2 = this.auth.currentUser) == null ? void 0 : _a2.uid) || "NULL");
+        reject(new Error(`Timeout waiting for auth state to settle. Expected: ${expectedUid}, Got: ${((_b2 = this.auth.currentUser) == null ? void 0 : _b2.uid) || "NULL"}`));
+      }, timeoutMs);
+    });
+  }
   /**
    * Registruje novog korisnika sa email-om i lozinkom
    */
@@ -16154,6 +16221,9 @@ ${stackTrace}`);
       const credential = import_auth8.GoogleAuthProvider.credential(idToken);
       const { user: firebaseUser } = await (0, import_auth8.signInWithCredential)(this.auth, credential);
       console.log("[AUTH] Firebase user signed in:", firebaseUser.uid);
+      console.log("[AUTH] Waiting for auth state to settle after sign-in...");
+      await this.waitForAuthStateToSettle(firebaseUser.uid);
+      console.log("[AUTH] \u2705 Auth state settled, proceeding with Firestore queries");
       const existingUser = await this.userService.getUserById(firebaseUser.uid);
       if (existingUser) {
         console.log("[AUTH] Existing user found, returning profile:", existingUser.uid);
@@ -16179,7 +16249,7 @@ ${stackTrace}`);
    * @returns Object containing user, practitioner (if exists), and draft profiles (if any)
    */
   async signUpPractitionerWithGoogle(idToken) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     try {
       console.log("[AUTH] Starting practitioner Google Sign-In/Sign-Up");
       let email;
@@ -16213,6 +16283,9 @@ ${stackTrace}`);
         console.log("[AUTH] User exists with Google provider, signing in");
         const credential2 = import_auth8.GoogleAuthProvider.credential(idToken);
         const { user: firebaseUser2 } = await (0, import_auth8.signInWithCredential)(this.auth, credential2);
+        console.log("[AUTH] Waiting for auth state to settle after sign-in...");
+        await this.waitForAuthStateToSettle(firebaseUser2.uid);
+        console.log("[AUTH] \u2705 Auth state settled, proceeding with Firestore queries");
         let existingUser2 = null;
         try {
           existingUser2 = await this.userService.getUserById(firebaseUser2.uid);
@@ -16224,6 +16297,16 @@ ${stackTrace}`);
             errorType: (_a = userError == null ? void 0 : userError.constructor) == null ? void 0 : _a.name,
             isAuthError: userError instanceof AuthError
           });
+          if (!this.auth.currentUser || this.auth.currentUser.uid !== firebaseUser2.uid) {
+            console.error("[AUTH] \u274C auth.currentUser became NULL before draft profile query!");
+            console.error("[AUTH] Expected UID:", firebaseUser2.uid);
+            console.error("[AUTH] Actual auth.currentUser:", ((_b = this.auth.currentUser) == null ? void 0 : _b.uid) || "NULL");
+            console.log("[AUTH] Re-signing in to restore auth state before query...");
+            const credential3 = import_auth8.GoogleAuthProvider.credential(idToken);
+            await (0, import_auth8.signInWithCredential)(this.auth, credential3);
+            await this.waitForAuthStateToSettle(firebaseUser2.uid, 2e3);
+            console.log("[AUTH] \u2705 Auth state restored, proceeding with query");
+          }
           const practitionerService2 = new PractitionerService(this.db, this.auth, this.app);
           const draftProfiles3 = await practitionerService2.getDraftProfilesByEmail(normalizedEmail);
           console.log("[AUTH] Draft profiles check result:", {
@@ -16245,7 +16328,7 @@ ${stackTrace}`);
             );
           }
           console.log("[AUTH] Draft profiles found, creating User document IMMEDIATELY after sign-in");
-          console.log("[AUTH] auth.currentUser at User creation time:", ((_b = this.auth.currentUser) == null ? void 0 : _b.uid) || "NULL");
+          console.log("[AUTH] auth.currentUser at User creation time:", ((_c = this.auth.currentUser) == null ? void 0 : _c.uid) || "NULL");
           try {
             const newUser = await this.userService.createUser(firebaseUser2, ["practitioner" /* PRACTITIONER */], {
               skipProfileCreation: true
@@ -16313,6 +16396,9 @@ ${stackTrace}`);
         }
         throw error;
       }
+      console.log("[AUTH] Waiting for auth state to settle after sign-in...");
+      await this.waitForAuthStateToSettle(firebaseUser.uid);
+      console.log("[AUTH] \u2705 Auth state settled, proceeding with Firestore queries");
       let existingUser = null;
       try {
         const existingUserDoc = await this.userService.getUserById(firebaseUser.uid);
@@ -16382,7 +16468,7 @@ ${stackTrace}`);
       };
     } catch (error) {
       console.error("[AUTH] Error in signUpPractitionerWithGoogle:", error);
-      console.error("[AUTH] Error type:", (_c = error == null ? void 0 : error.constructor) == null ? void 0 : _c.name);
+      console.error("[AUTH] Error type:", (_d = error == null ? void 0 : error.constructor) == null ? void 0 : _d.name);
       console.error("[AUTH] Error instanceof AuthError:", error instanceof AuthError);
       console.error("[AUTH] Error code:", error == null ? void 0 : error.code);
       console.error("[AUTH] Error message:", error == null ? void 0 : error.message);

package/dist/index.mjs

@@ -15489,6 +15489,73 @@ ${stackTrace}`);
     console.log("[AUTH] AuthService initialized");
     console.log("[AUTH] Initial auth.currentUser:", ((_a = this.auth.currentUser) == null ? void 0 : _a.uid) || "NULL");
   }
+  /**
+   * Waits for Firebase Auth state to settle after sign-in.
+   * 
+   * In React Native with AsyncStorage persistence, there's a critical issue:
+   * 1. signInWithCredential() sets auth.currentUser in memory immediately
+   * 2. But AsyncStorage persistence happens asynchronously
+   * 3. If AsyncStorage reads an old NULL value, it can OVERWRITE the current auth state
+   * 4. This causes auth.currentUser to become NULL even after it was set
+   * 
+   * This method uses onAuthStateChanged to wait for the auth state to be SET and STABLE.
+   * It ensures the auth state persists through AsyncStorage operations.
+   * 
+   * @param expectedUid - The UID we expect to see in auth.currentUser
+   * @param timeoutMs - Maximum time to wait (default 5 seconds)
+   * @returns Promise that resolves when auth state is ready and stable
+   */
+  async waitForAuthStateToSettle(expectedUid, timeoutMs = 5e3) {
+    var _a, _b, _c;
+    if (((_a = this.auth.currentUser) == null ? void 0 : _a.uid) === expectedUid) {
+      console.log("[AUTH] Auth state appears set, waiting for stability...");
+      await new Promise((resolve) => setTimeout(resolve, 200));
+      if (((_b = this.auth.currentUser) == null ? void 0 : _b.uid) === expectedUid) {
+        console.log("[AUTH] \u2705 Auth state stable for:", expectedUid);
+        return;
+      }
+    }
+    console.log("[AUTH] Waiting for auth state to settle for:", expectedUid);
+    console.log("[AUTH] Current auth.currentUser:", ((_c = this.auth.currentUser) == null ? void 0 : _c.uid) || "NULL");
+    return new Promise((resolve, reject) => {
+      const startTime = Date.now();
+      let resolved = false;
+      const unsubscribe = onAuthStateChanged(this.auth, (user) => {
+        if (resolved) return;
+        const currentUid = (user == null ? void 0 : user.uid) || null;
+        console.log("[AUTH] onAuthStateChanged fired:", currentUid || "NULL");
+        if (currentUid === expectedUid) {
+          setTimeout(() => {
+            var _a2;
+            if (resolved) return;
+            if (((_a2 = this.auth.currentUser) == null ? void 0 : _a2.uid) === expectedUid) {
+              resolved = true;
+              unsubscribe();
+              clearTimeout(timeout);
+              const elapsed = Date.now() - startTime;
+              console.log(`[AUTH] \u2705 Auth state settled and stable after ${elapsed}ms for:`, expectedUid);
+              resolve();
+            } else {
+              console.warn("[AUTH] \u26A0\uFE0F Auth state became NULL after being set, waiting more...");
+            }
+          }, 300);
+        } else if (currentUid === null && Date.now() - startTime > 1e3) {
+          console.error("[AUTH] \u274C Auth state became NULL after being set!");
+          console.error("[AUTH] This indicates AsyncStorage persistence issue");
+        }
+      });
+      const timeout = setTimeout(() => {
+        var _a2, _b2;
+        if (resolved) return;
+        resolved = true;
+        unsubscribe();
+        console.error("[AUTH] \u274C Timeout waiting for auth state to settle");
+        console.error("[AUTH] Expected UID:", expectedUid);
+        console.error("[AUTH] Actual auth.currentUser:", ((_a2 = this.auth.currentUser) == null ? void 0 : _a2.uid) || "NULL");
+        reject(new Error(`Timeout waiting for auth state to settle. Expected: ${expectedUid}, Got: ${((_b2 = this.auth.currentUser) == null ? void 0 : _b2.uid) || "NULL"}`));
+      }, timeoutMs);
+    });
+  }
   /**
    * Registruje novog korisnika sa email-om i lozinkom
    */
@@ -16241,6 +16308,9 @@ ${stackTrace}`);
       const credential = GoogleAuthProvider.credential(idToken);
       const { user: firebaseUser } = await signInWithCredential(this.auth, credential);
       console.log("[AUTH] Firebase user signed in:", firebaseUser.uid);
+      console.log("[AUTH] Waiting for auth state to settle after sign-in...");
+      await this.waitForAuthStateToSettle(firebaseUser.uid);
+      console.log("[AUTH] \u2705 Auth state settled, proceeding with Firestore queries");
       const existingUser = await this.userService.getUserById(firebaseUser.uid);
       if (existingUser) {
         console.log("[AUTH] Existing user found, returning profile:", existingUser.uid);
@@ -16266,7 +16336,7 @@ ${stackTrace}`);
    * @returns Object containing user, practitioner (if exists), and draft profiles (if any)
    */
   async signUpPractitionerWithGoogle(idToken) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     try {
       console.log("[AUTH] Starting practitioner Google Sign-In/Sign-Up");
       let email;
@@ -16300,6 +16370,9 @@ ${stackTrace}`);
         console.log("[AUTH] User exists with Google provider, signing in");
         const credential2 = GoogleAuthProvider.credential(idToken);
         const { user: firebaseUser2 } = await signInWithCredential(this.auth, credential2);
+        console.log("[AUTH] Waiting for auth state to settle after sign-in...");
+        await this.waitForAuthStateToSettle(firebaseUser2.uid);
+        console.log("[AUTH] \u2705 Auth state settled, proceeding with Firestore queries");
         let existingUser2 = null;
         try {
           existingUser2 = await this.userService.getUserById(firebaseUser2.uid);
@@ -16311,6 +16384,16 @@ ${stackTrace}`);
             errorType: (_a = userError == null ? void 0 : userError.constructor) == null ? void 0 : _a.name,
             isAuthError: userError instanceof AuthError
           });
+          if (!this.auth.currentUser || this.auth.currentUser.uid !== firebaseUser2.uid) {
+            console.error("[AUTH] \u274C auth.currentUser became NULL before draft profile query!");
+            console.error("[AUTH] Expected UID:", firebaseUser2.uid);
+            console.error("[AUTH] Actual auth.currentUser:", ((_b = this.auth.currentUser) == null ? void 0 : _b.uid) || "NULL");
+            console.log("[AUTH] Re-signing in to restore auth state before query...");
+            const credential3 = GoogleAuthProvider.credential(idToken);
+            await signInWithCredential(this.auth, credential3);
+            await this.waitForAuthStateToSettle(firebaseUser2.uid, 2e3);
+            console.log("[AUTH] \u2705 Auth state restored, proceeding with query");
+          }
           const practitionerService2 = new PractitionerService(this.db, this.auth, this.app);
           const draftProfiles3 = await practitionerService2.getDraftProfilesByEmail(normalizedEmail);
           console.log("[AUTH] Draft profiles check result:", {
@@ -16332,7 +16415,7 @@ ${stackTrace}`);
             );
           }
           console.log("[AUTH] Draft profiles found, creating User document IMMEDIATELY after sign-in");
-          console.log("[AUTH] auth.currentUser at User creation time:", ((_b = this.auth.currentUser) == null ? void 0 : _b.uid) || "NULL");
+          console.log("[AUTH] auth.currentUser at User creation time:", ((_c = this.auth.currentUser) == null ? void 0 : _c.uid) || "NULL");
           try {
             const newUser = await this.userService.createUser(firebaseUser2, ["practitioner" /* PRACTITIONER */], {
               skipProfileCreation: true
@@ -16400,6 +16483,9 @@ ${stackTrace}`);
         }
         throw error;
       }
+      console.log("[AUTH] Waiting for auth state to settle after sign-in...");
+      await this.waitForAuthStateToSettle(firebaseUser.uid);
+      console.log("[AUTH] \u2705 Auth state settled, proceeding with Firestore queries");
       let existingUser = null;
       try {
         const existingUserDoc = await this.userService.getUserById(firebaseUser.uid);
@@ -16469,7 +16555,7 @@ ${stackTrace}`);
       };
     } catch (error) {
       console.error("[AUTH] Error in signUpPractitionerWithGoogle:", error);
-      console.error("[AUTH] Error type:", (_c = error == null ? void 0 : error.constructor) == null ? void 0 : _c.name);
+      console.error("[AUTH] Error type:", (_d = error == null ? void 0 : error.constructor) == null ? void 0 : _d.name);
       console.error("[AUTH] Error instanceof AuthError:", error instanceof AuthError);
       console.error("[AUTH] Error code:", error == null ? void 0 : error.code);
       console.error("[AUTH] Error message:", error == null ? void 0 : error.message);

package/package.json

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

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

@@ -110,6 +110,87 @@ export class AuthService extends BaseService {
     console.log('[AUTH] Initial auth.currentUser:', this.auth.currentUser?.uid || 'NULL');
   }
 
+  /**
+   * Waits for Firebase Auth state to settle after sign-in.
+   * 
+   * In React Native with AsyncStorage persistence, there's a critical issue:
+   * 1. signInWithCredential() sets auth.currentUser in memory immediately
+   * 2. But AsyncStorage persistence happens asynchronously
+   * 3. If AsyncStorage reads an old NULL value, it can OVERWRITE the current auth state
+   * 4. This causes auth.currentUser to become NULL even after it was set
+   * 
+   * This method uses onAuthStateChanged to wait for the auth state to be SET and STABLE.
+   * It ensures the auth state persists through AsyncStorage operations.
+   * 
+   * @param expectedUid - The UID we expect to see in auth.currentUser
+   * @param timeoutMs - Maximum time to wait (default 5 seconds)
+   * @returns Promise that resolves when auth state is ready and stable
+   */
+  private async waitForAuthStateToSettle(expectedUid: string, timeoutMs: number = 5000): Promise<void> {
+    // If already correct, still wait a bit to ensure it's stable (not just set in memory)
+    if (this.auth.currentUser?.uid === expectedUid) {
+      console.log('[AUTH] Auth state appears set, waiting for stability...');
+      // Wait a small amount to ensure AsyncStorage persistence completes
+      await new Promise(resolve => setTimeout(resolve, 200));
+      // Check again after wait
+      if (this.auth.currentUser?.uid === expectedUid) {
+        console.log('[AUTH] ✅ Auth state stable for:', expectedUid);
+        return;
+      }
+    }
+
+    console.log('[AUTH] Waiting for auth state to settle for:', expectedUid);
+    console.log('[AUTH] Current auth.currentUser:', this.auth.currentUser?.uid || 'NULL');
+    
+    return new Promise((resolve, reject) => {
+      const startTime = Date.now();
+      let resolved = false;
+      
+      // Use onAuthStateChanged to wait for auth state to be SET
+      // This is more reliable than polling auth.currentUser
+      const unsubscribe = onAuthStateChanged(this.auth, (user) => {
+        if (resolved) return;
+        
+        const currentUid = user?.uid || null;
+        console.log('[AUTH] onAuthStateChanged fired:', currentUid || 'NULL');
+        
+        if (currentUid === expectedUid) {
+          // Auth state is set, but wait a bit more to ensure it's stable
+          // AsyncStorage might still be writing/reading
+          setTimeout(() => {
+            if (resolved) return;
+            
+            // Final check - is it still set?
+            if (this.auth.currentUser?.uid === expectedUid) {
+              resolved = true;
+              unsubscribe();
+              clearTimeout(timeout);
+              const elapsed = Date.now() - startTime;
+              console.log(`[AUTH] ✅ Auth state settled and stable after ${elapsed}ms for:`, expectedUid);
+              resolve();
+            } else {
+              console.warn('[AUTH] ⚠️ Auth state became NULL after being set, waiting more...');
+            }
+          }, 300); // Wait 300ms for AsyncStorage to stabilize
+        } else if (currentUid === null && Date.now() - startTime > 1000) {
+          // Auth state became NULL after being set - this is the bug we're trying to fix
+          console.error('[AUTH] ❌ Auth state became NULL after being set!');
+          console.error('[AUTH] This indicates AsyncStorage persistence issue');
+        }
+      });
+      
+      const timeout = setTimeout(() => {
+        if (resolved) return;
+        resolved = true;
+        unsubscribe();
+        console.error('[AUTH] ❌ Timeout waiting for auth state to settle');
+        console.error('[AUTH] Expected UID:', expectedUid);
+        console.error('[AUTH] Actual auth.currentUser:', this.auth.currentUser?.uid || 'NULL');
+        reject(new Error(`Timeout waiting for auth state to settle. Expected: ${expectedUid}, Got: ${this.auth.currentUser?.uid || 'NULL'}`));
+      }, timeoutMs);
+    });
+  }
+
   /**
    * Registruje novog korisnika sa email-om i lozinkom
    */
@@ -1099,6 +1180,13 @@ export class AuthService extends BaseService {
       const { user: firebaseUser } = await signInWithCredential(this.auth, credential);
       console.log('[AUTH] Firebase user signed in:', firebaseUser.uid);
 
+      // CRITICAL: Wait for auth state to settle before making Firestore queries
+      // In React Native with AsyncStorage persistence, auth.currentUser can be NULL
+      // immediately after signInWithCredential due to async persistence race condition
+      console.log('[AUTH] Waiting for auth state to settle after sign-in...');
+      await this.waitForAuthStateToSettle(firebaseUser.uid);
+      console.log('[AUTH] ✅ Auth state settled, proceeding with Firestore queries');
+
       // 4) Load our domain user document.
       const existingUser = await this.userService.getUserById(firebaseUser.uid);
       if (existingUser) {
@@ -1179,6 +1267,13 @@ export class AuthService extends BaseService {
         const credential = GoogleAuthProvider.credential(idToken);
         const { user: firebaseUser } = await signInWithCredential(this.auth, credential);
         
+        // CRITICAL: Wait for auth state to settle before making Firestore queries
+        // In React Native with AsyncStorage persistence, auth.currentUser can be NULL
+        // immediately after signInWithCredential due to async persistence race condition
+        console.log('[AUTH] Waiting for auth state to settle after sign-in...');
+        await this.waitForAuthStateToSettle(firebaseUser.uid);
+        console.log('[AUTH] ✅ Auth state settled, proceeding with Firestore queries');
+        
         let existingUser: User | null = null;
         try {
           existingUser = await this.userService.getUserById(firebaseUser.uid);
@@ -1193,6 +1288,25 @@ export class AuthService extends BaseService {
           });
           
           // Check for draft profiles before signing out
+          // CRITICAL: Firestore queries can trigger AsyncStorage reads which overwrite auth.currentUser
+          // If auth.currentUser is NULL, re-sign in immediately to restore it before the query
+          if (!this.auth.currentUser || this.auth.currentUser.uid !== firebaseUser.uid) {
+            console.error('[AUTH] ❌ auth.currentUser became NULL before draft profile query!');
+            console.error('[AUTH] Expected UID:', firebaseUser.uid);
+            console.error('[AUTH] Actual auth.currentUser:', this.auth.currentUser?.uid || 'NULL');
+            console.log('[AUTH] Re-signing in to restore auth state before query...');
+            
+            // Re-sign in with the credential to restore auth.currentUser
+            // This is the most reliable way to ensure auth state is set before Firestore queries
+            const credential = GoogleAuthProvider.credential(idToken);
+            await signInWithCredential(this.auth, credential);
+            
+            // Wait for auth state to settle after re-sign-in
+            await this.waitForAuthStateToSettle(firebaseUser.uid, 2000);
+            
+            console.log('[AUTH] ✅ Auth state restored, proceeding with query');
+          }
+          
           const practitionerService = new PractitionerService(this.db, this.auth, this.app);
           const draftProfiles = await practitionerService.getDraftProfilesByEmail(normalizedEmail);
           
@@ -1309,6 +1423,13 @@ export class AuthService extends BaseService {
         throw error;
       }
 
+      // CRITICAL: Wait for auth state to settle before making Firestore queries
+      // In React Native with AsyncStorage persistence, auth.currentUser can be NULL
+      // immediately after signInWithCredential due to async persistence race condition
+      console.log('[AUTH] Waiting for auth state to settle after sign-in...');
+      await this.waitForAuthStateToSettle(firebaseUser.uid);
+      console.log('[AUTH] ✅ Auth state settled, proceeding with Firestore queries');
+
       // Check for existing User document (in case user had email/password account that was just linked)
       let existingUser: User | null = null;
       try {