@b2y/email-service 1.0.2 → 1.0.3

package/Config.js

@@ -0,0 +1,41 @@
+// config.js
+require('dotenv').config();
+const Config = {
+  // Email Provider Configuration
+  emailProvider: process.env.EMAIL_PROVIDER,
+  
+  // Nodemailer Configuration
+  emailService: process.env.EMAIL_SERVICE,
+  emailHost: process.env.EMAIL_HOST,
+  smtpPort: process.env.SMTP_PORT,
+  emailUser: process.env.EMAIL_USERNAME,
+  emailPass: process.env.EMAIL_PASSWORD,
+  fromEmail: process.env.FROM_EMAIL,
+  
+  // SendGrid Configuration
+  sendGridApiKey: process.env.SENDGRID_API_KEY,
+  
+  // Postmark Configuration
+  postmarkApiKey: process.env.POSTMARK_API_KEY,
+  postmarkFromEmail: process.env.POSTMARK_FROM_EMAIL,
+  
+  // Amazon SES Configuration
+  awsRegion: process.env.AWS_REGION,
+  awsAccessKeyId: process.env.AWS_ACCESS_KEY_ID,
+  awsSecretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+  awsFromEmail: process.env.AWS_FROM_EMAIL,
+  
+  defaultLanguage: process.env.DEFAULT_LANGUAGE,
+  
+  // Database Configuration (if using database for templates)
+  dbHost: process.env.DB_HOST,
+  dbPort: process.env.DB_PORT,
+  dbName: process.env.DB_DATABASE,
+  dbUser: process.env.DB_USER,
+  dbPass: process.env.DB_PASSWORD,
+  dbschema:process.env.DB_SCHEMA,
+  dbssl:process.env.DBSSL,
+  
+};
+
+module.exports = Config;

package/Logger.js

@@ -0,0 +1,6 @@
+require('dotenv').config();
+const { createLogger } = require('b2y-logger');
+
+const logger = createLogger();
+
+module.exports = logger;

package/README.md

@@ -1,18 +1,18 @@
-# email-service
-
-A reusable, flexible Node.js email service supporting multiple providers like **Nodemailer (Gmail)** and **SendGrid**, with support for **dynamic HTML templates** using Handlebars.
-
-# Features
-
-- Common interface for multiple email providers
-- Supports Gmail via Nodemailer and SendGrid (easy to extend more)
-- Handlebars-based HTML templates with variables
-- Easily switch between providers without changing your code
-- Dynamic template loading from the filesystem
-- Configurable via environment variables or direct parameters
-
----
-
-# Installation
-
-npm install @ourgitname/email-service
+# email-service
+
+A reusable, flexible Node.js email service supporting multiple providers like **Nodemailer (Gmail)** and **SendGrid**, with support for **dynamic HTML templates** using Handlebars.
+
+# Features
+
+- Common interface for multiple email providers
+- Supports Gmail via Nodemailer and SendGrid (easy to extend more)
+- Handlebars-based HTML templates with variables
+- Easily switch between providers without changing your code
+- Dynamic template loading from the filesystem
+- Configurable via environment variables or direct parameters
+
+---
+
+# Installation
+
+npm install @ourgitname/email-service

package/index.js

