@blackcode_sa/metaestetics-api 1.5.44 → 1.5.45

package/package.json

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

package/src/admin/mailing/base.mailing.service.ts

@@ -29,9 +29,20 @@ export class BaseMailingService {
     // Use provided instances
     this.db = firestore;
     this.mailgunClient = mailgunClient;
-    // Removed internal config reading and client creation
-    // this.config = mailgunConfig || getMailgunConfig();
-    // this.mailgunClient = createMailgunClient(this.config);
+
+    // Validate instances
+    if (!this.db) {
+      console.error("[BaseMailingService] No Firestore instance provided");
+      throw new Error("Firestore instance is required");
+    }
+
+    if (!this.mailgunClient) {
+      console.error("[BaseMailingService] No Mailgun client provided");
+      throw new Error("Mailgun client is required");
+    }
+
+    // Log successful initialization
+    console.log("[BaseMailingService] Service initialized successfully");
   }
 
   /**
@@ -43,37 +54,80 @@ export class BaseMailingService {
     data: mailgun.messages.SendData // Caller must provide 'from'
   ): Promise<mailgun.messages.SendResponse> {
     try {
+      // Validate email data fields
+      if (!data) {
+        throw new Error("Email data object is required");
+      }
+
+      // Ensure all required fields are provided
+      if (!data.to) {
+        throw new Error("Email 'to' address is required");
+      }
+
       // Ensure 'from' field is provided by the caller
       if (!data.from) {
         throw new Error(
           "Email 'from' address must be provided in sendEmail data."
         );
       }
-      // Removed fallback to internal config.from
-      // const emailData = {
-      //   ...data,
-      //   from: data.from || this.config.from,
-      // };
+
+      if (!data.subject) {
+        throw new Error("Email 'subject' is required");
+      }
+
+      if (!data.html && !data.text) {
+        throw new Error("Email must have either 'html' or 'text' content");
+      }
+
+      console.log("[BaseMailingService] Sending email via Mailgun", {
+        to: data.to,
+        from: data.from,
+        subject: data.subject,
+        hasHtml: !!data.html,
+        hasText: !!data.text,
+      });
 
       // Send the email
       return await new Promise<mailgun.messages.SendResponse>(
         (resolve, reject) => {
-          this.mailgunClient.messages().send(data, (error, body) => {
-            if (error) {
-              console.error("[BaseMailingService] Error sending email:", error);
-              reject(error);
-            } else {
-              console.log(
-                "[BaseMailingService] Email sent successfully:",
-                body
-              );
-              resolve(body);
+          try {
+            const messagesApi = this.mailgunClient.messages();
+            if (!messagesApi) {
+              throw new Error("Could not get Mailgun messages API");
             }
-          });
+
+            messagesApi.send(data, (error, body) => {
+              if (error) {
+                console.error(
+                  "[BaseMailingService] Mailgun API error:",
+                  error instanceof Error ? error.message : error,
+                  error instanceof Error ? error.stack : ""
+                );
+                reject(error);
+              } else {
+                console.log(
+                  "[BaseMailingService] Email sent successfully:",
+                  body
+                );
+                resolve(body);
+              }
+            });
+          } catch (sendError) {
+            console.error(
+              "[BaseMailingService] Error in mailgun.messages().send():",
+              sendError instanceof Error ? sendError.message : sendError,
+              sendError instanceof Error ? sendError.stack : ""
+            );
+            reject(sendError);
+          }
         }
       );
     } catch (error) {
-      console.error("[BaseMailingService] Error in sendEmail:", error);
+      console.error(
+        "[BaseMailingService] Error in sendEmail:",
+        error instanceof Error ? error.message : error,
+        error instanceof Error ? error.stack : ""
+      );
       throw error;
     }
   }
@@ -96,13 +150,22 @@ export class BaseMailingService {
         subject: emailData.subject,
         templateName: emailData.templateName,
         success,
-        error: error ? JSON.stringify(error) : null,
+        error: error
+          ? error instanceof Error
+            ? { message: error.message, stack: error.stack }
+            : JSON.stringify(error)
+          : null,
         sentAt: admin.firestore.FieldValue.serverTimestamp(),
       });
+
+      console.log(
+        `[BaseMailingService] Email log recorded. Success: ${success}`
+      );
     } catch (logError) {
       console.error(
         "[BaseMailingService] Error logging email attempt:",
-        logError
+        logError instanceof Error ? logError.message : logError,
+        logError instanceof Error ? logError.stack : ""
       );
       // Don't throw here to prevent disrupting the main flow
     }
@@ -118,14 +181,30 @@ export class BaseMailingService {
     template: string,
     variables: Record<string, string>
   ): string {
-    let rendered = template;
+    if (!template) {
+      throw new Error("Email template is required");
+    }
 
-    // Replace template variables (format: {{variable_name}})
-    Object.entries(variables).forEach(([key, value]) => {
-      const regex = new RegExp(`{{\\s*${key}\\s*}}`, "g");
-      rendered = rendered.replace(regex, value);
-    });
+    try {
+      let rendered = template;
+
+      // Replace template variables (format: {{variable_name}})
+      Object.entries(variables).forEach(([key, value]) => {
+        const regex = new RegExp(`{{\\s*${key}\\s*}}`, "g");
+        rendered = rendered.replace(regex, value || "");
+      });
 
-    return rendered;
+      return rendered;
+    } catch (renderError) {
+      console.error(
+        "[BaseMailingService] Error rendering template:",
+        renderError instanceof Error ? renderError.message : renderError
+      );
+      throw new Error(
+        `Template rendering failed: ${
+          renderError instanceof Error ? renderError.message : "Unknown error"
+        }`
+      );
+    }
   }
 }

package/src/admin/mailing/practitionerInvite/practitionerInvite.mailing.ts

@@ -126,6 +126,18 @@ export class PractitionerInviteMailingService extends BaseMailingService {
         currentYear,
       };
 
+      // Debug log for template variables (excluding token for security)
+      console.log("[PractitionerInviteMailingService] Template variables:", {
+        clinicName: templateVariables.clinicName,
+        practitionerName: templateVariables.practitionerName,
+        expirationDate: templateVariables.expirationDate,
+        registrationUrl: templateVariables.registrationUrl,
+        contactName: templateVariables.contactName,
+        contactEmail: templateVariables.contactEmail,
+        // Don't log the invite token for security
+        hasInviteToken: !!templateVariables.inviteToken,
+      });
+
       // Render HTML email
       const html = this.renderTemplate(
         practitionerInvitationTemplate,
@@ -140,6 +152,16 @@ export class PractitionerInviteMailingService extends BaseMailingService {
         html,
       };
 
+      console.log(
+        "[PractitionerInviteMailingService] Sending email with data:",
+        {
+          to: emailData.to,
+          from: emailData.from,
+          subject: emailData.subject,
+          hasHtml: !!emailData.html,
+        }
+      );
+
       const result = await this.sendEmail(emailData);
 
       // Log success
@@ -156,7 +178,8 @@ export class PractitionerInviteMailingService extends BaseMailingService {
     } catch (error) {
       console.error(
         "[PractitionerInviteMailingService] Error sending invitation email:",
-        error
+        error instanceof Error ? error.message : error,
+        error instanceof Error ? error.stack : ""
       );
 
       // Log failure
@@ -192,7 +215,31 @@ export class PractitionerInviteMailingService extends BaseMailingService {
         tokenData.id
       );
 
+      // Validate token data
+      if (!tokenData || !tokenData.id || !tokenData.token || !tokenData.email) {
+        throw new Error(
+          `Invalid token data: Missing required properties. Token ID: ${tokenData?.id}`
+        );
+      }
+
+      if (!tokenData.practitionerId) {
+        throw new Error(
+          `Token ${tokenData.id} is missing practitionerId 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`);
+      }
+
       // Get practitioner data using constant and type
+      console.log(
+        `[PractitionerInviteMailingService] Fetching practitioner data: ${tokenData.practitionerId}`
+      );
       const practitionerRef = this.db
         .collection(PRACTITIONERS_COLLECTION)
         .doc(tokenData.practitionerId);
@@ -203,8 +250,20 @@ export class PractitionerInviteMailingService extends BaseMailingService {
       }
 
       const practitionerData = practitionerDoc.data() as Practitioner;
+      if (!practitionerData || !practitionerData.basicInfo) {
+        throw new Error(
+          `Practitioner ${tokenData.practitionerId} has invalid data structure`
+        );
+      }
+
+      console.log(
+        `[PractitionerInviteMailingService] Practitioner found: ${practitionerData.basicInfo.firstName} ${practitionerData.basicInfo.lastName}`
+      );
 
       // Get clinic data using constant and type
+      console.log(
+        `[PractitionerInviteMailingService] Fetching clinic data: ${tokenData.clinicId}`
+      );
       const clinicRef = this.db
         .collection(CLINICS_COLLECTION)
         .doc(tokenData.clinicId);
@@ -215,6 +274,26 @@ export class PractitionerInviteMailingService extends BaseMailingService {
       }
 
       const clinicData = clinicDoc.data() as Clinic;
+      if (!clinicData || !clinicData.contactInfo) {
+        throw new Error(
+          `Clinic ${tokenData.clinicId} has invalid data structure`
+        );
+      }
+
+      console.log(
+        `[PractitionerInviteMailingService] Clinic found: ${clinicData.name}`
+      );
+
+      // Clinic model doesn't have contactPerson, only contactInfo
+      // So we'll use simple contact information from contactInfo
+
+      // Validate fromAddress
+      if (!fromAddress) {
+        console.warn(
+          "[PractitionerInviteMailingService] No fromAddress provided, using default"
+        );
+        fromAddress = this.DEFAULT_FROM_ADDRESS;
+      }
 
       // Prepare email data using typed data
       const emailData: PractitionerInviteEmailData = {
@@ -233,12 +312,18 @@ export class PractitionerInviteMailingService extends BaseMailingService {
         clinic: {
           name: clinicData.name || "Medical Clinic",
           contactEmail: clinicData.contactInfo.email || "contact@medclinic.com",
+          // Since there's no contactPerson in the Clinic model, we'll just use "Clinic Admin"
+          contactName: "Clinic Admin",
         },
         options: {
           fromAddress: fromAddress,
         },
       };
 
+      console.log(
+        "[PractitionerInviteMailingService] Email data prepared, sending invitation"
+      );
+
       // Send the invitation email
       await this.sendInvitationEmail(emailData);
 
@@ -248,7 +333,8 @@ export class PractitionerInviteMailingService extends BaseMailingService {
     } catch (error) {
       console.error(
         "[PractitionerInviteMailingService] Error handling token creation event:",
-        error
+        error instanceof Error ? error.message : error,
+        error instanceof Error ? error.stack : ""
       );
       throw error;
     }