@blackcode_sa/metaestetics-api 1.5.25 → 1.5.28

package/dist/index.mjs

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/config/firebase.ts
 import { initializeApp } from "firebase/app";
 import { getFirestore } from "firebase/firestore";
@@ -5270,6 +5277,143 @@ async function getActiveClinicsByAdmin(db, adminId, clinicAdminService, clinicGr
     clinicGroupService
   );
 }
+async function getClinicById(db, clinicId) {
+  try {
+    const clinicRef = doc9(db, CLINICS_COLLECTION, clinicId);
+    const clinicSnapshot = await getDoc12(clinicRef);
+    if (!clinicSnapshot.exists()) {
+      return null;
+    }
+    const clinicData = clinicSnapshot.data();
+    return {
+      ...clinicData,
+      id: clinicSnapshot.id
+    };
+  } catch (error) {
+    console.error("[CLINIC_UTILS] Error getting clinic by ID:", error);
+    throw error;
+  }
+}
+async function getAllClinics(db, pagination, lastDoc) {
+  try {
+    const clinicsCollection = collection7(db, CLINICS_COLLECTION);
+    let clinicsQuery = query7(clinicsCollection);
+    if (pagination && pagination > 0) {
+      const { limit: limit4, startAfter: startAfter4 } = __require("firebase/firestore");
+      if (lastDoc) {
+        clinicsQuery = query7(
+          clinicsCollection,
+          startAfter4(lastDoc),
+          limit4(pagination)
+        );
+      } else {
+        clinicsQuery = query7(clinicsCollection, limit4(pagination));
+      }
+    }
+    const clinicsSnapshot = await getDocs7(clinicsQuery);
+    const lastVisible = clinicsSnapshot.docs[clinicsSnapshot.docs.length - 1];
+    const clinics = clinicsSnapshot.docs.map((doc28) => {
+      const data = doc28.data();
+      return {
+        ...data,
+        id: doc28.id
+      };
+    });
+    return {
+      clinics,
+      lastDoc: lastVisible
+    };
+  } catch (error) {
+    console.error("[CLINIC_UTILS] Error getting all clinics:", error);
+    throw error;
+  }
+}
+async function getAllClinicsInRange(db, center, rangeInKm, pagination, lastDoc, filters) {
+  try {
+    const { distanceBetween: distanceBetween2 } = __require("geofire-common");
+    const centerLat = center.latitude;
+    const centerLng = center.longitude;
+    const clinicsCollection = collection7(db, CLINICS_COLLECTION);
+    let clinicsQuery = query7(clinicsCollection);
+    if ((filters == null ? void 0 : filters.isActive) !== void 0) {
+      clinicsQuery = query7(
+        clinicsCollection,
+        where7("isActive", "==", filters.isActive)
+      );
+    }
+    const querySnapshot = await getDocs7(clinicsQuery);
+    console.log(
+      `[CLINIC_UTILS] Found ${querySnapshot.docs.length} total clinics to filter by distance`
+    );
+    const filteredDocs = [];
+    for (const doc28 of querySnapshot.docs) {
+      const clinic = doc28.data();
+      if (!clinic.location || !clinic.location.latitude || !clinic.location.longitude) {
+        continue;
+      }
+      const distanceInM = distanceBetween2(
+        [centerLat, centerLng],
+        [clinic.location.latitude, clinic.location.longitude]
+      );
+      const distanceInKm = distanceInM / 1e3;
+      if (distanceInKm <= rangeInKm) {
+        if ((filters == null ? void 0 : filters.tags) && filters.tags.length > 0) {
+          const hasAllTags = filters.tags.every(
+            (filterTag) => clinic.tags.some(
+              (clinicTag) => filterTag.id === clinicTag.id || filterTag.name === clinicTag.name
+            )
+          );
+          if (hasAllTags) {
+            filteredDocs.push({
+              doc: doc28,
+              distance: distanceInKm
+            });
+          }
+        } else {
+          filteredDocs.push({
+            doc: doc28,
+            distance: distanceInKm
+          });
+        }
+      }
+    }
+    console.log(
+      `[CLINIC_UTILS] Filtered to ${filteredDocs.length} clinics within ${rangeInKm}km`
+    );
+    filteredDocs.sort((a, b) => a.distance - b.distance);
+    let paginatedDocs = filteredDocs;
+    let lastVisible = null;
+    if (pagination && pagination > 0) {
+      let startIndex = 0;
+      if (lastDoc) {
+        const lastDocIndex = filteredDocs.findIndex(
+          (item) => item.doc.id === lastDoc.id
+        );
+        if (lastDocIndex !== -1) {
+          startIndex = lastDocIndex + 1;
+        }
+      }
+      paginatedDocs = filteredDocs.slice(startIndex, startIndex + pagination);
+      lastVisible = paginatedDocs.length > 0 ? paginatedDocs[paginatedDocs.length - 1].doc : null;
+    }
+    const clinics = paginatedDocs.map((item) => {
+      const data = item.doc.data();
+      return {
+        ...data,
+        id: item.doc.id,
+        distance: item.distance
+        // Include distance in response
+      };
+    });
+    return {
+      clinics,
+      lastDoc: lastVisible
+    };
+  } catch (error) {
+    console.error("[CLINIC_UTILS] Error getting clinics in range:", error);
+    throw error;
+  }
+}
 
 // src/services/clinic/utils/review.utils.ts
 import {
@@ -5614,6 +5758,45 @@ var ClinicService = class extends BaseService {
     });
     return clinic;
   }