@@ -1,23 +1,78 @@
-const BaseProvider = require('./providers/BaseProvider');
-const NodemailerProvider = require('./providers/NodemailerProvider');
-const SendgridProvider = require('./providers/SendgridProvider');
-const TemplateEngine = require('./utils/TemplateEngine');
-
-// Create a singleton instance of TemplateEngine for convenience
-const templateEngine = new TemplateEngine();
-
-const EmailService = require('./EmailService');
-
-module.exports = {
-  // Providers
-  BaseProvider,
-  NodemailerProvider,
-  SendgridProvider,
-  
-  // Template utilities
-  TemplateEngine,        // Export the class itself
-  templateEngine,        // Export a singleton instance
-  
-  // Service
-  EmailService
-};
+const BaseProvider = require('./providers/BaseProvider');
+const NodeMailerProvider = require('./providers/NodeMailerProvider');
+const SendgridProvider = require('./providers/SendgridProvider');
+const PostmarkProvider = require('./providers/PostmarkProvider');
+const AmazonSesProvider = require('./providers/AmazonSESProvider');
+const TemplateEngine = require('./utils/TemplateEngine');
+const EmailService = require('./service/EmailService');
+const Config = require('./Config');
+const logger = require('./Logger');
+const { sequelize, EmailTemplate } = require('./model/Connect');
+const { EmailProvider } = require('./enum/EmailProvider');
+const StatusMessage = require('./constants/StatusMessageConstants');
+// Initialize database connection
+async function initializeDatabase() {
+  try {
+    await sequelize.authenticate();
+    logger.info(StatusMessage.DB_CONNECTION_SUCCESS);
+    return { EmailTemplate };
+  } catch (error) {
+    logger.error(StatusMessage.DB_CONNECTION_FAILED, error);
+    throw error;
+  }
+}
+
+// Factory function to create email provider
+function createEmailProvider() {
+  const provider = (Config.emailProvider || '').toLowerCase().trim();
+  
+  switch (provider) {
+    case EmailProvider.NODE_MAILER:
+      return new NodeMailerProvider();
+    case EmailProvider.SENDGRID:
+      return new SendgridProvider();
+    case EmailProvider.POSTMARK:
+      return new PostmarkProvider();
+    case EmailProvider.AMAZON_SES:
+      return new AmazonSesProvider();
+    default:
+      logger.warn(StatusMessage.PROVIDER_DEFAULT_FALLBACK);
+      return new NodeMailerProvider();
+  }
+}
+
+// Factory function to create email service
+async function createEmailService(options = {}) {
+  try {
+    const provider = options.provider || createEmailProvider();
+    const dbClient = options.dbClient || await initializeDatabase();
+    
+    return new EmailService(provider, dbClient);
+  } catch (error) {
+    logger.error(`Failed to create email service: ${error.message}`);
+    throw error;
+  }
+}
+
+// Create a singleton instance
+let defaultEmailService;
+async function getEmailService() {
+  if (!defaultEmailService) {
+    defaultEmailService = await createEmailService();
+  }
+  return defaultEmailService;
+}
+
+module.exports = {
+  BaseProvider,
+  NodeMailerProvider,
+  SendgridProvider,
+  PostmarkProvider,
+  AmazonSesProvider,
+  EmailService,
+  TemplateEngine,
+  createEmailProvider,
+  createEmailService,
+  getEmailService,
+  Config
+};

package/package.json

@@ -1,43 +1,49 @@
-{
-  "name": "@b2y/email-service",
-  "version": "1.0.2",
-  "main": "index.js",
-  "exports": {
-    ".": "./index.js",
-    "./providers": "./providers/index.js",
-    "./providers/base": "./providers/BaseProvider.js",
-    "./providers/nodemailer": "./providers/NodemailerProvider.js",
-    "./providers/sendgrid": "./providers/SendgridProvider.js",
-    "./utils/templateEngine": "./utils/TemplateEngine.js",
-    "./EmailService": "./EmailService.js"
-  },
-  "files": [
-    "providers/",
-    "templates/",
-    "utils/",
-    "*.js"
-  ],
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "start": "node test.js"
-  },
-  "author": "",
-  "license": "ISC",
-  "description": "A flexible email service with support for multiple providers and custom templates",
-  "keywords": [
-    "email",
-    "templates",
-    "nodemailer",
-    "sendgrid"
-  ],
-  "publishConfig": { 
-  "access": "public" 
- },
-  "dependencies": {
-    "@sendgrid/mail": "^8.1.5",
-    "dotenv": "^16.5.0",
-    "handlebars": "^4.7.8",
-    "log4js": "^6.9.1",
-    "nodemailer": "^6.10.0"
-  }
-}
+{
+  "name": "@b2y/email-service",
+  "version": "1.0.3",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./providers": "./providers/index.js",
+    "./providers/base": "./providers/BaseProvider.js",
+    "./providers/nodemailer": "./providers/NodeMailerProvider.js",
+    "./providers/sendgrid": "./providers/SendGridProvider.js",
+    "./utils/templateEngine": "./utils/TemplateEngine.js",
+    "./EmailService": "./service/EmailService.js"
+  },
+  "files": [
+    "providers/",
+    "templates/",
+    "utils/",
+    "*.js"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "node test.js"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": "A flexible email service with support for multiple providers and custom templates",
+  "keywords": [
+    "email",
+    "templates",
+    "nodemailer",
+    "sendgrid"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@aws-sdk/client-ses": "^3.957.0",
+    "@sendgrid/mail": "^8.1.5",
+    "b2y-logger": "^1.1.0",
+    "dotenv": "^16.5.0",
+    "handlebars": "^4.7.8",
+    "log4js": "^6.9.1",
+    "nodemailer": "^6.10.0",
+    "pg": "^8.16.3",
+    "pg-hstore": "^2.3.4",
+    "postmark": "^4.0.5",
+    "sequelize": "^6.37.7"
+  }
+}

