@blackcode_sa/metaestetics-api 1.14.2 → 1.14.4

package/dist/index.d.mts

@@ -8410,6 +8410,18 @@ declare class AuthService extends BaseService {
         user: User;
         practitioner: Practitioner;
     }>;
+    /**
+     * Claims draft practitioner profiles after Google Sign-In.
+     * Similar to the token flow - creates User document and claims profiles in one transaction.
+     *
+     * @param idToken - The Google ID token
+     * @param practitionerIds - Array of draft practitioner profile IDs to claim
+     * @returns Object containing user and claimed practitioner
+     */
+    claimDraftProfilesWithGoogle(idToken: string, practitionerIds: string[]): Promise<{
+        user: User;
+        practitioner: Practitioner;
+    }>;
     /**
      * Pre-validate all signup data before any mutations
      * Prevents partial creation by catching issues early

package/dist/index.d.ts

@@ -8410,6 +8410,18 @@ declare class AuthService extends BaseService {
         user: User;
         practitioner: Practitioner;
     }>;
+    /**
+     * Claims draft practitioner profiles after Google Sign-In.
+     * Similar to the token flow - creates User document and claims profiles in one transaction.
+     *
+     * @param idToken - The Google ID token
+     * @param practitionerIds - Array of draft practitioner profile IDs to claim
+     * @returns Object containing user and claimed practitioner
+     */
+    claimDraftProfilesWithGoogle(idToken: string, practitionerIds: string[]): Promise<{
+        user: User;
+        practitioner: Practitioner;
+    }>;
     /**
      * Pre-validate all signup data before any mutations
      * Prevents partial creation by catching issues early

package/dist/index.js

@@ -15908,6 +15908,83 @@ var AuthService = class extends BaseService {
       throw handleSignupError(error);
     }
   }
+  /**
+   * Claims draft practitioner profiles after Google Sign-In.
+   * Similar to the token flow - creates User document and claims profiles in one transaction.
+   * 
+   * @param idToken - The Google ID token
+   * @param practitionerIds - Array of draft practitioner profile IDs to claim
+   * @returns Object containing user and claimed practitioner
+   */
+  async claimDraftProfilesWithGoogle(idToken, practitionerIds) {
+    try {
+      console.log("[AUTH] Starting claim draft profiles with Google", {
+        practitionerIdsCount: practitionerIds.length,
+        practitionerIds
+      });
+      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);
+      const practitionerService = new PractitionerService(this.db, this.auth, this.app);
+      let existingUser = null;
+      try {
+        existingUser = await this.userService.getUserById(firebaseUser.uid);
+        console.log("[AUTH] User document already exists:", existingUser.uid);
+      } catch (userError) {
+        console.log("[AUTH] User document does not exist, will create 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 };
+      });
+      console.log("[AUTH] Draft profiles claimed successfully", {
+        userId: transactionResult.user.uid,
+        practitionerId: transactionResult.practitioner.id
+      });
+      const updatedUser = await this.userService.getUserById(firebaseUser.uid);
+      return {
+        user: updatedUser,
+        practitioner: transactionResult.practitioner
+      };
+    } catch (error) {
+      console.error("[AUTH] Error claiming draft profiles with Google:", error);
+      throw handleSignupError(error);
+    }
+  }
   /**
    * Pre-validate all signup data before any mutations
    * Prevents partial creation by catching issues early
@@ -16117,30 +16194,14 @@ var AuthService = class extends BaseService {
               404
             );
           }
-          console.log("[AUTH] Draft profiles found, attempting to create user document");
+          console.log("[AUTH] Draft profiles found, returning to client for selection");
           const draftProfilesFound = await practitionerService2.getDraftProfilesByEmail(normalizedEmail);
-          try {
-            existingUser2 = await this.userService.createUser(firebaseUser2, ["practitioner" /* PRACTITIONER */], {
-              skipProfileCreation: true
-            });
-            console.log("[AUTH] Created user document for existing Firebase user with draft profiles:", existingUser2.uid);
-          } catch (createError) {
-            console.error("[AUTH] Error creating user document:", {
-              error: createError,
-              code: createError == null ? void 0 : createError.code,
-              message: createError == null ? void 0 : createError.message
-            });
-            try {
-              await (0, import_auth8.signOut)(this.auth);
-            } catch (signOutError) {
-              console.warn("[AUTH] Error signing out Firebase user (non-critical):", signOutError);
-            }
-            throw new AuthError(
-              "Unable to create account. Please use the token provided by your clinic to register, or contact support.",
-              "AUTH/USER_CREATION_FAILED",
-              500
-            );
-          }
+          return {
+            user: null,
+            // Will be created when claiming profiles
+            practitioner: null,
+            draftProfiles: draftProfilesFound
+          };
         }
         if (!existingUser2) {
           await (0, import_auth8.signOut)(this.auth);

package/dist/index.mjs

@@ -15995,6 +15995,83 @@ var AuthService = class extends BaseService {
       throw handleSignupError(error);
     }
   }
