@blackcode_sa/metaestetics-api 1.7.41 → 1.7.43

package/dist/index.js

@@ -825,7 +825,7 @@ var getFirebaseApp = async () => {
 };
 
 // src/services/auth.service.ts
-var import_auth5 = require("firebase/auth");
+var import_auth7 = require("firebase/auth");
 var import_firestore25 = require("firebase/firestore");
 
 // src/types/calendar/index.ts
@@ -871,7 +871,7 @@ var UserRole = /* @__PURE__ */ ((UserRole2) => {
 var USERS_COLLECTION = "users";
 
 // src/services/auth.service.ts
-var import_zod20 = require("zod");
+var import_zod22 = require("zod");
 
 // src/validations/schemas.ts
 var import_zod4 = require("zod");
@@ -882,12 +882,21 @@ var passwordSchema = import_zod4.z.string().min(8, "Password must be at least 8
 );
 var userRoleSchema = import_zod4.z.nativeEnum(UserRole);
 var userRolesSchema = import_zod4.z.array(userRoleSchema).min(1, "User must have at least one role").max(3, "User cannot have more than 3 roles");
-var timestampSchema = import_zod4.z.custom((data) => {
-  if (data && typeof data === "object" && "isEqual" in data) {
-    return true;
-  }
-  return data && typeof data === "object" && "toDate" in data && "seconds" in data && "nanoseconds" in data;
-}, "Must be a Timestamp object or serverTimestamp");
+var timestampSchema = import_zod4.z.custom(
+  (data) => {
+    if (data && typeof data === "object" && "isEqual" in data) {
+      return true;
+    }
+    if (data && typeof data === "object" && "toDate" in data && "seconds" in data && "nanoseconds" in data) {
+      return true;
+    }
+    if (data instanceof Date) {
+      return true;
+    }
+    return false;
+  },
+  "Must be a Timestamp object, Date object, or serverTimestamp"
+);
 var clinicAdminOptionsSchema = import_zod4.z.object({
   isGroupOwner: import_zod4.z.boolean(),
   groupToken: import_zod4.z.string().optional(),
@@ -1700,11 +1709,16 @@ var timestampSchema2 = import_zod5.z.union([
     seconds: import_zod5.z.number(),
     nanoseconds: import_zod5.z.number()
   }),
-  import_zod5.z.instanceof(import_firestore4.Timestamp)
+  import_zod5.z.instanceof(import_firestore4.Timestamp),
+  import_zod5.z.instanceof(Date)
+  // Add support for Date objects that Firestore returns on client
 ]).transform((data) => {
   if (data instanceof import_firestore4.Timestamp) {
     return data;
   }
+  if (data instanceof Date) {
+    return import_firestore4.Timestamp.fromDate(data);
+  }
   return new import_firestore4.Timestamp(data.seconds, data.nanoseconds);
 });
 
@@ -4618,10 +4632,10 @@ var practitionerBasicInfoSchema = import_zod14.z.object({
   lastName: import_zod14.z.string().min(2).max(50),
   title: import_zod14.z.string().min(2).max(100),
   email: import_zod14.z.string().email(),
-  phoneNumber: import_zod14.z.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number"),
-  dateOfBirth: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()),
+  phoneNumber: import_zod14.z.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number").nullable(),
+  dateOfBirth: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()).nullable(),
   gender: import_zod14.z.enum(["male", "female", "other"]),
-  profileImageUrl: mediaResourceSchema.optional(),
+  profileImageUrl: mediaResourceSchema.optional().nullable(),
   bio: import_zod14.z.string().max(1e3).optional(),
   languages: import_zod14.z.array(import_zod14.z.string()).min(1)
 });