package/providers/AmazonSESProvider.js

@@ -0,0 +1,77 @@
+// providers/AmazonSES.js
+const { SESClient, SendEmailCommand } = require('@aws-sdk/client-ses');
+const BaseProvider = require('./BaseProvider');
+const Config = require('../Config');
+const logger = require('../Logger');
+const StatusMessage = require('../constants/StatusMessageConstants');
+const { EmailProvider } = require('../enum/EmailProvider');
+
+class AmazonSESProvider extends BaseProvider {
+  constructor() {
+    super();
+    this.client = new SESClient({
+      region: Config.awsRegion,
+      credentials: {
+        accessKeyId: Config.awsAccessKeyId,
+        secretAccessKey: Config.awsSecretAccessKey
+      }
+    });
+  }
+
+  async sendEmail(options) {
+    try {
+      this.validateEmailOptions(options);
+      
+      const toAddresses = this.formatRecipients(options.to);
+      const ccAddresses = options.cc ? this.formatRecipients(options.cc) : [];
+      const bccAddresses = options.bcc ? this.formatRecipients(options.bcc) : [];
+      
+      const params = {
+        Source: options.from || Config.awsFromEmail,
+        Destination: {
+          ToAddresses: toAddresses,
+          ...(ccAddresses.length > 0 && { CcAddresses: ccAddresses }),
+          ...(bccAddresses.length > 0 && { BccAddresses: bccAddresses })
+        },
+        Message: {
+          Subject: {
+            Data: options.subject,
+            Charset: 'UTF-8'
+          },
+          Body: {
+            Html: {
+              Data: options.html,
+              Charset: 'UTF-8'
+            }
+          }
+        }
+      };
+
+      // Add attachments if present (SES requires using SendRawEmail for attachments)
+      if (options.attachments && options.attachments.length > 0) {
+        logger.warn('SES provider: Attachments require SendRawEmail. Consider implementing raw email support.');
+      }
+
+      const command = new SendEmailCommand(params);
+      const result = await this.client.send(command);
+      
+      logger.info('Email sent successfully via Amazon SES', {
+        messageId: result.MessageId,
+        recipients: { to: options.to, cc: options.cc, bcc: options.bcc },
+        tenantId: options.tenantId
+      });
+      
+      return {
+        success: true,
+        messageId: result.MessageId,
+        provider: EmailProvider.SES,
+        tenantId: options.tenantId
+      };
+    } catch (error) {
+      logger.error(`Amazon SES failed to send email: ${error.message}`);
+      throw new Error(`${StatusMessage.AMAZON_SES_SEND_ERROR}: ${error.message}`);
+    }
+  }
+}
+
+module.exports = AmazonSESProvider;

package/providers/BaseProvider.js