+  /**
+   * Claims draft practitioner profiles after Google Sign-In.
+   * Similar to the token flow - creates User document and claims profiles in one transaction.
+   * 
+   * @param idToken - The Google ID token
+   * @param practitionerIds - Array of draft practitioner profile IDs to claim
+   * @returns Object containing user and claimed practitioner
+   */
+  async claimDraftProfilesWithGoogle(idToken, practitionerIds) {
+    try {
+      console.log("[AUTH] Starting claim draft profiles with Google", {
+        practitionerIdsCount: practitionerIds.length,
+        practitionerIds
+      });
+      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);
+      const practitionerService = new PractitionerService(this.db, this.auth, this.app);
+      let existingUser = null;
+      try {
+        existingUser = await this.userService.getUserById(firebaseUser.uid);
+        console.log("[AUTH] User document already exists:", existingUser.uid);
+      } catch (userError) {
+        console.log("[AUTH] User document does not exist, will create 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 };
+      });
+      console.log("[AUTH] Draft profiles claimed successfully", {
+        userId: transactionResult.user.uid,
+        practitionerId: transactionResult.practitioner.id
+      });
+      const updatedUser = await this.userService.getUserById(firebaseUser.uid);
+      return {
+        user: updatedUser,
+        practitioner: transactionResult.practitioner
+      };
+    } catch (error) {
+      console.error("[AUTH] Error claiming draft profiles with Google:", error);
+      throw handleSignupError(error);
+    }
+  }
   /**
    * Pre-validate all signup data before any mutations
    * Prevents partial creation by catching issues early
@@ -16204,30 +16281,14 @@ var AuthService = class extends BaseService {
               404
             );
           }
-          console.log("[AUTH] Draft profiles found, attempting to create user document");
+          console.log("[AUTH] Draft profiles found, returning to client for selection");
           const draftProfilesFound = await practitionerService2.getDraftProfilesByEmail(normalizedEmail);
-          try {
-            existingUser2 = await this.userService.createUser(firebaseUser2, ["practitioner" /* PRACTITIONER */], {
-              skipProfileCreation: true
-            });
-            console.log("[AUTH] Created user document for existing Firebase user with draft profiles:", existingUser2.uid);
-          } catch (createError) {
-            console.error("[AUTH] Error creating user document:", {
-              error: createError,
-              code: createError == null ? void 0 : createError.code,
-              message: createError == null ? void 0 : createError.message
-            });
-            try {
-              await firebaseSignOut(this.auth);
-            } catch (signOutError) {
-              console.warn("[AUTH] Error signing out Firebase user (non-critical):", signOutError);
-            }
-            throw new AuthError(
-              "Unable to create account. Please use the token provided by your clinic to register, or contact support.",
-              "AUTH/USER_CREATION_FAILED",
-              500
-            );
-          }
+          return {
+            user: null,
+            // Will be created when claiming profiles
+            practitioner: null,
+            draftProfiles: draftProfilesFound
+          };
         }
         if (!existingUser2) {
           await firebaseSignOut(this.auth);

package/package.json

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

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

@@ -811,6 +811,109 @@ 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.
+   * 
+   * @param idToken - The Google ID token
+   * @param practitionerIds - Array of draft practitioner profile IDs to claim
+   * @returns Object containing user and claimed practitioner
+   */
+  async claimDraftProfilesWithGoogle(
+    idToken: string,
+    practitionerIds: string[]
+  ): Promise<{
+    user: User;
+    practitioner: Practitioner;
+  }> {
+    try {
+      console.log('[AUTH] Starting claim draft profiles with Google', {
+        practitionerIdsCount: practitionerIds.length,
+        practitionerIds,
+      });
+
+      if (practitionerIds.length === 0) {
+        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);
+
+      const practitionerService = new PractitionerService(this.db, this.auth, this.app);
+
+      // Check if User document already exists
+      let existingUser: User | null = null;
+      try {
+        existingUser = await this.userService.getUserById(firebaseUser.uid);
+        console.log('[AUTH] User document already exists:', existingUser.uid);
+      } catch (userError) {
+        console.log('[AUTH] User document does not exist, will create 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);
+        }
+
+        // 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
+          );
+        }
+
+        // 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,
+          });
+        }
+
+        console.log('[AUTH] Transaction completed successfully');
+        return { user, practitioner };
+      });
+
+      console.log('[AUTH] Draft profiles claimed successfully', {
+        userId: transactionResult.user.uid,
+        practitionerId: transactionResult.practitioner.id,
+      });
+
+      // Fetch updated user (with practitionerProfile reference)
+      const updatedUser = await this.userService.getUserById(firebaseUser.uid);
+
+      return {
+        user: updatedUser,
+        practitioner: transactionResult.practitioner,
+      };
+    } catch (error: any) {
+      console.error('[AUTH] Error claiming draft profiles with Google:', error);
+      throw handleSignupError(error);
+    }
+  }
+
   /**
    * Pre-validate all signup data before any mutations
    * Prevents partial creation by catching issues early
@@ -1099,35 +1202,19 @@ export class AuthService extends BaseService {
             );
           }
           
-          // Draft profiles exist - try to create User document
-          // Firestore rules should allow authenticated users to create their own User document
-          console.log('[AUTH] Draft profiles found, attempting to create user document');
+          // Draft profiles exist - return them to client
+          // User document creation will happen server-side when claiming profiles
+          // This avoids permission issues with client-side User document creation
+          console.log('[AUTH] Draft profiles found, returning to client for selection');
           const draftProfilesFound = await practitionerService.getDraftProfilesByEmail(normalizedEmail);
           
-          try {
-            existingUser = await this.userService.createUser(firebaseUser, [UserRole.PRACTITIONER], {
-              skipProfileCreation: true,
-            });
-            console.log('[AUTH] Created user document for existing Firebase user with draft profiles:', existingUser.uid);
-          } catch (createError: any) {
-            console.error('[AUTH] Error creating user document:', {
-              error: createError,
-              code: createError?.code,
-              message: createError?.message,
-            });
-            // If creation fails, sign out and throw error
-            // User will need to use token flow or contact support
-            try {
-              await firebaseSignOut(this.auth);
-            } catch (signOutError) {
-              console.warn('[AUTH] Error signing out Firebase user (non-critical):', signOutError);
-            }
-            throw new AuthError(
-              'Unable to create account. Please use the token provided by your clinic to register, or contact support.',
-              'AUTH/USER_CREATION_FAILED',
-              500,
-            );
-          }
+          // Return draft profiles without creating User document
+          // The User document will be created server-side via Cloud Function when claiming profiles
+          return {
+            user: null, // Will be created when claiming profiles
+            practitioner: null,
+            draftProfiles: draftProfilesFound,
+          };
         }
         
         // User document exists - check for practitioner profile and draft profiles