+  /**
+   * Retrieves a clinic by its ID
+   *
+   * @param clinicId - ID of the clinic to retrieve
+   * @returns The clinic if found, null otherwise
+   */
+  async getClinicById(clinicId) {
+    return getClinicById(this.db, clinicId);
+  }
+  /**
+   * Retrieves all clinics with optional pagination
+   *
+   * @param pagination - Optional number of clinics per page (0 or undefined returns all)
+   * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
+   * @returns Array of clinics and the last document for pagination
+   */
+  async getAllClinics(pagination, lastDoc) {
+    return getAllClinics(this.db, pagination, lastDoc);
+  }
+  /**
+   * Retrieves all clinics within a specified range from a location with optional pagination
+   *
+   * @param center - The center location coordinates {latitude, longitude}
+   * @param rangeInKm - The range in kilometers to search within
+   * @param pagination - Optional number of clinics per page (0 or undefined returns all)
+   * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
+   * @param filters - Optional filters to apply to the search (isActive, tags, etc.)
+   * @returns Array of clinics with distance information and the last document for pagination
+   */
+  async getAllClinicsInRange(center, rangeInKm, pagination, lastDoc, filters) {
+    return getAllClinicsInRange(
+      this.db,
+      center,
+      rangeInKm,
+      pagination,
+      lastDoc,
+      filters
+    );
+  }
 };
 
 // src/services/auth.service.ts
@@ -6480,7 +6663,8 @@ import {
   where as where11,
   updateDoc as updateDoc14,
   setDoc as setDoc13,
-  serverTimestamp as serverTimestamp13
+  serverTimestamp as serverTimestamp13,
+  writeBatch as writeBatch4
 } from "firebase/firestore";
 
 // src/types/procedure/index.ts