@@ -1,10 +1,74 @@
-const logger = require('../logger'); 
-
-class BaseProvider {
-  async sendEmail(options) {
-    logger.error('sendEmail method not implemented in BaseProvider');
-    throw new Error('sendEmail method not implemented');
-  }
-}
-
-module.exports = BaseProvider;
+// providers/BaseProvider.js
+const logger = require('../Logger');
+const StatusMessage = require('../constants/StatusMessageConstants');
+class BaseProvider {
+  constructor() {
+    if (new.target === BaseProvider) {
+      throw new Error(StatusMessage.CANNOT_INSTANTIATE_BASE);
+    }
+  }
+
+  async sendEmail(options) {
+    logger.error('sendEmail method not implemented in BaseProvider');
+    throw new Error(StatusMessage.PROVIDER_NOT_IMPLEMENTED);
+  }
+  
+  validateEmailOptions(options) {
+    const { to, subject, html, from } = options;
+    
+    if (!to || (Array.isArray(to) && to.length === 0)) {
+      throw new Error(StatusMessage.RECIPIENTS_REQUIRED);
+    }
+    
+    if (!subject) {
+      throw new Error(StatusMessage.SUBJECT_REQUIRED);
+    }
+    
+    if (!html) {
+      throw new Error(StatusMessage.HTML_CONTENT_REQUIRED);
+    }
+    
+    return true;
+  }
+  
+  formatRecipients(recipients) {
+    if (!recipients) return [];
+    
+    if (typeof recipients === 'string') {
+      return recipients.split(',').map(r => r.trim());
+    }
+    
+    if (Array.isArray(recipients)) {
+      return recipients;
+    }
+    
+    return [];
+  }
+
+  buildMailOptions(options) {
+    const { to, cc, bcc, subject, html, from, attachments } = options;
+    
+    const mailOptions = {
+      from,
+      to: this.formatRecipients(to),
+      subject,
+      html,
+    };
+    
+    if (cc && cc.length > 0) {
+      mailOptions.cc = this.formatRecipients(cc);
+    }
+    
+    if (bcc && bcc.length > 0) {
+      mailOptions.bcc = this.formatRecipients(bcc);
+    }
+    
+    if (attachments && attachments.length > 0) {
+      mailOptions.attachments = attachments;
+    }
+    
+    return mailOptions;
+  }
+}
+
+module.exports = BaseProvider;

package/providers/NodeMailerProvider.js

@@ -0,0 +1,53 @@
+// providers/NodeMailerProvider.js
+const nodemailer = require('nodemailer');
+const BaseProvider = require('./BaseProvider');
+const Config = require('../Config');
+const logger = require('../Logger');
+const StatusMessage = require('../constants/StatusMessageConstants');
+const { EmailProvider } = require('../enum/EmailProvider');
+
+class NodeMailerProvider extends BaseProvider {
+  constructor() {
+    super();
+    this.transporter = nodemailer.createTransport({ 
+      service: Config.emailService,
+      host: Config.emailHost,
+      port: Config.smtpPort,
+      secure: Config.smtpPort,
+      auth: {
+        user: Config.emailUser,
+        pass: Config.emailPass,
+      },
+    });
+  }
+
+  async sendEmail(options) {
+    try {
+      this.validateEmailOptions(options);
+      const mailOptions = this.buildMailOptions({
+        ...options,
+        from: options.from || Config.emailUser
+      });
+      
+      const result = await this.transporter.sendMail(mailOptions);
+      
+      logger.info('Email sent successfully via Nodemailer', {
+        messageId: result.messageId,
+        recipients: { to: options.to, cc: options.cc, bcc: options.bcc },
+        tenantId: options.tenantId
+      });
+      
+      return {
+        success: true,
+        messageId: result.messageId,
+        provider: EmailProvider.NODE_MAILER,
+        tenantId: options.tenantId
+      };
+    } catch (error) {
+      logger.error(`Nodemailer failed to send email: ${error.message}`);
+      throw new Error(`${StatusMessage.NODEMAILER_SEND_ERROR}: ${error.message}`);
+    }
+  }
+}
+
+module.exports = NodeMailerProvider;

package/providers/PostmarkProvider.js

