@blackcode_sa/metaestetics-api 1.5.50 → 1.5.52

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

@@ -1,308 +1,136 @@
-import * as mailgun from "mailgun-js";
 import * as admin from "firebase-admin";
-import { Logger } from "../logger";
+// Import the new Mailgun types if available, or use a generic 'any' if not directly importable
+// For a shared library, it's often better to define a minimal interface for what you need
+// or expect the caller (Cloud Function) to pass a pre-configured client of 'any' type.
+// import Mailgun from "mailgun.js"; // This might not be a direct dep of the API pkg
+import { Logger } from "../logger"; // Assuming logger is in Api/src/logger
 
 /**
- * Mailgun client type for compatibility with new mailgun.js library
- * This allows us to accept both older mailgun-js and newer mailgun.js clients
+ * Minimal interface for the new mailgun.js client's messages API
+ * This helps avoid a direct dependency on mailgun.js in the API package if not desired,
+ * or provides clearer typing if it is.
  */
-interface MailgunClientCompat {
-  messages: {
-    create?: (domain: string, data: any) => Promise<any>;
-    send?: (data: any, callback: (error: any, body: any) => void) => void;
-  };
+interface NewMailgunMessagesAPI {
+  create(domain: string, data: any): Promise<any>;
+}
+
+interface NewMailgunClient {
+  messages: NewMailgunMessagesAPI;
+  // Add other methods/properties if your BaseMailingService uses them
 }
 
 /**
  * Base mailing service class that provides common functionality for all mailing services
+ * This version is updated to expect a mailgun.js v10+ client.
  */
 export class BaseMailingService {
   protected db: FirebaseFirestore.Firestore;
-  protected mailgunClient: mailgun.Mailgun | MailgunClientCompat;
-  protected isNewMailgunClient: boolean = false;
-  // Removed config property as it's no longer managed here
-  // import {
-  //   getMailgunConfig,
-  //   createMailgunClient,
-  //   MailgunConfig,
-  // } from "./mailgun.config";
+  protected mailgunClient: NewMailgunClient; // Expecting the new mailgun.js client
 
   /**
    * Constructor for BaseMailingService
    * @param firestore Firestore instance provided by the caller
-   * @param mailgunClient Mailgun client instance provided by the caller
+   * @param mailgunClient Mailgun client instance (mailgun.js v10+) provided by the caller
    */
   constructor(
     firestore: FirebaseFirestore.Firestore,
-    mailgunClient: mailgun.Mailgun | MailgunClientCompat // Accept either old or new client
+    mailgunClient: NewMailgunClient // Expect the new client
   ) {
-    // Use provided instances
     this.db = firestore;
     this.mailgunClient = mailgunClient;
 
-    // Validate instances
     if (!this.db) {
       Logger.error("[BaseMailingService] No Firestore instance provided");
       throw new Error("Firestore instance is required");
     }
 
-    if (!this.mailgunClient) {
-      Logger.error("[BaseMailingService] No Mailgun client provided");
-      throw new Error("Mailgun client is required");
+    if (
+      !this.mailgunClient ||
+      typeof this.mailgunClient.messages?.create !== "function"
+    ) {
+      Logger.error(
+        "[BaseMailingService] Invalid Mailgun client provided (must be mailgun.js v10+ client)"
+      );
+      throw new Error("A valid mailgun.js v10+ client is required");
     }
 
-    // Detect which type of mailgun client we're using
-    this.isNewMailgunClient =
-      typeof (this.mailgunClient.messages as any).create === "function";
+    // The new client is configured with the URL (e.g., EU endpoint) by the caller.
+    // Validation of this configuration can be logged if details are accessible,
+    // but the primary responsibility for correct endpoint is now with client setup.
     Logger.info(
-      `[BaseMailingService] Using ${
-        this.isNewMailgunClient ? "new" : "legacy"
-      } Mailgun client`
+      "[BaseMailingService] Service initialized with mailgun.js client."
     );
-
-    // Validate the Mailgun client configuration
-    this.validateMailgunClient();
-
-    // Log successful initialization
-    Logger.info("[BaseMailingService] Service initialized successfully");
   }
 
   /**
-   * Validates that the Mailgun client is configured correctly
-   * Particularly checks for EU region configuration
-   */
-  private validateMailgunClient(): void {
-    try {
-      // For the legacy client, check EU region configuration
-      if (!this.isNewMailgunClient) {
-        const clientOptions = (this.mailgunClient as any).options || {};
-        const host = clientOptions.host || "";
-        const isEuRegion = host.includes("eu.mailgun.net");
-
-        Logger.info("[BaseMailingService] Mailgun client configuration:", {
-          host: host || "default",
-          isEuRegion,
-          domain: clientOptions.domain || "unknown",
-          clientType: "legacy",
-        });
-
-        // Check if this appears to be an EU domain but not using EU endpoint
-        if (
-          clientOptions.domain &&
-          clientOptions.domain.endsWith(".eu") &&
-          !isEuRegion
-        ) {
-          Logger.warn(
-            "[BaseMailingService] Domain appears to be in EU region but not using EU endpoint. " +
-              "If you're getting 401 Forbidden errors, ensure the host is set to 'api.eu.mailgun.net'"
-          );
-        }
-      } else {
-        // For the new client, we can't easily check the configuration
-        // but it should be properly configured with the URL parameter
-        Logger.info("[BaseMailingService] Using new Mailgun client", {
-          clientType: "mailgun.js",
-        });
-      }
-    } catch (error) {
-      // Just log the error, don't throw
-      Logger.warn("[BaseMailingService] Could not validate Mailgun client:", {
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
-  }
-
-  /**
-   * Sends an email using Mailgun
-   * @param data Email data to send, including the 'from' address
+   * Sends an email using the new Mailgun client API.
+   * @param domain The Mailgun domain to send from (e.g., mg.metaesthetics.net)
+   * @param data Email data to send, compatible with mailgun.js messages.create API
    * @returns Promise with the sending result
    */
   protected async sendEmail(
-    data: mailgun.messages.SendData // Caller must provide 'from'
+    domain: string, // The new API requires the domain as the first argument to messages.create
+    data: any // Data format according to mailgun.js messages.create
   ): Promise<any> {
-    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."
-        );
-      }
-
-      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");
-      }
+    if (!domain) {
+      throw new Error("Mailgun domain is required for sending email.");
+    }
+    if (!data) {
+      throw new Error("Email data object is required");
+    }
+    if (!data.to) {
+      throw new Error("Email 'to' address is required");
+    }
+    if (!data.from) {
+      throw new Error("Email 'from' address is required");
+    }
+    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");
+    }
 
-      Logger.info("[BaseMailingService] Sending email via Mailgun", {
+    Logger.info(
+      "[BaseMailingService] Sending email via Mailgun (mailgun.js API)",
+      {
+        domain,
         to: data.to,
         from: data.from,
         subject: data.subject,
         hasHtml: !!data.html,
         hasText: !!data.text,
-        clientType: this.isNewMailgunClient ? "mailgun.js" : "legacy",
-      });
-
-      // Use the appropriate API based on the client type
-      if (this.isNewMailgunClient) {
-        // New mailgun.js client
-        try {
-          const createMethod = (this.mailgunClient.messages as any).create;
-          // Get domain from client if possible, or from the from address as fallback
-          const domain =
-            this.getDomainFromOptions() || this.getDomainFromEmail(data.from);
-
-          if (!domain) {
-            throw new Error("Could not determine domain for Mailgun API call");
-          }
-
-          Logger.info(
-            "[BaseMailingService] Using domain for new Mailgun client:",
-            { domain }
-          );
-
-          // Call the create method with domain and data
-          const result = await createMethod(domain, data);
-          Logger.info(
-            "[BaseMailingService] Email sent successfully with new client"
-          );
-          return result;
-        } catch (error) {
-          Logger.error(
-            "[BaseMailingService] Error sending with new Mailgun client:",
-            {
-              error: error instanceof Error ? error.message : String(error),
-              stack: error instanceof Error ? error.stack : undefined,
-            }
-          );
-          throw error;
-        }
-      } else {
-        // Legacy mailgun-js client
-        return await new Promise<mailgun.messages.SendResponse>(
-          (resolve, reject) => {
-            try {
-              const messagesApi = this.mailgunClient.messages as any;
-              if (!messagesApi || !messagesApi.send) {
-                throw new Error("Could not get Mailgun messages API");
-              }
-
-              messagesApi.send(data, (error: any, body: any) => {
-                if (error) {
-                  // Enhanced error logging for auth/region issues
-                  if (error.statusCode === 401 || error.statusCode === 403) {
-                    const clientOptions =
-                      (this.mailgunClient as any).options || {};
-                    Logger.error(
-                      "[BaseMailingService] Mailgun authentication error - possible region mismatch:",
-                      {
-                        error: error instanceof Error ? error.message : error,
-                        statusCode: error.statusCode,
-                        domain: clientOptions.domain || "unknown",
-                        host: clientOptions.host || "default api.mailgun.net",
-                        suggestion:
-                          "If using EU region domains, ensure host is set to 'api.eu.mailgun.net'",
-                        response: (error as any).response
-                          ? JSON.stringify((error as any).response)
-                          : "No response details",
-                        request: (error as any).request
-                          ? {
-                              method: (error as any).request?.method,
-                              path: (error as any).request?.path,
-                              host: (error as any).request?.host,
-                            }
-                          : "No request details",
-                      }
-                    );
-                  } else {
-                    Logger.error("[BaseMailingService] Mailgun API error:", {
-                      error: error instanceof Error ? error.message : error,
-                      statusCode: error.statusCode,
-                      stack: error instanceof Error ? error.stack : undefined,
-                    });
-                  }
-                  reject(error);
-                } else {
-                  Logger.info(
-                    "[BaseMailingService] Email sent successfully:",
-                    body
-                  );
-                  resolve(body);
-                }
-              });
-            } catch (sendError) {
-              Logger.error(
-                "[BaseMailingService] Error in mailgun.messages().send():",
-                {
-                  error:
-                    sendError instanceof Error ? sendError.message : sendError,
-                  stack:
-                    sendError instanceof Error ? sendError.stack : undefined,
-                }
-              );
-              reject(sendError);
-            }
-          }
-        );
       }
-    } catch (error) {
-      Logger.error("[BaseMailingService] Error in sendEmail:", {
-        error: error instanceof Error ? error.message : error,
-        stack: error instanceof Error ? error.stack : undefined,
-      });
-      throw error;
-    }
-  }
-
-  /**
-   * Tries to get domain from mailgun client options
-   * @returns Domain string or undefined
-   */
-  private getDomainFromOptions(): string | undefined {
-    try {
-      // Different ways to get domain depending on client type
-      if (this.isNewMailgunClient) {
-        return (this.mailgunClient as any).domain;
-      } else {
-        const options = (this.mailgunClient as any).options;
-        return options?.domain;
-      }
-    } catch (e) {
-      return undefined;
-    }
-  }
+    );
 
-  /**
-   * Extracts domain from an email address
-   * @param email Email address
-   * @returns Domain part or undefined
-   */
-  private getDomainFromEmail(email: string): string | undefined {
     try {
-      // Extract from "Name <email@domain.com>" format
-      const match = email.match(/<([^>]+)>/) || [null, email];
-      const emailPart = match[1];
-
-      // Get domain part
-      const domainMatch = emailPart.match(/@([^@]+)$/);
-      if (domainMatch && domainMatch[1]) {
-        return domainMatch[1];
-      }
-      return undefined;
-    } catch (e) {
-      return undefined;
+      // Use the new mailgun.js client API: client.messages.create(domain, data)
+      const result = await this.mailgunClient.messages.create(domain, data);
+      Logger.info(
+        "[BaseMailingService] Email sent successfully with mailgun.js client",
+        result
+      );
+      return result;
+    } catch (error: any) {
+      Logger.error(
+        "[BaseMailingService] Error sending email with mailgun.js client",
+        {
+          errorMessage: error?.message,
+          errorDetails: error?.details, // mailgun.js errors often have a details field
+          errorStatusCode: error?.status, // and a status field for HTTP status code
+          stack: error?.stack,
+          domain,
+          to: data.to,
+        }
+      );
+      // Re-throw a more specific error or the original
+      const mailgunError = new Error(
+        `Mailgun API Error (${error?.status || "unknown"}): ${
+          error?.details || error?.message || "Failed to send email"
+        }`
+      );
+      (mailgunError as any).originalError = error;
+      throw mailgunError;
     }
   }
 
@@ -325,9 +153,12 @@ export class BaseMailingService {
         templateName: emailData.templateName,
         success,
         error: error
-          ? error instanceof Error
-            ? { message: error.message, stack: error.stack }
-            : JSON.stringify(error)
+          ? {
+              message: error.message,
+              details: (error as any).details,
+              status: (error as any).status,
+              stack: error.stack,
+            }
           : null,
         sentAt: admin.firestore.FieldValue.serverTimestamp(),
       });
@@ -335,10 +166,10 @@ export class BaseMailingService {
       Logger.info(
         `[BaseMailingService] Email log recorded. Success: ${success}`
       );
-    } catch (logError) {
+    } catch (logError: any) {
       Logger.error("[BaseMailingService] Error logging email attempt:", {
-        error: logError instanceof Error ? logError.message : logError,
-        stack: logError instanceof Error ? logError.stack : undefined,
+        errorMessage: logError.message,
+        stack: logError.stack,
       });
       // Don't throw here to prevent disrupting the main flow
     }
@@ -360,22 +191,17 @@ export class BaseMailingService {
 
     try {
       let rendered = template;
-
-      // Replace template variables (format: {{variable_name}})
       Object.entries(variables).forEach(([key, value]) => {
-        const regex = new RegExp(`{{\\s*${key}\\s*}}`, "g");
+        const regex = new RegExp(`{{\s*${key}\s*}}`, "g");
         rendered = rendered.replace(regex, value || "");
       });
-
       return rendered;
-    } catch (renderError) {
+    } catch (renderError: any) {
       Logger.error("[BaseMailingService] Error rendering template:", {
-        error: renderError instanceof Error ? renderError.message : renderError,
+        errorMessage: renderError.message,
       });
       throw new Error(
-        `Template rendering failed: ${
-          renderError instanceof Error ? renderError.message : "Unknown error"
-        }`
+        `Template rendering failed: ${renderError.message || "Unknown error"}`
       );
     }
   }

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

@@ -1,5 +1,4 @@
 import * as admin from "firebase-admin";
-import * as mailgun from "mailgun-js";
 import { BaseMailingService } from "../base.mailing.service";
 import { practitionerInvitationTemplate } from "./templates/invitation.template";
 import { Logger } from "../../logger";
@@ -8,9 +7,18 @@ import {
   Practitioner,
   PractitionerToken,
   PRACTITIONERS_COLLECTION,
+  PractitionerTokenStatus,
 } from "../../../types/practitioner";
 import { Clinic, CLINICS_COLLECTION } from "../../../types/clinic";
 
+// Define a minimal interface for the mailgun.js client if not importing full types
+interface NewMailgunMessagesAPI {
+  create(domain: string, data: any): Promise<any>;
+}
+interface NewMailgunClient {
+  messages: NewMailgunMessagesAPI;
+}
+
 /**
  * Interface for the data required to send a practitioner invitation email
  */
@@ -43,28 +51,28 @@ export interface PractitionerInviteEmailData {
     registrationUrl?: string;
     customSubject?: string;
     fromAddress?: string;
+    mailgunDomain?: string;
   };
 }
 
 /**
- * Service for sending practitioner invitation emails
+ * Service for sending practitioner invitation emails, updated for mailgun.js v10+
  */
 export class PractitionerInviteMailingService extends BaseMailingService {
   private readonly DEFAULT_REGISTRATION_URL =
-    "https://metaestetics.net/register";
+    "https://metaesthetics.net/register";
   private readonly DEFAULT_SUBJECT =
     "You've Been Invited to Join as a Practitioner";
-  private readonly DEFAULT_FROM_ADDRESS =
-    "MedClinic <no-reply@mg.metaesthetics.net>";
+  private readonly DEFAULT_MAILGUN_DOMAIN = "mg.metaesthetics.net";
 
   /**
    * Constructor for PractitionerInviteMailingService
    * @param firestore Firestore instance provided by the caller
-   * @param mailgunClient Mailgun client instance provided by the caller
+   * @param mailgunClient Mailgun client instance (mailgun.js v10+) provided by the caller
    */
   constructor(
     firestore: FirebaseFirestore.Firestore,
-    mailgunClient: mailgun.Mailgun
+    mailgunClient: NewMailgunClient
   ) {
     super(firestore, mailgunClient);
   }
@@ -74,9 +82,7 @@ export class PractitionerInviteMailingService extends BaseMailingService {
    * @param data The practitioner invitation data
    * @returns Promise resolved when email is sent
    */
-  async sendInvitationEmail(
-    data: PractitionerInviteEmailData
-  ): Promise<mailgun.messages.SendResponse> {
+  async sendInvitationEmail(data: PractitionerInviteEmailData): Promise<any> {
     try {
       Logger.info(
         "[PractitionerInviteMailingService] Sending invitation email to",
@@ -106,7 +112,10 @@ export class PractitionerInviteMailingService extends BaseMailingService {
 
       // Determine 'from' address
       const fromAddress =
-        data.options?.fromAddress || this.DEFAULT_FROM_ADDRESS;
+        data.options?.fromAddress ||
+        `MetaEstetics <no-reply@${
+          data.options?.mailgunDomain || this.DEFAULT_MAILGUN_DOMAIN
+        }>`;
 
       // Current year for copyright
       const currentYear = new Date().getFullYear().toString();
@@ -144,25 +153,31 @@ export class PractitionerInviteMailingService extends BaseMailingService {
         templateVariables
       );
 
-      // Send email - ensure 'from' is included
-      const emailData: mailgun.messages.SendData = {
+      // Data for the new sendEmail signature
+      const mailgunSendData = {
         to: data.token.email,
         from: fromAddress,
         subject,
         html,
       };
 
+      // Determine the domain to use for sending
+      const domainToSendFrom =
+        data.options?.mailgunDomain || this.DEFAULT_MAILGUN_DOMAIN;
+
       Logger.info(
         "[PractitionerInviteMailingService] Sending email with data:",
         {
-          to: emailData.to,
-          from: emailData.from,
-          subject: emailData.subject,
-          hasHtml: !!emailData.html,
+          domain: domainToSendFrom,
+          to: mailgunSendData.to,
+          from: mailgunSendData.from,
+          subject: mailgunSendData.subject,
+          hasHtml: !!mailgunSendData.html,
         }
       );
 
-      const result = await this.sendEmail(emailData);
+      // Call the updated sendEmail method from BaseMailingService
+      const result = await this.sendEmail(domainToSendFrom, mailgunSendData);
 
       // Log success
       await this.logEmailAttempt(
@@ -175,12 +190,14 @@ export class PractitionerInviteMailingService extends BaseMailingService {
       );
 
       return result;
-    } catch (error) {
+    } catch (error: any) {
       Logger.error(
         "[PractitionerInviteMailingService] Error sending invitation email:",
         {
-          error: error instanceof Error ? error.message : error,
-          stack: error instanceof Error ? error.stack : undefined,
+          errorMessage: error.message,
+          errorDetails: error.details,
+          errorStatus: error.status,
+          stack: error.stack,
         }
       );
 
@@ -205,11 +222,16 @@ export class PractitionerInviteMailingService extends BaseMailingService {
    * and sends the invitation email.
    * @param tokenData The fully typed token object including its id
    * @param fromAddress The 'from' email address to use, obtained from config
+   * @param mailgunDomain The mailgun domain to use for sending
    * @returns Promise resolved when the email is sent
    */
   async handleTokenCreationEvent(
     tokenData: PractitionerToken,
-    fromAddress: string
+    mailgunConfig: {
+      fromAddress: string;
+      domain: string;
+      registrationUrl?: string;
+    }
   ): Promise<void> {
     try {
       Logger.info(
@@ -239,8 +261,15 @@ export class PractitionerInviteMailingService extends BaseMailingService {
       }
 
       // Validate token status (handle both enum and string values)
-      if (!tokenData.status) {
-        throw new Error(`Token ${tokenData.id} has no status defined`);
+      if (
+        tokenData.status !== PractitionerTokenStatus.ACTIVE &&
+        String(tokenData.status).toLowerCase() !== "active"
+      ) {
+        Logger.warn(
+          "[PractitionerInviteMailingService] Token is not active, skipping email.",
+          { tokenId: tokenData.id, status: tokenData.status }
+        );
+        return;
       }
 
       // Log token status to help with debugging
@@ -305,11 +334,11 @@ export class PractitionerInviteMailingService extends BaseMailingService {
       // So we'll use simple contact information from contactInfo
 
       // Validate fromAddress
-      if (!fromAddress) {
+      if (!mailgunConfig.fromAddress) {
         Logger.warn(
           "[PractitionerInviteMailingService] No fromAddress provided, using default"
         );
-        fromAddress = this.DEFAULT_FROM_ADDRESS;
+        mailgunConfig.fromAddress = `MetaEstetics <no-reply@${this.DEFAULT_MAILGUN_DOMAIN}>`;
       }
 
       // Prepare email data using typed data
@@ -333,7 +362,9 @@ export class PractitionerInviteMailingService extends BaseMailingService {
           contactName: "Clinic Admin",
         },
         options: {
-          fromAddress: fromAddress,
+          fromAddress: mailgunConfig.fromAddress,
+          mailgunDomain: mailgunConfig.domain,
+          registrationUrl: mailgunConfig.registrationUrl,
         },
       };
 
@@ -347,12 +378,15 @@ export class PractitionerInviteMailingService extends BaseMailingService {
       Logger.info(
         "[PractitionerInviteMailingService] Invitation email sent successfully"
       );
-    } catch (error) {
+    } catch (error: any) {
       Logger.error(
         "[PractitionerInviteMailingService] Error handling token creation event:",
         {
-          error: error instanceof Error ? error.message : error,
-          stack: error instanceof Error ? error.stack : undefined,
+          errorMessage: error.message,
+          errorDetails: error.details,
+          errorStatus: error.status,
+          stack: error.stack,
+          tokenId: tokenData?.id,
         }
       );
       throw error;