@blackcode_sa/metaestetics-api 1.14.4 → 1.14.5

package/dist/index.d.mts

@@ -8412,9 +8412,9 @@ declare class AuthService extends BaseService {
     }>;
     /**
      * Claims draft practitioner profiles after Google Sign-In.
-     * Similar to the token flow - creates User document and claims profiles in one transaction.
+     * Uses the current authenticated user (from initial Google Sign-In).
      *
-     * @param idToken - The Google ID token
+     * @param idToken - The Google ID token (used to re-authenticate if needed)
      * @param practitionerIds - Array of draft practitioner profile IDs to claim
      * @returns Object containing user and claimed practitioner
      */

package/dist/index.d.ts

@@ -8412,9 +8412,9 @@ declare class AuthService extends BaseService {
     }>;
     /**
      * Claims draft practitioner profiles after Google Sign-In.
-     * Similar to the token flow - creates User document and claims profiles in one transaction.
+     * Uses the current authenticated user (from initial Google Sign-In).
      *
-     * @param idToken - The Google ID token
+     * @param idToken - The Google ID token (used to re-authenticate if needed)
      * @param practitionerIds - Array of draft practitioner profile IDs to claim
      * @returns Object containing user and claimed practitioner
      */

package/dist/index.js

@@ -15910,9 +15910,9 @@ var AuthService = class extends BaseService {
   }
   /**
    * Claims draft practitioner profiles after Google Sign-In.
-   * Similar to the token flow - creates User document and claims profiles in one transaction.
+   * Uses the current authenticated user (from initial Google Sign-In).
    * 
-   * @param idToken - The Google ID token
+   * @param idToken - The Google ID token (used to re-authenticate if needed)
    * @param practitionerIds - Array of draft practitioner profile IDs to claim
    * @returns Object containing user and claimed practitioner
    */