@@ -0,0 +1,62 @@
+// providers/PostmarkProvider.js
+const postmark = require('postmark');
+const BaseProvider = require('./BaseProvider');
+const Config = require('../Config');
+const logger = require('../Logger');
+const StatusMessage = require('../constants/StatusMessageConstants');
+const { EmailProvider } = require('../enum/EmailProvider');
+
+class PostmarkProvider extends BaseProvider {
+  constructor() {
+    super();
+    this.client = new postmark.Client(Config.postmarkApiKey);
+  }
+
+  async sendEmail(options) {
+    try {
+      this.validateEmailOptions(options);
+      const mailOptions = {
+        From: options.from || Config.postmarkFromEmail,
+        To: this.formatRecipients(options.to).join(','),
+        Subject: options.subject,
+        HtmlBody: options.html,
+      };
+      
+      if (options.cc && options.cc.length > 0) {
+        mailOptions.Cc = this.formatRecipients(options.cc).join(',');
+      }
+      
+      if (options.bcc && options.bcc.length > 0) {
+        mailOptions.Bcc = this.formatRecipients(options.bcc).join(',');
+      }
+      
+      if (options.attachments && options.attachments.length > 0) {
+        mailOptions.Attachments = options.attachments.map(att => ({
+          Name: att.filename,
+          Content: att.content,
+          ContentType: att.contentType
+        }));
+      }
+      
+      const result = await this.client.sendEmail(mailOptions);
+      
+      logger.info('Email sent successfully via Postmark', {
+        messageId: result.MessageID,
+        recipients: { to: options.to, cc: options.cc, bcc: options.bcc },
+        tenantId: options.tenantId
+      });
+      
+      return {
+        success: true,
+        messageId: result.MessageID,
+        provider: EmailProvider.POSTMARK,
+        tenantId: options.tenantId
+      };
+    } catch (error) {
+      logger.error(`Postmark failed to send email: ${error.message}`);
+      throw new Error(`${StatusMessage.POSTMARK_SEND_ERROR}: ${error.message}`);
+    }
+  }
+}
+
+module.exports = PostmarkProvider;

package/providers/SendgridProvider.js

@@ -1,33 +1,60 @@
-const sgMail = require('@sendgrid/mail');
-const BaseProvider = require('./BaseProvider');
-const config = require('../config');
-const logger = require('../logger'); 
-
-class SendGridProvider extends BaseProvider {
-  constructor() {
-    super();
-    sgMail.setApiKey(config.sendGridApiKey);
-  }
-
-  async sendEmail({ to, subject, html }) {
-    if (!to || !subject || !html) {
-      logger.error('Missing required email fields: to, subject, or html');
-      throw new Error('Missing required email fields: to, subject, or html');
-    }
-  
-    try {
-      return await sgMail.send({
-        to,
-        from: config.emailUser,
-        subject,
-        html,
-      });
-    } catch (error) {
-      logger.error(`SendGrid failed to send email: ${error.message}`);
-      throw new Error(`SendGrid failed to send email: ${error.message}`);
-    }
-  }
-  
-}
-
-module.exports = SendGridProvider;
+// providers/SendgridProvider.js
+const sgMail = require('@sendgrid/mail');
+const BaseProvider = require('./BaseProvider');
+const Config = require('../Config');
+const logger = require('../Logger');
+const { EmailProvider } = require('../enum/EmailProvider');
+
+class SendgridProvider extends BaseProvider {
+  constructor() {
+    super();
+    sgMail.setApiKey(Config.sendGridApiKey);
+  }
+
+  async sendEmail({ tenantId, to, cc, bcc, subject, html, from, attachments }) {
+    try {
+      this.validateEmailOptions({ to, subject, html, from });
+      
+      const mailOptions = {
+        to: this.formatRecipients(to),
+        from: Config.fromEmail,
+        subject,
+        html,
+      };
+      
+      if (cc && cc.length > 0) {
+        mailOptions.cc = this.formatRecipients(cc);
+      }
+      
+      if (bcc && bcc.length > 0) {
+        mailOptions.bcc = this.formatRecipients(bcc);
+      }
+      
+      if (attachments && attachments.length > 0) {
+        mailOptions.attachments = attachments;
+      }
+      
+      const result = await sgMail.send(mailOptions);
+      
+      logger.info('Email sent successfully via SendGrid', {
+        messageId: result[0].headers['x-message-id'],
+        recipients: { to, cc, bcc },
+        tenantId
+      });
+      
+      return {
+        success: true,
+        messageId: result[0].headers['x-message-id'],
+        provider: EmailProvider.SENDGRID,
+        tenantId
+      };
+      
+    } catch (error) {
+      logger.error(`SendGrid failed to send email : ${error.message}`);
+      throw new Error(`${StatusMessage.SENDGRID_SEND_ERROR}: ${error.message}`);
+    }
+  }
+}
+
+module.exports = SendgridProvider;
+

