@b2y/email-service 1.0.0

package/EmailService.js

@@ -0,0 +1,20 @@
+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/README.md

@@ -0,0 +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

package/config.js

@@ -0,0 +1,9 @@
+// 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/index.js

@@ -0,0 +1,23 @@
+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
+};

package/logger.js

@@ -0,0 +1,81 @@
+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/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@b2y/email-service",
+  "version": "1.0.0",
+  "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"
+  }
+}

package/providers/BaseProvider.js

@@ -0,0 +1,10 @@
+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;

package/providers/NodemailerProvider.js

@@ -0,0 +1,40 @@
+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/providers/SendgridProvider.js

@@ -0,0 +1,33 @@
+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;

package/server.js

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,7 @@
+<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

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

package/utils/TemplateEngine.js

@@ -0,0 +1,86 @@
+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;