@@ -4631,7 +4645,7 @@ var practitionerCertificationSchema = import_zod14.z.object({
   licenseNumber: import_zod14.z.string().min(3).max(50),
   issuingAuthority: import_zod14.z.string().min(2).max(100),
   issueDate: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()),
-  expiryDate: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()).optional(),
+  expiryDate: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()).optional().nullable(),
   verificationStatus: import_zod14.z.enum(["pending", "verified", "rejected"])
 });
 var timeSlotSchema = import_zod14.z.object({
@@ -7735,23 +7749,139 @@ var ClinicService = class extends BaseService {
   }
 };
 
+// src/services/auth/utils/firebase.utils.ts
+var import_auth5 = require("firebase/auth");
+var checkEmailExists = async (auth, email) => {
+  try {
+    const methods = await (0, import_auth5.fetchSignInMethodsForEmail)(auth, email);
+    return methods.length > 0;
+  } catch (error) {
+    console.warn(
+      "[FIREBASE] Could not check email existence, allowing signup to proceed:",
+      error
+    );
+    return false;
+  }
+};
+var cleanupFirebaseUser = async (firebaseUser) => {
+  try {
+    console.log("[FIREBASE] Cleaning up Firebase user", {
+      uid: firebaseUser.uid
+    });
+    await firebaseUser.delete();
+    console.log("[FIREBASE] Firebase user cleanup successful");
+  } catch (cleanupError) {
+    console.error("[FIREBASE] Failed to cleanup Firebase user:", cleanupError);
+  }
+};
+
+// src/services/auth/utils/error.utils.ts
+var import_zod20 = require("zod");
+var handleFirebaseError = (error) => {
+  const firebaseError = error;
+  switch (firebaseError.code) {
+    case "auth/email-already-in-use" /* EMAIL_ALREADY_IN_USE */:
+      return AUTH_ERRORS.EMAIL_ALREADY_EXISTS;
+    case "auth/weak-password":
+      return new Error(
+        "Password is too weak. Please choose a stronger password."
+      );
+    case "auth/invalid-email":
+      return new Error("Please enter a valid email address.");
+    case "auth/network-request-failed":
+      return new Error(
+        "Network error. Please check your internet connection and try again."
+      );
+    default:
+      return new Error(
+        `Account creation failed: ${firebaseError.message || "Unknown error"}`
+      );
+  }
+};
+var handleSignupError = (error) => {
+  if (error instanceof import_zod20.z.ZodError) {
+    const errorMessages = error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+    return new Error(`Validation failed: ${errorMessages}`);
+  }
+  if (error.code && error.code.startsWith("auth/")) {
+    return handleFirebaseError(error);
+  }
+  if (error.message && error.message.includes("token")) {
+    return new Error("Invalid or expired invitation token");
+  }
+  if (error.message && error.message.includes("validation")) {
+    return new Error(`Invalid practitioner data: ${error.message}`);
+  }
+  return new Error(
+    `Registration failed: ${error.message || "Unknown error occurred"}`
+  );
+};
+
+// src/services/auth/utils/practitioner.utils.ts
+var import_zod21 = require("zod");
+var profileDataSchema = import_zod21.z.object({
+  basicInfo: practitionerBasicInfoSchema.partial().optional(),
+  certification: practitionerCertificationSchema.partial().optional()
+}).partial();
+var buildPractitionerData = (data, userRef) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const basicInfo = {
+    firstName: data.firstName || "Name",
+    lastName: data.lastName || "Surname",
+    email: data.email,
+    phoneNumber: ((_b = (_a = data.profileData) == null ? void 0 : _a.basicInfo) == null ? void 0 : _b.phoneNumber) || null,
+    profileImageUrl: ((_d = (_c = data.profileData) == null ? void 0 : _c.basicInfo) == null ? void 0 : _d.profileImageUrl) || "",
+    gender: ((_f = (_e = data.profileData) == null ? void 0 : _e.basicInfo) == null ? void 0 : _f.gender) || "other",
+    bio: ((_h = (_g = data.profileData) == null ? void 0 : _g.basicInfo) == null ? void 0 : _h.bio) || "",
+    title: "Practitioner",
+    dateOfBirth: ((_j = (_i = data.profileData) == null ? void 0 : _i.basicInfo) == null ? void 0 : _j.dateOfBirth) || /* @__PURE__ */ new Date(),
+    languages: ((_l = (_k = data.profileData) == null ? void 0 : _k.basicInfo) == null ? void 0 : _l.languages) || ["English"]
+  };
+  const certification = ((_m = data.profileData) == null ? void 0 : _m.certification) || {
+    level: "aesthetician" /* AESTHETICIAN */,
+    specialties: [],
+    licenseNumber: "Pending",
+    issuingAuthority: "Pending",
+    issueDate: /* @__PURE__ */ new Date(),
+    verificationStatus: "pending"
+  };
+  return {
+    userRef,
+    basicInfo,
+    certification,
+    status: "active" /* ACTIVE */,
+    isActive: true,
+    isVerified: false
+  };
+};
+var validatePractitionerProfileData = async (profileData) => {
+  try {
+    await profileDataSchema.parseAsync(profileData);
+  } catch (error) {
+    if (error instanceof import_zod21.z.ZodError) {
+      const errorMessages = error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+      throw new Error(
+        `Practitioner profile validation failed: ${errorMessages}`
+      );
+    }
+    throw error;
+  }
+};
+
 // src/services/auth.service.ts
 var AuthService = class extends BaseService {
   constructor(db, auth, app, userService) {
     super(db, auth, app);
-    this.googleProvider = new import_auth5.GoogleAuthProvider();
-    this.facebookProvider = new import_auth5.FacebookAuthProvider();
-    this.appleProvider = new import_auth5.OAuthProvider("apple.com");
-    if (!userService) {
-      userService = new UserService(db, auth, app);
-    }
-    this.userService = userService;
+    this.googleProvider = new import_auth7.GoogleAuthProvider();
+    this.facebookProvider = new import_auth7.FacebookAuthProvider();
+    this.appleProvider = new import_auth7.OAuthProvider("apple.com");
+    this.userService = userService || new UserService(db, auth, app);
   }
   /**
    * Registruje novog korisnika sa email-om i lozinkom
    */
   async signUp(email, password, initialRole = "patient" /* PATIENT */) {
-    const { user: firebaseUser } = await (0, import_auth5.createUserWithEmailAndPassword)(
+    const { user: firebaseUser } = await (0, import_auth7.createUserWithEmailAndPassword)(
       this.auth,
       email,
       password
@@ -7783,7 +7913,7 @@ var AuthService = class extends BaseService {
       console.log("[AUTH] Creating Firebase user");
       let firebaseUser;
       try {
-        const result = await (0, import_auth5.createUserWithEmailAndPassword)(
+        const result = await (0, import_auth7.createUserWithEmailAndPassword)(
           this.auth,
           data.email,
           data.password
@@ -7794,7 +7924,7 @@ var AuthService = class extends BaseService {
         });
       } catch (firebaseError) {
         console.error("[AUTH] Firebase user creation failed:", firebaseError);
-        throw firebaseError;
+        throw handleFirebaseError(firebaseError);
       }
       console.log("[AUTH] Creating user with CLINIC_ADMIN role");
       let user;
@@ -8048,7 +8178,7 @@ var AuthService = class extends BaseService {
         clinicAdmin: adminProfile
       };
     } catch (error) {
-      if (error instanceof import_zod20.z.ZodError) {
+      if (error instanceof import_zod22.z.ZodError) {
         console.error(
           "[AUTH] Zod validation error in signUpClinicAdmin:",
           JSON.stringify(error.errors, null, 2)
@@ -8068,7 +8198,7 @@ var AuthService = class extends BaseService {
    * Prijavljuje korisnika sa email-om i lozinkom
    */
   async signIn(email, password) {
-    const { user: firebaseUser } = await (0, import_auth5.signInWithEmailAndPassword)(
+    const { user: firebaseUser } = await (0, import_auth7.signInWithEmailAndPassword)(
       this.auth,
       email,
       password
@@ -8107,7 +8237,7 @@ var AuthService = class extends BaseService {
         mediaService
       );
       clinicAdminService.setServices(clinicGroupService, clinicService);
-      const { user: firebaseUser } = await (0, import_auth5.signInWithEmailAndPassword)(
+      const { user: firebaseUser } = await (0, import_auth7.signInWithEmailAndPassword)(
         this.auth,
         email,
         password
@@ -8152,15 +8282,15 @@ var AuthService = class extends BaseService {
    * Prijavljuje korisnika sa Facebook-om
    */
   async signInWithFacebook() {
-    const provider = new import_auth5.FacebookAuthProvider();
-    const { user: firebaseUser } = await (0, import_auth5.signInWithPopup)(this.auth, provider);
+    const provider = new import_auth7.FacebookAuthProvider();
+    const { user: firebaseUser } = await (0, import_auth7.signInWithPopup)(this.auth, provider);
     return this.userService.getOrCreateUser(firebaseUser);
   }
   /**
    * Prijavljuje korisnika sa Google nalogom
    */
   async signInWithGoogle(initialRole = "patient" /* PATIENT */) {
-    const { user: firebaseUser } = await (0, import_auth5.signInWithPopup)(
+    const { user: firebaseUser } = await (0, import_auth7.signInWithPopup)(
       this.auth,
       this.googleProvider
     );
@@ -8170,22 +8300,22 @@ var AuthService = class extends BaseService {
    * Prijavljuje korisnika sa Apple-om
    */
   async signInWithApple() {
-    const provider = new import_auth5.OAuthProvider("apple.com");
-    const { user: firebaseUser } = await (0, import_auth5.signInWithPopup)(this.auth, provider);
+    const provider = new import_auth7.OAuthProvider("apple.com");
+    const { user: firebaseUser } = await (0, import_auth7.signInWithPopup)(this.auth, provider);
     return this.userService.getOrCreateUser(firebaseUser);
   }
   /**
    * Prijavljuje korisnika anonimno
    */
   async signInAnonymously() {
-    const { user: firebaseUser } = await (0, import_auth5.signInAnonymously)(this.auth);
+    const { user: firebaseUser } = await (0, import_auth7.signInAnonymously)(this.auth);
     return this.userService.getOrCreateUser(firebaseUser);
   }
   /**
    * Odjavljuje trenutnog korisnika
    */
   async signOut() {
-    await (0, import_auth5.signOut)(this.auth);
+    await (0, import_auth7.signOut)(this.auth);
   }
   /**
    * Vraća trenutno prijavljenog korisnika
@@ -8199,7 +8329,7 @@ var AuthService = class extends BaseService {
    * Registruje callback za promene stanja autentifikacije
    */
   onAuthStateChange(callback) {
-    return (0, import_auth5.onAuthStateChanged)(this.auth, callback);
+    return (0, import_auth7.onAuthStateChanged)(this.auth, callback);
   }
   async upgradeAnonymousUser(email, password) {
     try {
@@ -8216,14 +8346,14 @@ var AuthService = class extends BaseService {
           400
         );
       }
-      const credential = import_auth5.EmailAuthProvider.credential(email, password);
-      await (0, import_auth5.linkWithCredential)(currentUser, credential);
+      const credential = import_auth7.EmailAuthProvider.credential(email, password);
+      await (0, import_auth7.linkWithCredential)(currentUser, credential);
       return await this.userService.upgradeAnonymousUser(
         currentUser.uid,
         email
       );
     } catch (error) {
-      if (error instanceof import_zod20.z.ZodError) {
+      if (error instanceof import_zod22.z.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -8256,7 +8386,7 @@ var AuthService = class extends BaseService {
           400
         );
       }
-      const userCredential = await (0, import_auth5.signInWithPopup)(
+      const userCredential = await (0, import_auth7.signInWithPopup)(
         this.auth,
         this.googleProvider
       );
@@ -8287,7 +8417,7 @@ var AuthService = class extends BaseService {
         );
       }
       this.facebookProvider.addScope("email");
-      const userCredential = await (0, import_auth5.signInWithPopup)(
+      const userCredential = await (0, import_auth7.signInWithPopup)(
         this.auth,
         this.facebookProvider
       );
@@ -8319,7 +8449,7 @@ var AuthService = class extends BaseService {
       }
       this.appleProvider.addScope("email");
       this.appleProvider.addScope("name");
-      const userCredential = await (0, import_auth5.signInWithPopup)(
+      const userCredential = await (0, import_auth7.signInWithPopup)(
         this.auth,
         this.appleProvider
       );
@@ -8344,9 +8474,9 @@ var AuthService = class extends BaseService {
   async sendPasswordResetEmail(email) {
     try {
       await emailSchema.parseAsync(email);
-      await (0, import_auth5.sendPasswordResetEmail)(this.auth, email);
+      await (0, import_auth7.sendPasswordResetEmail)(this.auth, email);
     } catch (error) {
-      if (error instanceof import_zod20.z.ZodError) {
+      if (error instanceof import_zod22.z.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -8363,7 +8493,7 @@ var AuthService = class extends BaseService {
    */
   async verifyPasswordResetCode(oobCode) {
     try {
-      return await (0, import_auth5.verifyPasswordResetCode)(this.auth, oobCode);
+      return await (0, import_auth7.verifyPasswordResetCode)(this.auth, oobCode);
     } catch (error) {
       const firebaseError = error;
       if (firebaseError.code === "auth/expired-action-code" /* EXPIRED_ACTION_CODE */) {
@@ -8383,9 +8513,9 @@ var AuthService = class extends BaseService {
   async confirmPasswordReset(oobCode, newPassword) {
     try {
       await passwordSchema.parseAsync(newPassword);
-      await (0, import_auth5.confirmPasswordReset)(this.auth, oobCode, newPassword);
+      await (0, import_auth7.confirmPasswordReset)(this.auth, oobCode, newPassword);
     } catch (error) {
-      if (error instanceof import_zod20.z.ZodError) {
+      if (error instanceof import_zod22.z.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -8400,33 +8530,23 @@ var AuthService = class 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
    */
   async signUpPractitioner(data) {
-    var _a, _b, _c, _d;
+    let firebaseUser = null;
     try {
-      console.log("[AUTH] Starting practitioner signup process", {
+      console.log("[AUTH] Starting atomic practitioner signup process", {
         email: data.email,
         hasToken: !!data.token
       });
-      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;
-      }
+      await this.validateSignupData(data);
       console.log("[AUTH] Creating Firebase user");
-      let firebaseUser;
       try {
-        const result = await (0, import_auth5.createUserWithEmailAndPassword)(
+        const result = await (0, import_auth7.createUserWithEmailAndPassword)(
           this.auth,
           data.email,
           data.password
@@ -8437,136 +8557,110 @@ var AuthService = class extends BaseService {
         });
       } catch (firebaseError) {
         console.error("[AUTH] Firebase user creation failed:", firebaseError);
-        throw firebaseError;
-      }
-      console.log("[AUTH] Creating user with PRACTITIONER role");
-      let user;
-      try {
-        user = await this.userService.createUser(
-          firebaseUser,
-          ["practitioner" /* 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;
+        throw handleFirebaseError(firebaseError);
       }
-      console.log("[AUTH] Initializing practitioner service");
-      const practitionerService = new PractitionerService(
+      console.log("[AUTH] Starting Firestore transaction");
+      const transactionResult = await (0, import_firestore25.runTransaction)(
         this.db,
-        this.auth,
-        this.app
-      );
-      let practitioner = null;
-      if (data.token) {
-        console.log("[AUTH] Token provided, attempting to claim draft profile");
-        try {
-          practitioner = await practitionerService.validateTokenAndClaimProfile(
-            data.token,
-            firebaseUser.uid
-          );
-          if (!practitioner) {
-            throw new Error("Invalid or expired invitation token");
-          }
-          console.log("[AUTH] Successfully claimed draft profile", {
-            practitionerId: practitioner.id
-          });
-          await this.userService.updateUser(firebaseUser.uid, {
-            practitionerProfile: practitioner.id
-          });
+        async (transaction) => {
           console.log(
-            "[AUTH] User updated with practitioner profile reference"
+            "[AUTH] Transaction started - creating user and practitioner"
           );
-        } 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 = {};
-        }
-        const basicInfo = {
-          firstName: data.firstName || "",
-          lastName: data.lastName || "",
-          email: data.email,
-          phoneNumber: ((_a = data.profileData.basicInfo) == null ? void 0 : _a.phoneNumber) || "",
-          profileImageUrl: ((_b = data.profileData.basicInfo) == null ? void 0 : _b.profileImageUrl) || "",
-          gender: ((_c = data.profileData.basicInfo) == null ? void 0 : _c.gender) || "other",
-          // Default to "other" if not provided
-          bio: ((_d = data.profileData.basicInfo) == null ? void 0 : _d.bio) || "",
-          title: "Practitioner",
-          // Default title
-          dateOfBirth: /* @__PURE__ */ new Date(),
-          // Default to today
-          languages: ["English"]
-          // Default language
-        };
-        const certification = data.profileData.certification || {
-          level: "aesthetician" /* AESTHETICIAN */,
-          specialties: [],
-          licenseNumber: "Pending",
-          issuingAuthority: "Pending",
-          issueDate: /* @__PURE__ */ new Date(),
-          verificationStatus: "pending"
-        };
-        const createPractitionerData = {
-          userRef: firebaseUser.uid,
-          basicInfo,
-          certification,
-          status: "active" /* ACTIVE */,
-          isActive: true,
-          isVerified: false
-        };
-        try {
-          practitioner = await practitionerService.createPractitioner(
-            createPractitionerData
+          const practitionerService = new PractitionerService(
+            this.db,
+            this.auth,
+            this.app
           );
-          console.log("[AUTH] Practitioner profile created successfully", {
-            practitionerId: practitioner.id
-          });
+          console.log("[AUTH] Creating user document");
+          const user = await this.userService.createUser(
+            firebaseUser,
+            ["practitioner" /* PRACTITIONER */],
+            { skipProfileCreation: true }
+          );
+          let practitioner;
+          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] Linking practitioner to 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;
+          console.log("[AUTH] Transaction operations completed successfully");
+          return { user, practitioner };
         }
-      }
-      console.log("[AUTH] Practitioner signup completed successfully", {
-        userId: user.uid,
-        practitionerId: (practitioner == null ? void 0 : practitioner.id) || "unknown"
+      );
+      console.log("[AUTH] Atomic practitioner signup completed successfully", {
+        userId: transactionResult.user.uid,
+        practitionerId: transactionResult.practitioner.id
       });
-      return {
-        user,
-        practitioner
-      };
+      return transactionResult;
     } catch (error) {
-      if (error instanceof import_zod20.z.ZodError) {
-        console.error(
-          "[AUTH] Zod validation error in signUpPractitioner:",
-          JSON.stringify(error.errors, null, 2)
-        );
-        throw AUTH_ERRORS.VALIDATION_ERROR;
+      console.error(
+        "[AUTH] Atomic signup failed, initiating cleanup...",
+        error
+      );
+      if (firebaseUser) {
+        await cleanupFirebaseUser(firebaseUser);
       }
-      const firebaseError = error;
-      if (firebaseError.code === "auth/email-already-in-use" /* EMAIL_ALREADY_IN_USE */) {
-        console.error("[AUTH] Email already in use:", data.email);
+      throw handleSignupError(error);
+    }
+  }
+  /**
+   * Pre-validate all signup data before any mutations
+   * Prevents partial creation by catching issues early
+   */
+  async validateSignupData(data) {
+    console.log("[AUTH] Pre-validating signup data");
+    try {
+      await practitionerSignupSchema.parseAsync(data);
+      console.log("[AUTH] Schema validation passed");
+      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.error("[AUTH] Unhandled error in signUpPractitioner:", error);
+      console.log("[AUTH] Email availability confirmed");
+      if (data.token) {
+        const practitionerService = new PractitionerService(
+          this.db,
+          this.auth,
+          this.app
+        );
+        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");
+      }
+      if (data.profileData) {
+        await validatePractitionerProfileData(data.profileData);
+        console.log("[AUTH] Profile data validation passed");
+      }
+      console.log("[AUTH] All pre-validation checks passed");
+    } catch (error) {
+      console.error("[AUTH] Pre-validation failed:", error);
       throw error;
     }
   }
@@ -8589,7 +8683,7 @@ var AuthService = class extends BaseService {
         this.auth,
         this.app
       );
-      const { user: firebaseUser } = await (0, import_auth5.signInWithEmailAndPassword)(
+      const { user: firebaseUser } = await (0, import_auth7.signInWithEmailAndPassword)(
         this.auth,
         email,
         password
@@ -8832,63 +8926,63 @@ var import_firestore27 = require("firebase/firestore");
 var PROCEDURES_COLLECTION = "procedures";
 
 // src/validations/procedure.schema.ts
-var import_zod21 = require("zod");
-var createProcedureSchema = import_zod21.z.object({
-  name: import_zod21.z.string().min(1).max(200),
-  description: import_zod21.z.string().min(1).max(2e3),
-  family: import_zod21.z.nativeEnum(ProcedureFamily),
-  categoryId: import_zod21.z.string().min(1),
-  subcategoryId: import_zod21.z.string().min(1),
-  technologyId: import_zod21.z.string().min(1),
-  productId: import_zod21.z.string().min(1),
-  price: import_zod21.z.number().min(0),
-  currency: import_zod21.z.nativeEnum(Currency),
-  pricingMeasure: import_zod21.z.nativeEnum(PricingMeasure),
-  duration: import_zod21.z.number().min(1).max(480),
+var import_zod23 = require("zod");
+var createProcedureSchema = import_zod23.z.object({
+  name: import_zod23.z.string().min(1).max(200),
+  description: import_zod23.z.string().min(1).max(2e3),
+  family: import_zod23.z.nativeEnum(ProcedureFamily),
+  categoryId: import_zod23.z.string().min(1),
+  subcategoryId: import_zod23.z.string().min(1),
+  technologyId: import_zod23.z.string().min(1),
+  productId: import_zod23.z.string().min(1),
+  price: import_zod23.z.number().min(0),
+  currency: import_zod23.z.nativeEnum(Currency),
+  pricingMeasure: import_zod23.z.nativeEnum(PricingMeasure),
+  duration: import_zod23.z.number().min(1).max(480),
   // Max 8 hours
-  practitionerId: import_zod21.z.string().min(1),
-  clinicBranchId: import_zod21.z.string().min(1),
-  photos: import_zod21.z.array(mediaResourceSchema).optional()
-});
-var updateProcedureSchema = import_zod21.z.object({
-  name: import_zod21.z.string().min(3).max(100).optional(),
-  description: import_zod21.z.string().min(3).max(1e3).optional(),
-  price: import_zod21.z.number().min(0).optional(),
-  currency: import_zod21.z.nativeEnum(Currency).optional(),
-  pricingMeasure: import_zod21.z.nativeEnum(PricingMeasure).optional(),
-  duration: import_zod21.z.number().min(0).optional(),
-  isActive: import_zod21.z.boolean().optional(),
-  practitionerId: import_zod21.z.string().optional(),
-  categoryId: import_zod21.z.string().optional(),
-  subcategoryId: import_zod21.z.string().optional(),
-  technologyId: import_zod21.z.string().optional(),
-  productId: import_zod21.z.string().optional(),
-  clinicBranchId: import_zod21.z.string().optional(),
-  photos: import_zod21.z.array(mediaResourceSchema).optional()
+  practitionerId: import_zod23.z.string().min(1),
+  clinicBranchId: import_zod23.z.string().min(1),
+  photos: import_zod23.z.array(mediaResourceSchema).optional()
+});
+var updateProcedureSchema = import_zod23.z.object({
+  name: import_zod23.z.string().min(3).max(100).optional(),
+  description: import_zod23.z.string().min(3).max(1e3).optional(),
+  price: import_zod23.z.number().min(0).optional(),
+  currency: import_zod23.z.nativeEnum(Currency).optional(),
+  pricingMeasure: import_zod23.z.nativeEnum(PricingMeasure).optional(),
+  duration: import_zod23.z.number().min(0).optional(),
+  isActive: import_zod23.z.boolean().optional(),
+  practitionerId: import_zod23.z.string().optional(),
+  categoryId: import_zod23.z.string().optional(),
+  subcategoryId: import_zod23.z.string().optional(),
+  technologyId: import_zod23.z.string().optional(),
+  productId: import_zod23.z.string().optional(),
+  clinicBranchId: import_zod23.z.string().optional(),
+  photos: import_zod23.z.array(mediaResourceSchema).optional()
 });
 var procedureSchema = createProcedureSchema.extend({
-  id: import_zod21.z.string().min(1),
-  category: import_zod21.z.any(),
+  id: import_zod23.z.string().min(1),
+  category: import_zod23.z.any(),
   // We'll validate the full category object separately
-  subcategory: import_zod21.z.any(),
+  subcategory: import_zod23.z.any(),
   // We'll validate the full subcategory object separately
-  technology: import_zod21.z.any(),
+  technology: import_zod23.z.any(),
   // We'll validate the full technology object separately
-  product: import_zod21.z.any(),
+  product: import_zod23.z.any(),
   // We'll validate the full product object separately
-  blockingConditions: import_zod21.z.array(import_zod21.z.any()),
+  blockingConditions: import_zod23.z.array(import_zod23.z.any()),
   // We'll validate blocking conditions separately
-  contraindications: import_zod21.z.array(import_zod21.z.any()),
+  contraindications: import_zod23.z.array(import_zod23.z.any()),
   // We'll validate contraindications separately
-  treatmentBenefits: import_zod21.z.array(import_zod21.z.any()),
+  treatmentBenefits: import_zod23.z.array(import_zod23.z.any()),
   // We'll validate treatment benefits separately
-  preRequirements: import_zod21.z.array(import_zod21.z.any()),
+  preRequirements: import_zod23.z.array(import_zod23.z.any()),
   // We'll validate requirements separately
-  postRequirements: import_zod21.z.array(import_zod21.z.any()),
+  postRequirements: import_zod23.z.array(import_zod23.z.any()),
   // We'll validate requirements separately
-  certificationRequirement: import_zod21.z.any(),
+  certificationRequirement: import_zod23.z.any(),
   // We'll validate certification requirement separately
-  documentationTemplates: import_zod21.z.array(import_zod21.z.any()),
+  documentationTemplates: import_zod23.z.array(import_zod23.z.any()),
   // We'll validate documentation templates separately
   clinicInfo: clinicInfoSchema,
   // Clinic info validation
@@ -8896,9 +8990,9 @@ var procedureSchema = createProcedureSchema.extend({
   // Doctor info validation
   reviewInfo: procedureReviewInfoSchema,
   // Procedure review info validation
-  isActive: import_zod21.z.boolean(),
-  createdAt: import_zod21.z.date(),
-  updatedAt: import_zod21.z.date()
+  isActive: import_zod23.z.boolean(),
+  createdAt: import_zod23.z.date(),
+  updatedAt: import_zod23.z.date()
 });
 
 // src/services/procedure/procedure.service.ts
@@ -9320,20 +9414,20 @@ var ProcedureService = class extends BaseService {
       const proceduresCollection = (0, import_firestore27.collection)(this.db, PROCEDURES_COLLECTION);
       let proceduresQuery = (0, import_firestore27.query)(proceduresCollection);
       if (pagination && pagination > 0) {
-        const { limit: limit15, startAfter: startAfter13 } = await import("firebase/firestore");
+        const { limit: limit16, startAfter: startAfter14 } = await import("firebase/firestore");
         if (lastDoc) {
           proceduresQuery = (0, import_firestore27.query)(
             proceduresCollection,
             (0, import_firestore27.orderBy)("name"),
             // Use imported orderBy
-            startAfter13(lastDoc),
-            limit15(pagination)
+            startAfter14(lastDoc),
+            limit16(pagination)
           );
         } else {
           proceduresQuery = (0, import_firestore27.query)(
             proceduresCollection,
             (0, import_firestore27.orderBy)("name"),
-            limit15(pagination)
+            limit16(pagination)
           );
         }
       } else {
@@ -10732,42 +10826,42 @@ var SYNCED_CALENDARS_COLLECTION = "syncedCalendars";
 var import_firestore41 = require("firebase/firestore");
 
 // src/validations/calendar.schema.ts
-var import_zod23 = require("zod");
+var import_zod25 = require("zod");
 var import_firestore32 = require("firebase/firestore");
 
 // src/validations/profile-info.schema.ts
-var import_zod22 = require("zod");
+var import_zod24 = require("zod");
 var import_firestore31 = require("firebase/firestore");
-var clinicInfoSchema2 = import_zod22.z.object({
-  id: import_zod22.z.string(),
-  featuredPhoto: import_zod22.z.string(),
-  name: import_zod22.z.string(),
-  description: import_zod22.z.string(),
+var clinicInfoSchema2 = import_zod24.z.object({
+  id: import_zod24.z.string(),
+  featuredPhoto: import_zod24.z.string(),
+  name: import_zod24.z.string(),
+  description: import_zod24.z.string(),
   location: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema
 });
-var practitionerProfileInfoSchema = import_zod22.z.object({
-  id: import_zod22.z.string(),
-  practitionerPhoto: import_zod22.z.string().nullable(),
-  name: import_zod22.z.string(),
-  email: import_zod22.z.string().email(),
-  phone: import_zod22.z.string().nullable(),
+var practitionerProfileInfoSchema = import_zod24.z.object({
+  id: import_zod24.z.string(),
+  practitionerPhoto: import_zod24.z.string().nullable(),
+  name: import_zod24.z.string(),
+  email: import_zod24.z.string().email(),
+  phone: import_zod24.z.string().nullable(),
   certification: practitionerCertificationSchema
 });
-var patientProfileInfoSchema = import_zod22.z.object({
-  id: import_zod22.z.string(),
-  fullName: import_zod22.z.string(),
-  email: import_zod22.z.string().email(),
-  phone: import_zod22.z.string().nullable(),
-  dateOfBirth: import_zod22.z.instanceof(import_firestore31.Timestamp),
-  gender: import_zod22.z.nativeEnum(Gender)
+var patientProfileInfoSchema = import_zod24.z.object({
+  id: import_zod24.z.string(),
+  fullName: import_zod24.z.string(),
+  email: import_zod24.z.string().email(),
+  phone: import_zod24.z.string().nullable(),
+  dateOfBirth: import_zod24.z.instanceof(import_firestore31.Timestamp),
+  gender: import_zod24.z.nativeEnum(Gender)
 });
 
 // src/validations/calendar.schema.ts
 var MIN_APPOINTMENT_DURATION = 15;
-var calendarEventTimeSchema = import_zod23.z.object({
-  start: import_zod23.z.instanceof(Date).or(import_zod23.z.instanceof(import_firestore32.Timestamp)),
-  end: import_zod23.z.instanceof(Date).or(import_zod23.z.instanceof(import_firestore32.Timestamp))
+var calendarEventTimeSchema = import_zod25.z.object({
+  start: import_zod25.z.instanceof(Date).or(import_zod25.z.instanceof(import_firestore32.Timestamp)),
+  end: import_zod25.z.instanceof(Date).or(import_zod25.z.instanceof(import_firestore32.Timestamp))
 }).refine(
   (data) => {
     const startDate = data.start instanceof import_firestore32.Timestamp ? data.start.toDate() : data.start;
@@ -10788,46 +10882,46 @@ var calendarEventTimeSchema = import_zod23.z.object({
     path: ["start"]
   }
 );
-var timeSlotSchema2 = import_zod23.z.object({
-  start: import_zod23.z.date(),
-  end: import_zod23.z.date(),
-  isAvailable: import_zod23.z.boolean()
+var timeSlotSchema2 = import_zod25.z.object({
+  start: import_zod25.z.date(),
+  end: import_zod25.z.date(),
+  isAvailable: import_zod25.z.boolean()
 }).refine((data) => data.start < data.end, {
   message: "End time must be after start time",
   path: ["end"]
 });
-var syncedCalendarEventSchema = import_zod23.z.object({
-  eventId: import_zod23.z.string(),
-  syncedCalendarProvider: import_zod23.z.nativeEnum(SyncedCalendarProvider),
-  syncedAt: import_zod23.z.instanceof(Date).or(import_zod23.z.instanceof(import_firestore32.Timestamp))
+var syncedCalendarEventSchema = import_zod25.z.object({
+  eventId: import_zod25.z.string(),
+  syncedCalendarProvider: import_zod25.z.nativeEnum(SyncedCalendarProvider),
+  syncedAt: import_zod25.z.instanceof(Date).or(import_zod25.z.instanceof(import_firestore32.Timestamp))
 });
-var procedureInfoSchema = import_zod23.z.object({
-  name: import_zod23.z.string(),
-  description: import_zod23.z.string(),
-  duration: import_zod23.z.number().min(MIN_APPOINTMENT_DURATION),
-  price: import_zod23.z.number().min(0),
-  currency: import_zod23.z.nativeEnum(Currency)
+var procedureInfoSchema = import_zod25.z.object({
+  name: import_zod25.z.string(),
+  description: import_zod25.z.string(),
+  duration: import_zod25.z.number().min(MIN_APPOINTMENT_DURATION),
+  price: import_zod25.z.number().min(0),
+  currency: import_zod25.z.nativeEnum(Currency)
 });
-var procedureCategorizationSchema = import_zod23.z.object({
-  procedureFamily: import_zod23.z.string(),
+var procedureCategorizationSchema = import_zod25.z.object({
+  procedureFamily: import_zod25.z.string(),
   // Replace with proper enum when available
-  procedureCategory: import_zod23.z.string(),
+  procedureCategory: import_zod25.z.string(),
   // Replace with proper enum when available
-  procedureSubcategory: import_zod23.z.string(),
+  procedureSubcategory: import_zod25.z.string(),
   // Replace with proper enum when available
-  procedureTechnology: import_zod23.z.string(),
+  procedureTechnology: import_zod25.z.string(),
   // Replace with proper enum when available
-  procedureProduct: import_zod23.z.string()
+  procedureProduct: import_zod25.z.string()
   // Replace with proper enum when available
 });
-var createAppointmentSchema2 = import_zod23.z.object({
-  clinicId: import_zod23.z.string().min(1, "Clinic ID is required"),
-  doctorId: import_zod23.z.string().min(1, "Doctor ID is required"),
-  patientId: import_zod23.z.string().min(1, "Patient ID is required"),
-  procedureId: import_zod23.z.string().min(1, "Procedure ID is required"),
+var createAppointmentSchema2 = import_zod25.z.object({
+  clinicId: import_zod25.z.string().min(1, "Clinic ID is required"),
+  doctorId: import_zod25.z.string().min(1, "Doctor ID is required"),
+  patientId: import_zod25.z.string().min(1, "Patient ID is required"),
+  procedureId: import_zod25.z.string().min(1, "Procedure ID is required"),
   eventLocation: clinicLocationSchema,
   eventTime: calendarEventTimeSchema,
-  description: import_zod23.z.string().optional()
+  description: import_zod25.z.string().optional()
 }).refine(
   (data) => {
     return true;
@@ -10836,95 +10930,95 @@ var createAppointmentSchema2 = import_zod23.z.object({
     message: "Invalid appointment parameters"
   }
 );
-var updateAppointmentSchema2 = import_zod23.z.object({
-  appointmentId: import_zod23.z.string().min(1, "Appointment ID is required"),
-  clinicId: import_zod23.z.string().min(1, "Clinic ID is required"),
-  doctorId: import_zod23.z.string().min(1, "Doctor ID is required"),
-  patientId: import_zod23.z.string().min(1, "Patient ID is required"),
+var updateAppointmentSchema2 = import_zod25.z.object({
+  appointmentId: import_zod25.z.string().min(1, "Appointment ID is required"),
+  clinicId: import_zod25.z.string().min(1, "Clinic ID is required"),
+  doctorId: import_zod25.z.string().min(1, "Doctor ID is required"),
+  patientId: import_zod25.z.string().min(1, "Patient ID is required"),
   eventTime: calendarEventTimeSchema.optional(),
-  description: import_zod23.z.string().optional(),
-  status: import_zod23.z.nativeEnum(CalendarEventStatus).optional()
-});
-var createCalendarEventSchema = import_zod23.z.object({
-  id: import_zod23.z.string(),
-  clinicBranchId: import_zod23.z.string().nullable().optional(),
-  clinicBranchInfo: import_zod23.z.any().nullable().optional(),
-  practitionerProfileId: import_zod23.z.string().nullable().optional(),
+  description: import_zod25.z.string().optional(),
+  status: import_zod25.z.nativeEnum(CalendarEventStatus).optional()
+});
+var createCalendarEventSchema = import_zod25.z.object({
+  id: import_zod25.z.string(),
+  clinicBranchId: import_zod25.z.string().nullable().optional(),
+  clinicBranchInfo: import_zod25.z.any().nullable().optional(),
+  practitionerProfileId: import_zod25.z.string().nullable().optional(),
   practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: import_zod23.z.string().nullable().optional(),
+  patientProfileId: import_zod25.z.string().nullable().optional(),
   patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
-  procedureId: import_zod23.z.string().nullable().optional(),
-  appointmentId: import_zod23.z.string().nullable().optional(),
-  syncedCalendarEventId: import_zod23.z.array(syncedCalendarEventSchema).nullable().optional(),
-  eventName: import_zod23.z.string().min(1, "Event name is required"),
+  procedureId: import_zod25.z.string().nullable().optional(),
+  appointmentId: import_zod25.z.string().nullable().optional(),
+  syncedCalendarEventId: import_zod25.z.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: import_zod25.z.string().min(1, "Event name is required"),
   eventLocation: clinicLocationSchema.optional(),
   eventTime: calendarEventTimeSchema,
-  description: import_zod23.z.string().optional(),
-  status: import_zod23.z.nativeEnum(CalendarEventStatus),
-  syncStatus: import_zod23.z.nativeEnum(CalendarSyncStatus),
-  eventType: import_zod23.z.nativeEnum(CalendarEventType),
-  createdAt: import_zod23.z.any(),
+  description: import_zod25.z.string().optional(),
+  status: import_zod25.z.nativeEnum(CalendarEventStatus),
+  syncStatus: import_zod25.z.nativeEnum(CalendarSyncStatus),
+  eventType: import_zod25.z.nativeEnum(CalendarEventType),
+  createdAt: import_zod25.z.any(),
   // FieldValue for server timestamp
-  updatedAt: import_zod23.z.any()
+  updatedAt: import_zod25.z.any()
   // FieldValue for server timestamp
 });
-var updateCalendarEventSchema = import_zod23.z.object({
-  syncedCalendarEventId: import_zod23.z.array(syncedCalendarEventSchema).nullable().optional(),
-  appointmentId: import_zod23.z.string().nullable().optional(),
-  eventName: import_zod23.z.string().optional(),
+var updateCalendarEventSchema = import_zod25.z.object({
+  syncedCalendarEventId: import_zod25.z.array(syncedCalendarEventSchema).nullable().optional(),
+  appointmentId: import_zod25.z.string().nullable().optional(),
+  eventName: import_zod25.z.string().optional(),
   eventTime: calendarEventTimeSchema.optional(),
-  description: import_zod23.z.string().optional(),
-  status: import_zod23.z.nativeEnum(CalendarEventStatus).optional(),
-  syncStatus: import_zod23.z.nativeEnum(CalendarSyncStatus).optional(),
-  eventType: import_zod23.z.nativeEnum(CalendarEventType).optional(),
-  updatedAt: import_zod23.z.any()
+  description: import_zod25.z.string().optional(),
+  status: import_zod25.z.nativeEnum(CalendarEventStatus).optional(),
+  syncStatus: import_zod25.z.nativeEnum(CalendarSyncStatus).optional(),
+  eventType: import_zod25.z.nativeEnum(CalendarEventType).optional(),
+  updatedAt: import_zod25.z.any()
   // FieldValue for server timestamp
 });
-var calendarEventSchema = import_zod23.z.object({
-  id: import_zod23.z.string(),
-  clinicBranchId: import_zod23.z.string().nullable().optional(),
-  clinicBranchInfo: import_zod23.z.any().nullable().optional(),
+var calendarEventSchema = import_zod25.z.object({
+  id: import_zod25.z.string(),
+  clinicBranchId: import_zod25.z.string().nullable().optional(),
+  clinicBranchInfo: import_zod25.z.any().nullable().optional(),
   // Will be replaced with proper clinic info schema
-  practitionerProfileId: import_zod23.z.string().nullable().optional(),
+  practitionerProfileId: import_zod25.z.string().nullable().optional(),
   practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: import_zod23.z.string().nullable().optional(),
+  patientProfileId: import_zod25.z.string().nullable().optional(),
   patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
-  procedureId: import_zod23.z.string().nullable().optional(),
+  procedureId: import_zod25.z.string().nullable().optional(),
   procedureInfo: procedureInfoSchema.nullable().optional(),
   procedureCategorization: procedureCategorizationSchema.nullable().optional(),
-  appointmentId: import_zod23.z.string().nullable().optional(),
-  syncedCalendarEventId: import_zod23.z.array(syncedCalendarEventSchema).nullable().optional(),
-  eventName: import_zod23.z.string(),
+  appointmentId: import_zod25.z.string().nullable().optional(),
+  syncedCalendarEventId: import_zod25.z.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: import_zod25.z.string(),
   eventLocation: clinicLocationSchema.optional(),
   eventTime: calendarEventTimeSchema,
-  description: import_zod23.z.string().optional(),
-  status: import_zod23.z.nativeEnum(CalendarEventStatus),
-  syncStatus: import_zod23.z.nativeEnum(CalendarSyncStatus),
-  eventType: import_zod23.z.nativeEnum(CalendarEventType),
-  createdAt: import_zod23.z.instanceof(Date).or(import_zod23.z.instanceof(import_firestore32.Timestamp)),
-  updatedAt: import_zod23.z.instanceof(Date).or(import_zod23.z.instanceof(import_firestore32.Timestamp))
-});
-var createBlockingEventSchema = import_zod23.z.object({
-  entityType: import_zod23.z.enum(["practitioner", "clinic"]),
-  entityId: import_zod23.z.string().min(1, "Entity ID is required"),
-  eventName: import_zod23.z.string().min(1, "Event name is required").max(200, "Event name too long"),
+  description: import_zod25.z.string().optional(),
+  status: import_zod25.z.nativeEnum(CalendarEventStatus),
+  syncStatus: import_zod25.z.nativeEnum(CalendarSyncStatus),
+  eventType: import_zod25.z.nativeEnum(CalendarEventType),
+  createdAt: import_zod25.z.instanceof(Date).or(import_zod25.z.instanceof(import_firestore32.Timestamp)),
+  updatedAt: import_zod25.z.instanceof(Date).or(import_zod25.z.instanceof(import_firestore32.Timestamp))
+});
+var createBlockingEventSchema = import_zod25.z.object({
+  entityType: import_zod25.z.enum(["practitioner", "clinic"]),
+  entityId: import_zod25.z.string().min(1, "Entity ID is required"),
+  eventName: import_zod25.z.string().min(1, "Event name is required").max(200, "Event name too long"),
   eventTime: calendarEventTimeSchema,
-  eventType: import_zod23.z.enum([
+  eventType: import_zod25.z.enum([
     "blocking" /* BLOCKING */,
     "break" /* BREAK */,
     "free_day" /* FREE_DAY */,
     "other" /* OTHER */
   ]),
-  description: import_zod23.z.string().max(1e3, "Description too long").optional()
+  description: import_zod25.z.string().max(1e3, "Description too long").optional()
 });
-var updateBlockingEventSchema = import_zod23.z.object({
-  entityType: import_zod23.z.enum(["practitioner", "clinic"]),
-  entityId: import_zod23.z.string().min(1, "Entity ID is required"),
-  eventId: import_zod23.z.string().min(1, "Event ID is required"),
-  eventName: import_zod23.z.string().min(1, "Event name is required").max(200, "Event name too long").optional(),
+var updateBlockingEventSchema = import_zod25.z.object({
+  entityType: import_zod25.z.enum(["practitioner", "clinic"]),
+  entityId: import_zod25.z.string().min(1, "Entity ID is required"),
+  eventId: import_zod25.z.string().min(1, "Event ID is required"),
+  eventName: import_zod25.z.string().min(1, "Event name is required").max(200, "Event name too long").optional(),
   eventTime: calendarEventTimeSchema.optional(),
-  description: import_zod23.z.string().max(1e3, "Description too long").optional(),
-  status: import_zod23.z.nativeEnum(CalendarEventStatus).optional()
+  description: import_zod25.z.string().max(1e3, "Description too long").optional(),
+  status: import_zod25.z.nativeEnum(CalendarEventStatus).optional()
 });
 
 // src/services/calendar/utils/clinic.utils.ts
@@ -13661,7 +13755,7 @@ var import_firestore44 = require("firebase/firestore");
 var REVIEWS_COLLECTION = "reviews";
 
 // src/services/reviews/reviews.service.ts
-var import_zod24 = require("zod");
+var import_zod26 = require("zod");
 var ReviewService = class extends BaseService {
   constructor(db, auth, app) {
     super(db, auth, app);
@@ -13748,7 +13842,7 @@ var ReviewService = class extends BaseService {
       });
       return review;
     } catch (error) {
-      if (error instanceof import_zod24.z.ZodError) {
+      if (error instanceof import_zod26.z.ZodError) {
         throw new Error(`Invalid review data: ${error.message}`);
       }
       throw error;
@@ -15949,63 +16043,63 @@ var ProductService = class extends BaseService {
 };
 
 // src/validations/notification.schema.ts
-var import_zod25 = require("zod");
-var baseNotificationSchema = import_zod25.z.object({
-  id: import_zod25.z.string().optional(),
-  userId: import_zod25.z.string(),
-  notificationTime: import_zod25.z.any(),
+var import_zod27 = require("zod");
+var baseNotificationSchema = import_zod27.z.object({
+  id: import_zod27.z.string().optional(),
+  userId: import_zod27.z.string(),
+  notificationTime: import_zod27.z.any(),
   // Timestamp
-  notificationType: import_zod25.z.nativeEnum(NotificationType),
-  notificationTokens: import_zod25.z.array(import_zod25.z.string()),
-  status: import_zod25.z.nativeEnum(NotificationStatus),
-  createdAt: import_zod25.z.any().optional(),
+  notificationType: import_zod27.z.nativeEnum(NotificationType),
+  notificationTokens: import_zod27.z.array(import_zod27.z.string()),
+  status: import_zod27.z.nativeEnum(NotificationStatus),
+  createdAt: import_zod27.z.any().optional(),
   // Timestamp
-  updatedAt: import_zod25.z.any().optional(),
+  updatedAt: import_zod27.z.any().optional(),
   // Timestamp
-  title: import_zod25.z.string(),
-  body: import_zod25.z.string(),
-  isRead: import_zod25.z.boolean(),
-  userRole: import_zod25.z.nativeEnum(UserRole)
+  title: import_zod27.z.string(),
+  body: import_zod27.z.string(),
+  isRead: import_zod27.z.boolean(),
+  userRole: import_zod27.z.nativeEnum(UserRole)
 });
 var preRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod25.z.literal("preRequirementInstructionDue" /* PRE_REQUIREMENT_INSTRUCTION_DUE */),
-  treatmentId: import_zod25.z.string(),
-  requirements: import_zod25.z.array(import_zod25.z.string()),
-  deadline: import_zod25.z.any()
+  notificationType: import_zod27.z.literal("preRequirementInstructionDue" /* PRE_REQUIREMENT_INSTRUCTION_DUE */),
+  treatmentId: import_zod27.z.string(),
+  requirements: import_zod27.z.array(import_zod27.z.string()),
+  deadline: import_zod27.z.any()
   // Timestamp
 });
 var postRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod25.z.literal(
+  notificationType: import_zod27.z.literal(
     "postRequirementInstructionDue" /* POST_REQUIREMENT_INSTRUCTION_DUE */
   ),
-  treatmentId: import_zod25.z.string(),
-  requirements: import_zod25.z.array(import_zod25.z.string()),
-  deadline: import_zod25.z.any()
+  treatmentId: import_zod27.z.string(),
+  requirements: import_zod27.z.array(import_zod27.z.string()),
+  deadline: import_zod27.z.any()
   // Timestamp
 });
 var requirementInstructionDueNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod25.z.literal("requirementInstructionDue" /* REQUIREMENT_INSTRUCTION_DUE */),
-  appointmentId: import_zod25.z.string(),
-  patientRequirementInstanceId: import_zod25.z.string(),
-  instructionId: import_zod25.z.string(),
-  originalRequirementId: import_zod25.z.string().optional()
+  notificationType: import_zod27.z.literal("requirementInstructionDue" /* REQUIREMENT_INSTRUCTION_DUE */),
+  appointmentId: import_zod27.z.string(),
+  patientRequirementInstanceId: import_zod27.z.string(),
+  instructionId: import_zod27.z.string(),
+  originalRequirementId: import_zod27.z.string().optional()
 });
 var appointmentReminderNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod25.z.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
-  appointmentId: import_zod25.z.string(),
-  appointmentTime: import_zod25.z.any(),
+  notificationType: import_zod27.z.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
+  appointmentId: import_zod27.z.string(),
+  appointmentTime: import_zod27.z.any(),
   // Timestamp
-  treatmentType: import_zod25.z.string(),
-  doctorName: import_zod25.z.string()
+  treatmentType: import_zod27.z.string(),
+  doctorName: import_zod27.z.string()
 });
 var appointmentNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod25.z.literal("appointmentStatusChange" /* APPOINTMENT_STATUS_CHANGE */),
-  appointmentId: import_zod25.z.string(),
-  appointmentStatus: import_zod25.z.string(),
-  previousStatus: import_zod25.z.string(),
-  reason: import_zod25.z.string().optional()
+  notificationType: import_zod27.z.literal("appointmentStatusChange" /* APPOINTMENT_STATUS_CHANGE */),
+  appointmentId: import_zod27.z.string(),
+  appointmentStatus: import_zod27.z.string(),
+  previousStatus: import_zod27.z.string(),
+  reason: import_zod27.z.string().optional()
 });
-var notificationSchema = import_zod25.z.discriminatedUnion("notificationType", [
+var notificationSchema = import_zod27.z.discriminatedUnion("notificationType", [
   preRequirementNotificationSchema,
   postRequirementNotificationSchema,
   requirementInstructionDueNotificationSchema,