@blackcode_sa/metaestetics-api 1.14.15 → 1.14.17

package/dist/index.d.mts

@@ -8323,14 +8323,21 @@ declare class AuthService extends BaseService {
     constructor(db: Firestore, auth: Auth, app: FirebaseApp, userService: UserService);
     /**
      * Waits for Firebase Auth state to settle after sign-in.
-     * In React Native with Firebase JS SDK, auth.currentUser doesn't update synchronously
-     * after signInWithCredential. This causes Firestore permission issues.
+     *
+     * 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 10 seconds)
-     * @returns Promise that resolves when auth state is ready
+     * @param timeoutMs - Maximum time to wait (default 5 seconds)
+     * @returns Promise that resolves when auth state is ready and stable
      */
-    private waitForAuthState;
+    private waitForAuthStateToSettle;
     /**
      * Registruje novog korisnika sa email-om i lozinkom
      */

package/dist/index.d.ts

@@ -8323,14 +8323,21 @@ declare class AuthService extends BaseService {
     constructor(db: Firestore, auth: Auth, app: FirebaseApp, userService: UserService);
     /**
      * Waits for Firebase Auth state to settle after sign-in.
-     * In React Native with Firebase JS SDK, auth.currentUser doesn't update synchronously
-     * after signInWithCredential. This causes Firestore permission issues.
+     *
+     * 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 10 seconds)
-     * @returns Promise that resolves when auth state is ready
+     * @param timeoutMs - Maximum time to wait (default 5 seconds)
+     * @returns Promise that resolves when auth state is ready and stable
      */
-    private waitForAuthState;
+    private waitForAuthStateToSettle;
     /**
      * Registruje novog korisnika sa email-om i lozinkom
      */

package/dist/index.js

@@ -15388,44 +15388,85 @@ var AuthService = class extends BaseService {
     super(db, auth, app);
     this.googleProvider = new import_auth8.GoogleAuthProvider();
     this.userService = userService || new UserService(db, auth, app);
-    if (!this.auth.__authServiceId) {
-      this.auth.__authServiceId = "auth-service-" + Date.now();
-    }
-    console.log("[AUTH] AuthService constructor - auth ID:", this.auth.__authServiceId);
-    console.log("[AUTH] AuthService constructor - userService.auth ID:", ((_a = this.userService.auth) == null ? void 0 : _a.__authServiceId) || "NOT SET");
+    (0, import_auth8.onAuthStateChanged)(this.auth, (user) => {
+      var _a2, _b;
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const stackTrace = ((_a2 = new Error().stack) == null ? void 0 : _a2.split("\n").slice(2, 5).join("\n")) || "N/A";
+      console.log(`[AUTH STATE CHANGE] ${timestamp}`);
+      console.log(`[AUTH STATE CHANGE] User: ${(user == null ? void 0 : user.uid) || "NULL"} (email: ${(user == null ? void 0 : user.email) || "N/A"})`);
+      console.log(`[AUTH STATE CHANGE] auth.currentUser: ${((_b = this.auth.currentUser) == null ? void 0 : _b.uid) || "NULL"}`);
+      console.log(`[AUTH STATE CHANGE] Stack trace (first 3 frames):
+${stackTrace}`);
+      console.log("[AUTH STATE CHANGE] ---");
+    });
+    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 Firebase JS SDK, auth.currentUser doesn't update synchronously
-   * after signInWithCredential. This causes Firestore permission issues.
+   * 
+   * 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 10 seconds)
-   * @returns Promise that resolves when auth state is ready
+   * @param timeoutMs - Maximum time to wait (default 5 seconds)
+   * @returns Promise that resolves when auth state is ready and stable
    */
-  waitForAuthState(expectedUid, timeoutMs = 1e4) {
-    return new Promise((resolve, reject) => {
-      var _a;
-      if (((_a = this.auth.currentUser) == null ? void 0 : _a.uid) === expectedUid) {
-        console.log("[AUTH] Auth state already settled for:", expectedUid);
-        resolve();
+  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);
-      const timeout = setTimeout(() => {
-        unsubscribe();
-        console.error("[AUTH] Timeout waiting for auth state");
-        reject(new Error("Timeout waiting for auth state to settle"));
-      }, timeoutMs);
+    }
+    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) => {
-        console.log("[AUTH] Auth state changed:", (user == null ? void 0 : user.uid) || "null");
-        if ((user == null ? void 0 : user.uid) === expectedUid) {
-          clearTimeout(timeout);
-          unsubscribe();
-          console.log("[AUTH] Auth state settled successfully for:", expectedUid);
-          resolve();
+        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);
     });
   }
   /**
@@ -16180,6 +16221,9 @@ var AuthService = class extends BaseService {
       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);
@@ -16205,7 +16249,7 @@ var AuthService = class extends BaseService {
    * @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;
@@ -16239,6 +16283,9 @@ var AuthService = class extends BaseService {
         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);
@@ -16250,6 +16297,13 @@ var AuthService = class extends BaseService {
             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] Waiting for auth state to recover...");
+            await this.waitForAuthStateToSettle(firebaseUser2.uid, 2e3);
+          }
           const practitionerService2 = new PractitionerService(this.db, this.auth, this.app);
           const draftProfiles3 = await practitionerService2.getDraftProfilesByEmail(normalizedEmail);
           console.log("[AUTH] Draft profiles check result:", {
@@ -16271,7 +16325,7 @@ var AuthService = class extends BaseService {
             );
           }
           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
@@ -16339,6 +16393,9 @@ var AuthService = class extends BaseService {
         }
         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);
@@ -16408,7 +16465,7 @@ var AuthService = class extends BaseService {
       };
     } 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

@@ -15475,44 +15475,85 @@ var AuthService = class extends BaseService {
     super(db, auth, app);
     this.googleProvider = new GoogleAuthProvider();
     this.userService = userService || new UserService(db, auth, app);
-    if (!this.auth.__authServiceId) {
-      this.auth.__authServiceId = "auth-service-" + Date.now();
-    }
-    console.log("[AUTH] AuthService constructor - auth ID:", this.auth.__authServiceId);
-    console.log("[AUTH] AuthService constructor - userService.auth ID:", ((_a = this.userService.auth) == null ? void 0 : _a.__authServiceId) || "NOT SET");
+    onAuthStateChanged(this.auth, (user) => {
+      var _a2, _b;
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const stackTrace = ((_a2 = new Error().stack) == null ? void 0 : _a2.split("\n").slice(2, 5).join("\n")) || "N/A";
+      console.log(`[AUTH STATE CHANGE] ${timestamp}`);
+      console.log(`[AUTH STATE CHANGE] User: ${(user == null ? void 0 : user.uid) || "NULL"} (email: ${(user == null ? void 0 : user.email) || "N/A"})`);
+      console.log(`[AUTH STATE CHANGE] auth.currentUser: ${((_b = this.auth.currentUser) == null ? void 0 : _b.uid) || "NULL"}`);
+      console.log(`[AUTH STATE CHANGE] Stack trace (first 3 frames):
+${stackTrace}`);
+      console.log("[AUTH STATE CHANGE] ---");
+    });
+    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 Firebase JS SDK, auth.currentUser doesn't update synchronously
-   * after signInWithCredential. This causes Firestore permission issues.
+   * 
+   * 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 10 seconds)
-   * @returns Promise that resolves when auth state is ready
+   * @param timeoutMs - Maximum time to wait (default 5 seconds)
+   * @returns Promise that resolves when auth state is ready and stable
    */
-  waitForAuthState(expectedUid, timeoutMs = 1e4) {
-    return new Promise((resolve, reject) => {
-      var _a;
-      if (((_a = this.auth.currentUser) == null ? void 0 : _a.uid) === expectedUid) {
-        console.log("[AUTH] Auth state already settled for:", expectedUid);
-        resolve();
+  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);
-      const timeout = setTimeout(() => {
-        unsubscribe();
-        console.error("[AUTH] Timeout waiting for auth state");
-        reject(new Error("Timeout waiting for auth state to settle"));
-      }, timeoutMs);
+    }
+    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) => {
-        console.log("[AUTH] Auth state changed:", (user == null ? void 0 : user.uid) || "null");
-        if ((user == null ? void 0 : user.uid) === expectedUid) {
-          clearTimeout(timeout);
-          unsubscribe();
-          console.log("[AUTH] Auth state settled successfully for:", expectedUid);
-          resolve();
+        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);
     });
   }
   /**
@@ -16267,6 +16308,9 @@ var AuthService = class extends BaseService {
       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);
@@ -16292,7 +16336,7 @@ var AuthService = class extends BaseService {
    * @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;
@@ -16326,6 +16370,9 @@ var AuthService = class extends BaseService {
         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);
@@ -16337,6 +16384,13 @@ var AuthService = class extends BaseService {
             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] Waiting for auth state to recover...");
+            await this.waitForAuthStateToSettle(firebaseUser2.uid, 2e3);
+          }
           const practitionerService2 = new PractitionerService(this.db, this.auth, this.app);
           const draftProfiles3 = await practitionerService2.getDraftProfilesByEmail(normalizedEmail);
           console.log("[AUTH] Draft profiles check result:", {
@@ -16358,7 +16412,7 @@ var AuthService = class extends BaseService {
             );
           }
           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
@@ -16426,6 +16480,9 @@ var AuthService = class extends BaseService {
         }
         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);
@@ -16495,7 +16552,7 @@ var AuthService = class extends BaseService {
       };
     } 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.15",
+  "version": "1.14.17",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

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

@@ -92,53 +92,102 @@ export class AuthService extends BaseService {
     super(db, auth, app);
     this.userService = userService || new UserService(db, auth, app);
     
-    // DEBUG: Tag the auth instances to track them
-    // @ts-ignore
-    if (!this.auth.__authServiceId) {
-      // @ts-ignore
-      this.auth.__authServiceId = 'auth-service-' + Date.now();
-    }
-    // @ts-ignore
-    console.log('[AUTH] AuthService constructor - auth ID:', this.auth.__authServiceId);
-    // @ts-ignore
-    console.log('[AUTH] AuthService constructor - userService.auth ID:', (this.userService as any).auth?.__authServiceId || 'NOT SET');
+    // Initialize auth state change listener for debugging
+    // This helps track when auth.currentUser changes, which is critical for debugging
+    // the permission-denied issue during user document creation
+    onAuthStateChanged(this.auth, (user) => {
+      const timestamp = new Date().toISOString();
+      const stackTrace = new Error().stack?.split('\n').slice(2, 5).join('\n') || 'N/A';
+      console.log(`[AUTH STATE CHANGE] ${timestamp}`);
+      console.log(`[AUTH STATE CHANGE] User: ${user?.uid || 'NULL'} (email: ${user?.email || 'N/A'})`);
+      console.log(`[AUTH STATE CHANGE] auth.currentUser: ${this.auth.currentUser?.uid || 'NULL'}`);
+      console.log(`[AUTH STATE CHANGE] Stack trace (first 3 frames):\n${stackTrace}`);
+      console.log('[AUTH STATE CHANGE] ---');
+    });
+    
+    // Log initial auth state
+    console.log('[AUTH] AuthService initialized');
+    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 Firebase JS SDK, auth.currentUser doesn't update synchronously
-   * after signInWithCredential. This causes Firestore permission issues.
+   * 
+   * 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 10 seconds)
-   * @returns Promise that resolves when auth state is ready
+   * @param timeoutMs - Maximum time to wait (default 5 seconds)
+   * @returns Promise that resolves when auth state is ready and stable
    */
