@blackcode_sa/metaestetics-api 1.8.14 → 1.8.16

package/dist/index.mjs

@@ -6879,81 +6879,235 @@ var PractitionerService = class extends BaseService {
    */
   async getPractitionersByFilters(filters) {
     try {
-      const constraints = [];
-      if (!filters.includeDraftPractitioners) {
-        constraints.push(where10("status", "==", "active" /* ACTIVE */));
-      }
-      constraints.push(where10("isActive", "==", true));
-      if (filters.certifications && filters.certifications.length > 0) {
-        constraints.push(
-          where10(
-            "certification.certifications",
-            "array-contains-any",
-            filters.certifications
-          )
-        );
+      console.log("[PRACTITIONER_SERVICE] Starting practitioner filtering with fallback strategies");
+      if (filters.location && filters.radiusInKm) {
+        console.log("[PRACTITIONER_SERVICE] Executing geo query:", {
+          location: filters.location,
+          radius: filters.radiusInKm,
+          serviceName: "PractitionerService"
+        });
+        if (!filters.location.latitude || !filters.location.longitude) {
+          console.warn("[PRACTITIONER_SERVICE] Invalid location data:", filters.location);
+          filters.location = void 0;
+          filters.radiusInKm = void 0;
+        }
       }
       if (filters.nameSearch && filters.nameSearch.trim()) {
-        const searchTerm = filters.nameSearch.trim().toLowerCase();
-        constraints.push(where10("fullNameLower", ">=", searchTerm));
-        constraints.push(where10("fullNameLower", "<=", searchTerm + "\uF8FF"));
-      }
-      if (filters.procedureTechnology) {
-        constraints.push(where10("proceduresInfo.technologyName", "==", filters.procedureTechnology));
-      } else if (filters.procedureSubcategory) {
-        constraints.push(where10("proceduresInfo.subcategoryName", "==", filters.procedureSubcategory));
-      } else if (filters.procedureCategory) {
-        constraints.push(where10("proceduresInfo.categoryName", "==", filters.procedureCategory));
-      } else if (filters.procedureFamily) {
-        constraints.push(where10("proceduresInfo.family", "==", filters.procedureFamily));
-      }
-      if (filters.minRating !== void 0) {
-        constraints.push(where10("reviewInfo.averageRating", ">=", filters.minRating));
-      }
-      if (filters.maxRating !== void 0) {
-        constraints.push(where10("reviewInfo.averageRating", "<=", filters.maxRating));
+        try {
+          console.log("[PRACTITIONER_SERVICE] Strategy 1: Trying fullNameLower search");
+          const searchTerm = filters.nameSearch.trim().toLowerCase();
+          const constraints = [];
+          if (!filters.includeDraftPractitioners) {
+            constraints.push(where10("status", "==", "active" /* ACTIVE */));
+          }
+          constraints.push(where10("isActive", "==", true));
+          constraints.push(where10("fullNameLower", ">=", searchTerm));
+          constraints.push(where10("fullNameLower", "<=", searchTerm + "\uF8FF"));
+          constraints.push(orderBy4("fullNameLower"));
+          if (filters.lastDoc) {
+            if (typeof filters.lastDoc.data === "function") {
+              constraints.push(startAfter6(filters.lastDoc));
+            } else if (Array.isArray(filters.lastDoc)) {
+              constraints.push(startAfter6(...filters.lastDoc));
+            } else {
+              constraints.push(startAfter6(filters.lastDoc));
+            }
+          }
+          constraints.push(limit7(filters.pagination || 10));
+          const q = query10(collection10(this.db, PRACTITIONERS_COLLECTION), ...constraints);
+          const querySnapshot = await getDocs10(q);
+          const practitioners = querySnapshot.docs.map((doc37) => ({ ...doc37.data(), id: doc37.id }));
+          const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+          console.log(`[PRACTITIONER_SERVICE] Strategy 1 success: ${practitioners.length} practitioners`);
+          if (practitioners.length < (filters.pagination || 10)) {
+            return { practitioners, lastDoc: null };
+          }
+          return { practitioners, lastDoc };
+        } catch (error) {
+          console.log("[PRACTITIONER_SERVICE] Strategy 1 failed:", error);
+        }
       }
-      constraints.push(orderBy4("fullNameLower"));
-      if (filters.lastDoc) {
-        if (typeof filters.lastDoc.data === "function") {
-          constraints.push(startAfter6(filters.lastDoc));
-        } else if (Array.isArray(filters.lastDoc)) {
-          constraints.push(startAfter6(...filters.lastDoc));
+      try {
+        console.log("[PRACTITIONER_SERVICE] Strategy 2: Basic query with createdAt ordering");
+        const constraints = [];
+        if (!filters.includeDraftPractitioners) {
+          constraints.push(where10("status", "==", "active" /* ACTIVE */));
+        }
+        constraints.push(where10("isActive", "==", true));
+        if (filters.certifications && filters.certifications.length > 0) {
+          const certificationsToMatch = filters.certifications;
+          constraints.push(
+            where10("certification.specialties", "array-contains-any", certificationsToMatch)
+          );
+        }
+        if (filters.minRating !== void 0) {
+          constraints.push(where10("reviewInfo.averageRating", ">=", filters.minRating));
+        }
+        if (filters.maxRating !== void 0) {
+          constraints.push(where10("reviewInfo.averageRating", "<=", filters.maxRating));
+        }
+        constraints.push(orderBy4("createdAt", "desc"));
+        if (filters.location && filters.radiusInKm) {
+          constraints.push(limit7((filters.pagination || 10) * 2));
         } else {
-          constraints.push(startAfter6(filters.lastDoc));
+          if (filters.lastDoc) {
+            if (typeof filters.lastDoc.data === "function") {
+              constraints.push(startAfter6(filters.lastDoc));
+            } else if (Array.isArray(filters.lastDoc)) {
+              constraints.push(startAfter6(...filters.lastDoc));
+            } else {
+              constraints.push(startAfter6(filters.lastDoc));
+            }
+          }
+          constraints.push(limit7(filters.pagination || 10));
         }
-      }
-      constraints.push(limit7(filters.pagination || 5));
-      const q = query10(collection10(this.db, PRACTITIONERS_COLLECTION), ...constraints);
-      const querySnapshot = await getDocs10(q);
-      let practitioners = querySnapshot.docs.map((doc37) => ({ ...doc37.data(), id: doc37.id }));
-      if (filters.location && filters.radiusInKm && filters.radiusInKm > 0) {
-        const location = filters.location;
-        const radiusInKm = filters.radiusInKm;
-        practitioners = practitioners.filter((practitioner) => {
-          const clinics = practitioner.clinicsInfo || [];
-          return clinics.some((clinic) => {
-            const distance = distanceBetween(
-              [location.latitude, location.longitude],
-              [clinic.location.latitude, clinic.location.longitude]
-            );
-            const distanceInKm = distance / 1e3;
-            return distanceInKm <= radiusInKm;
+        const q = query10(collection10(this.db, PRACTITIONERS_COLLECTION), ...constraints);
+        const querySnapshot = await getDocs10(q);
+        let practitioners = querySnapshot.docs.map((doc37) => ({ ...doc37.data(), id: doc37.id }));
+        if (filters.location && filters.radiusInKm && filters.radiusInKm > 0) {
+          const location = filters.location;
+          const radiusInKm = filters.radiusInKm;
+          practitioners = practitioners.filter((practitioner) => {
+            const clinics = practitioner.clinicsInfo || [];
+            return clinics.some((clinic) => {
+              const distance = distanceBetween(
+                [location.latitude, location.longitude],
+                [clinic.location.latitude, clinic.location.longitude]
+              );
+              const distanceInKm = distance / 1e3;
+              return distanceInKm <= radiusInKm;
+            });
           });
-        });
+          practitioners = practitioners.slice(0, filters.pagination || 10);
+        }
+        practitioners = this.applyInMemoryFilters(practitioners, filters);
+        const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+        console.log(`[PRACTITIONER_SERVICE] Strategy 2 success: ${practitioners.length} practitioners`);
+        if (practitioners.length < (filters.pagination || 10)) {
+          return { practitioners, lastDoc: null };
+        }
+        return { practitioners, lastDoc };
+      } catch (error) {
+        console.log("[PRACTITIONER_SERVICE] Strategy 2 failed:", error);
       }
-      const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
-      return {
-        practitioners,
-        lastDoc
-      };
+      try {
+        console.log("[PRACTITIONER_SERVICE] Strategy 3: Minimal query fallback");
+        const constraints = [
+          where10("isActive", "==", true),
+          orderBy4("createdAt", "desc"),
+          limit7(filters.pagination || 10)
+        ];
+        const q = query10(collection10(this.db, PRACTITIONERS_COLLECTION), ...constraints);
+        const querySnapshot = await getDocs10(q);
+        let practitioners = querySnapshot.docs.map((doc37) => ({ ...doc37.data(), id: doc37.id }));
+        practitioners = this.applyInMemoryFilters(practitioners, filters);
+        const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+        console.log(`[PRACTITIONER_SERVICE] Strategy 3 success: ${practitioners.length} practitioners`);
+        if (practitioners.length < (filters.pagination || 10)) {
+          return { practitioners, lastDoc: null };
+        }
+        return { practitioners, lastDoc };
+      } catch (error) {
+        console.log("[PRACTITIONER_SERVICE] Strategy 3 failed:", error);
+      }
+      console.log("[PRACTITIONER_SERVICE] All strategies failed, returning empty result");
+      return { practitioners: [], lastDoc: null };
     } catch (error) {
-      console.error(
-        "[PRACTITIONER_SERVICE] Error filtering practitioners:",
-        error
-      );
-      throw error;
+      console.error("[PRACTITIONER_SERVICE] Error filtering practitioners:", error);
+      return { practitioners: [], lastDoc: null };
+    }
+  }
+  /**
+   * Applies in-memory filters to practitioners array
+   * Used when Firestore queries fail or for complex filtering
+   */
+  applyInMemoryFilters(practitioners, filters) {
+    let filteredPractitioners = [...practitioners];
+    if (filters.nameSearch && filters.nameSearch.trim()) {
+      const searchTerm = filters.nameSearch.trim().toLowerCase();
+      filteredPractitioners = filteredPractitioners.filter((practitioner) => {
+        var _a, _b;
+        const firstName = (((_a = practitioner.basicInfo) == null ? void 0 : _a.firstName) || "").toLowerCase();
+        const lastName = (((_b = practitioner.basicInfo) == null ? void 0 : _b.lastName) || "").toLowerCase();
+        const fullName = `${firstName} ${lastName}`.trim();
+        const fullNameLower = practitioner.fullNameLower || "";
+        return firstName.includes(searchTerm) || lastName.includes(searchTerm) || fullName.includes(searchTerm) || fullNameLower.includes(searchTerm);
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied name filter, results: ${filteredPractitioners.length}`);
+    }
+    if (filters.certifications && filters.certifications.length > 0) {
+      const certificationsToMatch = filters.certifications;
+      filteredPractitioners = filteredPractitioners.filter((practitioner) => {
+        var _a;
+        const practitionerCerts = ((_a = practitioner.certification) == null ? void 0 : _a.specialties) || [];
+        return certificationsToMatch.some((cert) => practitionerCerts.includes(cert));
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied certifications filter, results: ${filteredPractitioners.length}`);
+    }
+    if (filters.specialties && filters.specialties.length > 0) {
+      const specialtiesToMatch = filters.specialties;
+      filteredPractitioners = filteredPractitioners.filter((practitioner) => {
+        var _a;
+        const practitionerSpecs = ((_a = practitioner.certification) == null ? void 0 : _a.specialties) || [];
+        return specialtiesToMatch.some((spec) => practitionerSpecs.includes(spec));
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied specialties filter, results: ${filteredPractitioners.length}`);
+    }
+    if (filters.minRating !== void 0 || filters.maxRating !== void 0) {
+      filteredPractitioners = filteredPractitioners.filter((practitioner) => {
+        var _a;
+        const rating = ((_a = practitioner.reviewInfo) == null ? void 0 : _a.averageRating) || 0;
+        if (filters.minRating !== void 0 && rating < filters.minRating) return false;
+        if (filters.maxRating !== void 0 && rating > filters.maxRating) return false;
+        return true;
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied rating filter, results: ${filteredPractitioners.length}`);
+    }
+    if (filters.procedureFamily) {
+      filteredPractitioners = filteredPractitioners.filter((practitioner) => {
+        const proceduresInfo = practitioner.proceduresInfo || [];
+        return proceduresInfo.some((proc) => proc.family === filters.procedureFamily);
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied procedure family filter, results: ${filteredPractitioners.length}`);
+    }
+    if (filters.procedureCategory) {
+      filteredPractitioners = filteredPractitioners.filter((practitioner) => {
+        const proceduresInfo = practitioner.proceduresInfo || [];
+        return proceduresInfo.some((proc) => proc.categoryName === filters.procedureCategory);
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied procedure category filter, results: ${filteredPractitioners.length}`);
+    }
+    if (filters.procedureSubcategory) {
+      filteredPractitioners = filteredPractitioners.filter((practitioner) => {
+        const proceduresInfo = practitioner.proceduresInfo || [];
+        return proceduresInfo.some((proc) => proc.subcategoryName === filters.procedureSubcategory);
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied procedure subcategory filter, results: ${filteredPractitioners.length}`);
     }
+    if (filters.procedureTechnology) {
+      filteredPractitioners = filteredPractitioners.filter((practitioner) => {
+        const proceduresInfo = practitioner.proceduresInfo || [];
+        return proceduresInfo.some((proc) => proc.technologyName === filters.procedureTechnology);
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied procedure technology filter, results: ${filteredPractitioners.length}`);
+    }
+    if (filters.location && filters.radiusInKm && filters.radiusInKm > 0) {
+      const location = filters.location;
+      const radiusInKm = filters.radiusInKm;
+      filteredPractitioners = filteredPractitioners.filter((practitioner) => {
+        const clinics = practitioner.clinicsInfo || [];
+        return clinics.some((clinic) => {
+          const distance = distanceBetween(
+            [location.latitude, location.longitude],
+            [clinic.location.latitude, clinic.location.longitude]
+          );
+          const distanceInKm = distance / 1e3;
+          return distanceInKm <= radiusInKm;
+        });
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied geo filter, results: ${filteredPractitioners.length}`);
+    }
+    return filteredPractitioners;
   }
   /**
    * Enables free consultation for a practitioner in a specific clinic
@@ -8637,49 +8791,181 @@ import {
 } from "firebase/firestore";
 import { distanceBetween as distanceBetween4 } from "geofire-common";
 async function getClinicsByFilters(db, filters) {
-  var _a;
-  const constraints = [];
-  constraints.push(where15("isActive", "==", (_a = filters.isActive) != null ? _a : true));
-  if (filters.tags && filters.tags.length > 0) {
-    constraints.push(where15("tags", "array-contains", filters.tags[0]));
-  }
-  if (filters.procedureTechnology) {
-    constraints.push(where15("servicesInfo.technology", "==", filters.procedureTechnology));
-  } else if (filters.procedureSubcategory) {
-    constraints.push(where15("servicesInfo.subCategory", "==", filters.procedureSubcategory));
-  } else if (filters.procedureCategory) {
-    constraints.push(where15("servicesInfo.category", "==", filters.procedureCategory));
-  } else if (filters.procedureFamily) {
-    constraints.push(where15("servicesInfo.procedureFamily", "==", filters.procedureFamily));
-  }
-  let useNameLower = false;
-  let searchTerm = "";
-  if (filters.nameSearch && filters.nameSearch.trim()) {
-    searchTerm = filters.nameSearch.trim().toLowerCase();
-    constraints.push(where15("nameLower", ">=", searchTerm));
-    constraints.push(where15("nameLower", "<=", searchTerm + "\uF8FF"));
-    useNameLower = true;
-  }
-  if (filters.minRating !== void 0) {
-    constraints.push(where15("reviewInfo.averageRating", ">=", filters.minRating));
-  }
-  if (filters.maxRating !== void 0) {
-    constraints.push(where15("reviewInfo.averageRating", "<=", filters.maxRating));
-  }
-  constraints.push(orderBy5("nameLower"));
-  if (filters.lastDoc) {
-    if (typeof filters.lastDoc.data === "function") {
-      constraints.push(startAfter8(filters.lastDoc));
-    } else if (Array.isArray(filters.lastDoc)) {
-      constraints.push(startAfter8(...filters.lastDoc));
-    } else {
-      constraints.push(startAfter8(filters.lastDoc));
+  try {
+    console.log("[CLINIC_SERVICE] Starting clinic filtering with multiple strategies");
+    if (filters.center && filters.radiusInKm) {
+      console.log("[CLINIC_SERVICE] Executing geo query:", {
+        center: filters.center,
+        radius: filters.radiusInKm,
+        serviceName: "ClinicService"
+      });
+      if (!filters.center.latitude || !filters.center.longitude) {
+        console.warn("[CLINIC_SERVICE] Invalid location data:", filters.center);
+        filters.center = void 0;
+        filters.radiusInKm = void 0;
+      }
+    }
+    const getBaseConstraints = () => {
+      var _a;
+      const constraints = [];
+      constraints.push(where15("isActive", "==", (_a = filters.isActive) != null ? _a : true));
+      if (filters.tags && filters.tags.length > 0) {
+        constraints.push(where15("tags", "array-contains", filters.tags[0]));
+      }
+      if (filters.procedureTechnology) {
+        constraints.push(where15("servicesInfo.technology", "==", filters.procedureTechnology));
+      } else if (filters.procedureSubcategory) {
+        constraints.push(where15("servicesInfo.subCategory", "==", filters.procedureSubcategory));
+      } else if (filters.procedureCategory) {
+        constraints.push(where15("servicesInfo.category", "==", filters.procedureCategory));
+      } else if (filters.procedureFamily) {
+        constraints.push(where15("servicesInfo.procedureFamily", "==", filters.procedureFamily));
+      }
+      if (filters.minRating !== void 0) {
+        constraints.push(where15("reviewInfo.averageRating", ">=", filters.minRating));
+      }
+      if (filters.maxRating !== void 0) {
+        constraints.push(where15("reviewInfo.averageRating", "<=", filters.maxRating));
+      }
+      return constraints;
+    };
+    if (filters.nameSearch && filters.nameSearch.trim()) {
+      try {
+        console.log("[CLINIC_SERVICE] Strategy 1: Trying nameLower search");
+        const searchTerm = filters.nameSearch.trim().toLowerCase();
+        const constraints = getBaseConstraints();
+        constraints.push(where15("nameLower", ">=", searchTerm));
+        constraints.push(where15("nameLower", "<=", searchTerm + "\uF8FF"));
+        constraints.push(orderBy5("nameLower"));
+        if (filters.lastDoc) {
+          if (typeof filters.lastDoc.data === "function") {
+            constraints.push(startAfter8(filters.lastDoc));
+          } else if (Array.isArray(filters.lastDoc)) {
+            constraints.push(startAfter8(...filters.lastDoc));
+          } else {
+            constraints.push(startAfter8(filters.lastDoc));
+          }
+        }
+        constraints.push(limit9(filters.pagination || 5));
+        const q = query15(collection15(db, CLINICS_COLLECTION), ...constraints);
+        const querySnapshot = await getDocs15(q);
+        let clinics = querySnapshot.docs.map((doc37) => ({ ...doc37.data(), id: doc37.id }));
+        clinics = applyInMemoryFilters(clinics, filters);
+        const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+        console.log(`[CLINIC_SERVICE] Strategy 1 success: ${clinics.length} clinics`);
+        if (clinics.length < (filters.pagination || 5)) {
+          return { clinics, lastDoc: null };
+        }
+        return { clinics, lastDoc };
+      } catch (error) {
+        console.log("[CLINIC_SERVICE] Strategy 1 failed:", error);
+      }
     }
+    if (filters.nameSearch && filters.nameSearch.trim()) {
+      try {
+        console.log("[CLINIC_SERVICE] Strategy 2: Trying name field search");
+        const searchTerm = filters.nameSearch.trim().toLowerCase();
+        const constraints = getBaseConstraints();
+        constraints.push(where15("name", ">=", searchTerm));
+        constraints.push(where15("name", "<=", searchTerm + "\uF8FF"));
+        constraints.push(orderBy5("name"));
+        if (filters.lastDoc) {
+          if (typeof filters.lastDoc.data === "function") {
+            constraints.push(startAfter8(filters.lastDoc));
+          } else if (Array.isArray(filters.lastDoc)) {
+            constraints.push(startAfter8(...filters.lastDoc));
+          } else {
+            constraints.push(startAfter8(filters.lastDoc));
+          }
+        }
+        constraints.push(limit9(filters.pagination || 5));
+        const q = query15(collection15(db, CLINICS_COLLECTION), ...constraints);
+        const querySnapshot = await getDocs15(q);
+        let clinics = querySnapshot.docs.map((doc37) => ({ ...doc37.data(), id: doc37.id }));
+        clinics = applyInMemoryFilters(clinics, filters);
+        const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+        console.log(`[CLINIC_SERVICE] Strategy 2 success: ${clinics.length} clinics`);
+        if (clinics.length < (filters.pagination || 5)) {
+          return { clinics, lastDoc: null };
+        }
+        return { clinics, lastDoc };
+      } catch (error) {
+        console.log("[CLINIC_SERVICE] Strategy 2 failed:", error);
+      }
+    }
+    try {
+      console.log("[CLINIC_SERVICE] Strategy 3: Using createdAt ordering with client-side filtering");
+      const constraints = getBaseConstraints();
+      constraints.push(orderBy5("createdAt", "desc"));
+      if (filters.lastDoc) {
+        if (typeof filters.lastDoc.data === "function") {
+          constraints.push(startAfter8(filters.lastDoc));
+        } else if (Array.isArray(filters.lastDoc)) {
+          constraints.push(startAfter8(...filters.lastDoc));
+        } else {
+          constraints.push(startAfter8(filters.lastDoc));
+        }
+      }
+      constraints.push(limit9(filters.pagination || 5));
+      const q = query15(collection15(db, CLINICS_COLLECTION), ...constraints);
+      const querySnapshot = await getDocs15(q);
+      let clinics = querySnapshot.docs.map((doc37) => ({ ...doc37.data(), id: doc37.id }));
+      if (filters.nameSearch && filters.nameSearch.trim()) {
+        const searchTerm = filters.nameSearch.trim().toLowerCase();
+        clinics = clinics.filter((clinic) => {
+          const name = (clinic.name || "").toLowerCase();
+          const nameLower = clinic.nameLower || "";
+          return name.includes(searchTerm) || nameLower.includes(searchTerm);
+        });
+        console.log(`[CLINIC_SERVICE] Applied name filter, results: ${clinics.length}`);
+      }
+      clinics = applyInMemoryFilters(clinics, filters);
+      const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+      console.log(`[CLINIC_SERVICE] Strategy 3 success: ${clinics.length} clinics`);
+      if (clinics.length < (filters.pagination || 5)) {
+        return { clinics, lastDoc: null };
+      }
+      return { clinics, lastDoc };
+    } catch (error) {
+      console.log("[CLINIC_SERVICE] Strategy 3 failed:", error);
+    }
+    try {
+      console.log("[CLINIC_SERVICE] Strategy 4: Minimal fallback");
+      const constraints = [
+        where15("isActive", "==", true),
+        orderBy5("createdAt", "desc"),
+        limit9(filters.pagination || 5)
+      ];
+      const q = query15(collection15(db, CLINICS_COLLECTION), ...constraints);
+      const querySnapshot = await getDocs15(q);
+      let clinics = querySnapshot.docs.map((doc37) => ({ ...doc37.data(), id: doc37.id }));
+      if (filters.nameSearch && filters.nameSearch.trim()) {
+        const searchTerm = filters.nameSearch.trim().toLowerCase();
+        clinics = clinics.filter((clinic) => {
+          const name = (clinic.name || "").toLowerCase();
+          const nameLower = clinic.nameLower || "";
+          return name.includes(searchTerm) || nameLower.includes(searchTerm);
+        });
+        console.log(`[CLINIC_SERVICE] Applied name filter, results: ${clinics.length}`);
+      }
+      clinics = applyInMemoryFilters(clinics, filters);
+      const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+      console.log(`[CLINIC_SERVICE] Strategy 4 success: ${clinics.length} clinics`);
+      if (clinics.length < (filters.pagination || 5)) {
+        return { clinics, lastDoc: null };
+      }
+      return { clinics, lastDoc };
+    } catch (error) {
+      console.log("[CLINIC_SERVICE] Strategy 4 failed:", error);
+    }
+    console.log("[CLINIC_SERVICE] All strategies failed, returning empty result");
+    return { clinics: [], lastDoc: null };
+  } catch (error) {
+    console.error("[CLINIC_SERVICE] Error filtering clinics:", error);
+    return { clinics: [], lastDoc: null };
   }
-  constraints.push(limit9(filters.pagination || 5));
-  const q = query15(collection15(db, CLINICS_COLLECTION), ...constraints);
-  const querySnapshot = await getDocs15(q);
-  let clinics = querySnapshot.docs.map((doc37) => ({ ...doc37.data(), id: doc37.id }));
+}
+function applyInMemoryFilters(clinics, filters) {
   if (filters.tags && filters.tags.length > 1) {
     clinics = clinics.filter((clinic) => filters.tags.every((tag) => clinic.tags.includes(tag)));
   }
@@ -8692,9 +8978,9 @@ async function getClinicsByFilters(db, filters) {
       clinic.distance = distance;
       return distance <= filters.radiusInKm;
     });
+    clinics.sort((a, b) => (a.distance || 0) - (b.distance || 0));
   }
-  const lastVisibleDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
-  return { clinics, lastDoc: lastVisibleDoc };
+  return clinics;
 }
 
 // src/services/clinic/clinic.service.ts
@@ -14531,7 +14817,7 @@ var procedureSchema = createProcedureSchema.extend({
 });
 
 // src/services/procedure/procedure.service.ts
-import { distanceBetween as distanceBetween6, geohashQueryBounds as geohashQueryBounds5 } from "geofire-common";
+import { distanceBetween as distanceBetween6 } from "geofire-common";
 var ProcedureService = class extends BaseService {
   constructor(db, auth, app, categoryService, subcategoryService, technologyService, productService, mediaService) {
     super(db, auth, app);
@@ -15160,126 +15446,292 @@ var ProcedureService = class extends BaseService {
    */
   async getProceduresByFilters(filters) {
     try {
-      const isGeoQuery = filters.location && filters.radiusInKm && filters.radiusInKm > 0;
-      const constraints = [];
-      if (filters.isActive !== void 0) {
-        constraints.push(where29("isActive", "==", filters.isActive));
-      } else {
-        constraints.push(where29("isActive", "==", true));
-      }
-      if (filters.procedureFamily) {
-        constraints.push(where29("family", "==", filters.procedureFamily));
-      }
-      if (filters.procedureCategory) {
-        constraints.push(where29("category.id", "==", filters.procedureCategory));
-      }
-      if (filters.procedureSubcategory) {
-        constraints.push(where29("subcategory.id", "==", filters.procedureSubcategory));
-      }
-      if (filters.procedureTechnology) {
-        constraints.push(where29("technology.id", "==", filters.procedureTechnology));
-      }
-      if (filters.minPrice !== void 0) {
-        constraints.push(where29("price", ">=", filters.minPrice));
-      }
-      if (filters.maxPrice !== void 0) {
-        constraints.push(where29("price", "<=", filters.maxPrice));
-      }
-      if (filters.minRating !== void 0) {
-        constraints.push(where29("reviewInfo.averageRating", ">=", filters.minRating));
-      }
-      if (filters.maxRating !== void 0) {
-        constraints.push(where29("reviewInfo.averageRating", "<=", filters.maxRating));
-      }
-      if (filters.treatmentBenefits && filters.treatmentBenefits.length > 0) {
-        constraints.push(where29("treatmentBenefits", "array-contains-any", filters.treatmentBenefits));
+      console.log("[PROCEDURE_SERVICE] Starting procedure filtering with multiple strategies");
+      if (filters.location && filters.radiusInKm) {
+        console.log("[PROCEDURE_SERVICE] Executing geo query:", {
+          location: filters.location,
+          radius: filters.radiusInKm,
+          serviceName: "ProcedureService"
+        });
+        if (!filters.location.latitude || !filters.location.longitude) {
+          console.warn("[PROCEDURE_SERVICE] Invalid location data:", filters.location);
+          filters.location = void 0;
+          filters.radiusInKm = void 0;
+        }
       }
-      let useNameLower = false;
-      let searchTerm = "";
-      if (filters.nameSearch && filters.nameSearch.trim() !== "") {
-        searchTerm = filters.nameSearch.trim().toLowerCase();
-        useNameLower = true;
-        constraints.push(where29("nameLower", ">=", searchTerm));
-        constraints.push(where29("nameLower", "<=", searchTerm + "\uF8FF"));
-        constraints.push(orderBy17("nameLower"));
-      } else {
-        constraints.push(orderBy17("nameLower"));
+      const isGeoQuery = filters.location && filters.radiusInKm && filters.radiusInKm > 0;
+      if (isGeoQuery) {
+        return this.handleGeoQuery(filters);
       }
-      if (filters.lastDoc) {
-        if (typeof filters.lastDoc.data === "function") {
-          constraints.push(startAfter13(filters.lastDoc));
-        } else if (Array.isArray(filters.lastDoc)) {
-          constraints.push(startAfter13(...filters.lastDoc));
+      const getBaseConstraints = () => {
+        const constraints = [];
+        if (filters.isActive !== void 0) {
+          constraints.push(where29("isActive", "==", filters.isActive));
         } else {
-          constraints.push(startAfter13(filters.lastDoc));
+          constraints.push(where29("isActive", "==", true));
         }
-      }
-      if (filters.pagination && filters.pagination > 0) {
-        constraints.push(limit15(filters.pagination));
-      }
-      if (isGeoQuery) {
-        const center = filters.location;
-        const radiusInKm = filters.radiusInKm;
-        const bounds = geohashQueryBounds5(
-          [center.latitude, center.longitude],
-          radiusInKm * 1e3
-          // Convert to meters
-        );
-        let allDocs = [];
-        for (const bound of bounds) {
-          const geoConstraints = [
-            ...constraints.filter((c) => !c.fieldPath || c.fieldPath !== "name"),
-            // Remove name orderBy for geo
-            where29("clinicInfo.location.geohash", ">=", bound[0]),
-            where29("clinicInfo.location.geohash", "<=", bound[1]),
-            orderBy17("clinicInfo.location.geohash")
-          ];
-          const q = query29(collection29(this.db, PROCEDURES_COLLECTION), ...geoConstraints);
-          const querySnapshot = await getDocs29(q);
-          for (const doc37 of querySnapshot.docs) {
-            const procedure = { ...doc37.data(), id: doc37.id };
-            const distance = distanceBetween6(
-              [center.latitude, center.longitude],
-              [procedure.clinicInfo.location.latitude, procedure.clinicInfo.location.longitude]
-            );
-            const distanceInKm = distance / 1e3;
-            if (distanceInKm <= radiusInKm) {
-              allDocs.push({ ...procedure, distance: distanceInKm });
-            }
-          }
+        if (filters.procedureFamily) {
+          constraints.push(where29("family", "==", filters.procedureFamily));
+        }
+        if (filters.procedureCategory) {
+          constraints.push(where29("category.id", "==", filters.procedureCategory));
+        }
+        if (filters.procedureSubcategory) {
+          constraints.push(where29("subcategory.id", "==", filters.procedureSubcategory));
+        }
+        if (filters.procedureTechnology) {
+          constraints.push(where29("technology.id", "==", filters.procedureTechnology));
+        }
+        if (filters.minPrice !== void 0) {
+          constraints.push(where29("price", ">=", filters.minPrice));
+        }
+        if (filters.maxPrice !== void 0) {
+          constraints.push(where29("price", "<=", filters.maxPrice));
         }
-        allDocs.sort((a, b) => a.distance - b.distance);
-        let paginated = allDocs;
-        if (filters.pagination && filters.pagination > 0) {
-          let startIndex = 0;
+        if (filters.minRating !== void 0) {
+          constraints.push(where29("reviewInfo.averageRating", ">=", filters.minRating));
+        }
+        if (filters.maxRating !== void 0) {
+          constraints.push(where29("reviewInfo.averageRating", "<=", filters.maxRating));
+        }
+        if (filters.treatmentBenefits && filters.treatmentBenefits.length > 0) {
+          const benefitsToMatch = filters.treatmentBenefits;
+          constraints.push(where29("treatmentBenefits", "array-contains-any", benefitsToMatch));
+        }
+        return constraints;
+      };
+      if (filters.nameSearch && filters.nameSearch.trim()) {
+        try {
+          console.log("[PROCEDURE_SERVICE] Strategy 1: Trying nameLower search");
+          const searchTerm = filters.nameSearch.trim().toLowerCase();
+          const constraints = getBaseConstraints();
+          constraints.push(where29("nameLower", ">=", searchTerm));
+          constraints.push(where29("nameLower", "<=", searchTerm + "\uF8FF"));
+          constraints.push(orderBy17("nameLower"));
           if (filters.lastDoc) {
-            const lastDocIndex = allDocs.findIndex((p) => p.id === filters.lastDoc.id);
-            if (lastDocIndex !== -1) startIndex = lastDocIndex + 1;
+            if (typeof filters.lastDoc.data === "function") {
+              constraints.push(startAfter13(filters.lastDoc));
+            } else if (Array.isArray(filters.lastDoc)) {
+              constraints.push(startAfter13(...filters.lastDoc));
+            } else {
+              constraints.push(startAfter13(filters.lastDoc));
+            }
           }
-          paginated = allDocs.slice(startIndex, startIndex + filters.pagination);
+          constraints.push(limit15(filters.pagination || 10));
+          const q = query29(collection29(this.db, PROCEDURES_COLLECTION), ...constraints);
+          const querySnapshot = await getDocs29(q);
+          const procedures = querySnapshot.docs.map((doc37) => ({ ...doc37.data(), id: doc37.id }));
+          const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+          console.log(`[PROCEDURE_SERVICE] Strategy 1 success: ${procedures.length} procedures`);
+          if (procedures.length < (filters.pagination || 10)) {
+            return { procedures, lastDoc: null };
+          }
+          return { procedures, lastDoc };
+        } catch (error) {
+          console.log("[PROCEDURE_SERVICE] Strategy 1 failed:", error);
         }
-        const lastVisibleDoc = paginated.length > 0 ? paginated[paginated.length - 1] : null;
-        return { procedures: paginated, lastDoc: lastVisibleDoc };
-      } else {
-        let q = query29(collection29(this.db, PROCEDURES_COLLECTION), ...constraints);
-        let querySnapshot = await getDocs29(q);
-        if (useNameLower && querySnapshot.empty && searchTerm) {
-          constraints.pop();
-          constraints.pop();
-          constraints.pop();
+      }
+      if (filters.nameSearch && filters.nameSearch.trim()) {
+        try {
+          console.log("[PROCEDURE_SERVICE] Strategy 2: Trying name field search");
+          const searchTerm = filters.nameSearch.trim().toLowerCase();
+          const constraints = getBaseConstraints();
           constraints.push(where29("name", ">=", searchTerm));
           constraints.push(where29("name", "<=", searchTerm + "\uF8FF"));
           constraints.push(orderBy17("name"));
-          q = query29(collection29(this.db, PROCEDURES_COLLECTION), ...constraints);
-          querySnapshot = await getDocs29(q);
+          if (filters.lastDoc) {
+            if (typeof filters.lastDoc.data === "function") {
+              constraints.push(startAfter13(filters.lastDoc));
+            } else if (Array.isArray(filters.lastDoc)) {
+              constraints.push(startAfter13(...filters.lastDoc));
+            } else {
+              constraints.push(startAfter13(filters.lastDoc));
+            }
+          }
+          constraints.push(limit15(filters.pagination || 10));
+          const q = query29(collection29(this.db, PROCEDURES_COLLECTION), ...constraints);
+          const querySnapshot = await getDocs29(q);
+          const procedures = querySnapshot.docs.map((doc37) => ({ ...doc37.data(), id: doc37.id }));
+          const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+          console.log(`[PROCEDURE_SERVICE] Strategy 2 success: ${procedures.length} procedures`);
+          if (procedures.length < (filters.pagination || 10)) {
+            return { procedures, lastDoc: null };
+          }
+          return { procedures, lastDoc };
+        } catch (error) {
+          console.log("[PROCEDURE_SERVICE] Strategy 2 failed:", error);
         }
-        const procedures = querySnapshot.docs.map((doc37) => ({ ...doc37.data(), id: doc37.id }));
-        const lastVisibleDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
-        return { procedures, lastDoc: lastVisibleDoc };
       }
+      try {
+        console.log("[PROCEDURE_SERVICE] Strategy 3: Using createdAt orderBy with client-side filtering");
+        const constraints = getBaseConstraints();
+        constraints.push(orderBy17("createdAt", "desc"));
+        if (filters.lastDoc) {
+          if (typeof filters.lastDoc.data === "function") {
+            constraints.push(startAfter13(filters.lastDoc));
+          } else if (Array.isArray(filters.lastDoc)) {
+            constraints.push(startAfter13(...filters.lastDoc));
+          } else {
+            constraints.push(startAfter13(filters.lastDoc));
+          }
+        }
+        constraints.push(limit15(filters.pagination || 10));
+        const q = query29(collection29(this.db, PROCEDURES_COLLECTION), ...constraints);
+        const querySnapshot = await getDocs29(q);
+        let procedures = querySnapshot.docs.map((doc37) => ({ ...doc37.data(), id: doc37.id }));
+        procedures = this.applyInMemoryFilters(procedures, filters);
+        const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+        console.log(`[PROCEDURE_SERVICE] Strategy 3 success: ${procedures.length} procedures`);
+        if (procedures.length < (filters.pagination || 10)) {
+          return { procedures, lastDoc: null };
+        }
+        return { procedures, lastDoc };
+      } catch (error) {
+        console.log("[PROCEDURE_SERVICE] Strategy 3 failed:", error);
+      }
+      try {
+        console.log("[PROCEDURE_SERVICE] Strategy 4: Minimal query fallback");
+        const constraints = [
+          where29("isActive", "==", true),
+          orderBy17("createdAt", "desc"),
+          limit15(filters.pagination || 10)
+        ];
+        const q = query29(collection29(this.db, PROCEDURES_COLLECTION), ...constraints);
+        const querySnapshot = await getDocs29(q);
+        let procedures = querySnapshot.docs.map((doc37) => ({ ...doc37.data(), id: doc37.id }));
+        procedures = this.applyInMemoryFilters(procedures, filters);
+        const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+        console.log(`[PROCEDURE_SERVICE] Strategy 4 success: ${procedures.length} procedures`);
+        if (procedures.length < (filters.pagination || 10)) {
+          return { procedures, lastDoc: null };
+        }
+        return { procedures, lastDoc };
+      } catch (error) {
+        console.log("[PROCEDURE_SERVICE] Strategy 4 failed:", error);
+      }
+      console.log("[PROCEDURE_SERVICE] All strategies failed, returning empty result");
+      return { procedures: [], lastDoc: null };
     } catch (error) {
       console.error("[PROCEDURE_SERVICE] Error filtering procedures:", error);
-      throw error;
+      return { procedures: [], lastDoc: null };
+    }
+  }
+  /**
+   * Applies in-memory filters to procedures array
+   * Used when Firestore queries fail or for complex filtering
+   */
+  applyInMemoryFilters(procedures, filters) {
+    let filteredProcedures = [...procedures];
+    if (filters.nameSearch && filters.nameSearch.trim()) {
+      const searchTerm = filters.nameSearch.trim().toLowerCase();
+      filteredProcedures = filteredProcedures.filter((procedure) => {
+        const name = (procedure.name || "").toLowerCase();
+        const nameLower = procedure.nameLower || "";
+        return name.includes(searchTerm) || nameLower.includes(searchTerm);
+      });
+      console.log(`[PROCEDURE_SERVICE] Applied name filter, results: ${filteredProcedures.length}`);
+    }
+    if (filters.minPrice !== void 0 || filters.maxPrice !== void 0) {
+      filteredProcedures = filteredProcedures.filter((procedure) => {
+        const price = procedure.price || 0;
+        if (filters.minPrice !== void 0 && price < filters.minPrice) return false;
+        if (filters.maxPrice !== void 0 && price > filters.maxPrice) return false;
+        return true;
+      });
+      console.log(`[PROCEDURE_SERVICE] Applied price filter (${filters.minPrice}-${filters.maxPrice}), results: ${filteredProcedures.length}`);
+    }
+    if (filters.minRating !== void 0 || filters.maxRating !== void 0) {
+      filteredProcedures = filteredProcedures.filter((procedure) => {
+        var _a;
+        const rating = ((_a = procedure.reviewInfo) == null ? void 0 : _a.averageRating) || 0;
+        if (filters.minRating !== void 0 && rating < filters.minRating) return false;
+        if (filters.maxRating !== void 0 && rating > filters.maxRating) return false;
+        return true;
+      });
+      console.log(`[PROCEDURE_SERVICE] Applied rating filter, results: ${filteredProcedures.length}`);
+    }
+    if (filters.treatmentBenefits && filters.treatmentBenefits.length > 0) {
+      const benefitsToMatch = filters.treatmentBenefits;
+      filteredProcedures = filteredProcedures.filter((procedure) => {
+        const procedureBenefits = procedure.treatmentBenefits || [];
+        return benefitsToMatch.some((benefit) => procedureBenefits.includes(benefit));
+      });
+      console.log(`[PROCEDURE_SERVICE] Applied benefits filter, results: ${filteredProcedures.length}`);
+    }
+    if (filters.procedureFamily) {
+      filteredProcedures = filteredProcedures.filter((procedure) => procedure.family === filters.procedureFamily);
+      console.log(`[PROCEDURE_SERVICE] Applied family filter, results: ${filteredProcedures.length}`);
+    }
+    if (filters.procedureCategory) {
+      filteredProcedures = filteredProcedures.filter((procedure) => {
+        var _a;
+        return ((_a = procedure.category) == null ? void 0 : _a.id) === filters.procedureCategory;
+      });
+      console.log(`[PROCEDURE_SERVICE] Applied category filter, results: ${filteredProcedures.length}`);
+    }
+    if (filters.procedureSubcategory) {
+      filteredProcedures = filteredProcedures.filter((procedure) => {
+        var _a;
+        return ((_a = procedure.subcategory) == null ? void 0 : _a.id) === filters.procedureSubcategory;
+      });
+      console.log(`[PROCEDURE_SERVICE] Applied subcategory filter, results: ${filteredProcedures.length}`);
+    }
+    if (filters.procedureTechnology) {
+      filteredProcedures = filteredProcedures.filter((procedure) => {
+        var _a;
+        return ((_a = procedure.technology) == null ? void 0 : _a.id) === filters.procedureTechnology;
+      });
+      console.log(`[PROCEDURE_SERVICE] Applied technology filter, results: ${filteredProcedures.length}`);
+    }
+    if (filters.location && filters.radiusInKm && filters.radiusInKm > 0) {
+      const location = filters.location;
+      const radiusInKm = filters.radiusInKm;
+      filteredProcedures = filteredProcedures.filter((procedure) => {
+        var _a;
+        const clinicLocation = (_a = procedure.clinicInfo) == null ? void 0 : _a.location;
+        if (!(clinicLocation == null ? void 0 : clinicLocation.latitude) || !(clinicLocation == null ? void 0 : clinicLocation.longitude)) {
+          return false;
+        }
+        const distance = distanceBetween6(
+          [location.latitude, location.longitude],
+          [clinicLocation.latitude, clinicLocation.longitude]
+        ) / 1e3;
+        procedure.distance = distance;
+        return distance <= radiusInKm;
+      });
+      console.log(`[PROCEDURE_SERVICE] Applied geo filter, results: ${filteredProcedures.length}`);
+      filteredProcedures.sort((a, b) => (a.distance || 0) - (b.distance || 0));
+    }
+    return filteredProcedures;
+  }
+  handleGeoQuery(filters) {
+    console.log("[PROCEDURE_SERVICE] Executing geo query with enhanced debugging");
+    try {
+      const location = filters.location;
+      const radiusInKm = filters.radiusInKm;
+      console.log("[PROCEDURE_SERVICE] Geo query parameters:", {
+        latitude: location.latitude,
+        longitude: location.longitude,
+        radiusInKm,
+        pagination: filters.pagination || 10
+      });
+      const constraints = [
+        where29("isActive", "==", true),
+        orderBy17("createdAt", "desc"),
+        limit15((filters.pagination || 10) * 3)
+        // Get more results for geo filtering
+      ];
+      const q = query29(collection29(this.db, PROCEDURES_COLLECTION), ...constraints);
+      return getDocs29(q).then((querySnapshot) => {
+        let procedures = querySnapshot.docs.map((doc37) => ({ ...doc37.data(), id: doc37.id }));
+        procedures = this.applyInMemoryFilters(procedures, filters);
+        console.log(`[PROCEDURE_SERVICE] Geo query success: ${procedures.length} procedures within ${radiusInKm}km`);
+        const lastDoc = procedures.length < (filters.pagination || 10) ? null : querySnapshot.docs[querySnapshot.docs.length - 1];
+        return { procedures, lastDoc };
+      });
+    } catch (error) {
+      console.error("[PROCEDURE_SERVICE] Geo query failed:", error);
+      return Promise.resolve({ procedures: [], lastDoc: null });
     }
   }
   /**