@blackcode_sa/metaestetics-api 1.12.26 → 1.12.27

package/dist/admin/index.d.mts

@@ -3196,6 +3196,7 @@ declare class BookingAvailabilityCalculator {
      * @param intervals - Final available intervals
      * @param intervalMinutes - Scheduling interval in minutes
      * @param durationMinutes - Procedure duration in minutes
+     * @param tz - IANA timezone of the clinic
      * @returns Array of available booking slots
      */
     private static generateAvailableSlots;
@@ -3205,6 +3206,7 @@ declare class BookingAvailabilityCalculator {
      * @param slotStart - Start time of the slot
      * @param slotEnd - End time of the slot
      * @param intervals - Available intervals
+     * @param tz - IANA timezone of the clinic
      * @returns True if the slot is fully contained within an available interval
      */
     private static isSlotFullyAvailable;

package/dist/admin/index.d.ts

@@ -3196,6 +3196,7 @@ declare class BookingAvailabilityCalculator {
      * @param intervals - Final available intervals
      * @param intervalMinutes - Scheduling interval in minutes
      * @param durationMinutes - Procedure duration in minutes
+     * @param tz - IANA timezone of the clinic
      * @returns Array of available booking slots
      */
     private static generateAvailableSlots;
@@ -3205,6 +3206,7 @@ declare class BookingAvailabilityCalculator {
      * @param slotStart - Start time of the slot
      * @param slotEnd - End time of the slot
      * @param intervals - Available intervals
+     * @param tz - IANA timezone of the clinic
      * @returns True if the slot is fully contained within an available interval
      */
     private static isSlotFullyAvailable;

package/dist/admin/index.js

@@ -6603,7 +6603,8 @@ var BookingAvailabilityCalculator = class {
     const availableSlots = this.generateAvailableSlots(
       availableIntervals,
       schedulingIntervalMinutes,
-      procedureDurationMinutes
+      procedureDurationMinutes,
+      tz
     );
     return { availableSlots };
   }
@@ -6855,19 +6856,20 @@ var BookingAvailabilityCalculator = class {
    * @param intervals - Final available intervals
    * @param intervalMinutes - Scheduling interval in minutes
    * @param durationMinutes - Procedure duration in minutes
+   * @param tz - IANA timezone of the clinic
    * @returns Array of available booking slots
    */
-  static generateAvailableSlots(intervals, intervalMinutes, durationMinutes) {
+  static generateAvailableSlots(intervals, intervalMinutes, durationMinutes, tz) {
     const slots = [];
     console.log(
-      `Generating slots with ${intervalMinutes}min intervals for ${durationMinutes}min procedure`
+      `Generating slots with ${intervalMinutes}min intervals for ${durationMinutes}min procedure in timezone ${tz}`
     );
     const durationMs = durationMinutes * 60 * 1e3;
     const intervalMs = intervalMinutes * 60 * 1e3;
     for (const interval of intervals) {
       const intervalStart = interval.start.toDate();
       const intervalEnd = interval.end.toDate();
-      let slotStart = import_luxon.DateTime.fromJSDate(intervalStart);
+      let slotStart = import_luxon.DateTime.fromMillis(intervalStart.getTime(), { zone: tz });
       const minutesIntoDay = slotStart.hour * 60 + slotStart.minute;
       const minutesRemainder = minutesIntoDay % intervalMinutes;
       if (minutesRemainder > 0) {
@@ -6877,7 +6879,7 @@ var BookingAvailabilityCalculator = class {
       }
       while (slotStart.toMillis() + durationMs <= intervalEnd.getTime()) {
         const slotEnd = slotStart.plus({ minutes: durationMinutes });
-        if (this.isSlotFullyAvailable(slotStart, slotEnd, intervals)) {
+        if (this.isSlotFullyAvailable(slotStart, slotEnd, intervals, tz)) {
           slots.push({
             start: import_firestore2.Timestamp.fromMillis(slotStart.toMillis())
           });
@@ -6894,12 +6896,13 @@ var BookingAvailabilityCalculator = class {
    * @param slotStart - Start time of the slot
    * @param slotEnd - End time of the slot
    * @param intervals - Available intervals
+   * @param tz - IANA timezone of the clinic
    * @returns True if the slot is fully contained within an available interval
    */
-  static isSlotFullyAvailable(slotStart, slotEnd, intervals) {
+  static isSlotFullyAvailable(slotStart, slotEnd, intervals, tz) {
     return intervals.some((interval) => {
-      const intervalStart = import_luxon.DateTime.fromMillis(interval.start.toMillis());
-      const intervalEnd = import_luxon.DateTime.fromMillis(interval.end.toMillis());
+      const intervalStart = import_luxon.DateTime.fromMillis(interval.start.toMillis(), { zone: tz });
+      const intervalEnd = import_luxon.DateTime.fromMillis(interval.end.toMillis(), { zone: tz });
       return slotStart >= intervalStart && slotEnd <= intervalEnd;
     });
   }
@@ -7344,16 +7347,23 @@ var BookingAdmin = class {
         startTime: start.toDate().toISOString(),
         endTime: end.toDate().toISOString()
       });
-      const eventsRef = this.db.collection(`clinics/${clinicId}/calendar`).where("eventTime.start", ">=", start).where("eventTime.start", "<=", end);
+      const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1e3;
+      const queryStart = admin15.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 snapshot = await eventsRef.get();
       const events = snapshot.docs.map((doc) => ({
         ...doc.data(),
         id: doc.id
-      }));
+      })).filter((event) => {
+        return event.eventTime.end.toMillis() > start.toMillis();
+      });
       Logger.debug("[BookingAdmin] Retrieved clinic calendar events", {
         clinicId,
         eventsCount: events.length,
-        eventsTypes: this.summarizeEventTypes(events)
+        eventsTypes: this.summarizeEventTypes(events),
+        queryStartTime: queryStart.toDate().toISOString()
       });
       return events;
     } catch (error) {
@@ -7383,16 +7393,23 @@ var BookingAdmin = class {
         startTime: start.toDate().toISOString(),
         endTime: end.toDate().toISOString()
       });
-      const eventsRef = this.db.collection(`practitioners/${practitionerId}/calendar`).where("eventTime.start", ">=", start).where("eventTime.start", "<=", end);
+      const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1e3;
+      const queryStart = admin15.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 snapshot = await eventsRef.get();
       const events = snapshot.docs.map((doc) => ({
         ...doc.data(),
         id: doc.id
-      }));
+      })).filter((event) => {
+        return event.eventTime.end.toMillis() > start.toMillis();
+      });
       Logger.debug("[BookingAdmin] Retrieved practitioner calendar events", {
         practitionerId,
         eventsCount: events.length,
-        eventsTypes: this.summarizeEventTypes(events)
+        eventsTypes: this.summarizeEventTypes(events),
+        queryStartTime: queryStart.toDate().toISOString()
       });
       return events;
     } catch (error) {

package/dist/admin/index.mjs

@@ -6541,7 +6541,8 @@ var BookingAvailabilityCalculator = class {
     const availableSlots = this.generateAvailableSlots(
       availableIntervals,
       schedulingIntervalMinutes,
-      procedureDurationMinutes
+      procedureDurationMinutes,
+      tz
     );
     return { availableSlots };
   }
@@ -6793,19 +6794,20 @@ var BookingAvailabilityCalculator = class {
    * @param intervals - Final available intervals
    * @param intervalMinutes - Scheduling interval in minutes
    * @param durationMinutes - Procedure duration in minutes
+   * @param tz - IANA timezone of the clinic
    * @returns Array of available booking slots
    */
-  static generateAvailableSlots(intervals, intervalMinutes, durationMinutes) {
+  static generateAvailableSlots(intervals, intervalMinutes, durationMinutes, tz) {
     const slots = [];
     console.log(
-      `Generating slots with ${intervalMinutes}min intervals for ${durationMinutes}min procedure`
+      `Generating slots with ${intervalMinutes}min intervals for ${durationMinutes}min procedure in timezone ${tz}`
     );
     const durationMs = durationMinutes * 60 * 1e3;
     const intervalMs = intervalMinutes * 60 * 1e3;
     for (const interval of intervals) {
       const intervalStart = interval.start.toDate();
       const intervalEnd = interval.end.toDate();
-      let slotStart = DateTime.fromJSDate(intervalStart);
+      let slotStart = DateTime.fromMillis(intervalStart.getTime(), { zone: tz });
       const minutesIntoDay = slotStart.hour * 60 + slotStart.minute;
       const minutesRemainder = minutesIntoDay % intervalMinutes;
       if (minutesRemainder > 0) {
@@ -6815,7 +6817,7 @@ var BookingAvailabilityCalculator = class {
       }
       while (slotStart.toMillis() + durationMs <= intervalEnd.getTime()) {
         const slotEnd = slotStart.plus({ minutes: durationMinutes });
-        if (this.isSlotFullyAvailable(slotStart, slotEnd, intervals)) {
+        if (this.isSlotFullyAvailable(slotStart, slotEnd, intervals, tz)) {
           slots.push({
             start: Timestamp.fromMillis(slotStart.toMillis())
           });
@@ -6832,12 +6834,13 @@ var BookingAvailabilityCalculator = class {
    * @param slotStart - Start time of the slot
    * @param slotEnd - End time of the slot
    * @param intervals - Available intervals
+   * @param tz - IANA timezone of the clinic
    * @returns True if the slot is fully contained within an available interval
    */
-  static isSlotFullyAvailable(slotStart, slotEnd, intervals) {
+  static isSlotFullyAvailable(slotStart, slotEnd, intervals, tz) {
     return intervals.some((interval) => {
-      const intervalStart = DateTime.fromMillis(interval.start.toMillis());
-      const intervalEnd = DateTime.fromMillis(interval.end.toMillis());
+      const intervalStart = DateTime.fromMillis(interval.start.toMillis(), { zone: tz });
+      const intervalEnd = DateTime.fromMillis(interval.end.toMillis(), { zone: tz });
       return slotStart >= intervalStart && slotEnd <= intervalEnd;
     });
   }
@@ -7282,16 +7285,23 @@ var BookingAdmin = class {
         startTime: start.toDate().toISOString(),
         endTime: end.toDate().toISOString()
       });
-      const eventsRef = this.db.collection(`clinics/${clinicId}/calendar`).where("eventTime.start", ">=", start).where("eventTime.start", "<=", end);
+      const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1e3;
+      const queryStart = admin15.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 snapshot = await eventsRef.get();
       const events = snapshot.docs.map((doc) => ({
         ...doc.data(),
         id: doc.id
-      }));
+      })).filter((event) => {
+        return event.eventTime.end.toMillis() > start.toMillis();
+      });
       Logger.debug("[BookingAdmin] Retrieved clinic calendar events", {
         clinicId,
         eventsCount: events.length,
-        eventsTypes: this.summarizeEventTypes(events)
+        eventsTypes: this.summarizeEventTypes(events),
+        queryStartTime: queryStart.toDate().toISOString()
       });
       return events;
     } catch (error) {
@@ -7321,16 +7331,23 @@ var BookingAdmin = class {
         startTime: start.toDate().toISOString(),
         endTime: end.toDate().toISOString()
       });
-      const eventsRef = this.db.collection(`practitioners/${practitionerId}/calendar`).where("eventTime.start", ">=", start).where("eventTime.start", "<=", end);
+      const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1e3;
+      const queryStart = admin15.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 snapshot = await eventsRef.get();
       const events = snapshot.docs.map((doc) => ({
         ...doc.data(),
         id: doc.id
-      }));
+      })).filter((event) => {
+        return event.eventTime.end.toMillis() > start.toMillis();
+      });
       Logger.debug("[BookingAdmin] Retrieved practitioner calendar events", {
         practitionerId,
         eventsCount: events.length,
-        eventsTypes: this.summarizeEventTypes(events)
+        eventsTypes: this.summarizeEventTypes(events),
+        queryStartTime: queryStart.toDate().toISOString()
       });
       return events;
     } catch (error) {

package/package.json

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

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

@@ -339,22 +339,33 @@ export class BookingAdmin {
         endTime: end.toDate().toISOString(),
       });
 
+      const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1000;
+      const queryStart = admin.firestore.Timestamp.fromMillis(
+        start.toMillis() - MAX_EVENT_DURATION_MS
+      );
+
       const eventsRef = this.db
         .collection(`clinics/${clinicId}/calendar`)
-        .where("eventTime.start", ">=", start)
-        .where("eventTime.start", "<=", end);
+        .where("eventTime.start", ">=", queryStart)
+        .where("eventTime.start", "<", end)
+        .orderBy("eventTime.start");
 
       const snapshot = await eventsRef.get();
 
-      const events = snapshot.docs.map((doc) => ({
-        ...doc.data(),
-        id: doc.id,
-      }));
+      const events = snapshot.docs
+        .map((doc) => ({
+          ...doc.data(),
+          id: doc.id,
+        }))
+        .filter((event: any) => {
+          return event.eventTime.end.toMillis() > start.toMillis();
+        });
 
       Logger.debug("[BookingAdmin] Retrieved clinic calendar events", {
         clinicId,
         eventsCount: events.length,
         eventsTypes: this.summarizeEventTypes(events),
+        queryStartTime: queryStart.toDate().toISOString(),
       });
 
       return events;
@@ -392,22 +403,33 @@ export class BookingAdmin {
         endTime: end.toDate().toISOString(),
       });
 
+      const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1000;
+      const queryStart = admin.firestore.Timestamp.fromMillis(
+        start.toMillis() - MAX_EVENT_DURATION_MS
+      );
+
       const eventsRef = this.db
         .collection(`practitioners/${practitionerId}/calendar`)
-        .where("eventTime.start", ">=", start)
-        .where("eventTime.start", "<=", end);
+        .where("eventTime.start", ">=", queryStart)
+        .where("eventTime.start", "<", end)
+        .orderBy("eventTime.start");
 
       const snapshot = await eventsRef.get();
 
-      const events = snapshot.docs.map((doc) => ({
-        ...doc.data(),
-        id: doc.id,
-      }));
+      const events = snapshot.docs
+        .map((doc) => ({
+          ...doc.data(),
+          id: doc.id,
+        }))
+        .filter((event: any) => {
+          return event.eventTime.end.toMillis() > start.toMillis();
+        });
 
       Logger.debug("[BookingAdmin] Retrieved practitioner calendar events", {
         practitionerId,
         eventsCount: events.length,
         eventsTypes: this.summarizeEventTypes(events),
+        queryStartTime: queryStart.toDate().toISOString(),
       });
 
       return events;

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

@@ -96,7 +96,8 @@ export class BookingAvailabilityCalculator {
     const availableSlots = this.generateAvailableSlots(
       availableIntervals,
       schedulingIntervalMinutes,
-      procedureDurationMinutes
+      procedureDurationMinutes,
+      tz
     );
 
     return { availableSlots };
@@ -469,16 +470,18 @@ export class BookingAvailabilityCalculator {
    * @param intervals - Final available intervals
    * @param intervalMinutes - Scheduling interval in minutes
    * @param durationMinutes - Procedure duration in minutes
+   * @param tz - IANA timezone of the clinic
    * @returns Array of available booking slots
    */
   private static generateAvailableSlots(
     intervals: TimeInterval[],
     intervalMinutes: number,
-    durationMinutes: number
+    durationMinutes: number,
+    tz: string
   ): AvailableSlot[] {
     const slots: AvailableSlot[] = [];
     console.log(
-      `Generating slots with ${intervalMinutes}min intervals for ${durationMinutes}min procedure`
+      `Generating slots with ${intervalMinutes}min intervals for ${durationMinutes}min procedure in timezone ${tz}`
     );
 
     // Convert duration to milliseconds
@@ -492,8 +495,8 @@ export class BookingAvailabilityCalculator {
       const intervalStart = interval.start.toDate();
       const intervalEnd = interval.end.toDate();
 
-      // Start at the beginning of the interval
-      let slotStart = DateTime.fromJSDate(intervalStart);
+      // Start at the beginning of the interval IN CLINIC TIMEZONE
+      let slotStart = DateTime.fromMillis(intervalStart.getTime(), { zone: tz });
 
       // Adjust slotStart to the nearest interval boundary if needed
       const minutesIntoDay = slotStart.hour * 60 + slotStart.minute;
@@ -511,7 +514,7 @@ export class BookingAvailabilityCalculator {
         const slotEnd = slotStart.plus({ minutes: durationMinutes });
 
         // Check if this slot fits entirely within one of our available intervals
-        if (this.isSlotFullyAvailable(slotStart, slotEnd, intervals)) {
+        if (this.isSlotFullyAvailable(slotStart, slotEnd, intervals, tz)) {
           slots.push({
             start: Timestamp.fromMillis(slotStart.toMillis()),
           });
@@ -532,17 +535,19 @@ export class BookingAvailabilityCalculator {
    * @param slotStart - Start time of the slot
    * @param slotEnd - End time of the slot
    * @param intervals - Available intervals
+   * @param tz - IANA timezone of the clinic
    * @returns True if the slot is fully contained within an available interval
    */
   private static isSlotFullyAvailable(
     slotStart: DateTime,
     slotEnd: DateTime,
-    intervals: TimeInterval[]
+    intervals: TimeInterval[],
+    tz: string
   ): boolean {
     // Check if the slot is fully contained in any of the available intervals
     return intervals.some((interval) => {
-      const intervalStart = DateTime.fromMillis(interval.start.toMillis());
-      const intervalEnd = DateTime.fromMillis(interval.end.toMillis());
+      const intervalStart = DateTime.fromMillis(interval.start.toMillis(), { zone: tz });
+      const intervalEnd = DateTime.fromMillis(interval.end.toMillis(), { zone: tz });
 
       return slotStart >= intervalStart && slotEnd <= intervalEnd;
     });

package/src/admin/booking/timezones-problem.md

@@ -122,11 +122,55 @@ Alignment expectation:
   - Interval sizes that don’t divide 60 (e.g., 20 min), and variable procedure durations.
 
 ### Actionable checklist
-- Make all DateTime constructions in slot generation and containment checks use `{ zone: tz }`.
-- Replace `fromJSDate` with `fromMillis` in calculator paths.
-- Update event fetching to include overlaps with the timeframe; union queries or adjust model.
-- Re-assert the type contract: calculator receives only client `Timestamp` + `tz`.
-- Document UI responsibility to convert wall-clock (clinic `tz`) → UTC Timestamp exactly once.
+- ✅ Make all DateTime constructions in slot generation and containment checks use `{ zone: tz }`.
+- ✅ Replace `fromJSDate` with `fromMillis` in calculator paths.
+- ✅ Update event fetching to include overlaps with the timeframe; union queries or adjust model.
+- ⏳ Re-assert the type contract: calculator receives only client `Timestamp` + `tz`.
+- ⏳ Document UI responsibility to convert wall-clock (clinic `tz`) → UTC Timestamp exactly once.
+
+### PHASE 1 COMPLETED: Backend Calculator Fixes ✅
+
+**Date Completed:** October 1, 2025
+
+**Changes Made:**
+
+1. **booking.calculator.ts - generateAvailableSlots()**
+   - Added `tz: string` parameter
+   - Changed `DateTime.fromJSDate(intervalStart)` → `DateTime.fromMillis(intervalStart.getTime(), { zone: tz })`
+   - Now explicitly creates DateTime in clinic timezone for all slot calculations
+   
+2. **booking.calculator.ts - isSlotFullyAvailable()**
+   - Added `tz: string` parameter
+   - Changed `DateTime.fromMillis(interval.start.toMillis())` → `DateTime.fromMillis(interval.start.toMillis(), { zone: tz })`
+   - Interval boundary checks now use clinic timezone context
+
+3. **booking.calculator.ts - calculateSlots()**
+   - Updated call to `generateAvailableSlots()` to pass `tz` parameter
+   - Updated call to `isSlotFullyAvailable()` to pass `tz` parameter
+
+4. **booking.admin.ts - getClinicCalendarEvents()**
+   - Fixed event overlap logic with bounded query
+   - Added lower bound: `queryStart = start - 24 hours` to prevent querying all historical events
+   - Query: `eventTime.start >= queryStart AND eventTime.start < end`
+   - Added post-filter: `eventTime.end > start` to catch all overlapping events
+   - Prevents missing events that start before window but overlap into it
+   - Performance optimized: only queries ~24-48 hours of events instead of entire history
+
+5. **booking.admin.ts - getPractitionerCalendarEvents()**
+   - Applied same overlap fix with 24-hour lookback window
+   - Ensures busy time subtraction includes all conflicting events
+   - Efficient: assumes no appointments longer than 24 hours
+
+**Impact:**
+- Slot generation now correctly happens in clinic timezone
+- Slots are properly converted to UTC for storage/transmission
+- Event blocking now catches all overlapping events, not just those starting within window
+- Fixes timezone display issues for users in different timezones
+
+**Next Steps:**
+- Phase 2: Mobile app fixes (use original UTC timestamp from slots)
+- Phase 3: ClinicApp fixes (same as Mobile)
+- Phase 4: Testing across multiple timezones and DST boundaries
 
 ### Known risks
 - DST transitions can produce days with 23/25 hours; rounding/iteration must not assume 24h.

package/src/services/clinic/clinic.service.ts

@@ -17,7 +17,7 @@ import {
   arrayUnion,
   arrayRemove,
 } from "firebase/firestore";
-import { getFunctions, httpsCallable, connectFunctionsEmulator } from "firebase/functions";
+import { getFunctions, httpsCallable } from "firebase/functions";
 import { BaseService } from "../base.service";
 import {
   Clinic,