@blackcode_sa/metaestetics-api 1.6.18 → 1.6.20

package/dist/admin/index.js

@@ -3345,18 +3345,47 @@ var AppointmentAggregationService = class {
     try {
       const batch = this.db.batch();
       let instancesCreatedCount = 0;
+      let createdInstances = [];
+      Logger.info(
+        `[AggService] Found ${appointment.preProcedureRequirements.length} pre-requirements to process: ${JSON.stringify(
+          appointment.preProcedureRequirements.map((r) => {
+            var _a2, _b;
+            return {
+              id: r.id,
+              name: r.name,
+              type: r.type,
+              isActive: r.isActive,
+              hasTimeframe: !!r.timeframe,
+              notifyAtLength: ((_b = (_a2 = r.timeframe) == null ? void 0 : _a2.notifyAt) == null ? void 0 : _b.length) || 0
+            };
+          })
+        )}`
+      );
       for (const template of appointment.preProcedureRequirements) {
-        if (!template) continue;
+        if (!template) {
+          Logger.warn(
+            `[AggService] Found null/undefined template in preProcedureRequirements array`
+          );
+          continue;
+        }
         if (template.type !== "pre" /* PRE */ || !template.isActive) {
           Logger.debug(
             `[AggService] Skipping template ${template.id} (${template.name}): not an active PRE requirement.`
           );
           continue;
         }
+        if (!template.timeframe || !template.timeframe.notifyAt || template.timeframe.notifyAt.length === 0) {
+          Logger.warn(
+            `[AggService] Template ${template.id} (${template.name}) has no timeframe.notifyAt values. Creating with empty instructions.`
+          );
+        }
         Logger.debug(
           `[AggService] Processing template ${template.id} (${template.name}) for appt ${appointment.id}`
         );
         const newInstanceRef = this.db.collection(PATIENTS_COLLECTION).doc(appointment.patientId).collection(PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME).doc();
+        Logger.debug(
+          `[AggService] Created doc reference: ${newInstanceRef.path}`
+        );
         const instructions = (((_a = template.timeframe) == null ? void 0 : _a.notifyAt) || []).map((notifyAtValue) => {
           let dueTime = appointment.appointmentStartTime;
           if (template.timeframe && typeof notifyAtValue === "number") {
@@ -3403,17 +3432,123 @@ var AppointmentAggregationService = class {
           createdAt: admin10.firestore.FieldValue.serverTimestamp(),
           updatedAt: admin10.firestore.FieldValue.serverTimestamp()
         };
+        Logger.debug(
+          `[AggService] Setting data for requirement: ${JSON.stringify({
+            id: newInstanceRef.id,
+            patientId: newInstanceData.patientId,
+            appointmentId: newInstanceData.appointmentId,
+            requirementName: newInstanceData.requirementName,
+            instructionsCount: newInstanceData.instructions.length
+          })}`
+        );
         batch.set(newInstanceRef, newInstanceData);
+        createdInstances.push({
+          ref: newInstanceRef,
+          data: newInstanceData
+        });
         instancesCreatedCount++;
         Logger.debug(
           `[AggService] Added PatientRequirementInstance ${newInstanceRef.id} to batch for template ${template.id}.`
         );
       }
       if (instancesCreatedCount > 0) {
-        await batch.commit();
-        Logger.info(
-          `[AggService] Successfully created ${instancesCreatedCount} PRE_APPOINTMENT requirement instances for appointment ${appointment.id}.`
-        );
+        try {
+          await batch.commit();
+          Logger.info(
+            `[AggService] Successfully created ${instancesCreatedCount} PRE_APPOINTMENT requirement instances for appointment ${appointment.id}.`
+          );
+          try {
+            const verifySnapshot = await this.db.collection(PATIENTS_COLLECTION).doc(appointment.patientId).collection(PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME).where("appointmentId", "==", appointment.id).get();
+            if (verifySnapshot.empty) {
+              Logger.warn(
+                `[AggService] Batch commit reported success but documents not found! Attempting direct creation as fallback...`
+              );
+              const fallbackPromises = createdInstances.map(
+                async ({ ref, data }) => {
+                  try {
+                    await ref.set(data);
+                    Logger.info(
+                      `[AggService] Fallback direct creation success for ${ref.id}`
+                    );
+                    return true;
+                  } catch (fallbackError) {
+                    Logger.error(
+                      `[AggService] Fallback direct creation failed for ${ref.id}:`,
+                      fallbackError
+                    );
+                    return false;
+                  }
+                }
+              );
+              const fallbackResults = await Promise.allSettled(
+                fallbackPromises
+              );
+              const successCount = fallbackResults.filter(
+                (r) => r.status === "fulfilled" && r.value === true
+              ).length;
+              if (successCount > 0) {
+                Logger.info(
+                  `[AggService] Fallback mechanism created ${successCount} out of ${createdInstances.length} requirements`
+                );
+              } else {
+                Logger.error(
+                  `[AggService] Both batch and fallback mechanisms failed to create requirements`
+                );
+                throw new Error(
+                  "Failed to create patient requirements through both batch and direct methods"
+                );
+              }
+            } else {
+              Logger.info(
+                `[AggService] Verification confirmed ${verifySnapshot.size} requirement documents created`
+              );
+            }
+          } catch (verifyError) {
+            Logger.error(
+              `[AggService] Error during verification of created requirements:`,
+              verifyError
+            );
+          }
+        } catch (commitError) {
+          Logger.error(
+            `[AggService] Error committing batch for PRE_APPOINTMENT requirement instances for appointment ${appointment.id}:`,
+            commitError
+          );
+          Logger.info(`[AggService] Attempting direct creation as fallback...`);
+          const fallbackPromises = createdInstances.map(
+            async ({ ref, data }) => {
+              try {
+                await ref.set(data);
+                Logger.info(
+                  `[AggService] Fallback direct creation success for ${ref.id}`
+                );
+                return true;
+              } catch (fallbackError) {
+                Logger.error(
+                  `[AggService] Fallback direct creation failed for ${ref.id}:`,
+                  fallbackError
+                );
+                return false;
+              }
+            }
+          );
+          const fallbackResults = await Promise.allSettled(fallbackPromises);
+          const successCount = fallbackResults.filter(
+            (r) => r.status === "fulfilled" && r.value === true
+          ).length;
+          if (successCount > 0) {
+            Logger.info(
+              `[AggService] Fallback mechanism created ${successCount} out of ${createdInstances.length} requirements`
+            );
+          } else {
+            Logger.error(
+              `[AggService] Both batch and fallback mechanisms failed to create requirements`
+            );
+            throw new Error(
+              "Failed to create patient requirements through both batch and direct methods"
+            );
+          }
+        }
       } else {
         Logger.info(
           `[AggService] No new PRE_APPOINTMENT requirement instances were prepared for batch commit for appointment ${appointment.id}.`
@@ -3424,6 +3559,7 @@ var AppointmentAggregationService = class {
         `[AggService] Error creating PRE_APPOINTMENT requirement instances for appointment ${appointment.id}:`,
         error
       );
+      throw error;
     }
   }
   /**

package/dist/admin/index.mjs

@@ -3290,18 +3290,47 @@ var AppointmentAggregationService = class {
     try {
       const batch = this.db.batch();
       let instancesCreatedCount = 0;
+      let createdInstances = [];
+      Logger.info(
+        `[AggService] Found ${appointment.preProcedureRequirements.length} pre-requirements to process: ${JSON.stringify(
+          appointment.preProcedureRequirements.map((r) => {
+            var _a2, _b;
+            return {
+              id: r.id,
+              name: r.name,
+              type: r.type,
+              isActive: r.isActive,
+              hasTimeframe: !!r.timeframe,
+              notifyAtLength: ((_b = (_a2 = r.timeframe) == null ? void 0 : _a2.notifyAt) == null ? void 0 : _b.length) || 0
+            };
+          })
+        )}`
+      );
       for (const template of appointment.preProcedureRequirements) {
-        if (!template) continue;
+        if (!template) {
+          Logger.warn(
+            `[AggService] Found null/undefined template in preProcedureRequirements array`
+          );
+          continue;
+        }
         if (template.type !== "pre" /* PRE */ || !template.isActive) {
           Logger.debug(
             `[AggService] Skipping template ${template.id} (${template.name}): not an active PRE requirement.`
           );
           continue;
         }
+        if (!template.timeframe || !template.timeframe.notifyAt || template.timeframe.notifyAt.length === 0) {
+          Logger.warn(
+            `[AggService] Template ${template.id} (${template.name}) has no timeframe.notifyAt values. Creating with empty instructions.`
+          );
+        }
         Logger.debug(
           `[AggService] Processing template ${template.id} (${template.name}) for appt ${appointment.id}`
         );
         const newInstanceRef = this.db.collection(PATIENTS_COLLECTION).doc(appointment.patientId).collection(PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME).doc();
+        Logger.debug(
+          `[AggService] Created doc reference: ${newInstanceRef.path}`
+        );
         const instructions = (((_a = template.timeframe) == null ? void 0 : _a.notifyAt) || []).map((notifyAtValue) => {
           let dueTime = appointment.appointmentStartTime;
           if (template.timeframe && typeof notifyAtValue === "number") {
@@ -3348,17 +3377,123 @@ var AppointmentAggregationService = class {
           createdAt: admin10.firestore.FieldValue.serverTimestamp(),
           updatedAt: admin10.firestore.FieldValue.serverTimestamp()
         };
+        Logger.debug(
+          `[AggService] Setting data for requirement: ${JSON.stringify({
+            id: newInstanceRef.id,
+            patientId: newInstanceData.patientId,
+            appointmentId: newInstanceData.appointmentId,
+            requirementName: newInstanceData.requirementName,
+            instructionsCount: newInstanceData.instructions.length
+          })}`
+        );
         batch.set(newInstanceRef, newInstanceData);
+        createdInstances.push({
+          ref: newInstanceRef,
+          data: newInstanceData
+        });
         instancesCreatedCount++;
         Logger.debug(
           `[AggService] Added PatientRequirementInstance ${newInstanceRef.id} to batch for template ${template.id}.`
         );
       }
       if (instancesCreatedCount > 0) {
-        await batch.commit();
-        Logger.info(
-          `[AggService] Successfully created ${instancesCreatedCount} PRE_APPOINTMENT requirement instances for appointment ${appointment.id}.`
-        );
+        try {
+          await batch.commit();
+          Logger.info(
+            `[AggService] Successfully created ${instancesCreatedCount} PRE_APPOINTMENT requirement instances for appointment ${appointment.id}.`
+          );
+          try {
+            const verifySnapshot = await this.db.collection(PATIENTS_COLLECTION).doc(appointment.patientId).collection(PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME).where("appointmentId", "==", appointment.id).get();
+            if (verifySnapshot.empty) {
+              Logger.warn(
+                `[AggService] Batch commit reported success but documents not found! Attempting direct creation as fallback...`
+              );
+              const fallbackPromises = createdInstances.map(
+                async ({ ref, data }) => {
+                  try {
+                    await ref.set(data);
+                    Logger.info(
+                      `[AggService] Fallback direct creation success for ${ref.id}`
+                    );
+                    return true;
+                  } catch (fallbackError) {
+                    Logger.error(
+                      `[AggService] Fallback direct creation failed for ${ref.id}:`,
+                      fallbackError
+                    );
+                    return false;
+                  }
+                }
+              );
+              const fallbackResults = await Promise.allSettled(
+                fallbackPromises
+              );
+              const successCount = fallbackResults.filter(
+                (r) => r.status === "fulfilled" && r.value === true
+              ).length;
+              if (successCount > 0) {
+                Logger.info(
+                  `[AggService] Fallback mechanism created ${successCount} out of ${createdInstances.length} requirements`
+                );
+              } else {
+                Logger.error(
+                  `[AggService] Both batch and fallback mechanisms failed to create requirements`
+                );
+                throw new Error(
+                  "Failed to create patient requirements through both batch and direct methods"
+                );
+              }
+            } else {
+              Logger.info(
+                `[AggService] Verification confirmed ${verifySnapshot.size} requirement documents created`
+              );
+            }
+          } catch (verifyError) {
+            Logger.error(
+              `[AggService] Error during verification of created requirements:`,
+              verifyError
+            );
+          }
+        } catch (commitError) {
+          Logger.error(
+            `[AggService] Error committing batch for PRE_APPOINTMENT requirement instances for appointment ${appointment.id}:`,
+            commitError
+          );
+          Logger.info(`[AggService] Attempting direct creation as fallback...`);
+          const fallbackPromises = createdInstances.map(
+            async ({ ref, data }) => {
+              try {
+                await ref.set(data);
+                Logger.info(
+                  `[AggService] Fallback direct creation success for ${ref.id}`
+                );
+                return true;
+              } catch (fallbackError) {
+                Logger.error(
+                  `[AggService] Fallback direct creation failed for ${ref.id}:`,
+                  fallbackError
+                );
+                return false;
+              }
+            }
+          );
+          const fallbackResults = await Promise.allSettled(fallbackPromises);
+          const successCount = fallbackResults.filter(
+            (r) => r.status === "fulfilled" && r.value === true
+          ).length;
+          if (successCount > 0) {
+            Logger.info(
+              `[AggService] Fallback mechanism created ${successCount} out of ${createdInstances.length} requirements`
+            );
+          } else {
+            Logger.error(
+              `[AggService] Both batch and fallback mechanisms failed to create requirements`
+            );
+            throw new Error(
+              "Failed to create patient requirements through both batch and direct methods"
+            );
+          }
+        }
       } else {
         Logger.info(
           `[AggService] No new PRE_APPOINTMENT requirement instances were prepared for batch commit for appointment ${appointment.id}.`
@@ -3369,6 +3504,7 @@ var AppointmentAggregationService = class {
         `[AggService] Error creating PRE_APPOINTMENT requirement instances for appointment ${appointment.id}:`,
         error
       );
+      throw error;
     }
   }
   /**

package/package.json

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

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

@@ -507,9 +507,32 @@ export class AppointmentAggregationService {
     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 pre-requirements
+      Logger.info(
+        `[AggService] Found ${
+          appointment.preProcedureRequirements.length
+        } pre-requirements to process: ${JSON.stringify(
+          appointment.preProcedureRequirements.map((r) => ({
+            id: r.id,
+            name: r.name,
+            type: r.type,
+            isActive: r.isActive,
+            hasTimeframe: !!r.timeframe,
+            notifyAtLength: r.timeframe?.notifyAt?.length || 0,
+          }))
+        )}`
+      );
 
       for (const template of appointment.preProcedureRequirements) {
-        if (!template) continue; // Skip if template is null or undefined in the array
+        if (!template) {
+          Logger.warn(
+            `[AggService] Found null/undefined template in preProcedureRequirements array`
+          );
+          continue;
+        }
 
         // Ensure it's an active, PRE-type requirement
         if (template.type !== RequirementType.PRE || !template.isActive) {
@@ -519,6 +542,16 @@ export class AppointmentAggregationService {
           continue;
         }
 
+        if (
+          !template.timeframe ||
+          !template.timeframe.notifyAt ||
+          template.timeframe.notifyAt.length === 0
+        ) {
+          Logger.warn(
+            `[AggService] Template ${template.id} (${template.name}) has no timeframe.notifyAt values. Creating with empty instructions.`
+          );
+        }
+
         Logger.debug(
           `[AggService] Processing template ${template.id} (${template.name}) for appt ${appointment.id}`
         );
@@ -529,6 +562,11 @@ export class AppointmentAggregationService {
           .collection(PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME)
           .doc(); // Auto-generate ID for the new instance
 
+        // Log the path for debugging
+        Logger.debug(
+          `[AggService] Created doc reference: ${newInstanceRef.path}`
+        );
+
         const instructions: PatientRequirementInstruction[] = (
           template.timeframe?.notifyAt || []
         ).map((notifyAtValue) => {
@@ -585,7 +623,24 @@ export class AppointmentAggregationService {
           updatedAt: admin.firestore.FieldValue.serverTimestamp() as any,
         };
 
+        // Log the data being set
+        Logger.debug(
+          `[AggService] Setting data for requirement: ${JSON.stringify({
+            id: newInstanceRef.id,
+            patientId: newInstanceData.patientId,
+            appointmentId: newInstanceData.appointmentId,
+            requirementName: newInstanceData.requirementName,
+            instructionsCount: newInstanceData.instructions.length,
+          })}`
+        );
+
         batch.set(newInstanceRef, newInstanceData);
+        // Store for potential fallback
+        createdInstances.push({
+          ref: newInstanceRef,
+          data: newInstanceData,
+        });
+
         instancesCreatedCount++;
         Logger.debug(
           `[AggService] Added PatientRequirementInstance ${newInstanceRef.id} to batch for template ${template.id}.`
@@ -593,10 +648,119 @@ export class AppointmentAggregationService {
       }
 
       if (instancesCreatedCount > 0) {
-        await batch.commit();
-        Logger.info(
-          `[AggService] Successfully created ${instancesCreatedCount} PRE_APPOINTMENT requirement instances for appointment ${appointment.id}.`
-        );
+        try {
+          await batch.commit();
+          Logger.info(
+            `[AggService] Successfully created ${instancesCreatedCount} PRE_APPOINTMENT requirement instances for appointment ${appointment.id}.`
+          );
+
+          // Verify creation success
+          try {
+            const verifySnapshot = await this.db
+              .collection(PATIENTS_COLLECTION)
+              .doc(appointment.patientId)
+              .collection(PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME)
+              .where("appointmentId", "==", appointment.id)
+              .get();
+
+            if (verifySnapshot.empty) {
+              Logger.warn(
+                `[AggService] Batch commit reported success but documents not found! Attempting direct creation as fallback...`
+              );
+
+              // Fallback to direct creation if batch worked but docs aren't there
+              const fallbackPromises = createdInstances.map(
+                async ({ ref, data }) => {
+                  try {
+                    await ref.set(data);
+                    Logger.info(
+                      `[AggService] Fallback direct creation success for ${ref.id}`
+                    );
+                    return true;
+                  } catch (fallbackError) {
+                    Logger.error(
+                      `[AggService] Fallback direct creation failed for ${ref.id}:`,
+                      fallbackError
+                    );
+                    return false;
+                  }
+                }
+              );
+
+              const fallbackResults = await Promise.allSettled(
+                fallbackPromises
+              );
+              const successCount = fallbackResults.filter(
+                (r) => r.status === "fulfilled" && r.value === true
+              ).length;
+
+              if (successCount > 0) {
+                Logger.info(
+                  `[AggService] Fallback mechanism created ${successCount} out of ${createdInstances.length} requirements`
+                );
+              } else {
+                Logger.error(
+                  `[AggService] Both batch and fallback mechanisms failed to create requirements`
+                );
+                throw new Error(
+                  "Failed to create patient requirements through both batch and direct methods"
+                );
+              }
+            } else {
+              Logger.info(
+                `[AggService] Verification confirmed ${verifySnapshot.size} requirement documents created`
+              );
+            }
+          } catch (verifyError) {
+            Logger.error(
+              `[AggService] Error during verification of created requirements:`,
+              verifyError
+            );
+          }
+        } catch (commitError) {
+          Logger.error(
+            `[AggService] Error committing batch for PRE_APPOINTMENT requirement instances for appointment ${appointment.id}:`,
+            commitError
+          );
+
+          // Try direct creation as fallback
+          Logger.info(`[AggService] Attempting direct creation as fallback...`);
+          const fallbackPromises = createdInstances.map(
+            async ({ ref, data }) => {
+              try {
+                await ref.set(data);
+                Logger.info(
+                  `[AggService] Fallback direct creation success for ${ref.id}`
+                );
+                return true;
+              } catch (fallbackError) {
+                Logger.error(
+                  `[AggService] Fallback direct creation failed for ${ref.id}:`,
+                  fallbackError
+                );
+                return false;
+              }
+            }
+          );
+
+          const fallbackResults = await Promise.allSettled(fallbackPromises);
+          const successCount = fallbackResults.filter(
+            (r) => r.status === "fulfilled" && r.value === true
+          ).length;
+
+          if (successCount > 0) {
+            Logger.info(
+              `[AggService] Fallback mechanism created ${successCount} out of ${createdInstances.length} requirements`
+            );
+          } else {
+            Logger.error(
+              `[AggService] Both batch and fallback mechanisms failed to create requirements`
+            );
+            throw new Error(
+              "Failed to create patient requirements through both batch and direct methods"
+            );
+          }
+        }
       } else {
         Logger.info(
           `[AggService] No new PRE_APPOINTMENT requirement instances were prepared for batch commit for appointment ${appointment.id}.`
@@ -607,8 +771,7 @@ export class AppointmentAggregationService {
         `[AggService] Error creating PRE_APPOINTMENT requirement instances for appointment ${appointment.id}:`,
         error
       );
-      // Rethrow or handle as per error policy, e.g., if this failure should halt further processing.
-      // For now, just logging.
+      throw error; // Re-throw to ensure the caller knows there was a problem
     }
   }