@blackcode_sa/metaestetics-api 1.14.28 → 1.14.32

package/dist/admin/index.mjs

@@ -382,6 +382,15 @@ var PATIENT_MEDICAL_INFO_COLLECTION = "medical_info";
 var PATIENTS_COLLECTION = "patients";
 var PATIENT_SENSITIVE_INFO_COLLECTION = "sensitive-info";
 
+// src/types/patient/token.types.ts
+var INVITE_TOKENS_COLLECTION = "inviteTokens";
+var PatientTokenStatus = /* @__PURE__ */ ((PatientTokenStatus2) => {
+  PatientTokenStatus2["ACTIVE"] = "active";
+  PatientTokenStatus2["USED"] = "used";
+  PatientTokenStatus2["EXPIRED"] = "expired";
+  return PatientTokenStatus2;
+})(PatientTokenStatus || {});
+
 // src/types/clinic/practitioner-invite.types.ts
 var PractitionerInviteStatus = /* @__PURE__ */ ((PractitionerInviteStatus2) => {
   PractitionerInviteStatus2["PENDING"] = "pending";
@@ -11115,17 +11124,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 +11180,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,
@@ -13053,6 +13082,378 @@ var ExistingPractitionerInviteMailingService = class extends BaseMailingService
   }
 };
 