@@ -6536,6 +6720,10 @@ var procedureSchema = createProcedureSchema.extend({
   // We'll validate certification requirement separately
   documentationTemplates: z16.array(z16.any()),
   // We'll validate documentation templates separately
+  clinicInfo: clinicInfoSchema,
+  // Clinic info validation
+  doctorInfo: doctorInfoSchema,
+  // Doctor info validation
   isActive: z16.boolean(),
   createdAt: z16.date(),
   updatedAt: z16.date()
@@ -6556,6 +6744,7 @@ var ProcedureService = class extends BaseService {
    * @returns The created procedure
    */
   async createProcedure(data) {
+    var _a;
     const validatedData = createProcedureSchema.parse(data);
     const [category, subcategory, technology, product] = await Promise.all([
       this.categoryService.getById(validatedData.categoryId),
@@ -6572,6 +6761,51 @@ var ProcedureService = class extends BaseService {
     if (!category || !subcategory || !technology || !product) {
       throw new Error("One or more required entities not found");
     }
+    const clinicRef = doc13(
+      this.db,
+      CLINICS_COLLECTION,
+      validatedData.clinicBranchId
+    );
+    const clinicSnapshot = await getDoc16(clinicRef);
+    if (!clinicSnapshot.exists()) {
+      throw new Error(
+        `Clinic with ID ${validatedData.clinicBranchId} not found`
+      );
+    }
+    const clinic = clinicSnapshot.data();
+    const clinicInfo = {
+      id: clinicSnapshot.id,
+      name: clinic.name,
+      description: clinic.description || "",
+      featuredPhoto: clinic.featuredPhotos && clinic.featuredPhotos.length > 0 ? clinic.featuredPhotos[0] : clinic.coverPhoto || "",
+      location: clinic.location,
+      contactInfo: clinic.contactInfo
+    };
+    const practitionerRef = doc13(
+      this.db,
+      PRACTITIONERS_COLLECTION,
+      validatedData.practitionerId
+    );
+    const practitionerSnapshot = await getDoc16(practitionerRef);
+    if (!practitionerSnapshot.exists()) {
+      throw new Error(
+        `Practitioner with ID ${validatedData.practitionerId} not found`
+      );
+    }
+    const practitioner = practitionerSnapshot.data();
+    let doctorInfo = (_a = clinic.doctorsInfo) == null ? void 0 : _a.find(
+      (doctor) => doctor.id === validatedData.practitionerId
+    );
+    if (!doctorInfo) {
+      doctorInfo = {
+        id: practitionerSnapshot.id,
+        name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+        description: practitioner.basicInfo.bio || "",
+        photo: practitioner.basicInfo.profileImageUrl || "",
+        rating: 0,
+        services: []
+      };
+    }
     const procedure = {
       ...validatedData,
       category,
@@ -6584,6 +6818,8 @@ var ProcedureService = class extends BaseService {
       postRequirements: technology.requirements.post,
       certificationRequirement: technology.certificationRequirement,
       documentationTemplates: technology.documentationTemplates || [],
+      clinicInfo,
+      doctorInfo,
       isActive: true,
       createdAt: /* @__PURE__ */ new Date(),
       updatedAt: /* @__PURE__ */ new Date()
@@ -6703,6 +6939,237 @@ var ProcedureService = class extends BaseService {
       subcategories
     };
   }
+  /**
+   * Gets all procedures with optional pagination
+   *
+   * @param pagination - Optional number of procedures per page (0 or undefined returns all)
+   * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
+   * @returns Object containing procedures array and the last document for pagination
+   */
+  async getAllProcedures(pagination, lastDoc) {
+    try {
+      const proceduresCollection = collection12(this.db, PROCEDURES_COLLECTION);
+      let proceduresQuery = query11(proceduresCollection);
+      if (pagination && pagination > 0) {
+        const { limit: limit4, startAfter: startAfter4 } = __require("firebase/firestore");
+        if (lastDoc) {
+          proceduresQuery = query11(
+            proceduresCollection,
+            startAfter4(lastDoc),
+            limit4(pagination)
+          );
+        } else {
+          proceduresQuery = query11(proceduresCollection, limit4(pagination));
+        }
+      }
+      const proceduresSnapshot = await getDocs11(proceduresQuery);
+      const lastVisible = proceduresSnapshot.docs[proceduresSnapshot.docs.length - 1];
+      const procedures = proceduresSnapshot.docs.map((doc28) => {
+        const data = doc28.data();
+        if (!data.clinicInfo || !data.doctorInfo) {
+          console.warn(
+            `Procedure ${data.id} is missing clinicInfo or doctorInfo fields. These should be updated.`
+          );
+        }
+        return {
+          ...data,
+          id: doc28.id
+        };
+      });
+      return {
+        procedures,
+        lastDoc: lastVisible
+      };
+    } catch (error) {
+      console.error("[PROCEDURE_SERVICE] Error getting all procedures:", error);
+      throw error;
+    }
+  }
+  /**
+   * Updates the clinicInfo and doctorInfo fields in procedures when the source data changes
+   *
+   * @param entityType - The type of entity that changed ("clinic" or "doctor")
+   * @param entityId - The ID of the entity that changed
+   * @param updatedData - The updated data for the entity
+   * @returns Number of procedures updated
+   */
+  async updateProcedureAggregateData(entityType, entityId, updatedData) {
+    let proceduresQuery;
+    const updatedField = entityType === "clinic" ? "clinicInfo" : "doctorInfo";
+    if (entityType === "clinic") {
+      proceduresQuery = query11(
+        collection12(this.db, PROCEDURES_COLLECTION),
+        where11("clinicBranchId", "==", entityId)
+      );
+    } else {
+      proceduresQuery = query11(
+        collection12(this.db, PROCEDURES_COLLECTION),
+        where11("practitionerId", "==", entityId)
+      );
+    }
+    const snapshot = await getDocs11(proceduresQuery);
+    if (snapshot.empty) {
+      return 0;
+    }
+    let updatedFieldData;
+    if (entityType === "clinic") {
+      updatedFieldData = {
+        id: entityId,
+        name: updatedData.name,
+        description: updatedData.description || "",
+        featuredPhoto: updatedData.featuredPhotos && updatedData.featuredPhotos.length > 0 ? updatedData.featuredPhotos[0] : updatedData.coverPhoto || "",
+        location: updatedData.location,
+        contactInfo: updatedData.contactInfo
+      };
+    } else {
+      if (updatedData.basicInfo) {
+        updatedFieldData = {
+          id: entityId,
+          name: `${updatedData.basicInfo.firstName} ${updatedData.basicInfo.lastName}`,
+          description: updatedData.basicInfo.bio || "",
+          photo: updatedData.basicInfo.profileImageUrl || "",
+          rating: 0,
+          // This would need to be calculated or passed in
+          services: []
+          // This would need to be determined or passed in
+        };
+      } else {
+        updatedFieldData = {
+          id: entityId,
+          name: updatedData.name,
+          description: updatedData.description || "",
+          photo: updatedData.photo || "",
+          rating: updatedData.rating || 0,
+          services: updatedData.services || []
+        };
+      }
+    }
+    const batch = writeBatch4(this.db);
+    snapshot.docs.forEach((doc28) => {
+      batch.update(doc28.ref, {
+        [updatedField]: updatedFieldData,
+        updatedAt: serverTimestamp13()
+      });
+    });
+    await batch.commit();
+    return snapshot.size;
+  }
+  /**
+   * Updates the clinicInfo for all procedures associated with a specific clinic
+   *
+   * @param clinicId - The ID of the clinic that was updated
+   * @param clinicData - The updated clinic data
+   * @returns Number of procedures updated
+   */
+  async updateClinicInfoInProcedures(clinicId, clinicData) {
+    return this.updateProcedureAggregateData("clinic", clinicId, clinicData);
+  }
+  /**
+   * Updates the doctorInfo for all procedures associated with a specific practitioner
+   *
+   * @param practitionerId - The ID of the practitioner that was updated
+   * @param practitionerData - The updated practitioner data
+   * @returns Number of procedures updated
+   */
+  async updateDoctorInfoInProcedures(practitionerId, practitionerData) {
+    return this.updateProcedureAggregateData(
+      "doctor",
+      practitionerId,
+      practitionerData
+    );
+  }
+  /**
+   * Updates all existing procedures to include clinicInfo and doctorInfo
+   * This is a migration helper method that can be used to update existing procedures
+   *
+   * @returns Number of procedures updated
+   */
+  async migrateAllProceduresWithAggregateData() {
+    var _a;
+    const proceduresQuery = query11(collection12(this.db, PROCEDURES_COLLECTION));
+    const proceduresSnapshot = await getDocs11(proceduresQuery);
+    if (proceduresSnapshot.empty) {
+      return 0;
+    }
+    let updatedCount = 0;
+    const batch = writeBatch4(this.db);
+    const batchLimit = 500;
+    let batchCount = 0;
+    for (const procedureDoc of proceduresSnapshot.docs) {
+      const procedure = procedureDoc.data();
+      if (procedure.clinicInfo && procedure.doctorInfo) {
+        continue;
+      }
+      try {
+        const clinicRef = doc13(
+          this.db,
+          CLINICS_COLLECTION,
+          procedure.clinicBranchId
+        );
+        const clinicSnapshot = await getDoc16(clinicRef);
+        if (!clinicSnapshot.exists()) {
+          console.warn(
+            `Clinic ${procedure.clinicBranchId} not found for procedure ${procedure.id}`
+          );
+          continue;
+        }
+        const clinic = clinicSnapshot.data();
+        const clinicInfo = {
+          id: clinicSnapshot.id,
+          name: clinic.name,
+          description: clinic.description || "",
+          featuredPhoto: clinic.featuredPhotos && clinic.featuredPhotos.length > 0 ? clinic.featuredPhotos[0] : clinic.coverPhoto || "",
+          location: clinic.location,
+          contactInfo: clinic.contactInfo
+        };
+        const practitionerRef = doc13(
+          this.db,
+          PRACTITIONERS_COLLECTION,
+          procedure.practitionerId
+        );
+        const practitionerSnapshot = await getDoc16(practitionerRef);
+        if (!practitionerSnapshot.exists()) {
+          console.warn(
+            `Practitioner ${procedure.practitionerId} not found for procedure ${procedure.id}`
+          );
+          continue;
+        }
+        const practitioner = practitionerSnapshot.data();
+        let doctorInfo = (_a = clinic.doctorsInfo) == null ? void 0 : _a.find(
+          (doctor) => doctor.id === procedure.practitionerId
+        );
+        if (!doctorInfo) {
+          doctorInfo = {
+            id: practitionerSnapshot.id,
+            name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+            description: practitioner.basicInfo.bio || "",
+            photo: practitioner.basicInfo.profileImageUrl || "",
+            rating: 0,
+            services: []
+          };
+        }
+        batch.update(procedureDoc.ref, {
+          clinicInfo,
+          doctorInfo,
+          updatedAt: serverTimestamp13()
+        });
+        batchCount++;
+        updatedCount++;
+        if (batchCount >= batchLimit) {
+          await batch.commit();
+          console.log(`Committed batch of ${batchCount} procedure updates`);
+          batchCount = 0;
+        }
+      } catch (error) {
+        console.error(`Error updating procedure ${procedure.id}:`, error);
+      }
+    }
+    if (batchCount > 0) {
+      await batch.commit();
+      console.log(`Committed final batch of ${batchCount} procedure updates`);
+    }
+    return updatedCount;
+  }
 };
 
 // src/services/documentation-templates/documentation-template.service.ts
@@ -9566,6 +10033,8 @@ var CalendarServiceV2 = class extends BaseService {
     const updateParams = {
       appointmentId,
       clinicId,
+      eventTime: appointment.eventTime,
+      description: appointment.description || "",
       doctorId: appointment.practitionerProfileId || "",
       patientId: appointment.patientProfileId || "",
       status

package/package.json

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

package/src/services/calendar/calendar-refactored.service.ts

@@ -1106,6 +1106,8 @@ export class CalendarServiceV2 extends BaseService {
     const updateParams: UpdateAppointmentParams = {
       appointmentId,
       clinicId,
+      eventTime: appointment.eventTime,
+      description: appointment.description || "",
       doctorId: appointment.practitionerProfileId || "",
       patientId: appointment.patientProfileId || "",
       status,

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

@@ -301,4 +301,58 @@ export class ClinicService extends BaseService {
     // Note: The createClinic method already adds the clinic to the admin's managed clinics
     return clinic;
   }
+
+  /**
+   * Retrieves a clinic by its ID
+   *
+   * @param clinicId - ID of the clinic to retrieve
+   * @returns The clinic if found, null otherwise
+   */
+  async getClinicById(clinicId: string): Promise<Clinic | null> {
+    return ClinicUtils.getClinicById(this.db, clinicId);
+  }
+
+  /**
+   * Retrieves all clinics with optional pagination
+   *
+   * @param pagination - Optional number of clinics per page (0 or undefined returns all)
+   * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
+   * @returns Array of clinics and the last document for pagination
+   */
+  async getAllClinics(
+    pagination?: number,
+    lastDoc?: any
+  ): Promise<{ clinics: Clinic[]; lastDoc: any }> {
+    return ClinicUtils.getAllClinics(this.db, pagination, lastDoc);
+  }
+
+  /**
+   * Retrieves all clinics within a specified range from a location with optional pagination
+   *
+   * @param center - The center location coordinates {latitude, longitude}
+   * @param rangeInKm - The range in kilometers to search within
+   * @param pagination - Optional number of clinics per page (0 or undefined returns all)
+   * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
+   * @param filters - Optional filters to apply to the search (isActive, tags, etc.)
+   * @returns Array of clinics with distance information and the last document for pagination
+   */
+  async getAllClinicsInRange(
+    center: { latitude: number; longitude: number },
+    rangeInKm: number,
+    pagination?: number,
+    lastDoc?: any,
+    filters?: {
+      isActive?: boolean;
+      tags?: ClinicTag[];
+    }
+  ): Promise<{ clinics: (Clinic & { distance: number })[]; lastDoc: any }> {
+    return ClinicUtils.getAllClinicsInRange(
+      this.db,
+      center,
+      rangeInKm,
+      pagination,
+      lastDoc,
+      filters
+    );
+  }
 }