@blackcode_sa/metaestetics-api 1.5.44 → 1.5.46

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.5.44",
+  "version": "1.5.46",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -100,6 +100,9 @@
     "geofire-common": "^6.0.0",
     "zod": "^3.24.1"
   },
+  "optionalDependencies": {
+    "firebase-functions": "^6.2.0"
+  },
   "jest": {
     "preset": "ts-jest",
     "testEnvironment": "node",

package/src/admin/logger/index.ts

@@ -0,0 +1,78 @@
+/**
+ * Cloud Functions-compatible logger with fallback for other environments
+ *
+ * This logger automatically detects if it's running in a Cloud Functions environment
+ * and uses the appropriate logging method. It falls back to console methods in other environments.
+ */
+
+// Try to import Firebase Functions logger, but don't cause errors if it's not available
+let firebaseFunctionsLogger: any;
+try {
+  // Use dynamic import to avoid requiring firebase-functions in non-Functions environments
+  firebaseFunctionsLogger = require("firebase-functions/logger");
+  // Import the compatibility module for console.log support if available
+  require("firebase-functions/logger/compat");
+} catch (e) {
+  // Firebase Functions logger not available, will use fallback
+}
+
+/**
+ * Logger class that uses Firebase Functions logger when available
+ * with fallback to console methods when not in a Cloud Functions environment
+ */
+export class Logger {
+  /**
+   * Log an error message
+   * @param message Message to log
+   * @param data Optional data to include
+   */
+  static error(message: string, data?: any): void {
+    if (firebaseFunctionsLogger) {
+      firebaseFunctionsLogger.error(message, data);
+    } else {
+      console.error(message, data !== undefined ? data : "");
+    }
+  }
+
+  /**
+   * Log a warning message
+   * @param message Message to log
+   * @param data Optional data to include
+   */
+  static warn(message: string, data?: any): void {
+    if (firebaseFunctionsLogger) {
+      firebaseFunctionsLogger.warn(message, data);
+    } else {
+      console.warn(message, data !== undefined ? data : "");
+    }
+  }
+
+  /**
+   * Log an info message
+   * @param message Message to log
+   * @param data Optional data to include
+   */
+  static info(message: string, data?: any): void {
+    if (firebaseFunctionsLogger) {
+      firebaseFunctionsLogger.info(message, data);
+    } else {
+      console.info(message, data !== undefined ? data : "");
+    }
+  }
+
+  /**
+   * Log a debug message
+   * @param message Message to log
+   * @param data Optional data to include
+   */
+  static debug(message: string, data?: any): void {
+    if (firebaseFunctionsLogger) {
+      firebaseFunctionsLogger.debug(message, data);
+    } else {
+      console.debug(message, data !== undefined ? data : "");
+    }
+  }
+}
+
+// Default export for easier importing
+export default Logger;

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

@@ -1,11 +1,6 @@
 import * as mailgun from "mailgun-js";
 import * as admin from "firebase-admin";
-// Configuration is no longer read here
-// import {
-//   getMailgunConfig,
-//   createMailgunClient,
-//   MailgunConfig,
-// } from "./mailgun.config";
+import { Logger } from "../logger";
 
 /**
  * Base mailing service class that provides common functionality for all mailing services
@@ -14,7 +9,11 @@ export class BaseMailingService {
   protected db: FirebaseFirestore.Firestore;
   protected mailgunClient: mailgun.Mailgun;
   // Removed config property as it's no longer managed here
-  // protected config: MailgunConfig;
+  // import {
+  //   getMailgunConfig,
+  //   createMailgunClient,
+  //   MailgunConfig,
+  // } from "./mailgun.config";
 
   /**
    * Constructor for BaseMailingService
@@ -29,9 +28,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) {
+      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");
+    }
+
+    // Log successful initialization
+    Logger.info("[BaseMailingService] Service initialized successfully");
   }
 
   /**
@@ -43,37 +53,81 @@ 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");
+      }
+
+      Logger.info("[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) {
+                Logger.error("[BaseMailingService] Mailgun API error:", {
+                  error: error instanceof Error ? error.message : error,
+                  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) {
-      console.error("[BaseMailingService] Error in sendEmail:", error);
+      Logger.error("[BaseMailingService] Error in sendEmail:", {
+        error: error instanceof Error ? error.message : error,
+        stack: error instanceof Error ? error.stack : undefined,
+      });
       throw error;
     }
   }
@@ -96,14 +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(),
       });
-    } catch (logError) {
-      console.error(
-        "[BaseMailingService] Error logging email attempt:",
-        logError
+
+      Logger.info(
+        `[BaseMailingService] Email log recorded. Success: ${success}`
       );
+    } catch (logError) {
+      Logger.error("[BaseMailingService] Error logging email attempt:", {
+        error: logError instanceof Error ? logError.message : logError,
+        stack: logError instanceof Error ? logError.stack : undefined,
+      });
       // Don't throw here to prevent disrupting the main flow
     }
   }
@@ -118,14 +180,29 @@ export class BaseMailingService {
     template: string,
     variables: Record<string, string>
   ): string {
-    let rendered = template;
+    if (!template) {
+      throw new Error("Email template is required");
+    }
+
+    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);
-    });
+      // 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) {
+      Logger.error("[BaseMailingService] Error rendering template:", {
+        error: 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

@@ -2,7 +2,7 @@ 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";
 // Import specific types and collection constants
 import {
   Practitioner,
@@ -51,11 +51,11 @@ export interface PractitionerInviteEmailData {
  */
 export class PractitionerInviteMailingService extends BaseMailingService {
   private readonly DEFAULT_REGISTRATION_URL =
-    "https://app.medclinic.com/register";
+    "https://metaestetics.net/register";
   private readonly DEFAULT_SUBJECT =
     "You've Been Invited to Join as a Practitioner";
   private readonly DEFAULT_FROM_ADDRESS =
-    "MedClinic <no-reply@your-domain.com>";
+    "MedClinic <no-reply@mg.metaestetics.net>";
 
   /**
    * Constructor for PractitionerInviteMailingService
@@ -78,7 +78,7 @@ export class PractitionerInviteMailingService extends BaseMailingService {
     data: PractitionerInviteEmailData
   ): Promise<mailgun.messages.SendResponse> {
     try {
-      console.log(
+      Logger.info(
         "[PractitionerInviteMailingService] Sending invitation email to",
         data.token.email
       );
@@ -126,6 +126,18 @@ export class PractitionerInviteMailingService extends BaseMailingService {
         currentYear,
       };
 
+      // Debug log for template variables (excluding token for security)
+      Logger.info("[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,
       };
 
+      Logger.info(
+        "[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
@@ -154,9 +176,12 @@ export class PractitionerInviteMailingService extends BaseMailingService {
 
       return result;
     } catch (error) {
-      console.error(
+      Logger.error(
         "[PractitionerInviteMailingService] Error sending invitation email:",
-        error
+        {
+          error: error instanceof Error ? error.message : error,
+          stack: error instanceof Error ? error.stack : undefined,
+        }
       );
 
       // Log failure
@@ -187,12 +212,36 @@ export class PractitionerInviteMailingService extends BaseMailingService {
     fromAddress: string
   ): Promise<void> {
     try {
-      console.log(
+      Logger.info(
         "[PractitionerInviteMailingService] Handling token creation event for token:",
         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
+      Logger.info(
+        `[PractitionerInviteMailingService] Fetching practitioner data: ${tokenData.practitionerId}`
+      );
       const practitionerRef = this.db
         .collection(PRACTITIONERS_COLLECTION)
         .doc(tokenData.practitionerId);
@@ -203,8 +252,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`
+        );
+      }
+
+      Logger.info(
+        `[PractitionerInviteMailingService] Practitioner found: ${practitionerData.basicInfo.firstName} ${practitionerData.basicInfo.lastName}`
+      );
 
       // Get clinic data using constant and type
+      Logger.info(
+        `[PractitionerInviteMailingService] Fetching clinic data: ${tokenData.clinicId}`
+      );
       const clinicRef = this.db
         .collection(CLINICS_COLLECTION)
         .doc(tokenData.clinicId);
@@ -215,6 +276,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`
+        );
+      }
+
+      Logger.info(
+        `[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) {
+        Logger.warn(
+          "[PractitionerInviteMailingService] No fromAddress provided, using default"
+        );
+        fromAddress = this.DEFAULT_FROM_ADDRESS;
+      }
 
       // Prepare email data using typed data
       const emailData: PractitionerInviteEmailData = {
@@ -233,22 +314,31 @@ 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,
         },
       };
 
+      Logger.info(
+        "[PractitionerInviteMailingService] Email data prepared, sending invitation"
+      );
+
       // Send the invitation email
       await this.sendInvitationEmail(emailData);
 
-      console.log(
+      Logger.info(
         "[PractitionerInviteMailingService] Invitation email sent successfully"
       );
     } catch (error) {
-      console.error(
+      Logger.error(
         "[PractitionerInviteMailingService] Error handling token creation event:",
-        error
+        {
+          error: error instanceof Error ? error.message : error,
+          stack: error instanceof Error ? error.stack : undefined,
+        }
       );
       throw error;
     }