@@ -15925,60 +15925,61 @@ var AuthService = class extends BaseService {
       if (practitionerIds.length === 0) {
         throw new AuthError("No practitioner profiles selected to claim", "AUTH/NO_PROFILES_SELECTED", 400);
       }
-      const credential = import_auth8.GoogleAuthProvider.credential(idToken);
-      const { user: firebaseUser } = await (0, import_auth8.signInWithCredential)(this.auth, credential);
-      console.log("[AUTH] Signed in with Google:", firebaseUser.uid);
+      let firebaseUser = this.auth.currentUser;
+      if (!firebaseUser) {
+        console.log("[AUTH] No current user, re-authenticating with Google credential");
+        const credential = import_auth8.GoogleAuthProvider.credential(idToken);
+        const result = await (0, import_auth8.signInWithCredential)(this.auth, credential);
+        firebaseUser = result.user;
+      }
+      console.log("[AUTH] Using Firebase user:", firebaseUser.uid);
+      console.log("[AUTH] Forcing token refresh...");
+      await firebaseUser.getIdToken(true);
+      console.log("[AUTH] Token refreshed successfully");
       const practitionerService = new PractitionerService(this.db, this.auth, this.app);
-      let existingUser = null;
+      let user = null;
       try {
-        existingUser = await this.userService.getUserById(firebaseUser.uid);
-        console.log("[AUTH] User document already exists:", existingUser.uid);
+        user = await this.userService.getUserById(firebaseUser.uid);
+        console.log("[AUTH] User document already exists:", user.uid);
       } catch (userError) {
-        console.log("[AUTH] User document does not exist, will create it");
+        console.log("[AUTH] User document does not exist, creating it...");
       }
-      const transactionResult = await (0, import_firestore40.runTransaction)(this.db, async () => {
-        console.log("[AUTH] Transaction started - creating user and claiming profiles");
-        let user;
-        if (existingUser) {
-          user = existingUser;
-        } else {
-          console.log("[AUTH] Creating user document");
-          user = await this.userService.createUser(firebaseUser, ["practitioner" /* PRACTITIONER */], {
-            skipProfileCreation: true
-          });
-          console.log("[AUTH] User document created:", user.uid);
-        }
-        let practitioner;
-        if (practitionerIds.length === 1) {
-          console.log("[AUTH] Claiming single draft profile");
-          practitioner = await practitionerService.claimDraftProfileWithGoogle(
-            practitionerIds[0],
-            firebaseUser.uid
-          );
-        } else {
-          console.log("[AUTH] Claiming multiple draft profiles");
-          practitioner = await practitionerService.claimMultipleDraftProfilesWithGoogle(
-            practitionerIds,
-            firebaseUser.uid
-          );
-        }
-        if (!user.practitionerProfile || user.practitionerProfile !== practitioner.id) {
-          console.log("[AUTH] Linking practitioner to user");
-          await this.userService.updateUser(firebaseUser.uid, {
-            practitionerProfile: practitioner.id
-          });
-        }
-        console.log("[AUTH] Transaction completed successfully");
-        return { user, practitioner };
-      });
+      if (!user) {
+        console.log("[AUTH] Creating user document for:", firebaseUser.uid);
+        user = await this.userService.createUser(firebaseUser, ["practitioner" /* PRACTITIONER */], {
+          skipProfileCreation: true
+        });
+        console.log("[AUTH] User document created successfully:", user.uid);
+      }
+      let practitioner;
+      if (practitionerIds.length === 1) {
+        console.log("[AUTH] Claiming single draft profile:", practitionerIds[0]);
+        practitioner = await practitionerService.claimDraftProfileWithGoogle(
+          practitionerIds[0],
+          firebaseUser.uid
+        );
+      } else {
+        console.log("[AUTH] Claiming multiple draft profiles:", practitionerIds);
+        practitioner = await practitionerService.claimMultipleDraftProfilesWithGoogle(
+          practitionerIds,
+          firebaseUser.uid
+        );
+      }
+      console.log("[AUTH] Draft profiles claimed:", practitioner.id);
+      if (!user.practitionerProfile || user.practitionerProfile !== practitioner.id) {
+        console.log("[AUTH] Linking practitioner to user");
+        await this.userService.updateUser(firebaseUser.uid, {
+          practitionerProfile: practitioner.id
+        });
+      }
+      const updatedUser = await this.userService.getUserById(firebaseUser.uid);
       console.log("[AUTH] Draft profiles claimed successfully", {
-        userId: transactionResult.user.uid,
-        practitionerId: transactionResult.practitioner.id
+        userId: updatedUser.uid,
+        practitionerId: practitioner.id
       });
-      const updatedUser = await this.userService.getUserById(firebaseUser.uid);
       return {
         user: updatedUser,
-        practitioner: transactionResult.practitioner
+        practitioner
       };
     } catch (error) {
       console.error("[AUTH] Error claiming draft profiles with Google:", error);

package/dist/index.mjs

@@ -15997,9 +15997,9 @@ var AuthService = class extends BaseService {
   }
   /**
    * Claims draft practitioner profiles after Google Sign-In.
-   * Similar to the token flow - creates User document and claims profiles in one transaction.
+   * Uses the current authenticated user (from initial Google Sign-In).
    * 
-   * @param idToken - The Google ID token
+   * @param idToken - The Google ID token (used to re-authenticate if needed)
    * @param practitionerIds - Array of draft practitioner profile IDs to claim
    * @returns Object containing user and claimed practitioner
    */
@@ -16012,60 +16012,61 @@ var AuthService = class extends BaseService {
       if (practitionerIds.length === 0) {
         throw new AuthError("No practitioner profiles selected to claim", "AUTH/NO_PROFILES_SELECTED", 400);
       }
-      const credential = GoogleAuthProvider.credential(idToken);
-      const { user: firebaseUser } = await signInWithCredential(this.auth, credential);
-      console.log("[AUTH] Signed in with Google:", firebaseUser.uid);
+      let firebaseUser = this.auth.currentUser;
+      if (!firebaseUser) {
+        console.log("[AUTH] No current user, re-authenticating with Google credential");
+        const credential = GoogleAuthProvider.credential(idToken);
+        const result = await signInWithCredential(this.auth, credential);
+        firebaseUser = result.user;
+      }
+      console.log("[AUTH] Using Firebase user:", firebaseUser.uid);
+      console.log("[AUTH] Forcing token refresh...");
+      await firebaseUser.getIdToken(true);
+      console.log("[AUTH] Token refreshed successfully");
       const practitionerService = new PractitionerService(this.db, this.auth, this.app);
-      let existingUser = null;
+      let user = null;
       try {
-        existingUser = await this.userService.getUserById(firebaseUser.uid);
-        console.log("[AUTH] User document already exists:", existingUser.uid);
+        user = await this.userService.getUserById(firebaseUser.uid);
+        console.log("[AUTH] User document already exists:", user.uid);
       } catch (userError) {
-        console.log("[AUTH] User document does not exist, will create it");
+        console.log("[AUTH] User document does not exist, creating it...");
       }
-      const transactionResult = await runTransaction(this.db, async () => {
-        console.log("[AUTH] Transaction started - creating user and claiming profiles");
-        let user;
-        if (existingUser) {
-          user = existingUser;
-        } else {
-          console.log("[AUTH] Creating user document");
-          user = await this.userService.createUser(firebaseUser, ["practitioner" /* PRACTITIONER */], {
-            skipProfileCreation: true
-          });
-          console.log("[AUTH] User document created:", user.uid);
-        }
-        let practitioner;
-        if (practitionerIds.length === 1) {
-          console.log("[AUTH] Claiming single draft profile");
-          practitioner = await practitionerService.claimDraftProfileWithGoogle(
-            practitionerIds[0],
-            firebaseUser.uid
-          );
-        } else {
-          console.log("[AUTH] Claiming multiple draft profiles");
-          practitioner = await practitionerService.claimMultipleDraftProfilesWithGoogle(
-            practitionerIds,
-            firebaseUser.uid
-          );
-        }
-        if (!user.practitionerProfile || user.practitionerProfile !== practitioner.id) {
-          console.log("[AUTH] Linking practitioner to user");
-          await this.userService.updateUser(firebaseUser.uid, {
-            practitionerProfile: practitioner.id
-          });
-        }
-        console.log("[AUTH] Transaction completed successfully");
-        return { user, practitioner };
-      });
+      if (!user) {
+        console.log("[AUTH] Creating user document for:", firebaseUser.uid);
+        user = await this.userService.createUser(firebaseUser, ["practitioner" /* PRACTITIONER */], {
+          skipProfileCreation: true
+        });
+        console.log("[AUTH] User document created successfully:", user.uid);
+      }
+      let practitioner;
+      if (practitionerIds.length === 1) {
+        console.log("[AUTH] Claiming single draft profile:", practitionerIds[0]);
+        practitioner = await practitionerService.claimDraftProfileWithGoogle(
+          practitionerIds[0],
+          firebaseUser.uid
+        );
+      } else {
+        console.log("[AUTH] Claiming multiple draft profiles:", practitionerIds);
+        practitioner = await practitionerService.claimMultipleDraftProfilesWithGoogle(
+          practitionerIds,
+          firebaseUser.uid
+        );
+      }
+      console.log("[AUTH] Draft profiles claimed:", practitioner.id);
+      if (!user.practitionerProfile || user.practitionerProfile !== practitioner.id) {
+        console.log("[AUTH] Linking practitioner to user");
+        await this.userService.updateUser(firebaseUser.uid, {
+          practitionerProfile: practitioner.id
+        });
+      }
+      const updatedUser = await this.userService.getUserById(firebaseUser.uid);
       console.log("[AUTH] Draft profiles claimed successfully", {
-        userId: transactionResult.user.uid,
-        practitionerId: transactionResult.practitioner.id
+        userId: updatedUser.uid,
+        practitionerId: practitioner.id
       });
-      const updatedUser = await this.userService.getUserById(firebaseUser.uid);
       return {
         user: updatedUser,
-        practitioner: transactionResult.practitioner
+        practitioner
       };
     } catch (error) {
       console.error("[AUTH] Error claiming draft profiles with Google:", error);

package/package.json

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

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

@@ -813,9 +813,9 @@ export class AuthService extends BaseService {
 
   /**
    * Claims draft practitioner profiles after Google Sign-In.
-   * Similar to the token flow - creates User document and claims profiles in one transaction.
+   * Uses the current authenticated user (from initial Google Sign-In).
    * 
-   * @param idToken - The Google ID token
+   * @param idToken - The Google ID token (used to re-authenticate if needed)
    * @param practitionerIds - Array of draft practitioner profile IDs to claim
    * @returns Object containing user and claimed practitioner
    */
@@ -836,77 +836,77 @@ export class AuthService extends BaseService {
         throw new AuthError('No practitioner profiles selected to claim', 'AUTH/NO_PROFILES_SELECTED', 400);
       }
 
-      // Sign in with Google credential
-      const credential = GoogleAuthProvider.credential(idToken);
-      const { user: firebaseUser } = await signInWithCredential(this.auth, credential);
-      console.log('[AUTH] Signed in with Google:', firebaseUser.uid);
+      // Check if user is currently signed in, if not re-authenticate
+      let firebaseUser = this.auth.currentUser;
+      if (!firebaseUser) {
+        console.log('[AUTH] No current user, re-authenticating with Google credential');
+        const credential = GoogleAuthProvider.credential(idToken);
+        const result = await signInWithCredential(this.auth, credential);
+        firebaseUser = result.user;
+      }
+      console.log('[AUTH] Using Firebase user:', firebaseUser.uid);
+
+      // Force token refresh to ensure Firestore has fresh auth context
+      console.log('[AUTH] Forcing token refresh...');
+      await firebaseUser.getIdToken(true);
+      console.log('[AUTH] Token refreshed successfully');
 
       const practitionerService = new PractitionerService(this.db, this.auth, this.app);
 
-      // Check if User document already exists
-      let existingUser: User | null = null;
+      // Step 1: Check if User document already exists
+      let user: User | null = null;
       try {
-        existingUser = await this.userService.getUserById(firebaseUser.uid);
-        console.log('[AUTH] User document already exists:', existingUser.uid);
+        user = await this.userService.getUserById(firebaseUser.uid);
+        console.log('[AUTH] User document already exists:', user.uid);
       } catch (userError) {
-        console.log('[AUTH] User document does not exist, will create it');
+        console.log('[AUTH] User document does not exist, creating it...');
       }
 
-      // Execute all operations in a transaction (similar to token flow)
-      const transactionResult = await runTransaction(this.db, async () => {
-        console.log('[AUTH] Transaction started - creating user and claiming profiles');
-
-        // Create user document if it doesn't exist
-        let user: User;
-        if (existingUser) {
-          user = existingUser;
-        } else {
-          console.log('[AUTH] Creating user document');
-          user = await this.userService.createUser(firebaseUser, [UserRole.PRACTITIONER], {
-            skipProfileCreation: true,
-          });
-          console.log('[AUTH] User document created:', user.uid);
-        }
+      // Step 2: Create User document if it doesn't exist (NOT in transaction - matches token flow)
+      if (!user) {
+        console.log('[AUTH] Creating user document for:', firebaseUser.uid);
+        user = await this.userService.createUser(firebaseUser, [UserRole.PRACTITIONER], {
+          skipProfileCreation: true,
+        });
+        console.log('[AUTH] User document created successfully:', user.uid);
+      }
 
-        // Claim the draft profiles
-        let practitioner: Practitioner;
-        if (practitionerIds.length === 1) {
-          console.log('[AUTH] Claiming single draft profile');
-          practitioner = await practitionerService.claimDraftProfileWithGoogle(
-            practitionerIds[0],
-            firebaseUser.uid
-          );
-        } else {
-          console.log('[AUTH] Claiming multiple draft profiles');
-          practitioner = await practitionerService.claimMultipleDraftProfilesWithGoogle(
-            practitionerIds,
-            firebaseUser.uid
-          );
-        }
+      // Step 3: Claim the draft profiles
+      let practitioner: Practitioner;
+      if (practitionerIds.length === 1) {
+        console.log('[AUTH] Claiming single draft profile:', practitionerIds[0]);
+        practitioner = await practitionerService.claimDraftProfileWithGoogle(
+          practitionerIds[0],
+          firebaseUser.uid
+        );
+      } else {
+        console.log('[AUTH] Claiming multiple draft profiles:', practitionerIds);
+        practitioner = await practitionerService.claimMultipleDraftProfilesWithGoogle(
+          practitionerIds,
+          firebaseUser.uid
+        );
+      }
+      console.log('[AUTH] Draft profiles claimed:', practitioner.id);
 
-        // Link practitioner to user (if not already linked)
-        if (!user.practitionerProfile || user.practitionerProfile !== practitioner.id) {
-          console.log('[AUTH] Linking practitioner to user');
-          await this.userService.updateUser(firebaseUser.uid, {
-            practitionerProfile: practitioner.id,
-          });
-        }
+      // Step 4: Link practitioner to user
+      if (!user.practitionerProfile || user.practitionerProfile !== practitioner.id) {
+        console.log('[AUTH] Linking practitioner to user');
+        await this.userService.updateUser(firebaseUser.uid, {
+          practitionerProfile: practitioner.id,
+        });
+      }
 
-        console.log('[AUTH] Transaction completed successfully');
-        return { user, practitioner };
-      });
+      // Fetch updated user (with practitionerProfile reference)
+      const updatedUser = await this.userService.getUserById(firebaseUser.uid);
 
       console.log('[AUTH] Draft profiles claimed successfully', {
-        userId: transactionResult.user.uid,
-        practitionerId: transactionResult.practitioner.id,
+        userId: updatedUser.uid,
+        practitionerId: practitioner.id,
       });
 
-      // Fetch updated user (with practitionerProfile reference)
-      const updatedUser = await this.userService.getUserById(firebaseUser.uid);
-
       return {
         user: updatedUser,
-        practitioner: transactionResult.practitioner,
+        practitioner,
       };
     } catch (error: any) {
       console.error('[AUTH] Error claiming draft profiles with Google:', error);