-  private waitForAuthState(expectedUid: string, timeoutMs: number = 10000): Promise<void> {
-    return new Promise((resolve, reject) => {
-      // If already correct, resolve immediately
+  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 already settled for:', expectedUid);
-        resolve();
+        console.log('[AUTH] ✅ Auth state stable for:', expectedUid);
         return;
       }
+    }
 
-      console.log('[AUTH] Waiting for auth state to settle for:', expectedUid);
+    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;
       
-      const timeout = setTimeout(() => {
-        unsubscribe();
-        console.error('[AUTH] Timeout waiting for auth state');
-        reject(new Error('Timeout waiting for auth state to settle'));
-      }, timeoutMs);
-
+      // Use onAuthStateChanged to wait for auth state to be SET
+      // This is more reliable than polling auth.currentUser
       const unsubscribe = onAuthStateChanged(this.auth, (user) => {
-        console.log('[AUTH] Auth state changed:', user?.uid || 'null');
-        if (user?.uid === expectedUid) {
-          clearTimeout(timeout);
-          unsubscribe();
-          console.log('[AUTH] Auth state settled successfully for:', expectedUid);
-          resolve();
+        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);
     });
   }
 
@@ -1131,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) {
@@ -1211,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);
@@ -1225,6 +1288,17 @@ export class AuthService extends BaseService {
           });
           
           // Check for draft profiles before signing out
+          // CRITICAL: Verify auth.currentUser is still set before Firestore query
+          // AsyncStorage persistence can cause it to become NULL even after being set
+          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] Waiting for auth state to recover...');
+            // Try to wait for it to come back
+            await this.waitForAuthStateToSettle(firebaseUser.uid, 2000);
+          }
+          
           const practitionerService = new PractitionerService(this.db, this.auth, this.app);
           const draftProfiles = await practitionerService.getDraftProfilesByEmail(normalizedEmail);
           
@@ -1341,6 +1415,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 {