@blackcode_sa/metaestetics-api 1.4.6 → 1.4.7

package/dist/index.js

@@ -2615,23 +2615,54 @@ var updateClinicSchema = createClinicSchema.partial();
 
 // src/services/clinic/utils/admin.utils.ts
 async function createClinicAdmin(db, data, clinicGroupService) {
+  console.log("[CLINIC_ADMIN] Starting clinic admin creation", {
+    userRef: data.userRef
+  });
+  console.log("[CLINIC_ADMIN] Input data:", JSON.stringify(data, null, 2));
+  try {
+    const validatedData2 = createClinicAdminSchema.parse(data);
+    console.log("[CLINIC_ADMIN] Data validation passed");
+  } catch (validationError) {
+    console.error("[CLINIC_ADMIN] Data validation failed:", validationError);
+    throw validationError;
+  }
   const validatedData = createClinicAdminSchema.parse(data);
-  const existingAdmin = await getClinicAdminByUserRef(
-    db,
-    validatedData.userRef
-  );
-  if (existingAdmin) {
-    throw new Error("User already has an admin profile");
+  console.log("[CLINIC_ADMIN] Checking if user already has an admin profile", {
+    userRef: validatedData.userRef
+  });
+  try {
+    const existingAdmin = await getClinicAdminByUserRef(
+      db,
+      validatedData.userRef
+    );
+    if (existingAdmin) {
+      console.error("[CLINIC_ADMIN] User already has an admin profile", {
+        adminId: existingAdmin.id
+      });
+      throw new Error("User already has an admin profile");
+    }
+    console.log("[CLINIC_ADMIN] User does not have an existing admin profile");
+  } catch (error) {
+    if (error.message === "User already has an admin profile") {
+      throw error;
+    }
+    console.error("[CLINIC_ADMIN] Error checking for existing admin:", error);
+    throw error;
   }
   let clinicGroupId = validatedData.clinicGroupId;
+  console.log("[CLINIC_ADMIN] Checking clinic group situation", {
+    isGroupOwner: validatedData.isGroupOwner,
+    hasGroupId: !!clinicGroupId
+  });
   if (validatedData.isGroupOwner && !clinicGroupId) {
+    console.log("[CLINIC_ADMIN] Creating default group for owner");
     const defaultGroup = {
       name: `${validatedData.contactInfo.firstName}'s Group`,
       ownerId: validatedData.userRef,
       contactPerson: validatedData.contactInfo,
       contactInfo: {
         email: validatedData.contactInfo.email,
-        phoneNumber: validatedData.contactInfo.phoneNumber
+        phoneNumber: validatedData.contactInfo.phoneNumber || ""
       },
       hqLocation: {
         address: "",
@@ -2643,24 +2674,61 @@ async function createClinicAdmin(db, data, clinicGroupService) {
       },
       isActive: true
     };
-    const clinicGroup = await clinicGroupService.createClinicGroup(
-      defaultGroup,
-      validatedData.userRef,
-      true
-    );
-    clinicGroupId = clinicGroup.id;
+    console.log("[CLINIC_ADMIN] Default group data prepared", {
+      groupName: defaultGroup.name
+    });
+    try {
+      const clinicGroup = await clinicGroupService.createClinicGroup(
+        defaultGroup,
+        validatedData.userRef,
+        true
+      );
+      clinicGroupId = clinicGroup.id;
+      console.log("[CLINIC_ADMIN] Default group created successfully", {
+        groupId: clinicGroupId
+      });
+    } catch (groupCreationError) {
+      console.error(
+        "[CLINIC_ADMIN] Error creating default group:",
+        groupCreationError
+      );
+      throw groupCreationError;
+    }
   } else if (!validatedData.isGroupOwner && !clinicGroupId) {
+    console.error("[CLINIC_ADMIN] Missing clinic group ID for non-owner admin");
     throw new Error("Clinic group ID is required for non-owner admins");
   } else if (!validatedData.isGroupOwner && clinicGroupId) {
-    const groupExists = await checkClinicGroupExists(
-      db,
-      clinicGroupId,
-      clinicGroupService
-    );
-    if (!groupExists) {
-      throw new Error("Specified clinic group does not exist");
+    console.log("[CLINIC_ADMIN] Checking if specified clinic group exists", {
+      groupId: clinicGroupId
+    });
+    try {
+      const groupExists = await checkClinicGroupExists(
+        db,
+        clinicGroupId,
+        clinicGroupService
+      );
+      if (!groupExists) {
+        console.error("[CLINIC_ADMIN] Specified clinic group does not exist", {
+          groupId: clinicGroupId
+        });
+        throw new Error("Specified clinic group does not exist");
+      }
+      console.log("[CLINIC_ADMIN] Specified clinic group exists");
+    } catch (groupCheckError) {
+      console.error(
+        "[CLINIC_ADMIN] Error checking if clinic group exists:",
+        groupCheckError
+      );
+      throw groupCheckError;
     }
   }
+  console.log("[CLINIC_ADMIN] Preparing admin data object");
+  if (!clinicGroupId) {
+    console.error(
+      "[CLINIC_ADMIN] clinicGroupId is undefined, which should not happen at this point"
+    );
+    throw new Error("clinicGroupId is required but was undefined");
+  }
   const adminData = {
     id: validatedData.userRef,
     userRef: validatedData.userRef,
@@ -2676,20 +2744,68 @@ async function createClinicAdmin(db, data, clinicGroupService) {
     createdAt: (0, import_firestore11.serverTimestamp)(),
     updatedAt: (0, import_firestore11.serverTimestamp)()
   };
-  clinicAdminSchema.parse({
-    ...adminData,
-    createdAt: import_firestore11.Timestamp.now(),
-    updatedAt: import_firestore11.Timestamp.now()
+  console.log("[CLINIC_ADMIN] Validating complete admin object");
+  try {
+    clinicAdminSchema.parse({
+      ...adminData,
+      createdAt: import_firestore11.Timestamp.now(),
+      updatedAt: import_firestore11.Timestamp.now()
+    });
+    console.log("[CLINIC_ADMIN] Admin object validation passed");
+  } catch (schemaError) {
+    console.error(
+      "[CLINIC_ADMIN] Admin object validation failed:",
+      JSON.stringify(schemaError, null, 2)
+    );
+    throw schemaError;
+  }
+  console.log("[CLINIC_ADMIN] Saving admin to Firestore", {
+    adminId: adminData.id
   });
-  await (0, import_firestore11.setDoc)((0, import_firestore11.doc)(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
+  try {
+    await (0, import_firestore11.setDoc)((0, import_firestore11.doc)(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
+    console.log("[CLINIC_ADMIN] Admin saved successfully");
+  } catch (firestoreError) {
+    console.error(
+      "[CLINIC_ADMIN] Error saving admin to Firestore:",
+      firestoreError
+    );
+    throw firestoreError;
+  }
   if (clinicGroupId) {
-    await clinicGroupService.addAdminToGroup(clinicGroupId, adminData.id);
+    console.log("[CLINIC_ADMIN] Adding admin to clinic group", {
+      adminId: adminData.id,
+      groupId: clinicGroupId
+    });
+    try {
+      await clinicGroupService.addAdminToGroup(clinicGroupId, adminData.id);
+      console.log("[CLINIC_ADMIN] Admin added to group successfully");
+    } catch (addToGroupError) {
+      console.error(
+        "[CLINIC_ADMIN] Error adding admin to group:",
+        addToGroupError
+      );
+      throw addToGroupError;
+    }
   }
-  const createdAdmin = await getClinicAdmin(db, adminData.id);
-  if (!createdAdmin) {
-    throw new Error("Failed to retrieve created admin");
+  console.log("[CLINIC_ADMIN] Retrieving created admin");
+  try {
+    const createdAdmin = await getClinicAdmin(db, adminData.id);
+    if (!createdAdmin) {
+      console.error("[CLINIC_ADMIN] Failed to retrieve created admin");
+      throw new Error("Failed to retrieve created admin");
+    }
+    console.log("[CLINIC_ADMIN] Admin creation completed successfully", {
+      adminId: createdAdmin.id
+    });
+    return createdAdmin;
+  } catch (retrieveError) {
+    console.error(
+      "[CLINIC_ADMIN] Error retrieving created admin:",
+      retrieveError
+    );
+    throw retrieveError;
   }
-  return createdAdmin;
 }
 async function checkClinicGroupExists(db, groupId, clinicGroupService) {
   const group = await clinicGroupService.getClinicGroup(groupId);
@@ -3650,18 +3766,54 @@ function generateId() {
   return `${randomPart}-${timestamp}`;
 }
 async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdminService) {
+  console.log("[CLINIC_GROUP] Starting clinic group creation", {
+    ownerId,
+    isDefault
+  });
+  console.log("[CLINIC_GROUP] Input data:", JSON.stringify(data, null, 2));
+  try {
+    const validatedData2 = createClinicGroupSchema.parse(data);
+    console.log("[CLINIC_GROUP] Data validation passed");
+  } catch (validationError) {
+    console.error("[CLINIC_GROUP] Data validation failed:", validationError);
+    throw validationError;
+  }
   const validatedData = createClinicGroupSchema.parse(data);
-  const owner = await clinicAdminService.getClinicAdmin(ownerId);
-  if (!owner) {
-    throw new Error("Owner not found or is not a clinic admin");
+  try {
+    console.log("[CLINIC_GROUP] Checking if owner exists", { ownerId });
+    const owner = await clinicAdminService.getClinicAdmin(ownerId);
+    if (!owner) {
+      console.error("[CLINIC_GROUP] Owner not found or is not a clinic admin", {
+        ownerId
+      });
+      throw new Error("Owner not found or is not a clinic admin");
+    }
+    console.log("[CLINIC_GROUP] Owner verified as clinic admin");
+  } catch (ownerError) {
+    console.error("[CLINIC_GROUP] Error verifying owner:", ownerError);
+    throw ownerError;
   }
+  console.log("[CLINIC_GROUP] Generating geohash for location");
   if (validatedData.hqLocation) {
-    validatedData.hqLocation.geohash = (0, import_geofire_common2.geohashForLocation)([
-      validatedData.hqLocation.latitude,
-      validatedData.hqLocation.longitude
-    ]);
+    try {
+      validatedData.hqLocation.geohash = (0, import_geofire_common2.geohashForLocation)([
+        validatedData.hqLocation.latitude,
+        validatedData.hqLocation.longitude
+      ]);
+      console.log("[CLINIC_GROUP] Geohash generated successfully", {
+        geohash: validatedData.hqLocation.geohash
+      });
+    } catch (geohashError) {
+      console.error("[CLINIC_GROUP] Error generating geohash:", geohashError);
+      throw geohashError;
+    }
   }
   const now = import_firestore15.Timestamp.now();
+  console.log("[CLINIC_GROUP] Preparing clinic group data object");
+  console.log("[CLINIC_GROUP] Logo value:", {
+    logoValue: validatedData.logo,
+    logoType: validatedData.logo === null ? "null" : typeof validatedData.logo
+  });
   const groupData = {
     ...validatedData,
     id: (0, import_firestore15.doc)((0, import_firestore15.collection)(db, CLINIC_GROUPS_COLLECTION)).id,
@@ -3686,17 +3838,63 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
     isActive: true
   };
   try {
-    clinicGroupSchema.parse(groupData);
-    await (0, import_firestore15.setDoc)((0, import_firestore15.doc)(db, CLINIC_GROUPS_COLLECTION, groupData.id), groupData);
-    await clinicAdminService.updateClinicAdmin(ownerId, {
-      clinicGroupId: groupData.id,
-      isGroupOwner: true
+    console.log("[CLINIC_GROUP] Validating complete clinic group object");
+    try {
+      clinicGroupSchema.parse(groupData);
+      console.log("[CLINIC_GROUP] Clinic group validation passed");
+    } catch (schemaError) {
+      console.error(
+        "[CLINIC_GROUP] Clinic group validation failed:",
+        JSON.stringify(schemaError, null, 2)
+      );
+      throw schemaError;
+    }
+    console.log("[CLINIC_GROUP] Saving clinic group to Firestore", {
+      groupId: groupData.id
+    });
+    try {
+      await (0, import_firestore15.setDoc)((0, import_firestore15.doc)(db, CLINIC_GROUPS_COLLECTION, groupData.id), groupData);
+      console.log("[CLINIC_GROUP] Clinic group saved successfully");
+    } catch (firestoreError) {
+      console.error(
+        "[CLINIC_GROUP] Error saving to Firestore:",
+        firestoreError
+      );
+      throw firestoreError;
+    }
+    console.log("[CLINIC_GROUP] Updating clinic admin profile for owner", {
+      ownerId
+    });
+    try {
+      await clinicAdminService.updateClinicAdmin(ownerId, {
+        clinicGroupId: groupData.id,
+        isGroupOwner: true
+      });
+      console.log("[CLINIC_GROUP] Clinic admin profile updated successfully");
+    } catch (updateError) {
+      console.error(
+        "[CLINIC_GROUP] Error updating clinic admin profile:",
+        updateError
+      );
+      throw updateError;
+    }
+    console.log("[CLINIC_GROUP] Clinic group creation completed successfully", {
+      groupId: groupData.id,
+      groupName: groupData.name
     });
     return groupData;
   } catch (error) {
     if (error instanceof import_zod13.z.ZodError) {
+      console.error(
+        "[CLINIC_GROUP] Zod validation error:",
+        JSON.stringify(error.errors, null, 2)
+      );
       throw new Error("Invalid clinic group data: " + error.message);
     }
+    console.error(
+      "[CLINIC_GROUP] Unhandled error in createClinicGroup:",
+      error
+    );
     throw error;
   }
 }
@@ -4476,19 +4674,52 @@ var AuthService = class extends BaseService {
    */
   async signUpClinicAdmin(data) {
     try {
-      await clinicAdminSignupSchema.parseAsync(data);
-      const { user: firebaseUser } = await (0, import_auth5.createUserWithEmailAndPassword)(
-        this.auth,
-        data.email,
-        data.password
-      );
-      const user = await this.userService.createUser(
-        firebaseUser,
-        ["clinic_admin" /* CLINIC_ADMIN */],
-        {
-          skipProfileCreation: true
-        }
-      );
+      console.log("[AUTH] Starting clinic admin signup process", {
+        email: data.email
+      });
+      try {
+        await clinicAdminSignupSchema.parseAsync(data);
+        console.log("[AUTH] Clinic admin signup data validation passed");
+      } catch (validationError) {
+        console.error(
+          "[AUTH] Validation error in signUpClinicAdmin:",
+          validationError
+        );
+        throw validationError;
+      }
+      console.log("[AUTH] Creating Firebase user");
+      let firebaseUser;
+      try {
+        const result = await (0, import_auth5.createUserWithEmailAndPassword)(
+          this.auth,
+          data.email,
+          data.password
+        );
+        firebaseUser = result.user;
+        console.log("[AUTH] Firebase user created successfully", {
+          uid: firebaseUser.uid
+        });
+      } catch (firebaseError) {
+        console.error("[AUTH] Firebase user creation failed:", firebaseError);
+        throw firebaseError;
+      }
+      console.log("[AUTH] Creating user with CLINIC_ADMIN role");
+      let user;
+      try {
+        user = await this.userService.createUser(
+          firebaseUser,
+          ["clinic_admin" /* CLINIC_ADMIN */],
+          {
+            skipProfileCreation: true
+          }
+        );
+        console.log("[AUTH] User with CLINIC_ADMIN role created successfully", {
+          userId: user.uid
+        });
+      } catch (userCreationError) {
+        console.error("[AUTH] User creation failed:", userCreationError);
+        throw userCreationError;
+      }
       const contactPerson = {
         firstName: data.firstName,
         lastName: data.lastName,
@@ -4496,6 +4727,8 @@ var AuthService = class extends BaseService {
         email: data.email,
         phoneNumber: data.phoneNumber
       };
+      console.log("[AUTH] Contact person object created");
+      console.log("[AUTH] Initializing clinic services");
       const clinicAdminService = new ClinicAdminService(
         this.db,
         this.auth,
@@ -4515,8 +4748,13 @@ var AuthService = class extends BaseService {
         clinicAdminService
       );
       clinicAdminService.setServices(clinicGroupService, clinicService);
+      console.log(
+        "[AUTH] Services initialized and circular dependencies resolved"
+      );
       if (data.isCreatingNewGroup) {
+        console.log("[AUTH] Creating new clinic group flow");
         if (!data.clinicGroupData) {
+          console.error("[AUTH] Clinic group data is missing");
           throw new Error(
             "Clinic group data is required when creating a new group"
           );
@@ -4531,36 +4769,79 @@ var AuthService = class extends BaseService {
           logo: data.clinicGroupData.logo || null,
           subscriptionModel: data.clinicGroupData.subscriptionModel || "no_subscription" /* NO_SUBSCRIPTION */
         };
-        await clinicGroupService.createClinicGroup(
-          createClinicGroupData,
-          firebaseUser.uid,
-          true
-        );
+        console.log("[AUTH] Clinic group data prepared", {
+          groupName: createClinicGroupData.name
+        });
+        try {
+          await clinicGroupService.createClinicGroup(
+            createClinicGroupData,
+            firebaseUser.uid,
+            true
+          );
+          console.log("[AUTH] Clinic group created successfully");
+        } catch (groupCreationError) {
+          console.error(
+            "[AUTH] Clinic group creation failed:",
+            groupCreationError
+          );
+          throw groupCreationError;
+        }
       } else {
+        console.log("[AUTH] Joining existing clinic group flow");
         if (!data.inviteToken) {
+          console.error("[AUTH] Invite token is missing");
           throw new Error(
             "Invite token is required when joining an existing group"
           );
         }
+        console.log("[AUTH] Invite token provided", {
+          token: data.inviteToken
+        });
+        console.log("[AUTH] Searching for token in clinic groups");
         const groupsRef = (0, import_firestore19.collection)(this.db, CLINIC_GROUPS_COLLECTION);
         const q = (0, import_firestore19.query)(groupsRef);
         const querySnapshot = await (0, import_firestore19.getDocs)(q);
         let foundGroup = null;
         let foundToken = null;
+        console.log(
+          "[AUTH] Found",
+          querySnapshot.size,
+          "clinic groups to check"
+        );
         for (const docSnapshot of querySnapshot.docs) {
           const group = docSnapshot.data();
-          const token = group.adminTokens.find(
-            (t) => t.token === data.inviteToken && t.status === "active" /* ACTIVE */ && new Date(t.expiresAt.toDate()) > /* @__PURE__ */ new Date()
-          );
+          console.log("[AUTH] Checking group", {
+            groupId: group.id,
+            groupName: group.name
+          });
+          const token = group.adminTokens.find((t) => {
+            const isMatch = t.token === data.inviteToken && t.status === "active" /* ACTIVE */ && new Date(t.expiresAt.toDate()) > /* @__PURE__ */ new Date();
+            console.log("[AUTH] Checking token", {
+              tokenId: t.id,
+              tokenMatch: t.token === data.inviteToken,
+              tokenStatus: t.status,
+              tokenActive: t.status === "active" /* ACTIVE */,
+              tokenExpiry: new Date(t.expiresAt.toDate()),
+              tokenExpired: new Date(t.expiresAt.toDate()) <= /* @__PURE__ */ new Date(),
+              isMatch
+            });
+            return isMatch;
+          });
           if (token) {
             foundGroup = group;
             foundToken = token;
+            console.log("[AUTH] Found matching token in group", {
+              groupId: group.id,
+              tokenId: token.id
+            });
             break;
           }
         }
         if (!foundGroup || !foundToken) {
+          console.error("[AUTH] No valid token found in any clinic group");
           throw new Error("Invalid or expired invite token");
         }
+        console.log("[AUTH] Creating clinic admin");
         const createClinicAdminData = {
           userRef: firebaseUser.uid,
           clinicGroupId: foundGroup.id,
@@ -4570,22 +4851,46 @@ var AuthService = class extends BaseService {
           roleTitle: data.title,
           isActive: true
         };
-        await clinicAdminService.createClinicAdmin(createClinicAdminData);
-        await clinicGroupService.verifyAndUseAdminToken(
-          foundGroup.id,
-          data.inviteToken,
-          firebaseUser.uid
-        );
+        try {
+          await clinicAdminService.createClinicAdmin(createClinicAdminData);
+          console.log("[AUTH] Clinic admin created successfully");
+        } catch (adminCreationError) {
+          console.error(
+            "[AUTH] Clinic admin creation failed:",
+            adminCreationError
+          );
+          throw adminCreationError;
+        }
+        try {
+          await clinicGroupService.verifyAndUseAdminToken(
+            foundGroup.id,
+            data.inviteToken,
+            firebaseUser.uid
+          );
+          console.log("[AUTH] Token marked as used successfully");
+        } catch (tokenUseError) {
+          console.error("[AUTH] Failed to mark token as used:", tokenUseError);
+          throw tokenUseError;
+        }
       }
+      console.log("[AUTH] Clinic admin signup completed successfully", {
+        userId: user.uid
+      });
       return user;
     } catch (error) {
       if (error instanceof import_zod15.z.ZodError) {
+        console.error(
+          "[AUTH] Zod validation error in signUpClinicAdmin:",
+          JSON.stringify(error.errors, null, 2)
+        );
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       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 AUTH_ERRORS.EMAIL_ALREADY_EXISTS;
       }
+      console.error("[AUTH] Unhandled error in signUpClinicAdmin:", error);
       throw error;
     }
   }