+// src/admin/mailing/patientInvite/templates/invitation.template.ts
+var patientInvitationTemplate = `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Claim Your Patient Profile at {{clinicName}}</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      line-height: 1.6;
+      color: #333;
+      margin: 0;
+      padding: 0;
+    }
+    .container {
+      max-width: 600px;
+      margin: 0 auto;
+      padding: 20px;
+    }
+    .header {
+      background-color: #2C8E99;
+      padding: 20px;
+      text-align: center;
+      color: white;
+    }
+    .content {
+      padding: 20px;
+      background-color: #f9f9f9;
+    }
+    .footer {
+      padding: 20px;
+      text-align: center;
+      font-size: 12px;
+      color: #888;
+    }
+    .button {
+      display: inline-block;
+      background-color: #2C8E99;
+      color: white;
+      text-decoration: none;
+      padding: 12px 24px;
+      border-radius: 4px;
+      margin: 20px 0;
+      font-weight: bold;
+    }
+    .token {
+      font-size: 28px;
+      font-weight: bold;
+      color: #2C8E99;
+      padding: 15px 25px;
+      background-color: #e0f4f6;
+      border-radius: 8px;
+      display: inline-block;
+      letter-spacing: 4px;
+      margin: 15px 0;
+      font-family: monospace;
+    }
+    .info-box {
+      background-color: #fff;
+      border-left: 4px solid #2C8E99;
+      padding: 15px;
+      margin: 20px 0;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="header">
+      <h1>Welcome to MetaEstetics</h1>
+    </div>
+    <div class="content">
+      <p>Hello {{patientName}},</p>
+      
+      <p>A patient profile has been created for you at <strong>{{clinicName}}</strong>. You can now claim this profile to access your personal health dashboard and appointment history.</p>
+      
+      <div class="info-box">
+        <p><strong>What you'll get access to:</strong></p>
+        <ul>
+          <li>Your complete treatment history</li>
+          <li>Upcoming appointment details</li>
+          <li>Pre and post-treatment instructions</li>
+          <li>Direct messaging with your clinic</li>
+        </ul>
+      </div>
+      
+      <p>To claim your profile, use this registration token:</p>
+      
+      <div style="text-align: center;">
+        <span class="token">{{inviteToken}}</span>
+      </div>
+      
+      <p><strong>Important:</strong> This token will expire on <strong>{{expirationDate}}</strong>.</p>
+      
+      <p>To create your account:</p>
+      <ol>
+        <li>Download the MetaEstetics Patient app or visit {{registrationUrl}}</li>
+        <li>Create an account using your email address</li>
+        <li>When prompted, enter the token shown above</li>
+        <li>Your profile will be automatically linked to your new account</li>
+      </ol>
+      
+      <div style="text-align: center;">
+        <a href="{{registrationUrl}}" class="button">Create Your Account</a>
+      </div>
+      
+      <p>If you have any questions or didn't expect this email, please contact {{contactName}} at {{contactEmail}}.</p>
+    </div>
+    <div class="footer">
+      <p>This is an automated message from {{clinicName}}. Please do not reply to this email.</p>
+      <p>&copy; {{currentYear}} MetaEstetics. All rights reserved.</p>
+    </div>
+  </div>
+</body>
+</html>
+`;
+
+// src/admin/mailing/patientInvite/patientInvite.mailing.ts
+var PatientInviteMailingService = class extends BaseMailingService {
+  /**
+   * Constructor for PatientInviteMailingService
+   * @param firestore - Firestore instance provided by the caller
+   * @param mailgunClient - Mailgun client instance (mailgun.js v10+) provided by the caller
+   */
+  constructor(firestore19, mailgunClient) {
+    super(firestore19, mailgunClient);
+    this.DEFAULT_REGISTRATION_URL = "https://metaesthetics.net/patient/register";
+    this.DEFAULT_SUBJECT = "Claim Your Patient Profile - MetaEstetics";
+    this.DEFAULT_MAILGUN_DOMAIN = "mg.metaesthetics.net";
+  }
+  /**
+   * Sends a patient invitation email
+   * @param data - The patient invitation data
+   * @returns Promise resolved when email is sent
+   */
+  async sendInvitationEmail(data) {
+    var _a, _b, _c, _d, _e, _f;
+    try {
+      Logger.info(
+        "[PatientInviteMailingService] Sending invitation email to",
+        data.token.email
+      );
+      const expirationDate = data.token.expiresAt.toDate().toLocaleDateString("en-US", {
+        weekday: "long",
+        year: "numeric",
+        month: "long",
+        day: "numeric"
+      });
+      const registrationUrl = ((_a = data.options) == null ? void 0 : _a.registrationUrl) || this.DEFAULT_REGISTRATION_URL;
+      const contactName = data.clinic.contactName || "Clinic Administrator";
+      const contactEmail = data.clinic.contactEmail;
+      const subject = ((_b = data.options) == null ? void 0 : _b.customSubject) || this.DEFAULT_SUBJECT;
+      const fromAddress = ((_c = data.options) == null ? void 0 : _c.fromAddress) || `MetaEstetics <no-reply@${((_d = data.options) == null ? void 0 : _d.mailgunDomain) || this.DEFAULT_MAILGUN_DOMAIN}>`;
+      const currentYear = (/* @__PURE__ */ new Date()).getFullYear().toString();
+      const patientName = `${data.patient.firstName} ${data.patient.lastName}`;
+      const templateVariables = {
+        clinicName: data.clinic.name,
+        patientName,
+        inviteToken: data.token.token,
+        expirationDate,
+        registrationUrl,
+        contactName,
+        contactEmail,
+        currentYear
+      };
+      Logger.info("[PatientInviteMailingService] Template variables:", {
+        clinicName: templateVariables.clinicName,
+        patientName: templateVariables.patientName,
+        expirationDate: templateVariables.expirationDate,
+        registrationUrl: templateVariables.registrationUrl,
+        contactName: templateVariables.contactName,
+        contactEmail: templateVariables.contactEmail,
+        hasInviteToken: !!templateVariables.inviteToken
+      });
+      const html = this.renderTemplate(
+        patientInvitationTemplate,
+        templateVariables
+      );
+      const mailgunSendData = {
+        to: data.token.email,
+        from: fromAddress,
+        subject,
+        html
+      };
+      const domainToSendFrom = ((_e = data.options) == null ? void 0 : _e.mailgunDomain) || this.DEFAULT_MAILGUN_DOMAIN;
+      Logger.info("[PatientInviteMailingService] Sending email with data:", {
+        domain: domainToSendFrom,
+        to: mailgunSendData.to,
+        from: mailgunSendData.from,
+        subject: mailgunSendData.subject,
+        hasHtml: !!mailgunSendData.html
+      });
+      const result = await this.sendEmail(domainToSendFrom, mailgunSendData);
+      await this.logEmailAttempt(
+        {
+          to: data.token.email,
+          subject,
+          templateName: "patient_invitation"
+        },
+        true
+      );
+      return result;
+    } catch (error) {
+      Logger.error(
+        "[PatientInviteMailingService] Error sending invitation email:",
+        {
+          errorMessage: error.message,
+          errorDetails: error.details,
+          errorStatus: error.status,
+          stack: error.stack
+        }
+      );
+      await this.logEmailAttempt(
+        {
+          to: data.token.email,
+          subject: ((_f = data.options) == null ? void 0 : _f.customSubject) || this.DEFAULT_SUBJECT,
+          templateName: "patient_invitation"
+        },
+        false,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Handles the patient token creation event from Cloud Functions.
+   * Fetches necessary data and sends the invitation email.
+   * @param tokenData - The fully typed token object including its id
+   * @param mailgunConfig - Mailgun configuration (from, domain, optional registrationUrl)
+   * @returns Promise resolved when the email is sent
+   */
+  async handleTokenCreationEvent(tokenData, mailgunConfig) {
+    try {
+      Logger.info(
+        "[PatientInviteMailingService] Handling token creation event for token:",
+        tokenData.id
+      );
+      if (!tokenData || !tokenData.id || !tokenData.token || !tokenData.email) {
+        throw new Error(
+          `Invalid token data: Missing required properties. Token ID: ${tokenData == null ? void 0 : tokenData.id}`
+        );
+      }
+      if (!tokenData.patientId) {
+        throw new Error(
+          `Token ${tokenData.id} is missing patientId reference`
+        );
+      }
+      if (!tokenData.clinicId) {
+        throw new Error(`Token ${tokenData.id} is missing clinicId reference`);
+      }
+      if (!tokenData.expiresAt) {
+        throw new Error(`Token ${tokenData.id} is missing expiration date`);
+      }
+      if (tokenData.status !== "active" /* ACTIVE */ && String(tokenData.status).toLowerCase() !== "active") {
+        Logger.warn(
+          "[PatientInviteMailingService] Token is not active, skipping email.",
+          { tokenId: tokenData.id, status: tokenData.status }
+        );
+        return;
+      }
+      Logger.info(
+        `[PatientInviteMailingService] Token status validation:`,
+        {
+          tokenId: tokenData.id,
+          status: tokenData.status,
+          statusType: typeof tokenData.status
+        }
+      );
+      Logger.info(
+        `[PatientInviteMailingService] Fetching patient data: ${tokenData.patientId}`
+      );
+      const patientRef = this.db.collection(PATIENTS_COLLECTION).doc(tokenData.patientId);
+      const patientDoc = await patientRef.get();
+      if (!patientDoc.exists) {
+        throw new Error(`Patient ${tokenData.patientId} not found`);
+      }
+      const patientData = patientDoc.data();
+      if (!patientData) {
+        throw new Error(
+          `Patient ${tokenData.patientId} has invalid data structure`
+        );
+      }
+      const sensitiveInfoRef = patientRef.collection(PATIENT_SENSITIVE_INFO_COLLECTION).doc(tokenData.patientId);
+      const sensitiveInfoDoc = await sensitiveInfoRef.get();
+      let firstName = "Patient";
+      let lastName = "";
+      if (sensitiveInfoDoc.exists) {
+        const sensitiveInfo = sensitiveInfoDoc.data();
+        firstName = (sensitiveInfo == null ? void 0 : sensitiveInfo.firstName) || "Patient";
+        lastName = (sensitiveInfo == null ? void 0 : sensitiveInfo.lastName) || "";
+      } else {
+        Logger.warn(
+          `[PatientInviteMailingService] No sensitive info found for patient ${tokenData.patientId}, using displayName`
+        );
+        const displayNameParts = (patientData.displayName || "Patient").split(" ");
+        firstName = displayNameParts[0] || "Patient";
+        lastName = displayNameParts.slice(1).join(" ") || "";
+      }
+      Logger.info(
+        `[PatientInviteMailingService] Patient found: ${firstName} ${lastName}`
+      );
+      Logger.info(
+        `[PatientInviteMailingService] Fetching clinic data: ${tokenData.clinicId}`
+      );
+      const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(tokenData.clinicId);
+      const clinicDoc = await clinicRef.get();
+      if (!clinicDoc.exists) {
+        throw new Error(`Clinic ${tokenData.clinicId} not found`);
+      }
+      const clinicData = clinicDoc.data();
+      if (!clinicData || !clinicData.contactInfo) {
+        throw new Error(
+          `Clinic ${tokenData.clinicId} has invalid data structure`
+        );
+      }
+      Logger.info(
+        `[PatientInviteMailingService] Clinic found: ${clinicData.name}`
+      );
+      if (!mailgunConfig.fromAddress) {
+        Logger.warn(
+          "[PatientInviteMailingService] No fromAddress provided, using default"
+        );
+        mailgunConfig.fromAddress = `MetaEstetics <no-reply@${this.DEFAULT_MAILGUN_DOMAIN}>`;
+      }
+      const emailData = {
+        token: {
+          id: tokenData.id,
+          token: tokenData.token,
+          patientId: tokenData.patientId,
+          email: tokenData.email,
+          clinicId: tokenData.clinicId,
+          expiresAt: tokenData.expiresAt
+        },
+        patient: {
+          firstName,
+          lastName
+        },
+        clinic: {
+          name: clinicData.name || "Medical Clinic",
+          contactEmail: clinicData.contactInfo.email || "contact@clinic.com",
+          contactName: "Clinic Admin"
+        },
+        options: {
+          fromAddress: mailgunConfig.fromAddress,
+          mailgunDomain: mailgunConfig.domain,
+          registrationUrl: mailgunConfig.registrationUrl
+        }
+      };
+      Logger.info(
+        "[PatientInviteMailingService] Email data prepared, sending invitation"
+      );
+      await this.sendInvitationEmail(emailData);
+      Logger.info(
+        "[PatientInviteMailingService] Invitation email sent successfully"
+      );
+    } catch (error) {
+      Logger.error(
+        "[PatientInviteMailingService] Error handling token creation event:",
+        {
+          errorMessage: error.message,
+          errorDetails: error.details,
+          errorStatus: error.status,
+          stack: error.stack,
+          tokenId: tokenData == null ? void 0 : tokenData.id
+        }
+      );
+      throw error;
+    }
+  }
+};
+
 // src/admin/users/user-profile.admin.ts
 import * as admin18 from "firebase-admin";
 var UserProfileAdminService = class {
@@ -13358,6 +13759,7 @@ export {
   DocumentManagerAdminService,
   ExistingPractitionerInviteMailingService,
   FilledFormsAggregationService,
+  INVITE_TOKENS_COLLECTION,
   Logger,
   NOTIFICATIONS_COLLECTION,
   NO_SHOW_ANALYTICS_SUBCOLLECTION,
@@ -13371,8 +13773,10 @@ export {
   PROCEDURE_ANALYTICS_SUBCOLLECTION,
   PatientAggregationService,
   PatientInstructionStatus,
+  PatientInviteMailingService,
   PatientRequirementOverallStatus,
   PatientRequirementsAdminService,
+  PatientTokenStatus,
   PractitionerAggregationService,
   PractitionerInviteAggregationService,
   PractitionerInviteMailingService,

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.32",
   "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/admin/index.ts

@@ -15,6 +15,8 @@ export type { ClinicInfo } from '../types/profile';
 export type { Practitioner, PractitionerToken } from '../types/practitioner';
 export type { PractitionerInvite } from '../types/clinic/practitioner-invite.types';
 export type { DoctorInfo } from '../types/clinic';
+export type { PatientToken } from '../types/patient/token.types';
+export { PatientTokenStatus, INVITE_TOKENS_COLLECTION } from '../types/patient/token.types';
 export type { Procedure, ProcedureSummaryInfo } from '../types/procedure';
 export type { PatientProfile as Patient } from '../types/patient';
 export type { Appointment } from '../types/appointment';