package/utils/TemplateEngine.js

@@ -1,86 +1,99 @@
-const fs = require('fs');
-const path = require('path');
-const handlebars = require('handlebars');
-const logger = require('../logger');
-
-class TemplateEngine {
-  constructor(options = {}) {
-    // Default templates directory in the module
-    this.defaultTemplateDir = path.join(__dirname, '..', 'templates');
-    
-    // Custom templates directory provided by the user
-    this.customTemplateDir = options.customTemplateDir || null;
-    
-    // Array to store additional template directories
-    this.additionalTemplateDirs = [];
-  }
-
-  // Add a new template directory to search for templates
-  addTemplateDirectory(dirPath, prepend = false) {
-    if (!fs.existsSync(dirPath)) {
-      logger.warn(`Template directory does not exist: ${dirPath}`);
-      return false;
-    }
-
-    if (prepend) {
-      this.additionalTemplateDirs.unshift(dirPath);
-    } else {
-      this.additionalTemplateDirs.push(dirPath);
-    }
-    
-    logger.info(`Added template directory: ${dirPath}`);
-    return true;
-  }
-
-  // Reset all additional template directories
-  resetTemplateDirectories() {
-    this.additionalTemplateDirs = [];
-    logger.info('Reset additional template directories');
-  }
-
-  compileTemplate(templateName, variables) {
-    let templateContent;
-    let templatePath;
-    
-    // First try to find the template in the additional directories
-    for (const dir of this.additionalTemplateDirs) {
-      templatePath = path.join(dir, `${templateName}.html`);
-      if (fs.existsSync(templatePath)) {
-        templateContent = fs.readFileSync(templatePath, 'utf-8');
-        logger.info(`Using template from additional directory: ${templatePath}`);
-        break;
-      }
-    }
-    
-    // Then try the custom directory if no template found yet
-    if (!templateContent && this.customTemplateDir) {
-      templatePath = path.join(this.customTemplateDir, `${templateName}.html`);
-      if (fs.existsSync(templatePath)) {
-        templateContent = fs.readFileSync(templatePath, 'utf-8');
-        logger.info(`Using custom template: ${templatePath}`);
-      }
-    }
-    
-    // Finally try the default directory if still no template found
-    if (!templateContent) {
-      templatePath = path.join(this.defaultTemplateDir, `${templateName}.html`);
-      if (fs.existsSync(templatePath)) {
-        templateContent = fs.readFileSync(templatePath, 'utf-8');
-        logger.info(`Using default template: ${templatePath}`);
-      } else {
-        logger.error(`Template "${templateName}" not found in any configured template directory`);
-        throw new Error(`Template "${templateName}" not found`);
-      }
-    }
-    
-    try {
-      const template = handlebars.compile(templateContent);
-      return template(variables);
-    } catch (err) {
-      logger.error(`Error compiling template "${templateName}": ${err.message}`);
-      throw new Error(`Error compiling template "${templateName}": ${err.message}`);
-    }
-  }
-}
-
-module.exports = TemplateEngine;
+const handlebars = require('handlebars');
+const logger = require('../Logger');
+
+class TemplateEngine {
+  constructor(dbClient) {
+    if (!dbClient) throw new Error(StatusMessage.DB_CLIENT_REQUIRED);
+    this.EmailTemplate = dbClient.EmailTemplate;
+    this.registerHelpers();
+  }
+
+  registerHelpers() {
+    handlebars.registerHelper('eq', (a, b) => a === b);
+    handlebars.registerHelper('ne', (a, b) => a !== b);
+    handlebars.registerHelper('gt', (a, b) => a > b);
+    handlebars.registerHelper('lt', (a, b) => a < b);
+    handlebars.registerHelper('uppercase', (str) => str ? str.toUpperCase() : '');
+    handlebars.registerHelper('lowercase', (str) => str ? str.toLowerCase() : '');
+    handlebars.registerHelper('formatDate', (date) => {
+      if (!date) return '';
+      return new Date(date).toLocaleDateString();
+    });
+  }
+
+  async getTemplateFromDB(templateName, tenantId, langCode) {
+    try {
+      logger.info(`Fetching template: ${templateName} in language: ${langCode}`);
+      const template = await this.EmailTemplate.findOne({
+        where: {
+          TemplateName: templateName,
+          TenantId: tenantId,
+          LangCode: langCode
+        }
+      });
+
+      if (!template) {
+        logger.warn(`Template "${templateName}" not found in language ${langCode}`);    
+        const defaultTemplate = await this.EmailTemplate.findOne({
+          where: {
+            TemplateName: templateName,
+            TenantId: tenantId,
+            LangCode: langCode
+          }
+        });
+
+        if (!defaultTemplate) {
+          throw new Error(`Template "${templateName}" not found in any language`);
+        }
+        
+        return {
+          subject: defaultTemplate.Subject,
+          body: defaultTemplate.Body
+        };
+      }
+
+      return {
+        subject: template.Subject,
+        body: template.Body
+      };
+    } catch (error) {
+      logger.error(`Error fetching template from DB: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async compileTemplate(templateName, variables = {}, tenantId, langCode) {
+    try {
+      logger.info(`Compiling template: ${templateName} in language: ${langCode}`);
+      
+      const templateData = await this.getTemplateFromDB(templateName, tenantId, langCode);
+      
+      const subjectTemplate = handlebars.compile(templateData.subject);
+      const bodyTemplate = handlebars.compile(templateData.body);
+      
+      return {
+        subject: subjectTemplate(variables),
+        body: bodyTemplate(variables)
+      };
+    } catch (error) {
+      logger.error(`Error compiling template "${templateName}": ${error.message}`);
+      throw error;
+    }
+  }
+
+  replacePlaceholders(content, placeholders = {}) {
+    if (!content || typeof content !== 'string') {
+      return content;
+    }
+
+    try {
+      const template = handlebars.compile(content);
+      return template(placeholders);
+    } catch (err) {
+      logger.error(`Error replacing placeholders: ${err.message}`);
+      return content;
+    }
+  }
+}
+
+module.exports = TemplateEngine;

package/EmailService.js

@@ -1,20 +0,0 @@
-const TemplateEngine = require('./utils/TemplateEngine');
-
-class EmailService {
-  constructor(options = {}) {
-    if (!options.provider) throw new Error('Email provider is required');
-    this.provider = options.provider;
-    
-    // Create the template engine with custom directory if provided
-    this.templateEngine = new TemplateEngine({
-      customTemplateDir: options.customTemplateDir
-    });
-  }
-
-  async sendTemplateEmail(templateName, to, subject, variables = {}) {
-    const html = this.templateEngine.compileTemplate(templateName, variables);
-    return this.provider.sendEmail({ to, subject, html });
-  }
-}
-
-module.exports = EmailService;

package/config.js

@@ -1,9 +0,0 @@
-// config.js
-require('dotenv').config();
-
-module.exports = {
-  emailService: process.env.EMAIL_SERVICE,
-  emailUser: process.env.EMAIL_USER,
-  emailPass: process.env.EMAIL_PASS,
-  sendGridApiKey: process.env.SENDGRID_API_KEY,
-};

package/logger.js

@@ -1,81 +0,0 @@
-const log4js = require('log4js');
-const path = require('path');
-const fs = require('fs');
-
-
-// Get log directory from environment variable or use default
-const LOG_DIR = process.env.LOG_DIR || path.join(process.cwd(), '..', 'logs');
-
-// Ensure the log directory exists
-if (!fs.existsSync(LOG_DIR)) {
-  fs.mkdirSync(LOG_DIR, { recursive: true });
-}
-
-log4js.configure({
-  appenders: {
-    console: { type: 'console' },
-    combined: {
-      type: 'file',
-      filename: path.join(LOG_DIR, 'EmailTemplate.log'),
-      maxLogSize: 5 * 1024 * 1024, // 5MB
-      backups: 100,
-      compress: true,
-      keepFileExt: true
-    }
-  },
-  categories: { default: { appenders: ['console', 'combined'], level: 'debug' } }
-});
-
-// Function to get the caller file name
-const getCallerFile = () => {
-  const originalFunc = Error.prepareStackTrace;
-  let callerFile;
-  
-  try {
-    const err = new Error();
-    Error.prepareStackTrace = (_, stack) => stack;
-    const stack = err.stack;
-
-    for (let i = 0; i < stack.length; i++) {
-      const fileName = stack[i].getFileName();
-      if (fileName && !fileName.includes('logger.js') && !fileName.includes('node_modules')) {
-        callerFile = path.basename(fileName);
-        break;
-      }
-    }
-  } catch (error) {
-    callerFile = 'unknown';
-  }
-  
-  Error.prepareStackTrace = originalFunc;
-  return callerFile || 'unknown';
-};
-
-// Custom logger function to attach file name dynamically
-const log = (level, message, data) => {
-  const fileName = getCallerFile();
-  log4js.getLogger(fileName)[level](message, data);
-};
-
-module.exports = {
-  debug: (message, data) => log('debug', message, data),
-  info: (message, data) => log('info', message, data),
-  warn: (message, data) => log('warn', message, data),
-  error: (message, errorOrData) => {
-    let enhancedData = errorOrData;
-
-    if (errorOrData instanceof Error) {
-      const { file, line, column } = getErrorDetails(errorOrData);
-      enhancedData = {
-        error: errorOrData.message,
-        stack: errorOrData.stack,
-        location: `${file}:${line}:${column}`
-      };
-    } else if (errorOrData && errorOrData.error instanceof Error) {
-      const { file, line, column } = getErrorDetails(errorOrData.error);
-      enhancedData = { ...errorOrData, location: `${file}:${line}:${column}` };
-    }
-
-    log('error', message, enhancedData);
-  }
-};

package/providers/NodemailerProvider.js

@@ -1,40 +0,0 @@
-const nodemailer = require('nodemailer');
-const BaseProvider = require('./BaseProvider');
-const config = require('../config');
-const logger = require('../logger'); 
-
-class NodemailerProvider extends BaseProvider {
-  constructor() {
-    super();
-    this.transporter = nodemailer.createTransport({
-      service: config.emailService,
-      auth: {
-        user: config.emailUser,
-        pass: config.emailPass,
-      },
-    });
-  }
-  
-
-  async sendEmail({ to, subject, html }) {
-    if (!to || !subject || !html) {
-      logger.error('Missing required email fields: to, subject, or html');
-      throw new Error('Missing required email fields: to, subject, or html');
-    }
-  
-    try {
-      return await this.transporter.sendMail({
-        from: config.emailUser,
-        to,
-        subject,
-        html,
-      });
-    } catch (error) {
-      logger.error(`Nodemailer failed to send email: ${error.message}`);
-      throw new Error(`Nodemailer failed to send email: ${error.message}`);
-    }
-  }
-  
-}
-
-module.exports = NodemailerProvider;

package/server.js

@@ -1,15 +0,0 @@
-const { compileTemplate } = require('./utils/TemplateEngine');
-
-class EmailService {
-  constructor(provider) {
-    if (!provider) throw new Error('Email provider is required');
-    this.provider = provider;
-  }
-
-  async sendTemplateEmail(templateName, to, subject, variables = {}) {
-    const html = compileTemplate(templateName, variables);
-    return this.provider.sendEmail({ to, subject, html });
-  }
-}
-
-module.exports = EmailService;

package/templates/resetPassword.html

@@ -1,7 +0,0 @@
-<p>Dear User,</p>
-<p>Your OTP for password reset is: <strong>{{otp}}</strong></p>
-<p>This OTP is valid for 10 minutes.</p>
-<p>If you did not request this, please ignore this email.</p>
-<br>
-<p>Best Regards,</p>
-<p>TestCompany</p>

package/templates/welcome.html

@@ -1,6 +0,0 @@
-<html>
-  <body>
-    <h1>Welcome, {{name}}!</h1>
-    <p>Thanks for joining {{company}}.</p>
-  </body>
-</html>