@blackcode_sa/metaestetics-api 1.8.18 → 1.10.0

package/src/services/procedure/procedure.service.ts

@@ -20,57 +20,39 @@ import {
   startAfter,
   QueryConstraint,
   documentId,
-} from "firebase/firestore";
-import { BaseService } from "../base.service";
+} from 'firebase/firestore';
+import { BaseService } from '../base.service';
 import {
   Procedure,
   CreateProcedureData,
   UpdateProcedureData,
   PROCEDURES_COLLECTION,
   ProcedureSummaryInfo,
-} from "../../types/procedure";
-import {
-  createProcedureSchema,
-  updateProcedureSchema,
-} from "../../validations/procedure.schema";
-import { z } from "zod";
-import { Auth } from "firebase/auth";
-import { Firestore } from "firebase/firestore";
-import { FirebaseApp } from "firebase/app";
-import {
-  Category,
-  CATEGORIES_COLLECTION,
-} from "../../backoffice/types/category.types";
-import {
-  Subcategory,
-  SUBCATEGORIES_COLLECTION,
-} from "../../backoffice/types/subcategory.types";
-import {
-  Technology,
-  TECHNOLOGIES_COLLECTION,
-} from "../../backoffice/types/technology.types";
-import {
-  Product,
-  PRODUCTS_COLLECTION,
-} from "../../backoffice/types/product.types";
-import { CategoryService } from "../../backoffice/services/category.service";
-import { SubcategoryService } from "../../backoffice/services/subcategory.service";
-import { TechnologyService } from "../../backoffice/services/technology.service";
-import { ProductService } from "../../backoffice/services/product.service";
-import {
-  Practitioner,
-  PRACTITIONERS_COLLECTION,
-} from "../../types/practitioner";
+} from '../../types/procedure';
+import { createProcedureSchema, updateProcedureSchema } from '../../validations/procedure.schema';
+import { z } from 'zod';
+import { Auth } from 'firebase/auth';
+import { Firestore } from 'firebase/firestore';
+import { FirebaseApp } from 'firebase/app';
+import { Category, CATEGORIES_COLLECTION } from '../../backoffice/types/category.types';
+import { Subcategory, SUBCATEGORIES_COLLECTION } from '../../backoffice/types/subcategory.types';
+import { Technology, TECHNOLOGIES_COLLECTION } from '../../backoffice/types/technology.types';
+import { Product, PRODUCTS_COLLECTION } from '../../backoffice/types/product.types';
+import { CategoryService } from '../../backoffice/services/category.service';
+import { SubcategoryService } from '../../backoffice/services/subcategory.service';
+import { TechnologyService } from '../../backoffice/services/technology.service';
+import { ProductService } from '../../backoffice/services/product.service';
+import { Practitioner, PRACTITIONERS_COLLECTION } from '../../types/practitioner';
 import {
   CertificationLevel,
   CertificationSpecialty,
   ProcedureFamily,
-} from "../../backoffice/types";
-import { Clinic, CLINICS_COLLECTION } from "../../types/clinic";
-import { ProcedureReviewInfo } from "../../types/reviews";
-import { distanceBetween, geohashQueryBounds } from "geofire-common";
-import { TreatmentBenefit } from "../../backoffice/types/static/treatment-benefit.types";
-import { MediaService, MediaAccessLevel } from "../media/media.service";
+} from '../../backoffice/types';
+import { Clinic, CLINICS_COLLECTION } from '../../types/clinic';
+import { ProcedureReviewInfo } from '../../types/reviews';
+import { distanceBetween, geohashQueryBounds } from 'geofire-common';
+import { TreatmentBenefit } from '../../backoffice/types/static/treatment-benefit.types';
+import { MediaService, MediaAccessLevel } from '../media/media.service';
 
 export class ProcedureService extends BaseService {
   private categoryService: CategoryService;
@@ -87,7 +69,7 @@ export class ProcedureService extends BaseService {
     subcategoryService: SubcategoryService,
     technologyService: TechnologyService,
     productService: ProductService,
-    mediaService: MediaService
+    mediaService: MediaService,
   ) {
     super(db, auth, app);
     this.categoryService = categoryService;
@@ -107,25 +89,23 @@ export class ProcedureService extends BaseService {
   private async processMedia(
     media: string | File | Blob | null | undefined,
     ownerId: string,
-    collectionName: string
+    collectionName: string,
   ): Promise<string | null> {
     if (!media) return null;
 
     // If already a string URL, return it directly
-    if (typeof media === "string") {
+    if (typeof media === 'string') {
       return media;
     }
 
     // If it's a File, upload it using MediaService
     if (media instanceof File || media instanceof Blob) {
-      console.log(
-        `[ProcedureService] Uploading ${collectionName} media for ${ownerId}`
-      );
+      console.log(`[ProcedureService] Uploading ${collectionName} media for ${ownerId}`);
       const metadata = await this.mediaService.uploadMedia(
         media,
         ownerId,
         MediaAccessLevel.PUBLIC,
-        collectionName
+        collectionName,
       );
       return metadata.url;
     }
@@ -143,18 +123,14 @@ export class ProcedureService extends BaseService {
   private async processMediaArray(
     mediaArray: (string | File | Blob)[] | undefined,
     ownerId: string,
-    collectionName: string
+    collectionName: string,
   ): Promise<string[]> {
     if (!mediaArray || mediaArray.length === 0) return [];
 
     const result: string[] = [];
 
     for (const media of mediaArray) {
-      const processedUrl = await this.processMedia(
-        media,
-        ownerId,
-        collectionName
-      );
+      const processedUrl = await this.processMedia(media, ownerId, collectionName);
       if (processedUrl) {
         result.push(processedUrl);
       }
@@ -177,45 +153,27 @@ export class ProcedureService extends BaseService {
     // Get references to related entities (Category, Subcategory, Technology, Product)
     const [category, subcategory, technology, product] = await Promise.all([
       this.categoryService.getById(validatedData.categoryId),
-      this.subcategoryService.getById(
-        validatedData.categoryId,
-        validatedData.subcategoryId
-      ),
+      this.subcategoryService.getById(validatedData.categoryId, validatedData.subcategoryId),
       this.technologyService.getById(validatedData.technologyId),
-      this.productService.getById(
-        validatedData.technologyId,
-        validatedData.productId
-      ),
+      this.productService.getById(validatedData.technologyId, validatedData.productId),
     ]);
 
     if (!category || !subcategory || !technology || !product) {
-      throw new Error("One or more required base entities not found");
+      throw new Error('One or more required base entities not found');
     }
 
     // Get clinic and practitioner information for aggregation
-    const clinicRef = doc(
-      this.db,
-      CLINICS_COLLECTION,
-      validatedData.clinicBranchId
-    );
+    const clinicRef = doc(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId);
     const clinicSnapshot = await getDoc(clinicRef);
     if (!clinicSnapshot.exists()) {
-      throw new Error(
-        `Clinic with ID ${validatedData.clinicBranchId} not found`
-      );
+      throw new Error(`Clinic with ID ${validatedData.clinicBranchId} not found`);
     }
     const clinic = clinicSnapshot.data() as Clinic; // Assert type
 
-    const practitionerRef = doc(
-      this.db,
-      PRACTITIONERS_COLLECTION,
-      validatedData.practitionerId
-    );
+    const practitionerRef = doc(this.db, PRACTITIONERS_COLLECTION, validatedData.practitionerId);
     const practitionerSnapshot = await getDoc(practitionerRef);
     if (!practitionerSnapshot.exists()) {
-      throw new Error(
-        `Practitioner with ID ${validatedData.practitionerId} not found`
-      );
+      throw new Error(`Practitioner with ID ${validatedData.practitionerId} not found`);
     }
     const practitioner = practitionerSnapshot.data() as Practitioner; // Assert type
 
@@ -225,7 +183,7 @@ export class ProcedureService extends BaseService {
       processedPhotos = await this.processMediaArray(
         validatedData.photos,
         procedureId,
-        "procedure-photos"
+        'procedure-photos',
       );
     }
 
@@ -233,15 +191,15 @@ export class ProcedureService extends BaseService {
     const clinicInfo = {
       id: clinicSnapshot.id,
       name: clinic.name,
-      description: clinic.description || "",
+      description: clinic.description || '',
       featuredPhoto:
         clinic.featuredPhotos && clinic.featuredPhotos.length > 0
-          ? typeof clinic.featuredPhotos[0] === "string"
+          ? typeof clinic.featuredPhotos[0] === 'string'
             ? clinic.featuredPhotos[0]
-            : ""
-          : typeof clinic.coverPhoto === "string"
+            : ''
+          : typeof clinic.coverPhoto === 'string'
           ? clinic.coverPhoto
-          : "",
+          : '',
       location: clinic.location,
       contactInfo: clinic.contactInfo,
     };
@@ -250,17 +208,17 @@ export class ProcedureService extends BaseService {
     const doctorInfo = {
       id: practitionerSnapshot.id,
       name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
-      description: practitioner.basicInfo.bio || "",
+      description: practitioner.basicInfo.bio || '',
       photo:
-        typeof practitioner.basicInfo.profileImageUrl === "string"
+        typeof practitioner.basicInfo.profileImageUrl === 'string'
           ? practitioner.basicInfo.profileImageUrl
-          : "", // Default to empty string if not a processed URL
+          : '', // Default to empty string if not a processed URL
       rating: practitioner.reviewInfo?.averageRating || 0,
       services: practitioner.procedures || [],
     };
 
     // Create the procedure object
-    const newProcedure: Omit<Procedure, "createdAt" | "updatedAt"> = {
+    const newProcedure: Omit<Procedure, 'createdAt' | 'updatedAt'> = {
       id: procedureId,
       ...validatedData,
       nameLower: validatedData.nameLower || validatedData.name.toLowerCase(),
@@ -314,12 +272,12 @@ export class ProcedureService extends BaseService {
    * @returns A promise that resolves to an array of the newly created procedures.
    */
   async bulkCreateProcedures(
-    baseData: Omit<CreateProcedureData, "practitionerId">,
-    practitionerIds: string[]
+    baseData: Omit<CreateProcedureData, 'practitionerId'>,
+    practitionerIds: string[],
   ): Promise<Procedure[]> {
     // 1. Validation
     if (!practitionerIds || practitionerIds.length === 0) {
-      throw new Error("Practitioner IDs array cannot be empty.");
+      throw new Error('Practitioner IDs array cannot be empty.');
     }
 
     // Add a dummy practitionerId for the validation schema to pass
@@ -327,28 +285,19 @@ export class ProcedureService extends BaseService {
     const validatedData = createProcedureSchema.parse(validationData);
 
     // 2. Fetch common data once to avoid redundant reads
-    const [category, subcategory, technology, product, clinicSnapshot] =
-      await Promise.all([
-        this.categoryService.getById(validatedData.categoryId),
-        this.subcategoryService.getById(
-          validatedData.categoryId,
-          validatedData.subcategoryId
-        ),
-        this.technologyService.getById(validatedData.technologyId),
-        this.productService.getById(
-          validatedData.technologyId,
-          validatedData.productId
-        ),
-        getDoc(doc(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId)),
-      ]);
+    const [category, subcategory, technology, product, clinicSnapshot] = await Promise.all([
+      this.categoryService.getById(validatedData.categoryId),
+      this.subcategoryService.getById(validatedData.categoryId, validatedData.subcategoryId),
+      this.technologyService.getById(validatedData.technologyId),
+      this.productService.getById(validatedData.technologyId, validatedData.productId),
+      getDoc(doc(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId)),
+    ]);
 
     if (!category || !subcategory || !technology || !product) {
-      throw new Error("One or more required base entities not found");
+      throw new Error('One or more required base entities not found');
     }
     if (!clinicSnapshot.exists()) {
-      throw new Error(
-        `Clinic with ID ${validatedData.clinicBranchId} not found`
-      );
+      throw new Error(`Clinic with ID ${validatedData.clinicBranchId} not found`);
     }
     const clinic = clinicSnapshot.data() as Clinic;
 
@@ -359,7 +308,7 @@ export class ProcedureService extends BaseService {
       processedPhotos = await this.processMediaArray(
         validatedData.photos,
         batchId,
-        "procedure-photos-batch"
+        'procedure-photos-batch',
       );
     }
 
@@ -370,7 +319,7 @@ export class ProcedureService extends BaseService {
       const chunk = practitionerIds.slice(i, i + 30);
       const practitionersQuery = query(
         collection(this.db, PRACTITIONERS_COLLECTION),
-        where(documentId(), "in", chunk)
+        where(documentId(), 'in', chunk),
       );
       const practitionersSnapshot = await getDocs(practitionersQuery);
       practitionersSnapshot.docs.forEach((doc) => {
@@ -381,12 +330,8 @@ export class ProcedureService extends BaseService {
     // Verify all practitioners were found
     if (practitionersMap.size !== practitionerIds.length) {
       const foundIds = Array.from(practitionersMap.keys());
-      const notFoundIds = practitionerIds.filter(
-        (id) => !foundIds.includes(id)
-      );
-      throw new Error(
-        `The following practitioners were not found: ${notFoundIds.join(", ")}`
-      );
+      const notFoundIds = practitionerIds.filter((id) => !foundIds.includes(id));
+      throw new Error(`The following practitioners were not found: ${notFoundIds.join(', ')}`);
     }
 
     // 5. Use a Firestore batch for atomic creation
@@ -395,15 +340,15 @@ export class ProcedureService extends BaseService {
     const clinicInfo = {
       id: clinicSnapshot.id,
       name: clinic.name,
-      description: clinic.description || "",
+      description: clinic.description || '',
       featuredPhoto:
         clinic.featuredPhotos && clinic.featuredPhotos.length > 0
-          ? typeof clinic.featuredPhotos[0] === "string"
+          ? typeof clinic.featuredPhotos[0] === 'string'
             ? clinic.featuredPhotos[0]
-            : ""
-          : typeof clinic.coverPhoto === "string"
+            : ''
+          : typeof clinic.coverPhoto === 'string'
           ? clinic.coverPhoto
-          : "",
+          : '',
       location: clinic.location,
       contactInfo: clinic.contactInfo,
     };
@@ -414,11 +359,11 @@ export class ProcedureService extends BaseService {
       const doctorInfo = {
         id: practitioner.id,
         name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
-        description: practitioner.basicInfo.bio || "",
+        description: practitioner.basicInfo.bio || '',
         photo:
-          typeof practitioner.basicInfo.profileImageUrl === "string"
+          typeof practitioner.basicInfo.profileImageUrl === 'string'
             ? practitioner.basicInfo.profileImageUrl
-            : "",
+            : '',
         rating: practitioner.reviewInfo?.averageRating || 0,
         services: practitioner.procedures || [],
       };
@@ -428,7 +373,7 @@ export class ProcedureService extends BaseService {
       const procedureRef = doc(this.db, PROCEDURES_COLLECTION, procedureId);
 
       // Construct the new procedure, reusing common data
-      const newProcedure: Omit<Procedure, "createdAt" | "updatedAt"> = {
+      const newProcedure: Omit<Procedure, 'createdAt' | 'updatedAt'> = {
         id: procedureId,
         ...validatedData,
         nameLower: validatedData.nameLower || validatedData.name.toLowerCase(),
@@ -474,10 +419,7 @@ export class ProcedureService extends BaseService {
     const fetchedProcedures: Procedure[] = [];
     for (let i = 0; i < createdProcedureIds.length; i += 30) {
       const chunk = createdProcedureIds.slice(i, i + 30);
-      const q = query(
-        collection(this.db, PROCEDURES_COLLECTION),
-        where(documentId(), "in", chunk)
-      );
+      const q = query(collection(this.db, PROCEDURES_COLLECTION), where(documentId(), 'in', chunk));
       const snapshot = await getDocs(q);
       snapshot.forEach((doc) => {
         fetchedProcedures.push(doc.data() as Procedure);
@@ -508,13 +450,11 @@ export class ProcedureService extends BaseService {
    * @param clinicBranchId - The ID of the clinic branch
    * @returns List of procedures
    */
-  async getProceduresByClinicBranch(
-    clinicBranchId: string
-  ): Promise<Procedure[]> {
+  async getProceduresByClinicBranch(clinicBranchId: string): Promise<Procedure[]> {
     const q = query(
       collection(this.db, PROCEDURES_COLLECTION),
-      where("clinicBranchId", "==", clinicBranchId),
-      where("isActive", "==", true)
+      where('clinicBranchId', '==', clinicBranchId),
+      where('isActive', '==', true),
     );
     const snapshot = await getDocs(q);
     return snapshot.docs.map((doc) => doc.data() as Procedure);
@@ -525,13 +465,11 @@ export class ProcedureService extends BaseService {
    * @param practitionerId - The ID of the practitioner
    * @returns List of procedures
    */
-  async getProceduresByPractitioner(
-    practitionerId: string
-  ): Promise<Procedure[]> {
+  async getProceduresByPractitioner(practitionerId: string): Promise<Procedure[]> {
     const q = query(
       collection(this.db, PROCEDURES_COLLECTION),
-      where("practitionerId", "==", practitionerId),
-      where("isActive", "==", true)
+      where('practitionerId', '==', practitionerId),
+      where('isActive', '==', true),
     );
     const snapshot = await getDocs(q);
     return snapshot.docs.map((doc) => doc.data() as Procedure);
@@ -542,13 +480,11 @@ export class ProcedureService extends BaseService {
    * @param practitionerId - The ID of the practitioner
    * @returns List of inactive procedures
    */
-  async getInactiveProceduresByPractitioner(
-    practitionerId: string
-  ): Promise<Procedure[]> {
+  async getInactiveProceduresByPractitioner(practitionerId: string): Promise<Procedure[]> {
     const q = query(
       collection(this.db, PROCEDURES_COLLECTION),
-      where("practitionerId", "==", practitionerId),
-      where("isActive", "==", false)
+      where('practitionerId', '==', practitionerId),
+      where('isActive', '==', false),
     );
     const snapshot = await getDocs(q);
     return snapshot.docs.map((doc) => doc.data() as Procedure);
@@ -560,10 +496,7 @@ export class ProcedureService extends BaseService {
    * @param data - The data to update the procedure with
    * @returns The updated procedure
    */
-  async updateProcedure(
-    id: string,
-    data: UpdateProcedureData
-  ): Promise<Procedure> {
+  async updateProcedure(id: string, data: UpdateProcedureData): Promise<Procedure> {
     const validatedData = updateProcedureSchema.parse(data);
     const procedureRef = doc(this.db, PROCEDURES_COLLECTION, id);
     const procedureSnapshot = await getDoc(procedureRef);
@@ -587,54 +520,42 @@ export class ProcedureService extends BaseService {
       updatedProcedureData.photos = await this.processMediaArray(
         validatedData.photos,
         id,
-        "procedure-photos"
+        'procedure-photos',
       );
     }
 
     // --- Prepare updates and fetch new related data if IDs change ---
 
     // Handle Practitioner Change
-    if (
-      validatedData.practitionerId &&
-      validatedData.practitionerId !== oldPractitionerId
-    ) {
+    if (validatedData.practitionerId && validatedData.practitionerId !== oldPractitionerId) {
       practitionerChanged = true;
       const newPractitionerRef = doc(
         this.db,
         PRACTITIONERS_COLLECTION,
-        validatedData.practitionerId
+        validatedData.practitionerId,
       );
       const newPractitionerSnap = await getDoc(newPractitionerRef);
       if (!newPractitionerSnap.exists())
-        throw new Error(
-          `New Practitioner ${validatedData.practitionerId} not found`
-        );
+        throw new Error(`New Practitioner ${validatedData.practitionerId} not found`);
       newPractitioner = newPractitionerSnap.data() as Practitioner;
       // Update doctorInfo within the procedure document
       updatedProcedureData.doctorInfo = {
         id: newPractitioner.id,
         name: `${newPractitioner.basicInfo.firstName} ${newPractitioner.basicInfo.lastName}`,
-        description: newPractitioner.basicInfo.bio || "",
+        description: newPractitioner.basicInfo.bio || '',
         photo:
-          typeof newPractitioner.basicInfo.profileImageUrl === "string"
+          typeof newPractitioner.basicInfo.profileImageUrl === 'string'
             ? newPractitioner.basicInfo.profileImageUrl
-            : "", // Default to empty string if not a processed URL
+            : '', // Default to empty string if not a processed URL
         rating: newPractitioner.reviewInfo?.averageRating || 0,
         services: newPractitioner.procedures || [],
       };
     }
 
     // Handle Clinic Change
-    if (
-      validatedData.clinicBranchId &&
-      validatedData.clinicBranchId !== oldClinicId
-    ) {
+    if (validatedData.clinicBranchId && validatedData.clinicBranchId !== oldClinicId) {
       clinicChanged = true;
-      const newClinicRef = doc(
-        this.db,
-        CLINICS_COLLECTION,
-        validatedData.clinicBranchId
-      );
+      const newClinicRef = doc(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId);
       const newClinicSnap = await getDoc(newClinicRef);
       if (!newClinicSnap.exists())
         throw new Error(`New Clinic ${validatedData.clinicBranchId} not found`);
@@ -643,15 +564,15 @@ export class ProcedureService extends BaseService {
       updatedProcedureData.clinicInfo = {
         id: newClinic.id,
         name: newClinic.name,
-        description: newClinic.description || "",
+        description: newClinic.description || '',
         featuredPhoto:
           newClinic.featuredPhotos && newClinic.featuredPhotos.length > 0
-            ? typeof newClinic.featuredPhotos[0] === "string"
+            ? typeof newClinic.featuredPhotos[0] === 'string'
               ? newClinic.featuredPhotos[0]
-              : ""
-            : typeof newClinic.coverPhoto === "string"
+              : ''
+            : typeof newClinic.coverPhoto === 'string'
             ? newClinic.coverPhoto
-            : "",
+            : '',
         location: newClinic.location,
         contactInfo: newClinic.contactInfo,
       };
@@ -663,11 +584,8 @@ export class ProcedureService extends BaseService {
       updatedProcedureData.nameLower = validatedData.name.toLowerCase();
     }
     if (validatedData.categoryId) {
-      const category = await this.categoryService.getById(
-        validatedData.categoryId
-      );
-      if (!category)
-        throw new Error(`Category ${validatedData.categoryId} not found`);
+      const category = await this.categoryService.getById(validatedData.categoryId);
+      if (!category) throw new Error(`Category ${validatedData.categoryId} not found`);
       updatedProcedureData.category = category;
       finalCategoryId = category.id; // Update finalCategoryId if category changed
     }
@@ -676,26 +594,21 @@ export class ProcedureService extends BaseService {
     if (validatedData.subcategoryId && finalCategoryId) {
       const subcategory = await this.subcategoryService.getById(
         finalCategoryId,
-        validatedData.subcategoryId
+        validatedData.subcategoryId,
       );
       if (!subcategory)
         throw new Error(
-          `Subcategory ${validatedData.subcategoryId} not found for category ${finalCategoryId}`
+          `Subcategory ${validatedData.subcategoryId} not found for category ${finalCategoryId}`,
         );
       updatedProcedureData.subcategory = subcategory;
     } else if (validatedData.subcategoryId) {
-      console.warn(
-        "Attempted to update subcategory without a valid categoryId"
-      );
+      console.warn('Attempted to update subcategory without a valid categoryId');
     }
 
     let finalTechnologyId = existingProcedure.technology.id;
     if (validatedData.technologyId) {
-      const technology = await this.technologyService.getById(
-        validatedData.technologyId
-      );
-      if (!technology)
-        throw new Error(`Technology ${validatedData.technologyId} not found`);
+      const technology = await this.technologyService.getById(validatedData.technologyId);
+      if (!technology) throw new Error(`Technology ${validatedData.technologyId} not found`);
       updatedProcedureData.technology = technology;
       finalTechnologyId = technology.id; // Update finalTechnologyId if technology changed
       // Update related fields derived from technology
@@ -703,25 +616,20 @@ export class ProcedureService extends BaseService {
       updatedProcedureData.treatmentBenefits = technology.benefits;
       updatedProcedureData.preRequirements = technology.requirements.pre;
       updatedProcedureData.postRequirements = technology.requirements.post;
-      updatedProcedureData.certificationRequirement =
-        technology.certificationRequirement;
-      updatedProcedureData.documentationTemplates =
-        technology.documentationTemplates || [];
+      updatedProcedureData.certificationRequirement = technology.certificationRequirement;
+      updatedProcedureData.documentationTemplates = technology.documentationTemplates || [];
     }
 
     // Only fetch product if its ID is provided AND we have a valid finalTechnologyId
     if (validatedData.productId && finalTechnologyId) {
-      const product = await this.productService.getById(
-        finalTechnologyId,
-        validatedData.productId
-      );
+      const product = await this.productService.getById(finalTechnologyId, validatedData.productId);
       if (!product)
         throw new Error(
-          `Product ${validatedData.productId} not found for technology ${finalTechnologyId}`
+          `Product ${validatedData.productId} not found for technology ${finalTechnologyId}`,
         );
       updatedProcedureData.product = product;
     } else if (validatedData.productId) {
-      console.warn("Attempted to update product without a valid technologyId");
+      console.warn('Attempted to update product without a valid technologyId');
     }
 
     // Update the procedure document
@@ -805,7 +713,7 @@ export class ProcedureService extends BaseService {
    */
   async getAllProcedures(
     pagination?: number,
-    lastDoc?: any
+    lastDoc?: any,
   ): Promise<{ procedures: Procedure[]; lastDoc: any }> {
     try {
       const proceduresCollection = collection(this.db, PROCEDURES_COLLECTION);
@@ -813,29 +721,24 @@ export class ProcedureService extends BaseService {
 
       // Apply pagination if specified
       if (pagination && pagination > 0) {
-        const { limit, startAfter } = await import("firebase/firestore"); // Use dynamic import if needed top-level
+        const { limit, startAfter } = await import('firebase/firestore'); // Use dynamic import if needed top-level
 
         if (lastDoc) {
           proceduresQuery = query(
             proceduresCollection,
-            orderBy("name"), // Use imported orderBy
+            orderBy('name'), // Use imported orderBy
             startAfter(lastDoc),
-            limit(pagination)
+            limit(pagination),
           );
         } else {
-          proceduresQuery = query(
-            proceduresCollection,
-            orderBy("name"),
-            limit(pagination)
-          ); // Use imported orderBy
+          proceduresQuery = query(proceduresCollection, orderBy('name'), limit(pagination)); // Use imported orderBy
         }
       } else {
-        proceduresQuery = query(proceduresCollection, orderBy("name")); // Use imported orderBy
+        proceduresQuery = query(proceduresCollection, orderBy('name')); // Use imported orderBy
       }
 
       const proceduresSnapshot = await getDocs(proceduresQuery);
-      const lastVisible =
-        proceduresSnapshot.docs[proceduresSnapshot.docs.length - 1];
+      const lastVisible = proceduresSnapshot.docs[proceduresSnapshot.docs.length - 1];
 
       const procedures = proceduresSnapshot.docs.map((doc) => {
         const data = doc.data() as Procedure;
@@ -850,7 +753,7 @@ export class ProcedureService extends BaseService {
         lastDoc: lastVisible,
       };
     } catch (error) {
-      console.error("[PROCEDURE_SERVICE] Error getting all procedures:", error);
+      console.error('[PROCEDURE_SERVICE] Error getting all procedures:', error);
       throw error;
     }
   }
@@ -899,16 +802,16 @@ export class ProcedureService extends BaseService {
     lastDoc: any;
   }> {
     try {
-      console.log("[PROCEDURE_SERVICE] Starting procedure filtering with multiple strategies");
+      console.log('[PROCEDURE_SERVICE] Starting procedure filtering with multiple strategies');
 
       // Geo query debug i validacija
       if (filters.location && filters.radiusInKm) {
         console.log('[PROCEDURE_SERVICE] Executing geo query:', {
           location: filters.location,
           radius: filters.radiusInKm,
-          serviceName: 'ProcedureService'
+          serviceName: 'ProcedureService',
         });
-        
+
         // Validacija location podataka
         if (!filters.location.latitude || !filters.location.longitude) {
           console.warn('[PROCEDURE_SERVICE] Invalid location data:', filters.location);
@@ -926,42 +829,42 @@ export class ProcedureService extends BaseService {
       // Base constraints (used in all strategies)
       const getBaseConstraints = () => {
         const constraints: QueryConstraint[] = [];
-        
+
         // Active status filter
         if (filters.isActive !== undefined) {
-          constraints.push(where("isActive", "==", filters.isActive));
+          constraints.push(where('isActive', '==', filters.isActive));
         } else {
-          constraints.push(where("isActive", "==", true));
+          constraints.push(where('isActive', '==', true));
         }
 
         // Filter constraints
         if (filters.procedureFamily) {
-          constraints.push(where("family", "==", filters.procedureFamily));
+          constraints.push(where('family', '==', filters.procedureFamily));
         }
         if (filters.procedureCategory) {
-          constraints.push(where("category.id", "==", filters.procedureCategory));
+          constraints.push(where('category.id', '==', filters.procedureCategory));
         }
         if (filters.procedureSubcategory) {
-          constraints.push(where("subcategory.id", "==", filters.procedureSubcategory));
+          constraints.push(where('subcategory.id', '==', filters.procedureSubcategory));
         }
         if (filters.procedureTechnology) {
-          constraints.push(where("technology.id", "==", filters.procedureTechnology));
+          constraints.push(where('technology.id', '==', filters.procedureTechnology));
         }
         if (filters.minPrice !== undefined) {
-          constraints.push(where("price", ">=", filters.minPrice));
+          constraints.push(where('price', '>=', filters.minPrice));
         }
         if (filters.maxPrice !== undefined) {
-          constraints.push(where("price", "<=", filters.maxPrice));
+          constraints.push(where('price', '<=', filters.maxPrice));
         }
         if (filters.minRating !== undefined) {
-          constraints.push(where("reviewInfo.averageRating", ">=", filters.minRating));
+          constraints.push(where('reviewInfo.averageRating', '>=', filters.minRating));
         }
         if (filters.maxRating !== undefined) {
-          constraints.push(where("reviewInfo.averageRating", "<=", filters.maxRating));
+          constraints.push(where('reviewInfo.averageRating', '<=', filters.maxRating));
         }
         if (filters.treatmentBenefits && filters.treatmentBenefits.length > 0) {
           const benefitsToMatch = filters.treatmentBenefits;
-          constraints.push(where("treatmentBenefits", "array-contains-any", benefitsToMatch));
+          constraints.push(where('treatmentBenefits', 'array-contains-any', benefitsToMatch));
         }
 
         return constraints;
@@ -970,15 +873,15 @@ export class ProcedureService extends BaseService {
       // Strategy 1: Try nameLower search if nameSearch exists
       if (filters.nameSearch && filters.nameSearch.trim()) {
         try {
-          console.log("[PROCEDURE_SERVICE] Strategy 1: Trying nameLower search");
+          console.log('[PROCEDURE_SERVICE] Strategy 1: Trying nameLower search');
           const searchTerm = filters.nameSearch.trim().toLowerCase();
           const constraints = getBaseConstraints();
-          constraints.push(where("nameLower", ">=", searchTerm));
-          constraints.push(where("nameLower", "<=", searchTerm + "\uf8ff"));
-          constraints.push(orderBy("nameLower"));
+          constraints.push(where('nameLower', '>=', searchTerm));
+          constraints.push(where('nameLower', '<=', searchTerm + '\uf8ff'));
+          constraints.push(orderBy('nameLower'));
 
           if (filters.lastDoc) {
-            if (typeof filters.lastDoc.data === "function") {
+            if (typeof filters.lastDoc.data === 'function') {
               constraints.push(startAfter(filters.lastDoc));
             } else if (Array.isArray(filters.lastDoc)) {
               constraints.push(startAfter(...filters.lastDoc));
@@ -990,33 +893,38 @@ export class ProcedureService extends BaseService {
 
           const q = query(collection(this.db, PROCEDURES_COLLECTION), ...constraints);
           const querySnapshot = await getDocs(q);
-          const procedures = querySnapshot.docs.map(doc => ({ ...doc.data(), id: doc.id } as Procedure));
-          const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
-          
+          const procedures = querySnapshot.docs.map(
+            (doc) => ({ ...doc.data(), id: doc.id } as Procedure),
+          );
+          const lastDoc =
+            querySnapshot.docs.length > 0
+              ? querySnapshot.docs[querySnapshot.docs.length - 1]
+              : null;
+
           console.log(`[PROCEDURE_SERVICE] Strategy 1 success: ${procedures.length} procedures`);
-          
+
           // Fix Load More - ako je broj rezultata manji od pagination, nema više
           if (procedures.length < (filters.pagination || 10)) {
             return { procedures, lastDoc: null };
           }
           return { procedures, lastDoc };
         } catch (error) {
-          console.log("[PROCEDURE_SERVICE] Strategy 1 failed:", error);
+          console.log('[PROCEDURE_SERVICE] Strategy 1 failed:', error);
         }
       }
 
       // Strategy 2: Try name field search as fallback
       if (filters.nameSearch && filters.nameSearch.trim()) {
         try {
-          console.log("[PROCEDURE_SERVICE] Strategy 2: Trying name field search");
+          console.log('[PROCEDURE_SERVICE] Strategy 2: Trying name field search');
           const searchTerm = filters.nameSearch.trim().toLowerCase();
           const constraints = getBaseConstraints();
-          constraints.push(where("name", ">=", searchTerm));
-          constraints.push(where("name", "<=", searchTerm + "\uf8ff"));
-          constraints.push(orderBy("name"));
+          constraints.push(where('name', '>=', searchTerm));
+          constraints.push(where('name', '<=', searchTerm + '\uf8ff'));
+          constraints.push(orderBy('name'));
 
           if (filters.lastDoc) {
-            if (typeof filters.lastDoc.data === "function") {
+            if (typeof filters.lastDoc.data === 'function') {
               constraints.push(startAfter(filters.lastDoc));
             } else if (Array.isArray(filters.lastDoc)) {
               constraints.push(startAfter(...filters.lastDoc));
@@ -1028,29 +936,36 @@ export class ProcedureService extends BaseService {
 
           const q = query(collection(this.db, PROCEDURES_COLLECTION), ...constraints);
           const querySnapshot = await getDocs(q);
-          const procedures = querySnapshot.docs.map(doc => ({ ...doc.data(), id: doc.id } as Procedure));
-          const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
-          
+          const procedures = querySnapshot.docs.map(
+            (doc) => ({ ...doc.data(), id: doc.id } as Procedure),
+          );
+          const lastDoc =
+            querySnapshot.docs.length > 0
+              ? querySnapshot.docs[querySnapshot.docs.length - 1]
+              : null;
+
           console.log(`[PROCEDURE_SERVICE] Strategy 2 success: ${procedures.length} procedures`);
-          
+
           // Fix Load More - ako je broj rezultata manji od pagination, nema više
           if (procedures.length < (filters.pagination || 10)) {
             return { procedures, lastDoc: null };
           }
           return { procedures, lastDoc };
         } catch (error) {
-          console.log("[PROCEDURE_SERVICE] Strategy 2 failed:", error);
+          console.log('[PROCEDURE_SERVICE] Strategy 2 failed:', error);
         }
       }
 
       // Strategy 3: orderBy createdAt with client-side filtering
       try {
-        console.log("[PROCEDURE_SERVICE] Strategy 3: Using createdAt orderBy with client-side filtering");
+        console.log(
+          '[PROCEDURE_SERVICE] Strategy 3: Using createdAt orderBy with client-side filtering',
+        );
         const constraints = getBaseConstraints();
-        constraints.push(orderBy("createdAt", "desc"));
+        constraints.push(orderBy('createdAt', 'desc'));
 
         if (filters.lastDoc) {
-          if (typeof filters.lastDoc.data === "function") {
+          if (typeof filters.lastDoc.data === 'function') {
             constraints.push(startAfter(filters.lastDoc));
           } else if (Array.isArray(filters.lastDoc)) {
             constraints.push(startAfter(...filters.lastDoc));
@@ -1062,57 +977,62 @@ export class ProcedureService extends BaseService {
 
         const q = query(collection(this.db, PROCEDURES_COLLECTION), ...constraints);
         const querySnapshot = await getDocs(q);
-        let procedures = querySnapshot.docs.map(doc => ({ ...doc.data(), id: doc.id } as Procedure));
+        let procedures = querySnapshot.docs.map(
+          (doc) => ({ ...doc.data(), id: doc.id } as Procedure),
+        );
 
         // Apply all client-side filters using centralized function
         procedures = this.applyInMemoryFilters(procedures, filters);
 
-        const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+        const lastDoc =
+          querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
         console.log(`[PROCEDURE_SERVICE] Strategy 3 success: ${procedures.length} procedures`);
-        
+
         // Fix Load More - ako je broj rezultata manji od pagination, nema više
         if (procedures.length < (filters.pagination || 10)) {
           return { procedures, lastDoc: null };
         }
         return { procedures, lastDoc };
       } catch (error) {
-        console.log("[PROCEDURE_SERVICE] Strategy 3 failed:", error);
+        console.log('[PROCEDURE_SERVICE] Strategy 3 failed:', error);
       }
 
       // Strategy 4: Minimal query fallback
       try {
-        console.log("[PROCEDURE_SERVICE] Strategy 4: Minimal query fallback");
+        console.log('[PROCEDURE_SERVICE] Strategy 4: Minimal query fallback');
         const constraints: QueryConstraint[] = [
-          where("isActive", "==", true),
-          orderBy("createdAt", "desc"),
-          limit(filters.pagination || 10)
+          where('isActive', '==', true),
+          orderBy('createdAt', 'desc'),
+          limit(filters.pagination || 10),
         ];
 
         const q = query(collection(this.db, PROCEDURES_COLLECTION), ...constraints);
         const querySnapshot = await getDocs(q);
-        let procedures = querySnapshot.docs.map(doc => ({ ...doc.data(), id: doc.id } as Procedure));
+        let procedures = querySnapshot.docs.map(
+          (doc) => ({ ...doc.data(), id: doc.id } as Procedure),
+        );
 
         // Apply all client-side filters using centralized function
         procedures = this.applyInMemoryFilters(procedures, filters);
 
-        const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+        const lastDoc =
+          querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
         console.log(`[PROCEDURE_SERVICE] Strategy 4 success: ${procedures.length} procedures`);
-        
+
         // Fix Load More - ako je broj rezultata manji od pagination, nema više
         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] Strategy 4 failed:', error);
       }
 
       // All strategies failed
-      console.log("[PROCEDURE_SERVICE] All strategies failed, returning empty result");
+      console.log('[PROCEDURE_SERVICE] All strategies failed, returning empty result');
       return { procedures: [], lastDoc: null };
-
     } catch (error) {
-      console.error("[PROCEDURE_SERVICE] Error filtering procedures:", error);
+      console.error('[PROCEDURE_SERVICE] Error filtering procedures:', error);
       return { procedures: [], lastDoc: null };
     }
   }
@@ -1121,13 +1041,16 @@ export class ProcedureService extends BaseService {
    * Applies in-memory filters to procedures array
    * Used when Firestore queries fail or for complex filtering
    */
-  private applyInMemoryFilters(procedures: Procedure[], filters: any): (Procedure & { distance?: number })[] {
+  private applyInMemoryFilters(
+    procedures: Procedure[],
+    filters: any,
+  ): (Procedure & { distance?: number })[] {
     let filteredProcedures = [...procedures]; // Create copy to avoid mutating original
 
     // Name search filter
     if (filters.nameSearch && filters.nameSearch.trim()) {
       const searchTerm = filters.nameSearch.trim().toLowerCase();
-      filteredProcedures = filteredProcedures.filter(procedure => {
+      filteredProcedures = filteredProcedures.filter((procedure) => {
         const name = (procedure.name || '').toLowerCase();
         const nameLower = procedure.nameLower || '';
         return name.includes(searchTerm) || nameLower.includes(searchTerm);
@@ -1137,82 +1060,105 @@ export class ProcedureService extends BaseService {
 
     // Price filtering
     if (filters.minPrice !== undefined || filters.maxPrice !== undefined) {
-      filteredProcedures = filteredProcedures.filter(procedure => {
+      filteredProcedures = filteredProcedures.filter((procedure) => {
         const price = procedure.price || 0;
         if (filters.minPrice !== undefined && price < filters.minPrice) return false;
         if (filters.maxPrice !== undefined && price > filters.maxPrice) return false;
         return true;
       });
-      console.log(`[PROCEDURE_SERVICE] Applied price filter (${filters.minPrice}-${filters.maxPrice}), results: ${filteredProcedures.length}`);
+      console.log(
+        `[PROCEDURE_SERVICE] Applied price filter (${filters.minPrice}-${filters.maxPrice}), results: ${filteredProcedures.length}`,
+      );
     }
 
     // Rating filtering
     if (filters.minRating !== undefined || filters.maxRating !== undefined) {
-      filteredProcedures = filteredProcedures.filter(procedure => {
+      filteredProcedures = filteredProcedures.filter((procedure) => {
         const rating = procedure.reviewInfo?.averageRating || 0;
         if (filters.minRating !== undefined && rating < filters.minRating) return false;
         if (filters.maxRating !== undefined && rating > filters.maxRating) return false;
         return true;
       });
-      console.log(`[PROCEDURE_SERVICE] Applied rating filter, results: ${filteredProcedures.length}`);
+      console.log(
+        `[PROCEDURE_SERVICE] Applied rating filter, results: ${filteredProcedures.length}`,
+      );
     }
 
     // Treatment benefits filtering
     if (filters.treatmentBenefits && filters.treatmentBenefits.length > 0) {
       const benefitsToMatch = filters.treatmentBenefits;
-      filteredProcedures = filteredProcedures.filter(procedure => {
+      filteredProcedures = filteredProcedures.filter((procedure) => {
         const procedureBenefits = procedure.treatmentBenefits || [];
         return benefitsToMatch.some((benefit: any) => procedureBenefits.includes(benefit));
       });
-      console.log(`[PROCEDURE_SERVICE] Applied benefits filter, results: ${filteredProcedures.length}`);
+      console.log(
+        `[PROCEDURE_SERVICE] Applied benefits filter, results: ${filteredProcedures.length}`,
+      );
     }
 
     // Procedure family filtering
     if (filters.procedureFamily) {
-      filteredProcedures = filteredProcedures.filter(procedure => procedure.family === filters.procedureFamily);
-      console.log(`[PROCEDURE_SERVICE] Applied family filter, results: ${filteredProcedures.length}`);
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.family === filters.procedureFamily,
+      );
+      console.log(
+        `[PROCEDURE_SERVICE] Applied family filter, results: ${filteredProcedures.length}`,
+      );
     }
 
     // Category filtering
     if (filters.procedureCategory) {
-      filteredProcedures = filteredProcedures.filter(procedure => procedure.category?.id === filters.procedureCategory);
-      console.log(`[PROCEDURE_SERVICE] Applied category filter, results: ${filteredProcedures.length}`);
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.category?.id === filters.procedureCategory,
+      );
+      console.log(
+        `[PROCEDURE_SERVICE] Applied category filter, results: ${filteredProcedures.length}`,
+      );
     }
 
     // Subcategory filtering
     if (filters.procedureSubcategory) {
-      filteredProcedures = filteredProcedures.filter(procedure => procedure.subcategory?.id === filters.procedureSubcategory);
-      console.log(`[PROCEDURE_SERVICE] Applied subcategory filter, results: ${filteredProcedures.length}`);
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.subcategory?.id === filters.procedureSubcategory,
+      );
+      console.log(
+        `[PROCEDURE_SERVICE] Applied subcategory filter, results: ${filteredProcedures.length}`,
+      );
     }
 
     // Technology filtering
     if (filters.procedureTechnology) {
-      filteredProcedures = filteredProcedures.filter(procedure => procedure.technology?.id === filters.procedureTechnology);
-      console.log(`[PROCEDURE_SERVICE] Applied technology filter, results: ${filteredProcedures.length}`);
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.technology?.id === filters.procedureTechnology,
+      );
+      console.log(
+        `[PROCEDURE_SERVICE] Applied technology filter, results: ${filteredProcedures.length}`,
+      );
     }
 
     // Geo-radius filter
     if (filters.location && filters.radiusInKm && filters.radiusInKm > 0) {
       const location = filters.location;
       const radiusInKm = filters.radiusInKm;
-      filteredProcedures = filteredProcedures.filter(procedure => {
+      filteredProcedures = filteredProcedures.filter((procedure) => {
         const clinicLocation = procedure.clinicInfo?.location;
         if (!clinicLocation?.latitude || !clinicLocation?.longitude) {
           return false;
         }
-        
-        const distance = distanceBetween(
-          [location.latitude, location.longitude],
-          [clinicLocation.latitude, clinicLocation.longitude]
-        ) / 1000; // Convert to km
-        
+
+        const distance =
+          distanceBetween(
+            [location.latitude, location.longitude],
+            [clinicLocation.latitude, clinicLocation.longitude],
+          ) / 1000; // Convert to km
+
         // Attach distance for frontend sorting/display
         (procedure as any).distance = distance;
-        
+
         return distance <= radiusInKm;
       });
       console.log(`[PROCEDURE_SERVICE] Applied geo filter, results: ${filteredProcedures.length}`);
-      
+
       // Sort by distance when geo filtering is applied
       filteredProcedures.sort((a, b) => ((a as any).distance || 0) - ((b as any).distance || 0));
     }
@@ -1220,45 +1166,69 @@ export class ProcedureService extends BaseService {
     return filteredProcedures as (Procedure & { distance?: number })[];
   }
 
-  private handleGeoQuery(filters: any): Promise<{ procedures: (Procedure & { distance?: number })[]; lastDoc: any }> {
-    console.log('[PROCEDURE_SERVICE] Executing geo query with enhanced debugging');
-    
+  private handleGeoQuery(
+    filters: any,
+  ): Promise<{ procedures: (Procedure & { distance?: number })[]; lastDoc: any }> {
+    console.log('[PROCEDURE_SERVICE] Executing geo query with geohash bounds');
     try {
-      // Enhanced geo query implementation with proper debugging
       const location = filters.location;
       const radiusInKm = filters.radiusInKm;
-      
-      console.log('[PROCEDURE_SERVICE] Geo query parameters:', {
-        latitude: location.latitude,
-        longitude: location.longitude,
-        radiusInKm: radiusInKm,
-        pagination: filters.pagination || 10
-      });
 
-      // For now, return a basic query and apply geo filtering
-      // This can be enhanced with proper geohash bounds later
-      const constraints: QueryConstraint[] = [
-        where("isActive", "==", true),
-        orderBy("createdAt", "desc"),
-        limit((filters.pagination || 10) * 3) // Get more results for geo filtering
-      ];
-
-      const q = query(collection(this.db, PROCEDURES_COLLECTION), ...constraints);
-      
-      return getDocs(q).then(querySnapshot => {
-        let procedures = querySnapshot.docs.map(doc => ({ ...doc.data(), id: doc.id } as Procedure));
-        
-        // Apply all filters using centralized function (includes geo filtering)
-        procedures = this.applyInMemoryFilters(procedures, filters);
-        
-        console.log(`[PROCEDURE_SERVICE] Geo query success: ${procedures.length} procedures within ${radiusInKm}km`);
-        
-        // Fix Load More for geo queries
-        const lastDoc = procedures.length < (filters.pagination || 10) ? null : querySnapshot.docs[querySnapshot.docs.length - 1];
-        
-        return { procedures, lastDoc };
+      if (!location || !radiusInKm) {
+        return Promise.resolve({ procedures: [], lastDoc: null });
+      }
+
+      const bounds = geohashQueryBounds([location.latitude, location.longitude], radiusInKm * 1000);
+
+      const fetches = bounds.map((b) => {
+        const constraints: QueryConstraint[] = [
+          where('clinicInfo.location.geohash', '>=', b[0]),
+          where('clinicInfo.location.geohash', '<=', b[1]),
+          where('isActive', '==', filters.isActive !== undefined ? filters.isActive : true),
+        ];
+        return getDocs(query(collection(this.db, PROCEDURES_COLLECTION), ...constraints));
       });
-      
+
+      return Promise.all(fetches)
+        .then((snaps) => {
+          const collected: Procedure[] = [];
+          snaps.forEach((snap) => {
+            snap.docs.forEach((d) => collected.push({ ...(d.data() as Procedure), id: d.id }));
+          });
+
+          // Deduplicate by id
+          const uniqueMap = new Map<string, Procedure>();
+          for (const p of collected) {
+            uniqueMap.set(p.id, p);
+          }
+          let procedures = Array.from(uniqueMap.values());
+
+          // Apply remaining filters including precise distance and sorting
+          procedures = this.applyInMemoryFilters(procedures, filters);
+
+          // Manual pagination
+          const pageSize = filters.pagination || 10;
+          let startIndex = 0;
+          if (
+            filters.lastDoc &&
+            typeof filters.lastDoc === 'object' &&
+            (filters.lastDoc as any).id
+          ) {
+            const idx = procedures.findIndex((p) => p.id === (filters.lastDoc as any).id);
+            if (idx >= 0) startIndex = idx + 1;
+          }
+          const page = procedures.slice(startIndex, startIndex + pageSize);
+          const newLastDoc = page.length === pageSize ? page[page.length - 1] : null;
+
+          console.log(
+            `[PROCEDURE_SERVICE] Geo query success: ${page.length} (of ${procedures.length}) within ${radiusInKm}km`,
+          );
+          return { procedures: page, lastDoc: newLastDoc };
+        })
+        .catch((err) => {
+          console.error('[PROCEDURE_SERVICE] Geo bounds fetch failed:', err);
+          return { procedures: [], lastDoc: null };
+        });
     } catch (error) {
       console.error('[PROCEDURE_SERVICE] Geo query failed:', error);
       return Promise.resolve({ procedures: [], lastDoc: null });
@@ -1272,7 +1242,7 @@ export class ProcedureService extends BaseService {
    * @returns The created procedure
    */
   async createConsultationProcedure(
-    data: Omit<CreateProcedureData, "productId">
+    data: Omit<CreateProcedureData, 'productId'>,
   ): Promise<Procedure> {
     // Generate procedure ID first so we can use it for media uploads
     const procedureId = this.generateId();
@@ -1286,7 +1256,7 @@ export class ProcedureService extends BaseService {
     ]);
 
     if (!category || !subcategory || !technology) {
-      throw new Error("One or more required base entities not found");
+      throw new Error('One or more required base entities not found');
     }
 
     // Get clinic and practitioner information for aggregation
@@ -1297,11 +1267,7 @@ export class ProcedureService extends BaseService {
     }
     const clinic = clinicSnapshot.data() as Clinic;
 
-    const practitionerRef = doc(
-      this.db,
-      PRACTITIONERS_COLLECTION,
-      data.practitionerId
-    );
+    const practitionerRef = doc(this.db, PRACTITIONERS_COLLECTION, data.practitionerId);
     const practitionerSnapshot = await getDoc(practitionerRef);
     if (!practitionerSnapshot.exists()) {
       throw new Error(`Practitioner with ID ${data.practitionerId} not found`);
@@ -1311,26 +1277,22 @@ export class ProcedureService extends BaseService {
     // Process photos if provided
     let processedPhotos: string[] = [];
     if (data.photos && data.photos.length > 0) {
-      processedPhotos = await this.processMediaArray(
-        data.photos,
-        procedureId,
-        "procedure-photos"
-      );
+      processedPhotos = await this.processMediaArray(data.photos, procedureId, 'procedure-photos');
     }
 
     // Create aggregated clinic info for the procedure document
     const clinicInfo = {
       id: clinicSnapshot.id,
       name: clinic.name,
-      description: clinic.description || "",
+      description: clinic.description || '',
       featuredPhoto:
         clinic.featuredPhotos && clinic.featuredPhotos.length > 0
-          ? typeof clinic.featuredPhotos[0] === "string"
+          ? typeof clinic.featuredPhotos[0] === 'string'
             ? clinic.featuredPhotos[0]
-            : ""
-          : typeof clinic.coverPhoto === "string"
+            : ''
+          : typeof clinic.coverPhoto === 'string'
           ? clinic.coverPhoto
-          : "",
+          : '',
       location: clinic.location,
       contactInfo: clinic.contactInfo,
     };
@@ -1339,22 +1301,22 @@ export class ProcedureService extends BaseService {
     const doctorInfo = {
       id: practitionerSnapshot.id,
       name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
-      description: practitioner.basicInfo.bio || "",
+      description: practitioner.basicInfo.bio || '',
       photo:
-        typeof practitioner.basicInfo.profileImageUrl === "string"
+        typeof practitioner.basicInfo.profileImageUrl === 'string'
           ? practitioner.basicInfo.profileImageUrl
-          : "",
+          : '',
       rating: practitioner.reviewInfo?.averageRating || 0,
       services: practitioner.procedures || [],
     };
 
     // Create a placeholder product for consultation procedures
     const consultationProduct: Product = {
-      id: "consultation-no-product",
-      name: "No Product Required",
-      description: "Consultation procedures do not require specific products",
-      brandId: "consultation-brand",
-      brandName: "Consultation",
+      id: 'consultation-no-product',
+      name: 'No Product Required',
+      description: 'Consultation procedures do not require specific products',
+      brandId: 'consultation-brand',
+      brandName: 'Consultation',
       technologyId: data.technologyId,
       technologyName: technology.name,
       isActive: true,
@@ -1363,7 +1325,7 @@ export class ProcedureService extends BaseService {
     };
 
     // Create the procedure object
-    const newProcedure: Omit<Procedure, "createdAt" | "updatedAt"> = {
+    const newProcedure: Omit<Procedure, 'createdAt' | 'updatedAt'> = {
       id: procedureId,
       ...data,
       nameLower: (data as any).nameLower || data.name.toLowerCase(),
@@ -1412,18 +1374,20 @@ export class ProcedureService extends BaseService {
    * This is optimized for mobile map usage to reduce payload size.
    * @returns Array of minimal procedure info for map
    */
-  async getProceduresForMap(): Promise<{
-    id: string;
-    name: string;
-    clinicId: string | undefined;
-    clinicName: string | undefined;
-    address: string;
-    latitude: number | undefined;
-    longitude: number | undefined;
-  }[]> {
+  async getProceduresForMap(): Promise<
+    {
+      id: string;
+      name: string;
+      clinicId: string | undefined;
+      clinicName: string | undefined;
+      address: string;
+      latitude: number | undefined;
+      longitude: number | undefined;
+    }[]
+  > {
     const proceduresRef = collection(this.db, PROCEDURES_COLLECTION);
     const snapshot = await getDocs(proceduresRef);
-    const proceduresForMap = snapshot.docs.map(doc => {
+    const proceduresForMap = snapshot.docs.map((doc) => {
       const data = doc.data();
       return {
         id: doc.id,