@blackcode_sa/metaestetics-api 1.12.59 → 1.12.62

package/dist/index.mjs

@@ -4669,6 +4669,7 @@ var reviewSchema = z8.object({
   clinicReview: clinicReviewSchema.optional(),
   practitionerReview: practitionerReviewSchema.optional(),
   procedureReview: procedureReviewSchema.optional(),
+  extendedProcedureReviews: z8.array(procedureReviewSchema).optional(),
   overallComment: z8.string().min(1).max(2e3),
   overallRating: z8.number().min(1).max(5)
 });
@@ -4677,13 +4678,14 @@ var createReviewSchema = z8.object({
   clinicReview: createClinicReviewSchema.optional(),
   practitionerReview: createPractitionerReviewSchema.optional(),
   procedureReview: createProcedureReviewSchema.optional(),
+  extendedProcedureReviews: z8.array(createProcedureReviewSchema).optional(),
   overallComment: z8.string().min(1).max(2e3)
 }).refine(
   (data) => {
-    return data.clinicReview || data.practitionerReview || data.procedureReview;
+    return data.clinicReview || data.practitionerReview || data.procedureReview || data.extendedProcedureReviews && data.extendedProcedureReviews.length > 0;
   },
   {
-    message: "At least one review type (clinic, practitioner, or procedure) must be provided",
+    message: "At least one review type (clinic, practitioner, procedure, or extended procedure) must be provided",
     path: ["reviewType"]
   }
 );
