@blackcode_sa/metaestetics-api 1.7.41 → 1.7.43

package/src/services/auth.service.ts

@@ -17,18 +17,24 @@ import {
   sendPasswordResetEmail,
   verifyPasswordResetCode,
   confirmPasswordReset,
+  fetchSignInMethodsForEmail,
 } from "firebase/auth";
 import {
+  getFirestore,
+  collection,
   doc,
-  setDoc,
   getDoc,
-  serverTimestamp,
-  collection,
+  setDoc,
+  updateDoc,
+  deleteDoc,
   query,
   where,
   getDocs,
+  orderBy,
+  limit,
+  startAfter,
   Timestamp,
-  updateDoc,
+  runTransaction,
   Firestore,
 } from "firebase/firestore";
 import { FirebaseApp } from "firebase/app";
@@ -72,6 +78,15 @@ import { PractitionerService } from "./practitioner/practitioner.service";
 import { practitionerSignupSchema } from "../validations/practitioner.schema";
 import { CertificationLevel } from "../backoffice/types/static/certification.types";
 import { MediaService } from "./media/media.service";
+// Import utility functions
+import {
+  checkEmailExists,
+  cleanupFirebaseUser,
+  handleFirebaseError,
+  handleSignupError,
+  buildPractitionerData,
+  validatePractitionerProfileData,
+} from "./auth/utils";
 
 export class AuthService extends BaseService {
   private googleProvider = new GoogleAuthProvider();
@@ -83,15 +98,10 @@ export class AuthService extends BaseService {
     db: Firestore,
     auth: Auth,
     app: FirebaseApp,
-    userService?: UserService
+    userService: UserService
   ) {
     super(db, auth, app);
-
-    // Kreiramo UserService ako nije prosleđen
-    if (!userService) {
-      userService = new UserService(db, auth, app);
-    }
-    this.userService = userService;
+    this.userService = userService || new UserService(db, auth, app);
   }
 
   /**
@@ -155,7 +165,7 @@ export class AuthService extends BaseService {
         });
       } catch (firebaseError) {
         console.error("[AUTH] Firebase user creation failed:", firebaseError);
-        throw firebaseError;
+        throw handleFirebaseError(firebaseError);
       }
 
       // Create user with CLINIC_ADMIN role
@@ -879,8 +889,8 @@ export class AuthService extends BaseService {
   }
 
   /**
-   * Registers a new practitioner user with email and password
-   * Can either create a new practitioner profile or claim an existing draft profile with a token
+   * Registers a new practitioner user with email and password (ATOMIC VERSION)
+   * Uses Firestore transactions to ensure atomicity and proper rollback on failures
    *
    * @param data - Practitioner signup data containing either new profile details or token for claiming draft profile
    * @returns Object containing the created user and practitioner profile
@@ -896,27 +906,19 @@ export class AuthService extends BaseService {
     user: User;
     practitioner: Practitioner;
   }> {
+    let firebaseUser: any = null;
+
     try {
-      console.log("[AUTH] Starting practitioner signup process", {
+      console.log("[AUTH] Starting atomic practitioner signup process", {
         email: data.email,
         hasToken: !!data.token,
       });
 
-      // Validate data
-      try {
-        await practitionerSignupSchema.parseAsync(data);
-        console.log("[AUTH] Practitioner signup data validation passed");
-      } catch (validationError) {
-        console.error(
-          "[AUTH] Validation error in signUpPractitioner:",
-          validationError
-        );
-        throw validationError;
-      }
+      // Step 1: Pre-validate all data before any mutations
+      await this.validateSignupData(data);
 
-      // Create Firebase user
+      // Step 2: Create Firebase user (outside transaction - can't be easily rolled back)
       console.log("[AUTH] Creating Firebase user");
-      let firebaseUser;
       try {
         const result = await createUserWithEmailAndPassword(
           this.auth,
@@ -929,159 +931,145 @@ export class AuthService extends BaseService {
         });
       } catch (firebaseError) {
         console.error("[AUTH] Firebase user creation failed:", firebaseError);
-        throw firebaseError;
+        throw handleFirebaseError(firebaseError);
       }
 
-      // Create user with PRACTITIONER role
-      console.log("[AUTH] Creating user with PRACTITIONER role");
-      let user;
-      try {
-        user = await this.userService.createUser(
-          firebaseUser,
-          [UserRole.PRACTITIONER],
-          {
-            skipProfileCreation: true, // We'll create the profile separately
-          }
-        );
-        console.log("[AUTH] User with PRACTITIONER role created successfully", {
-          userId: user.uid,
-        });
-      } catch (userCreationError) {
-        console.error("[AUTH] User creation failed:", userCreationError);
-        throw userCreationError;
-      }
-
-      // Initialize practitioner service
-      console.log("[AUTH] Initializing practitioner service");
-      const practitionerService = new PractitionerService(
+      // Step 3: Execute all database operations in a single transaction
+      console.log("[AUTH] Starting Firestore transaction");
+      const transactionResult = await runTransaction(
         this.db,
-        this.auth,
-        this.app
-      );
-
-      let practitioner: Practitioner | null = null;
+        async (transaction) => {
+          console.log(
+            "[AUTH] Transaction started - creating user and practitioner"
+          );
 
-      // Check if we're claiming an existing draft profile with a token
-      if (data.token) {
-        console.log("[AUTH] Token provided, attempting to claim draft profile");
+          // Initialize services
+          const practitionerService = new PractitionerService(
+            this.db,
+            this.auth,
+            this.app
+          );
 
-        try {
-          // Validate token and claim the profile
-          practitioner = await practitionerService.validateTokenAndClaimProfile(
-            data.token,
-            firebaseUser.uid
+          // Create user document using existing method (not in transaction for now)
+          console.log("[AUTH] Creating user document");
+          const user = await this.userService.createUser(
+            firebaseUser,
+            [UserRole.PRACTITIONER],
+            { skipProfileCreation: true }
           );
 
-          if (!practitioner) {
-            throw new Error("Invalid or expired invitation token");
+          let practitioner: Practitioner;
+
+          // Handle practitioner profile creation/claiming
+          if (data.token) {
+            console.log(
+              "[AUTH] Claiming existing practitioner profile with token"
+            );
+            const claimedPractitioner =
+              await practitionerService.validateTokenAndClaimProfile(
+                data.token,
+                firebaseUser.uid
+              );
+            if (!claimedPractitioner) {
+              throw new Error("Invalid or expired invitation token");
+            }
+            practitioner = claimedPractitioner;
+          } else {
+            console.log("[AUTH] Creating new practitioner profile");
+            const practitionerData = buildPractitionerData(
+              data,
+              firebaseUser.uid
+            );
+            practitioner = await practitionerService.createPractitioner(
+              practitionerData
+            );
           }
 
-          console.log("[AUTH] Successfully claimed draft profile", {
-            practitionerId: practitioner.id,
-          });
-
-          // Link the practitioner profile to the user
+          // Link practitioner to user
+          console.log("[AUTH] Linking practitioner to user");
           await this.userService.updateUser(firebaseUser.uid, {
             practitionerProfile: practitioner.id,
           });
-          console.log(
-            "[AUTH] User updated with practitioner profile reference"
-          );
-        } catch (tokenError) {
-          console.error("[AUTH] Failed to claim draft profile:", tokenError);
-          throw tokenError;
-        }
-      } else {
-        console.log("[AUTH] Creating new practitioner profile");
 
-        if (!data.profileData) {
-          data.profileData = {};
+          console.log("[AUTH] Transaction operations completed successfully");
+          return { user, practitioner };
         }
+      );
 
-        // We need to create a full PractitionerBasicInfo object
-        const basicInfo: PractitionerBasicInfo = {
-          firstName: data.firstName || "",
-          lastName: data.lastName || "",
-          email: data.email,
-          phoneNumber: data.profileData.basicInfo?.phoneNumber || "",
-          profileImageUrl: data.profileData.basicInfo?.profileImageUrl || "",
-          gender: data.profileData.basicInfo?.gender || "other", // Default to "other" if not provided
-          bio: data.profileData.basicInfo?.bio || "",
-          title: "Practitioner", // Default title
-          dateOfBirth: new Date(), // Default to today
-          languages: ["English"], // Default language
-        };
+      console.log("[AUTH] Atomic practitioner signup completed successfully", {
+        userId: transactionResult.user.uid,
+        practitionerId: transactionResult.practitioner.id,
+      });
 
-        // Basic certification information with placeholders
-        const certification: PractitionerCertification = data.profileData
-          .certification || {
-          level: CertificationLevel.AESTHETICIAN,
-          specialties: [],
-          licenseNumber: "Pending",
-          issuingAuthority: "Pending",
-          issueDate: new Date(),
-          verificationStatus: "pending",
-        };
+      return transactionResult;
+    } catch (error) {
+      console.error(
+        "[AUTH] Atomic signup failed, initiating cleanup...",
+        error
+      );
 
-        // Create basic profile data
-        const createPractitionerData: CreatePractitionerData = {
-          userRef: firebaseUser.uid,
-          basicInfo,
-          certification,
-          status: PractitionerStatus.ACTIVE,
-          isActive: true,
-          isVerified: false,
-        };
+      // Cleanup Firebase user if transaction failed
+      if (firebaseUser) {
+        await cleanupFirebaseUser(firebaseUser);
+      }
 
-        try {
-          practitioner = await practitionerService.createPractitioner(
-            createPractitionerData
-          );
-          console.log("[AUTH] Practitioner profile created successfully", {
-            practitionerId: practitioner.id,
-          });
+      throw handleSignupError(error);
+    }
+  }
 
-          // Link the practitioner profile to the user
-          await this.userService.updateUser(firebaseUser.uid, {
-            practitionerProfile: practitioner.id,
-          });
-          console.log(
-            "[AUTH] User updated with practitioner profile reference"
-          );
-        } catch (createError) {
-          console.error(
-            "[AUTH] Failed to create practitioner profile:",
-            createError
-          );
-          throw createError;
-        }
-      }
+  /**
+   * Pre-validate all signup data before any mutations
+   * Prevents partial creation by catching issues early
+   */
+  private async validateSignupData(data: {
+    email: string;
+    password: string;
+    firstName?: string;
+    lastName?: string;
+    token?: string;
+    profileData?: Partial<CreatePractitionerData>;
+  }): Promise<void> {
+    console.log("[AUTH] Pre-validating signup data");
 
-      console.log("[AUTH] Practitioner signup completed successfully", {
-        userId: user.uid,
-        practitionerId: practitioner?.id || "unknown",
-      });
+    try {
+      // 1. Schema validation
+      await practitionerSignupSchema.parseAsync(data);
+      console.log("[AUTH] Schema validation passed");
+
+      // 2. Check if email already exists (before creating Firebase user)
+      const emailExists = await checkEmailExists(this.auth, data.email);
+      if (emailExists) {
+        console.log("[AUTH] Email already exists:", data.email);
+        throw AUTH_ERRORS.EMAIL_ALREADY_EXISTS;
+      }
+      console.log("[AUTH] Email availability confirmed");
 
-      return {
-        user,
-        practitioner,
-      };
-    } catch (error) {
-      if (error instanceof z.ZodError) {
-        console.error(
-          "[AUTH] Zod validation error in signUpPractitioner:",
-          JSON.stringify(error.errors, null, 2)
+      // 3. Validate token if provided
+      if (data.token) {
+        const practitionerService = new PractitionerService(
+          this.db,
+          this.auth,
+          this.app
         );
-        throw AUTH_ERRORS.VALIDATION_ERROR;
+        const isValidToken = await practitionerService.validateToken(
+          data.token
+        );
+        if (!isValidToken) {
+          console.log("[AUTH] Invalid token provided:", data.token);
+          throw new Error("Invalid or expired invitation token");
+        }
+        console.log("[AUTH] Token validation passed");
       }
 
-      const firebaseError = error as FirebaseError;
-      if (firebaseError.code === FirebaseErrorCode.EMAIL_ALREADY_IN_USE) {
-        console.error("[AUTH] Email already in use:", data.email);
-        throw AUTH_ERRORS.EMAIL_ALREADY_EXISTS;
+      // 4. Validate profile data structure if provided
+      if (data.profileData) {
+        await validatePractitionerProfileData(data.profileData);
+        console.log("[AUTH] Profile data validation passed");
       }
 
-      console.error("[AUTH] Unhandled error in signUpPractitioner:", error);
+      console.log("[AUTH] All pre-validation checks passed");
+    } catch (error) {
+      console.error("[AUTH] Pre-validation failed:", error);
       throw error;
     }
   }

package/src/services/practitioner/practitioner.service.ts

@@ -110,7 +110,7 @@ export class PractitionerService extends BaseService {
    * @returns URL string of the uploaded or existing photo
    */
   private async handleProfilePhotoUpload(
-    profilePhoto: MediaResource | undefined,
+    profilePhoto: MediaResource | undefined | null,
     practitionerId: string
   ): Promise<string | undefined> {
     if (!profilePhoto) {
@@ -151,7 +151,9 @@ export class PractitionerService extends BaseService {
    * @returns Processed basic info with URL string for profileImageUrl
    */
   private async processBasicInfo(
-    basicInfo: PractitionerBasicInfo & { profileImageUrl?: MediaResource },
+    basicInfo: PractitionerBasicInfo & {
+      profileImageUrl?: MediaResource | null;
+    },
     practitionerId: string
   ): Promise<PractitionerBasicInfo> {
     const processedBasicInfo = { ...basicInfo };
@@ -723,7 +725,7 @@ export class PractitionerService extends BaseService {
       if (validData.basicInfo) {
         processedData.basicInfo = await this.processBasicInfo(
           validData.basicInfo as PractitionerBasicInfo & {
-            profileImageUrl?: MediaResource;
+            profileImageUrl?: MediaResource | null;
           },
           practitionerId
         );

package/src/types/index.ts

@@ -14,9 +14,9 @@ export interface User {
   email: string | null;
   roles: UserRole[];
   isAnonymous: boolean;
-  createdAt: Timestamp | FieldValue;
-  updatedAt: Timestamp | FieldValue;
-  lastLoginAt: Timestamp | FieldValue;
+  createdAt: Timestamp | FieldValue | Date;
+  updatedAt: Timestamp | FieldValue | Date;
+  lastLoginAt: Timestamp | FieldValue | Date;
   patientProfile?: string;
   practitionerProfile?: string;
   adminProfile?: string;

package/src/types/practitioner/index.ts

@@ -24,10 +24,10 @@ export interface PractitionerBasicInfo {
   lastName: string;
   title: string;
   email: string;
-  phoneNumber: string;
-  dateOfBirth: Timestamp | Date;
+  phoneNumber: string | null;
+  dateOfBirth: Timestamp | Date | null;
   gender: "male" | "female" | "other";
-  profileImageUrl?: MediaResource;
+  profileImageUrl?: MediaResource | null;
   bio?: string;
   languages: string[];
 }
@@ -41,7 +41,7 @@ export interface PractitionerCertification {
   licenseNumber: string;
   issuingAuthority: string;
   issueDate: Timestamp | Date;
-  expiryDate?: Timestamp | Date;
+  expiryDate?: Timestamp | Date | null;
   verificationStatus: "pending" | "verified" | "rejected";
 }
 

package/src/validations/common.schema.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { Timestamp } from "firebase/firestore";
 
-// Create a custom schema for Timestamp that properly handles both raw objects and Timestamp instances
+// Create a custom schema for Timestamp that properly handles Timestamp instances, raw objects, and Date objects
 export const timestampSchema = z
   .union([
     z.object({
@@ -9,11 +9,16 @@ export const timestampSchema = z
       nanoseconds: z.number(),
     }),
     z.instanceof(Timestamp),
+    z.instanceof(Date), // Add support for Date objects that Firestore returns on client
   ])
   .transform((data) => {
     if (data instanceof Timestamp) {
       return data;
     }
+    if (data instanceof Date) {
+      // Convert Date back to Timestamp for consistency
+      return Timestamp.fromDate(data);
+    }
     return new Timestamp(data.seconds, data.nanoseconds);
   });
 

package/src/validations/practitioner.schema.ts

@@ -25,10 +25,13 @@ export const practitionerBasicInfoSchema = z.object({
   lastName: z.string().min(2).max(50),
   title: z.string().min(2).max(100),
   email: z.string().email(),
-  phoneNumber: z.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number"),
-  dateOfBirth: z.instanceof(Timestamp).or(z.date()),
+  phoneNumber: z
+    .string()
+    .regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number")
+    .nullable(),
+  dateOfBirth: z.instanceof(Timestamp).or(z.date()).nullable(),
   gender: z.enum(["male", "female", "other"]),
-  profileImageUrl: mediaResourceSchema.optional(),
+  profileImageUrl: mediaResourceSchema.optional().nullable(),
   bio: z.string().max(1000).optional(),
   languages: z.array(z.string()).min(1),
 });
@@ -42,7 +45,7 @@ export const practitionerCertificationSchema = z.object({
   licenseNumber: z.string().min(3).max(50),
   issuingAuthority: z.string().min(2).max(100),
   issueDate: z.instanceof(Timestamp).or(z.date()),
-  expiryDate: z.instanceof(Timestamp).or(z.date()).optional(),
+  expiryDate: z.instanceof(Timestamp).or(z.date()).optional().nullable(),
   verificationStatus: z.enum(["pending", "verified", "rejected"]),
 });
 

package/src/validations/schemas.ts

@@ -24,21 +24,33 @@ export const userRolesSchema = z
   .min(1, "User must have at least one role")
   .max(3, "User cannot have more than 3 roles");
 
-export const timestampSchema = z.custom<Timestamp | FieldValue>((data) => {
-  // If it's a serverTimestamp (FieldValue), it's valid
-  if (data && typeof data === "object" && "isEqual" in data) {
-    return true;
-  }
+export const timestampSchema = z.custom<Timestamp | FieldValue | Date>(
+  (data) => {
+    // If it's a serverTimestamp (FieldValue), it's valid
+    if (data && typeof data === "object" && "isEqual" in data) {
+      return true;
+    }
 
-  // If it's a Timestamp object, validate its structure
-  return (
-    data &&
-    typeof data === "object" &&
-    "toDate" in data &&
-    "seconds" in data &&
-    "nanoseconds" in data
-  );
-}, "Must be a Timestamp object or serverTimestamp");
+    // If it's a Timestamp object, validate its structure
+    if (
+      data &&
+      typeof data === "object" &&
+      "toDate" in data &&
+      "seconds" in data &&
+      "nanoseconds" in data
+    ) {
+      return true;
+    }
+
+    // If it's a JavaScript Date object (what Firestore returns on client), it's valid
+    if (data instanceof Date) {
+      return true;
+    }
+
+    return false;
+  },
+  "Must be a Timestamp object, Date object, or serverTimestamp"
+);
 
 /**
  * Validaciona šema za clinic admin opcije pri kreiranju