@blackcode_sa/metaestetics-api 1.14.28 → 1.14.29

package/dist/admin/index.js

@@ -11188,17 +11188,27 @@ var BookingAdmin = class {
         startTime: start.toDate().toISOString(),
         endTime: end.toDate().toISOString()
       });
-      const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1e3;
+      const MAX_EVENT_DURATION_MS = 30 * 24 * 60 * 60 * 1e3;
       const queryStart = admin16.firestore.Timestamp.fromMillis(
         start.toMillis() - MAX_EVENT_DURATION_MS
       );
-      const eventsRef = this.db.collection(`clinics/${clinicId}/calendar`).where("eventTime.start", ">=", queryStart).where("eventTime.start", "<", end).orderBy("eventTime.start");
+      const eventsRef = this.db.collection(`clinics/${clinicId}/calendar`).where("eventTime.start", ">=", queryStart).where("eventTime.start", "<=", end).orderBy("eventTime.start");
       const snapshot = await eventsRef.get();
       const events = snapshot.docs.map((doc3) => ({
         ...doc3.data(),
         id: doc3.id
       })).filter((event) => {
-        return event.eventTime.end.toMillis() > start.toMillis();
+        const overlaps = event.eventTime.end.toMillis() > start.toMillis();
+        if (!overlaps) {
+          Logger.debug("[BookingAdmin] Filtered out non-overlapping event", {
+            eventId: event.id,
+            eventStart: event.eventTime.start.toDate().toISOString(),
+            eventEnd: event.eventTime.end.toDate().toISOString(),
+            queryStart: start.toDate().toISOString(),
+            queryEnd: end.toDate().toISOString()
+          });
+        }
+        return overlaps;
       });
       Logger.debug("[BookingAdmin] Retrieved clinic calendar events", {
         clinicId,
@@ -11234,17 +11244,27 @@ var BookingAdmin = class {
         startTime: start.toDate().toISOString(),
         endTime: end.toDate().toISOString()
       });
-      const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1e3;
+      const MAX_EVENT_DURATION_MS = 30 * 24 * 60 * 60 * 1e3;
       const queryStart = admin16.firestore.Timestamp.fromMillis(
         start.toMillis() - MAX_EVENT_DURATION_MS
       );
-      const eventsRef = this.db.collection(`practitioners/${practitionerId}/calendar`).where("eventTime.start", ">=", queryStart).where("eventTime.start", "<", end).orderBy("eventTime.start");
+      const eventsRef = this.db.collection(`practitioners/${practitionerId}/calendar`).where("eventTime.start", ">=", queryStart).where("eventTime.start", "<=", end).orderBy("eventTime.start");
       const snapshot = await eventsRef.get();
       const events = snapshot.docs.map((doc3) => ({
         ...doc3.data(),
         id: doc3.id
       })).filter((event) => {
-        return event.eventTime.end.toMillis() > start.toMillis();
+        const overlaps = event.eventTime.end.toMillis() > start.toMillis();
+        if (!overlaps) {
+          Logger.debug("[BookingAdmin] Filtered out non-overlapping practitioner event", {
+            eventId: event.id,
+            eventStart: event.eventTime.start.toDate().toISOString(),
+            eventEnd: event.eventTime.end.toDate().toISOString(),
+            queryStart: start.toDate().toISOString(),
+            queryEnd: end.toDate().toISOString()
+          });
+        }
+        return overlaps;
       });
       Logger.debug("[BookingAdmin] Retrieved practitioner calendar events", {
         practitionerId,

package/dist/admin/index.mjs

@@ -11115,17 +11115,27 @@ var BookingAdmin = class {
         startTime: start.toDate().toISOString(),
         endTime: end.toDate().toISOString()
       });
-      const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1e3;
+      const MAX_EVENT_DURATION_MS = 30 * 24 * 60 * 60 * 1e3;
       const queryStart = admin16.firestore.Timestamp.fromMillis(
         start.toMillis() - MAX_EVENT_DURATION_MS
       );
-      const eventsRef = this.db.collection(`clinics/${clinicId}/calendar`).where("eventTime.start", ">=", queryStart).where("eventTime.start", "<", end).orderBy("eventTime.start");
+      const eventsRef = this.db.collection(`clinics/${clinicId}/calendar`).where("eventTime.start", ">=", queryStart).where("eventTime.start", "<=", end).orderBy("eventTime.start");
       const snapshot = await eventsRef.get();
       const events = snapshot.docs.map((doc3) => ({
         ...doc3.data(),
         id: doc3.id
       })).filter((event) => {
-        return event.eventTime.end.toMillis() > start.toMillis();
+        const overlaps = event.eventTime.end.toMillis() > start.toMillis();
+        if (!overlaps) {
+          Logger.debug("[BookingAdmin] Filtered out non-overlapping event", {
+            eventId: event.id,
+            eventStart: event.eventTime.start.toDate().toISOString(),
+            eventEnd: event.eventTime.end.toDate().toISOString(),
+            queryStart: start.toDate().toISOString(),
+            queryEnd: end.toDate().toISOString()
+          });
+        }
+        return overlaps;
       });
       Logger.debug("[BookingAdmin] Retrieved clinic calendar events", {
         clinicId,
@@ -11161,17 +11171,27 @@ var BookingAdmin = class {
         startTime: start.toDate().toISOString(),
         endTime: end.toDate().toISOString()
       });
-      const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1e3;
+      const MAX_EVENT_DURATION_MS = 30 * 24 * 60 * 60 * 1e3;
       const queryStart = admin16.firestore.Timestamp.fromMillis(
         start.toMillis() - MAX_EVENT_DURATION_MS
       );
-      const eventsRef = this.db.collection(`practitioners/${practitionerId}/calendar`).where("eventTime.start", ">=", queryStart).where("eventTime.start", "<", end).orderBy("eventTime.start");
+      const eventsRef = this.db.collection(`practitioners/${practitionerId}/calendar`).where("eventTime.start", ">=", queryStart).where("eventTime.start", "<=", end).orderBy("eventTime.start");
       const snapshot = await eventsRef.get();
       const events = snapshot.docs.map((doc3) => ({
         ...doc3.data(),
         id: doc3.id
       })).filter((event) => {
-        return event.eventTime.end.toMillis() > start.toMillis();
+        const overlaps = event.eventTime.end.toMillis() > start.toMillis();
+        if (!overlaps) {
+          Logger.debug("[BookingAdmin] Filtered out non-overlapping practitioner event", {
+            eventId: event.id,
+            eventStart: event.eventTime.start.toDate().toISOString(),
+            eventEnd: event.eventTime.end.toDate().toISOString(),
+            queryStart: start.toDate().toISOString(),
+            queryEnd: end.toDate().toISOString()
+          });
+        }
+        return overlaps;
       });
       Logger.debug("[BookingAdmin] Retrieved practitioner calendar events", {
         practitionerId,

package/dist/index.js

@@ -16780,15 +16780,37 @@ async function searchCalendarEventsUtil(db, params) {
     constraints.push((0, import_firestore45.where)("eventType", "==", filters.eventType));
   }
   if (filters.dateRange) {
-    constraints.push((0, import_firestore45.where)("eventTime.start", ">=", filters.dateRange.start));
+    const MAX_EVENT_DURATION_MS = 30 * 24 * 60 * 60 * 1e3;
+    const extendedStart = import_firestore45.Timestamp.fromMillis(
+      filters.dateRange.start.toMillis() - MAX_EVENT_DURATION_MS
+    );
+    constraints.push((0, import_firestore45.where)("eventTime.start", ">=", extendedStart));
     constraints.push((0, import_firestore45.where)("eventTime.start", "<=", filters.dateRange.end));
   }
   try {
     const finalQuery = (0, import_firestore45.query)(collectionRef, ...constraints);
     const querySnapshot = await (0, import_firestore45.getDocs)(finalQuery);
-    const events = querySnapshot.docs.map(
+    let events = querySnapshot.docs.map(
       (doc47) => ({ id: doc47.id, ...doc47.data() })
     );
+    if (filters.dateRange) {
+      events = events.filter((event) => {
+        const overlaps = event.eventTime.end.toMillis() > filters.dateRange.start.toMillis();
+        if (!overlaps) {
+          console.debug(
+            `[searchCalendarEventsUtil] Filtered out non-overlapping event:`,
+            {
+              eventId: event.id,
+              eventStart: event.eventTime.start.toDate().toISOString(),
+              eventEnd: event.eventTime.end.toDate().toISOString(),
+              queryStart: filters.dateRange.start.toDate().toISOString(),
+              queryEnd: filters.dateRange.end.toDate().toISOString()
+            }
+          );
+        }
+        return overlaps;
+      });
+    }
     return events;
   } catch (error) {
     console.error("Error searching calendar events:", error);

package/dist/index.mjs

@@ -16926,15 +16926,37 @@ async function searchCalendarEventsUtil(db, params) {
     constraints.push(where25("eventType", "==", filters.eventType));
   }
   if (filters.dateRange) {
-    constraints.push(where25("eventTime.start", ">=", filters.dateRange.start));
+    const MAX_EVENT_DURATION_MS = 30 * 24 * 60 * 60 * 1e3;
+    const extendedStart = Timestamp26.fromMillis(
+      filters.dateRange.start.toMillis() - MAX_EVENT_DURATION_MS
+    );
+    constraints.push(where25("eventTime.start", ">=", extendedStart));
     constraints.push(where25("eventTime.start", "<=", filters.dateRange.end));
   }
   try {
     const finalQuery = query25(collectionRef, ...constraints);
     const querySnapshot = await getDocs25(finalQuery);
-    const events = querySnapshot.docs.map(
+    let events = querySnapshot.docs.map(
       (doc47) => ({ id: doc47.id, ...doc47.data() })
     );
+    if (filters.dateRange) {
+      events = events.filter((event) => {
+        const overlaps = event.eventTime.end.toMillis() > filters.dateRange.start.toMillis();
+        if (!overlaps) {
+          console.debug(
+            `[searchCalendarEventsUtil] Filtered out non-overlapping event:`,
+            {
+              eventId: event.id,
+              eventStart: event.eventTime.start.toDate().toISOString(),
+              eventEnd: event.eventTime.end.toDate().toISOString(),
+              queryStart: filters.dateRange.start.toDate().toISOString(),
+              queryEnd: filters.dateRange.end.toDate().toISOString()
+            }
+          );
+        }
+        return overlaps;
+      });
+    }
     return events;
   } catch (error) {
     console.error("Error searching calendar events:", error);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.14.28",
+  "version": "1.14.29",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/admin/booking/booking.admin.ts

@@ -339,26 +339,44 @@ export class BookingAdmin {
         endTime: end.toDate().toISOString(),
       });
 
-      const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1000;
+      // Increased to 30 days to handle long blocking events (e.g., holidays, extended time off)
+      // This ensures we catch blocking events that start before our query range but overlap with it
+      const MAX_EVENT_DURATION_MS = 30 * 24 * 60 * 60 * 1000;
       const queryStart = admin.firestore.Timestamp.fromMillis(
         start.toMillis() - MAX_EVENT_DURATION_MS
       );
 
+      // Query for events that:
+      // 1. Start before or during our query range (eventTime.start < end)
+      // 2. We'll post-filter to ensure they overlap (eventTime.end > start)
       const eventsRef = this.db
         .collection(`clinics/${clinicId}/calendar`)
         .where("eventTime.start", ">=", queryStart)
-        .where("eventTime.start", "<", end)
+        .where("eventTime.start", "<=", end)
         .orderBy("eventTime.start");
 
       const snapshot = await eventsRef.get();
 
+      // Post-filter to ensure events actually overlap with our query range
+      // An event overlaps if: eventTime.start < queryEnd AND eventTime.end > queryStart
       const events = snapshot.docs
         .map((doc) => ({
           ...doc.data(),
           id: doc.id,
         }))
         .filter((event: any) => {
-          return event.eventTime.end.toMillis() > start.toMillis();
+          // Event overlaps if it ends after our start time
+          const overlaps = event.eventTime.end.toMillis() > start.toMillis();
+          if (!overlaps) {
+            Logger.debug("[BookingAdmin] Filtered out non-overlapping event", {
+              eventId: event.id,
+              eventStart: event.eventTime.start.toDate().toISOString(),
+              eventEnd: event.eventTime.end.toDate().toISOString(),
+              queryStart: start.toDate().toISOString(),
+              queryEnd: end.toDate().toISOString(),
+            });
+          }
+          return overlaps;
         });
 
       Logger.debug("[BookingAdmin] Retrieved clinic calendar events", {
@@ -403,26 +421,44 @@ export class BookingAdmin {
         endTime: end.toDate().toISOString(),
       });
 
-      const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1000;
+      // Increased to 30 days to handle long blocking events (e.g., holidays, extended time off)
+      // This ensures we catch blocking events that start before our query range but overlap with it
+      const MAX_EVENT_DURATION_MS = 30 * 24 * 60 * 60 * 1000;
       const queryStart = admin.firestore.Timestamp.fromMillis(
         start.toMillis() - MAX_EVENT_DURATION_MS
       );
 
+      // Query for events that:
+      // 1. Start before or during our query range (eventTime.start <= end)
+      // 2. We'll post-filter to ensure they overlap (eventTime.end > start)
       const eventsRef = this.db
         .collection(`practitioners/${practitionerId}/calendar`)
         .where("eventTime.start", ">=", queryStart)
-        .where("eventTime.start", "<", end)
+        .where("eventTime.start", "<=", end)
         .orderBy("eventTime.start");
 
       const snapshot = await eventsRef.get();
 
+      // Post-filter to ensure events actually overlap with our query range
+      // An event overlaps if: eventTime.start < queryEnd AND eventTime.end > queryStart
       const events = snapshot.docs
         .map((doc) => ({
           ...doc.data(),
           id: doc.id,
         }))
         .filter((event: any) => {
-          return event.eventTime.end.toMillis() > start.toMillis();
+          // Event overlaps if it ends after our start time
+          const overlaps = event.eventTime.end.toMillis() > start.toMillis();
+          if (!overlaps) {
+            Logger.debug("[BookingAdmin] Filtered out non-overlapping practitioner event", {
+              eventId: event.id,
+              eventStart: event.eventTime.start.toDate().toISOString(),
+              eventEnd: event.eventTime.end.toDate().toISOString(),
+              queryStart: start.toDate().toISOString(),
+              queryEnd: end.toDate().toISOString(),
+            });
+          }
+          return overlaps;
         });
 
       Logger.debug("[BookingAdmin] Retrieved practitioner calendar events", {

package/src/services/calendar/utils/calendar-event.utils.ts

@@ -622,7 +622,15 @@ export async function searchCalendarEventsUtil(
   }
   if (filters.dateRange) {
     // Firestore requires range filters on the same field
-    constraints.push(where("eventTime.start", ">=", filters.dateRange.start));
+    // We query for events that start within or before the date range
+    // Then post-filter to ensure they overlap (eventTime.end > dateRange.start)
+    // To catch events that start before but overlap, we extend the query start backwards
+    const MAX_EVENT_DURATION_MS = 30 * 24 * 60 * 60 * 1000; // 30 days for long blocking events
+    const extendedStart = Timestamp.fromMillis(
+      filters.dateRange.start.toMillis() - MAX_EVENT_DURATION_MS
+    );
+    
+    constraints.push(where("eventTime.start", ">=", extendedStart));
     constraints.push(where("eventTime.start", "<=", filters.dateRange.end));
     // Note: You might need to order by eventTime.start for range filters to work efficiently
     // constraints.push(orderBy("eventTime.start"));
@@ -633,10 +641,32 @@ export async function searchCalendarEventsUtil(
     const finalQuery = query(collectionRef, ...constraints);
     const querySnapshot = await getDocs(finalQuery);
 
-    const events = querySnapshot.docs.map(
+    let events = querySnapshot.docs.map(
       (doc) => ({ id: doc.id, ...doc.data() } as CalendarEvent)
     );
 
+    // Post-filter to ensure events actually overlap with the date range (if provided)
+    // An event overlaps if: eventTime.start < dateRange.end AND eventTime.end > dateRange.start
+    if (filters.dateRange) {
+      events = events.filter((event) => {
+        const overlaps =
+          event.eventTime.end.toMillis() > filters.dateRange!.start.toMillis();
+        if (!overlaps) {
+          console.debug(
+            `[searchCalendarEventsUtil] Filtered out non-overlapping event:`,
+            {
+              eventId: event.id,
+              eventStart: event.eventTime.start.toDate().toISOString(),
+              eventEnd: event.eventTime.end.toDate().toISOString(),
+              queryStart: filters.dateRange!.start.toDate().toISOString(),
+              queryEnd: filters.dateRange!.end.toDate().toISOString(),
+            }
+          );
+        }
+        return overlaps;
+      });
+    }
+
     return events;
   } catch (error) {
     console.error("Error searching calendar events:", error);