@@ -17916,16 +17918,17 @@ var ReviewService = class extends BaseService {
    * @returns The created review
    */
   async createReview(data, appointmentId) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     try {
       console.log("\u{1F50D} ReviewService.createReview - Input data:", {
         appointmentId,
         hasClinicReview: !!data.clinicReview,
         hasPractitionerReview: !!data.practitionerReview,
         hasProcedureReview: !!data.procedureReview,
-        practitionerId: (_a = data.practitionerReview) == null ? void 0 : _a.practitionerId,
-        clinicId: (_b = data.clinicReview) == null ? void 0 : _b.clinicId,
-        procedureId: (_c = data.procedureReview) == null ? void 0 : _c.procedureId
+        extendedProcedureReviewsCount: ((_a = data.extendedProcedureReviews) == null ? void 0 : _a.length) || 0,
+        practitionerId: (_b = data.practitionerReview) == null ? void 0 : _b.practitionerId,
+        clinicId: (_c = data.clinicReview) == null ? void 0 : _c.clinicId,
+        procedureId: (_d = data.procedureReview) == null ? void 0 : _d.procedureId
       });
       const validatedData = createReviewSchema.parse(data);
       const ratings = [];
@@ -17965,6 +17968,20 @@ var ReviewService = class extends BaseService {
         data.procedureReview.overallRating = procedureAverage;
         ratings.push(procedureAverage);
       }
+      if (data.extendedProcedureReviews && data.extendedProcedureReviews.length > 0) {
+        data.extendedProcedureReviews.forEach((extendedReview) => {
+          const extendedRatings = [
+            extendedReview.effectivenessOfTreatment,
+            extendedReview.outcomeExplanation,
+            extendedReview.painManagement,
+            extendedReview.followUpCare,
+            extendedReview.valueForMoney
+          ];
+          const extendedAverage = this.calculateAverage(extendedRatings);
+          extendedReview.overallRating = extendedAverage;
+          ratings.push(extendedAverage);
+        });
+      }
       const overallRating = this.calculateAverage(ratings);
       const reviewId = this.generateId();
       if (data.clinicReview) {
@@ -17980,6 +17997,14 @@ var ReviewService = class extends BaseService {
         data.procedureReview.fullReviewId = reviewId;
       }
       const now = /* @__PURE__ */ new Date();
+      if (data.extendedProcedureReviews && data.extendedProcedureReviews.length > 0) {
+        data.extendedProcedureReviews.forEach((extendedReview) => {
+          extendedReview.id = this.generateId();
+          extendedReview.fullReviewId = reviewId;
+          extendedReview.createdAt = now;
+          extendedReview.updatedAt = now;
+        });
+      }
       const review = {
         id: reviewId,
         appointmentId,
@@ -17987,6 +18012,7 @@ var ReviewService = class extends BaseService {
         clinicReview: data.clinicReview,
         practitionerReview: data.practitionerReview,
         procedureReview: data.procedureReview,
+        extendedProcedureReviews: data.extendedProcedureReviews,
         overallComment: data.overallComment,
         overallRating,
         createdAt: now,
@@ -18001,9 +18027,10 @@ var ReviewService = class extends BaseService {
       });
       console.log("\u2705 ReviewService.createReview - Review saved to Firestore:", {
         reviewId,
-        practitionerId: (_d = review.practitionerReview) == null ? void 0 : _d.practitionerId,
-        clinicId: (_e = review.clinicReview) == null ? void 0 : _e.clinicId,
-        procedureId: (_f = review.procedureReview) == null ? void 0 : _f.procedureId
+        practitionerId: (_e = review.practitionerReview) == null ? void 0 : _e.practitionerId,
+        clinicId: (_f = review.clinicReview) == null ? void 0 : _f.clinicId,
+        procedureId: (_g = review.procedureReview) == null ? void 0 : _g.procedureId,
+        extendedProcedureReviewsCount: ((_h = review.extendedProcedureReviews) == null ? void 0 : _h.length) || 0
       });
       return review;
     } catch (error) {
@@ -18019,7 +18046,7 @@ var ReviewService = class extends BaseService {
    * @returns The review with entity names if found, null otherwise
    */
   async getReview(reviewId) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     console.log("\u{1F50D} ReviewService.getReview - Getting review:", reviewId);
     const docRef = doc37(this.db, REVIEWS_COLLECTION, reviewId);
     const docSnap = await getDoc38(docRef);
@@ -18053,12 +18080,27 @@ var ReviewService = class extends BaseService {
             procedureName: appointment.procedureInfo.name
           };
         }
+        if (enhancedReview.extendedProcedureReviews && enhancedReview.extendedProcedureReviews.length > 0) {
+          const extendedProcedures = ((_a = appointment.metadata) == null ? void 0 : _a.extendedProcedures) || [];
+          enhancedReview.extendedProcedureReviews = enhancedReview.extendedProcedureReviews.map((extendedReview) => {
+            const procedureInfo = extendedProcedures.find(
+              (ep) => ep.procedureId === extendedReview.procedureId
+            );
+            if (procedureInfo) {
+              return {
+                ...extendedReview,
+                procedureName: procedureInfo.procedureName
+              };
+            }
+            return extendedReview;
+          });
+        }
         if (appointment.patientInfo) {
           enhancedReview.patientName = appointment.patientInfo.fullName;
         }
         console.log("\u2705 ReviewService.getReview - Enhanced review:", {
           reviewId,
-          hasEntityNames: !!(((_a = enhancedReview.clinicReview) == null ? void 0 : _a.clinicName) || ((_b = enhancedReview.practitionerReview) == null ? void 0 : _b.practitionerName) || ((_c = enhancedReview.procedureReview) == null ? void 0 : _c.procedureName) || enhancedReview.patientName)
+          hasEntityNames: !!(((_b = enhancedReview.clinicReview) == null ? void 0 : _b.clinicName) || ((_c = enhancedReview.practitionerReview) == null ? void 0 : _c.practitionerName) || ((_d = enhancedReview.procedureReview) == null ? void 0 : _d.procedureName) || enhancedReview.patientName || ((_e = enhancedReview.extendedProcedureReviews) == null ? void 0 : _e.some((epr) => epr.procedureName)))
         });
         return enhancedReview;
       }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.12.59",
+  "version": "1.12.62",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -56,16 +56,16 @@
   "author": "Blackcode SA",
   "license": "MIT",
   "scripts": {
-    "clean": "rm -rf dist",
+    "clean": "node -e \"const fs=require('fs');const path=require('path');const dist='dist';if(fs.existsSync(dist))fs.rmSync(dist,{recursive:true,force:true})\"",
     "build:main": "tsup src/index.ts --format cjs,esm --dts --external react-native",
     "build:admin": "tsup src/admin/index.ts --format cjs,esm --dts --out-dir dist/admin --external react-native",
     "build:backoffice": "tsup src/backoffice/index.ts --format cjs,esm --dts --out-dir dist/backoffice",
     "build": "npm run clean && npm run build:main && npm run build:admin && npm run build:backoffice",
     "dev": "tsup src/index.ts --format cjs,esm --dts --watch --external react-native",
     "prepublishOnly": "npm run build",
-    "publish:patch": "bash ./publish.sh patch",
-    "publish:minor": "bash ./publish.sh minor",
-    "publish:major": "bash ./publish.sh major",
+    "publish:patch": "node scripts/publish.js patch",
+    "publish:minor": "node scripts/publish.js minor",
+    "publish:major": "node scripts/publish.js major",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage"

package/src/admin/aggregation/appointment/appointment.aggregation.service.ts

@@ -25,6 +25,8 @@ import {
 } from '../../../types/patient';
 import { Practitioner, PRACTITIONERS_COLLECTION } from '../../../types/practitioner';
 import { Clinic, CLINICS_COLLECTION } from '../../../types/clinic';
+import { Procedure, PROCEDURES_COLLECTION } from '../../../types/procedure';
+import { RequirementSourceProcedure } from '../../../types/patient/patient-requirements';
 // import { UserRole } from "../../../types"; // Not directly used
 
 // Dependent Admin Services
@@ -38,6 +40,14 @@ import { CalendarEventStatus } from '../../../types/calendar';
 
 // Mailgun client will be injected via constructor
 
+/**
+ * Type for requirement with source procedure tracking
+ */
+type RequirementWithSource = {
+  requirement: RequirementTemplate;
+  sourceProcedures: RequirementSourceProcedure[];
+};
+
 /**
  * @class AppointmentAggregationService
  * @description Handles aggregation tasks and side effects related to appointment lifecycle events.
@@ -861,11 +871,141 @@ export class AppointmentAggregationService {
     }
   }
 
+  /**
+   * Fetches post-requirements from a procedure document
+   * @param procedureId - The procedure ID to fetch requirements from
+   * @returns Promise resolving to array of post-requirements with source procedure info
+   */
+  private async fetchPostRequirementsFromProcedure(
+    procedureId: string,
+  ): Promise<RequirementWithSource[]> {
+    try {
+      const procedureDoc = await this.db.collection(PROCEDURES_COLLECTION).doc(procedureId).get();
+      if (!procedureDoc.exists) {
+        Logger.warn(`[AggService] Procedure ${procedureId} not found when fetching requirements`);
+        return [];
+      }
+
+      const procedure = procedureDoc.data() as Procedure;
+      const postRequirements = procedure.postRequirements || [];
+
+      if (postRequirements.length === 0) {
+        return [];
+      }
+
+      return postRequirements.map(req => ({
+        requirement: req,
+        sourceProcedures: [
+          {
+            procedureId: procedure.id,
+            procedureName: procedure.name,
+          },
+        ],
+      }));
+    } catch (error) {
+      Logger.error(
+        `[AggService] Error fetching post-requirements from procedure ${procedureId}:`,
+        error,
+      );
+      return [];
+    }
+  }
+
+  /**
+   * Collects all post-requirements from primary and extended procedures
+   * @param appointment - The appointment to collect requirements for
+   * @returns Promise resolving to array of requirements with source procedures
+   */
+  private async collectAllPostRequirements(
+    appointment: Appointment,
+  ): Promise<RequirementWithSource[]> {
+    const allRequirements: RequirementWithSource[] = [];
+
+    // Fetch from primary procedure
+    if (appointment.procedureId) {
+      const primaryRequirements = await this.fetchPostRequirementsFromProcedure(
+        appointment.procedureId,
+      );
+      allRequirements.push(...primaryRequirements);
+    }
+
+    // Fetch from extended procedures
+    const extendedProcedures = appointment.metadata?.extendedProcedures || [];
+    if (extendedProcedures.length > 0) {
+      Logger.info(
+        `[AggService] Fetching post-requirements from ${extendedProcedures.length} extended procedures`,
+      );
+
+      const extendedRequirementsPromises = extendedProcedures.map(extProc =>
+        this.fetchPostRequirementsFromProcedure(extProc.procedureId),
+      );
+
+      const extendedRequirementsArrays = await Promise.all(extendedRequirementsPromises);
+      extendedRequirementsArrays.forEach(reqs => {
+        allRequirements.push(...reqs);
+      });
+    }
+
+    return allRequirements;
+  }
+
+  /**
+   * Generates a unique key for a requirement based on ID and timeframe
+   * @param requirement - The requirement to generate a key for
+   * @returns Unique key string
+   */
+  private getRequirementKey(requirement: RequirementTemplate): string {
+    const timeframeSig = JSON.stringify({
+      duration: requirement.timeframe?.duration || 0,
+      unit: requirement.timeframe?.unit || '',
+      notifyAt: (requirement.timeframe?.notifyAt || []).slice().sort((a, b) => a - b),
+    });
+    return `${requirement.id}:${timeframeSig}`;
+  }
+
+  /**
+   * Deduplicates requirements based on requirement ID and timeframe
+   * Merges source procedures when requirements match
+   * @param requirements - Array of requirements with sources
+   * @returns Deduplicated array of requirements
+   */
+  private deduplicateRequirements(
+    requirements: RequirementWithSource[],
+  ): RequirementWithSource[] {
+    const requirementMap = new Map<string, RequirementWithSource>();
+
+    for (const reqWithSource of requirements) {
+      const key = this.getRequirementKey(reqWithSource.requirement);
+
+      if (requirementMap.has(key)) {
+        // Merge source procedures
+        const existing = requirementMap.get(key)!;
+        const existingProcedureIds = new Set(
+          existing.sourceProcedures.map(sp => sp.procedureId),
+        );
+
+        // Add new source procedures that don't already exist
+        reqWithSource.sourceProcedures.forEach(sp => {
+          if (!existingProcedureIds.has(sp.procedureId)) {
+            existing.sourceProcedures.push(sp);
+          }
+        });
+      } else {
+        // New requirement, add it
+        requirementMap.set(key, {
+          requirement: reqWithSource.requirement,
+          sourceProcedures: [...reqWithSource.sourceProcedures],
+        });
+      }
+    }
+
+    return Array.from(requirementMap.values());
+  }
+
   /**
    * Creates POST_APPOINTMENT PatientRequirementInstance documents for a given appointment.
-   * Uses the `appointment.postProcedureRequirements` array.
-   * For each active POST requirement template, it constructs a new PatientRequirementInstance document
-   * with derived instructions and batch writes them to Firestore under the patient's `patient_requirements` subcollection.
+   * Fetches requirements from primary and extended procedures, deduplicates them,
+   * and creates requirement instances with source procedure tracking.
    *
    * @param {Appointment} appointment - The appointment for which to create post-requirement instances.
    * @returns {Promise<void>} A promise that resolves when the operation is complete.
@@ -882,39 +1022,49 @@ export class AppointmentAggregationService {
       return;
     }
 
-    if (
-      !appointment.postProcedureRequirements ||
-      appointment.postProcedureRequirements.length === 0
-    ) {
+    try {
+      // Collect all post-requirements from primary and extended procedures
+      const allRequirements = await this.collectAllPostRequirements(appointment);
+
+      if (allRequirements.length === 0) {
+        Logger.info(
+          `[AggService] No post-requirements found from any procedures for appointment ${appointment.id}. Nothing to create.`,
+        );
+        return;
+      }
+
+      // Deduplicate requirements based on ID + timeframe
+      const deduplicatedRequirements = this.deduplicateRequirements(allRequirements);
+
       Logger.info(
-        `[AggService] No postProcedureRequirements found on appointment ${appointment.id}. Nothing to create.`,
+        `[AggService] Found ${allRequirements.length} total post-requirements, ${deduplicatedRequirements.length} after deduplication`,
       );
-      return;
-    }
-
-    try {
-      const batch = this.db.batch();
-      let instancesCreatedCount = 0;
-      // Store created instances for fallback direct creation if needed
-      let createdInstances = [];
 
-      // Log more details about the post-requirements
+      // Log details about the deduplicated requirements
       Logger.info(
-        `[AggService] Found ${
-          appointment.postProcedureRequirements.length
-        } post-requirements to process: ${JSON.stringify(
-          appointment.postProcedureRequirements.map(r => ({
-            id: r.id,
-            name: r.name,
-            type: r.type,
-            isActive: r.isActive,
-            hasTimeframe: !!r.timeframe,
-            notifyAtLength: r.timeframe?.notifyAt?.length || 0,
+        `[AggService] Processing deduplicated post-requirements: ${JSON.stringify(
+          deduplicatedRequirements.map(r => ({
+            id: r.requirement.id,
+            name: r.requirement.name,
+            type: r.requirement.type,
+            isActive: r.requirement.isActive,
+            hasTimeframe: !!r.requirement.timeframe,
+            notifyAtLength: r.requirement.timeframe?.notifyAt?.length || 0,
+            sourceProcedures: r.sourceProcedures.map(sp => ({
+              procedureId: sp.procedureId,
+              procedureName: sp.procedureName,
+            })),
           })),
         )}`,
       );
 
-      for (const template of appointment.postProcedureRequirements) {
+      const batch = this.db.batch();
+      let instancesCreatedCount = 0;
+      // Store created instances for fallback direct creation if needed
+      let createdInstances = [];
+
+      for (const reqWithSource of deduplicatedRequirements) {
+        const template = reqWithSource.requirement;
         if (!template) {
           Logger.warn(
             `[AggService] Found null/undefined template in postProcedureRequirements array`,
@@ -1000,6 +1150,7 @@ export class AppointmentAggregationService {
           requirementImportance: template.importance,
           overallStatus: PatientRequirementOverallStatus.ACTIVE,
           instructions: instructions,
+          sourceProcedures: reqWithSource.sourceProcedures, // Track which procedures this requirement comes from
           createdAt: admin.firestore.FieldValue.serverTimestamp() as any,
           updatedAt: admin.firestore.FieldValue.serverTimestamp() as any,
         };
@@ -1012,6 +1163,10 @@ export class AppointmentAggregationService {
             appointmentId: newInstanceData.appointmentId,
             requirementName: newInstanceData.requirementName,
             instructionsCount: newInstanceData.instructions.length,
+            sourceProcedures: newInstanceData.sourceProcedures?.map(sp => ({
+              procedureId: sp.procedureId,
+              procedureName: sp.procedureName,
+            })) || [],
           })}`,
         );
 

package/src/admin/aggregation/reviews/reviews.aggregation.service.ts

@@ -65,6 +65,18 @@ export class ReviewsAggregationService {
       );
     }
 
+    // Update extended procedures if they exist
+    if (review.extendedProcedureReviews && review.extendedProcedureReviews.length > 0) {
+      console.log(
+        `[ReviewsAggregationService] Processing ${review.extendedProcedureReviews.length} extended procedure reviews`
+      );
+      review.extendedProcedureReviews.forEach((extendedReview) => {
+        updatePromises.push(
+          this.updateProcedureReviewInfo(extendedReview.procedureId)
+        );
+      });
+    }
+
     // Wait for all updates to complete
     await Promise.all(updatePromises);
     console.log(
@@ -117,6 +129,22 @@ export class ReviewsAggregationService {
       );
     }
 
+    // Update extended procedures if they exist
+    if (review.extendedProcedureReviews && review.extendedProcedureReviews.length > 0) {
+      console.log(
+        `[ReviewsAggregationService] Processing deletion of ${review.extendedProcedureReviews.length} extended procedure reviews`
+      );
+      review.extendedProcedureReviews.forEach((extendedReview) => {
+        updatePromises.push(
+          this.updateProcedureReviewInfo(
+            extendedReview.procedureId,
+            extendedReview,
+            true
+          )
+        );
+      });
+    }
+
     // Wait for all updates to complete
     await Promise.all(updatePromises);
     console.log(
@@ -430,14 +458,32 @@ export class ReviewsAggregationService {
         recommendationPercentage: 0,
       };
 
-    // Get all reviews for this procedure
-    const reviewsQuery = await this.db
+    // Get all reviews for this procedure (both main and extended)
+    // We need to check both procedureReview.procedureId and extendedProcedureReviews array
+    const allReviewsQuery = await this.db
       .collection(REVIEWS_COLLECTION)
-      .where("procedureReview.procedureId", "==", procedureId)
       .get();
 
-    // If we're removing the last review or there are no reviews, set default values
-    if ((isRemoval && reviewsQuery.size <= 1) || reviewsQuery.empty) {
+    // Filter reviews that contain this procedure (either as main or extended)
+    const reviews = allReviewsQuery.docs.map((doc) => doc.data() as Review);
+    const procedureReviews: ProcedureReview[] = [];
+
+    reviews.forEach((review) => {
+      // Check if this is the main procedure
+      if (review.procedureReview && review.procedureReview.procedureId === procedureId) {
+        procedureReviews.push(review.procedureReview);
+      }
+      // Check if this is in extended procedures
+      if (review.extendedProcedureReviews && review.extendedProcedureReviews.length > 0) {
+        const matchingExtended = review.extendedProcedureReviews.filter(
+          (extReview) => extReview.procedureId === procedureId
+        );
+        procedureReviews.push(...matchingExtended);
+      }
+    });
+
+    // If there are no reviews, set default values
+    if (procedureReviews.length === 0) {
       const updatedReviewInfo: ProcedureReviewInfo = {
         totalReviews: 0,
         averageRating: 0,
@@ -460,12 +506,6 @@ export class ReviewsAggregationService {
       return updatedReviewInfo;
     }
 
-    // Calculate new averages from all reviews
-    const reviews = reviewsQuery.docs.map((doc) => doc.data() as Review);
-    const procedureReviews = reviews
-      .map((review) => review.procedureReview)
-      .filter((review): review is ProcedureReview => review !== undefined);
-
     // Calculate averages
     let totalRating = 0;
     let totalEffectivenessOfTreatment = 0;
@@ -599,11 +639,19 @@ export class ReviewsAggregationService {
       review.procedureReview.isVerified = true;
     }
 
+    // Update extended procedure reviews if they exist
+    if (review.extendedProcedureReviews && review.extendedProcedureReviews.length > 0) {
+      review.extendedProcedureReviews.forEach((extReview) => {
+        extReview.isVerified = true;
+      });
+    }
+
     // Update the review
     batch.update(reviewRef, {
       clinicReview: review.clinicReview,
       practitionerReview: review.practitionerReview,
       procedureReview: review.procedureReview,
+      extendedProcedureReviews: review.extendedProcedureReviews,
       updatedAt: admin.firestore.FieldValue.serverTimestamp(),
     });
 

package/src/services/reviews/reviews.service.ts

@@ -45,6 +45,7 @@ export class ReviewService extends BaseService {
         hasClinicReview: !!data.clinicReview,
         hasPractitionerReview: !!data.practitionerReview,
         hasProcedureReview: !!data.procedureReview,
+        extendedProcedureReviewsCount: data.extendedProcedureReviews?.length || 0,
         practitionerId: data.practitionerReview?.practitionerId,
         clinicId: data.clinicReview?.clinicId,
         procedureId: data.procedureReview?.procedureId,
@@ -95,6 +96,22 @@ export class ReviewService extends BaseService {
         ratings.push(procedureAverage);
       }
 
+      // Process extended procedure reviews
+      if (data.extendedProcedureReviews && data.extendedProcedureReviews.length > 0) {
+        data.extendedProcedureReviews.forEach((extendedReview) => {
+          const extendedRatings = [
+            extendedReview.effectivenessOfTreatment,
+            extendedReview.outcomeExplanation,
+            extendedReview.painManagement,
+            extendedReview.followUpCare,
+            extendedReview.valueForMoney,
+          ];
+          const extendedAverage = this.calculateAverage(extendedRatings);
+          extendedReview.overallRating = extendedAverage;
+          ratings.push(extendedAverage);
+        });
+      }
+
       const overallRating = this.calculateAverage(ratings);
 
       // Generate a unique ID for the main review
@@ -118,6 +135,16 @@ export class ReviewService extends BaseService {
 
       // Create the review object with timestamps
       const now = new Date();
+
+      // Add IDs to extended procedure reviews
+      if (data.extendedProcedureReviews && data.extendedProcedureReviews.length > 0) {
+        data.extendedProcedureReviews.forEach((extendedReview) => {
+          extendedReview.id = this.generateId();
+          extendedReview.fullReviewId = reviewId;
+          extendedReview.createdAt = now;
+          extendedReview.updatedAt = now;
+        });
+      }
       const review: Review = {
         id: reviewId,
         appointmentId,
@@ -125,6 +152,7 @@ export class ReviewService extends BaseService {
         clinicReview: data.clinicReview,
         practitionerReview: data.practitionerReview,
         procedureReview: data.procedureReview,
+        extendedProcedureReviews: data.extendedProcedureReviews,
         overallComment: data.overallComment,
         overallRating,
         createdAt: now,
@@ -147,6 +175,7 @@ export class ReviewService extends BaseService {
         practitionerId: review.practitionerReview?.practitionerId,
         clinicId: review.clinicReview?.clinicId,
         procedureId: review.procedureReview?.procedureId,
+        extendedProcedureReviewsCount: review.extendedProcedureReviews?.length || 0,
       });
 
       // Note: Related entity updates (clinic, practitioner, procedure) are now handled
@@ -212,6 +241,23 @@ export class ReviewService extends BaseService {
           };
         }
 
+        // Enhance extended procedure reviews with names
+        if (enhancedReview.extendedProcedureReviews && enhancedReview.extendedProcedureReviews.length > 0) {
+          const extendedProcedures = appointment.metadata?.extendedProcedures || [];
+          enhancedReview.extendedProcedureReviews = enhancedReview.extendedProcedureReviews.map((extendedReview) => {
+            const procedureInfo = extendedProcedures.find(
+              (ep) => ep.procedureId === extendedReview.procedureId
+            );
+            if (procedureInfo) {
+              return {
+                ...extendedReview,
+                procedureName: procedureInfo.procedureName,
+              };
+            }
+            return extendedReview;
+          });
+        }
+
         // Add patient name to the main review object
         if (appointment.patientInfo) {
           enhancedReview.patientName = appointment.patientInfo.fullName;
@@ -223,7 +269,8 @@ export class ReviewService extends BaseService {
             enhancedReview.clinicReview?.clinicName ||
             enhancedReview.practitionerReview?.practitionerName ||
             enhancedReview.procedureReview?.procedureName ||
-            enhancedReview.patientName
+            enhancedReview.patientName ||
+            enhancedReview.extendedProcedureReviews?.some(epr => epr.procedureName)
           ),
         });
 

package/src/types/patient/patient-requirements.ts

@@ -50,6 +50,14 @@ export enum PatientRequirementOverallStatus {
   FAILED_TO_PROCESS = "failedToProcess", // An error occurred during its creation or initial processing.
 }
 
+/**
+ * Represents source procedure information for a requirement instance
+ */
+export interface RequirementSourceProcedure {
+  procedureId: string;
+  procedureName: string;
+}
+
 /**
  * Represents an instance of a backoffice Requirement, tailored to a specific patient and appointment.
  * This document lives in the patient's subcollection: `patients/{patientId}/patientRequirements/{instanceId}`.
@@ -70,6 +78,9 @@ export interface PatientRequirementInstance {
   // Contains each specific timed instruction derived from the Requirement's timeframe.notifyAt
   instructions: PatientRequirementInstruction[];
 
+  // NEW: Track which procedure(s) this requirement comes from
+  sourceProcedures?: RequirementSourceProcedure[];
+
   // Timestamps for the instance itself
   createdAt: Timestamp;
   updatedAt: Timestamp;