core-services-sdk 1.2.4 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-services-sdk",
-  "version": "1.2.4",
+  "version": "1.3.1",
   "main": "src/index.js",
   "type": "module",
   "scripts": {
@@ -20,9 +20,13 @@
   "description": "",
   "dependencies": {
     "amqplib": "^0.10.8",
+    "aws-sdk": "^2.1692.0",
+    "dot": "^1.1.3",
     "http-status": "^2.1.0",
     "mongodb": "^6.17.0",
     "node-fetch": "^3.3.2",
+    "nodemailer": "^7.0.5",
+    "nodemailer-sendgrid-transport": "^0.2.0",
     "uuid": "^11.1.0",
     "xml2js": "^0.6.2"
   },

package/src/index.js

@@ -4,4 +4,12 @@ export * from './mongodb/connect.js'
 export * from './rabbit-mq/index.js'
 export * as http from './http/http.js'
 export * from './http/responseType.js'
+export { initMailer } from './mailer/index.js'
 export { HttpError } from './http/HttpError.js'
+export { Mailer } from './mailer/mailer.service.js'
+export { TransportFactory } from './mailer/transport.factory.js'
+export {
+  isItFile,
+  loadTemplates,
+  getTemplateContent,
+} from './templates/template-loader.js'

package/src/mailer/index.js

@@ -0,0 +1,9 @@
+import { Mailer } from './mailer.service.js'
+import { TransportFactory } from './transport.factory.js'
+
+export const initMailer = (config) => {
+  const transport = TransportFactory.create(config)
+  const mailer = new Mailer(transport)
+
+  return mailer
+}

package/src/mailer/mailer.service.js

@@ -0,0 +1,28 @@
+export class Mailer {
+  /**
+   * @param {object} transporter - Nodemailer transporter instance
+   */
+  constructor(transporter) {
+    if (!transporter || typeof transporter.sendMail !== 'function') {
+      throw new Error('Invalid transporter')
+    }
+    this.transporter = transporter
+  }
+
+  /**
+   * Send an email
+   */
+  async send({ to, subject, html, text, from, cc, bcc, replyTo, attachments }) {
+    return this.transporter.sendMail({
+      to,
+      cc,
+      bcc,
+      text,
+      from,
+      html,
+      subject,
+      replyTo,
+      attachments,
+    })
+  }
+}

package/src/mailer/transport.factory.js

@@ -0,0 +1,45 @@
+import aws from 'aws-sdk'
+import nodemailer from 'nodemailer'
+import sgTransport from 'nodemailer-sendgrid-transport'
+
+export class TransportFactory {
+  /**
+   * @param {object} config
+   * @returns {import('nodemailer').Transporter}
+   */
+  static create(config) {
+    switch (config.type) {
+      case 'smtp':
+        return nodemailer.createTransport({
+          host: config.host,
+          port: config.port,
+          secure: config.secure,
+          auth: config.auth,
+        })
+
+      case 'gmail':
+        return nodemailer.createTransport({
+          service: 'gmail',
+          auth: config.auth,
+        })
+
+      case 'sendgrid':
+        return nodemailer.createTransport(
+          sgTransport({
+            auth: { api_key: config.apiKey },
+          }),
+        )
+
+      case 'ses':
+        const ses = new aws.SES({
+          accessKeyId: config.accessKeyId,
+          secretAccessKey: config.secretAccessKey,
+          region: config.region,
+        })
+        return nodemailer.createTransport({ SES: { ses, aws } })
+
+      default:
+        throw new Error(`Unsupported transport type: ${config.type}`)
+    }
+  }
+}

package/src/templates/template-loader.js

@@ -0,0 +1,70 @@
+import dot from 'dot'
+import { lstat, readFile } from 'fs/promises'
+
+const { compile } = dot
+
+/**
+ * Check if the input is a file path.
+ * @param {string} filePathOrString - Either a string of template content or a file path to a template.
+ * @returns {Promise<boolean>} - True if it's a valid file path, false otherwise.
+ */
+export const isItFile = async (filePathOrString) => {
+  try {
+    const stats = await lstat(filePathOrString)
+    return stats.isFile()
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Get template content from string or file.
+ * @param {string} maybeFilePathOrString - Raw template string or path to template file.
+ * @returns {Promise<string>} - The resolved content of the template.
+ */
+export const getTemplateContent = async (maybeFilePathOrString) => {
+  return (await isItFile(maybeFilePathOrString))
+    ? readFile(maybeFilePathOrString, 'utf-8')
+    : maybeFilePathOrString
+}
+
+/**
+ * Load and compile templates using dot.js
+ *
+ * @param {Record<string, string>} templateSet - An object with keys as template names (e.g. "subject", "html") and values as either raw strings or file paths.
+ * @returns {Promise<Record<string, (params: Record<string, any>) => string>>} - A map of compiled template functions.
+ *
+ * @example
+ * // Inline templates
+ * const templates = await loadTemplates({
+ *   from: '"{{=it.name}}" <{{=it.email}}>',
+ *   html: '<div>Hello {{=it.name}}, welcome aboard!</div>',
+ *   subject: 'Welcome to {{=it.appName}}',
+ * })
+ *
+ * const result = {
+ *   from: templates.from({ name: 'ChatGPT', email: 'chat@gpt.com' }),
+ *   html: templates.html({ name: 'Haim' }),
+ *   subject: templates.subject({ appName: 'Authenzify' }),
+ * }
+ * console.log(result)
+ *
+ * @example
+ * // Template loaded from files
+ * const templates = await loadTemplates({
+ *   from: './email-templates/from.ejs',
+ *   html: './email-templates/body.html',
+ *   subject: './email-templates/subject.ejs',
+ * })
+ *
+ * const output = templates.subject({ appName: 'MyApp' })
+ */
+export const loadTemplates = async (templateSet) => {
+  const entries = await Promise.all(
+    Object.entries(templateSet).map(async ([key, value]) => {
+      const content = await getTemplateContent(value)
+      return [key, compile(content)]
+    }),
+  )
+  return Object.fromEntries(entries)
+}

package/tests/mailer.integration.test.js

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest'
+import nodemailer from 'nodemailer'
+import { Mailer } from '../src/mailer/mailer.service.js'
+
+describe('Mailer (integration)', () => {
+  it('should send email using ethereal SMTP', async () => {
+    // Create ethereal test account
+    const testAccount = await nodemailer.createTestAccount()
+
+    // Create Nodemailer transporter for ethereal
+    const transporter = nodemailer.createTransport({
+      host: testAccount.smtp.host,
+      port: testAccount.smtp.port,
+      secure: testAccount.smtp.secure,
+      auth: {
+        user: testAccount.user,
+        pass: testAccount.pass,
+      },
+    })
+
+    // Create Mailer instance
+    const mailer = new Mailer(transporter)
+
+    // Send test email
+    const result = await mailer.send({
+      to: 'recipient@example.com',
+      text: 'Hello from test - plain text',
+      from: '"My App" <no-reply@example.com>',
+      subject: 'core-service-sdk:Integration Test Email',
+      html: '<h1>Hello from core-service-sdk test</h1><p>This is a core-service-sdk</p>',
+      cc: '',
+      bcc: '',
+      replyTo: '',
+      attachments: '',
+    })
+
+    // Assert response
+    expect(result.messageId).toBeDefined()
+
+    // Print preview URL (clickable in terminal)
+    const previewUrl = nodemailer.getTestMessageUrl(result)
+    console.log(`📨 Preview this email: ${previewUrl}`)
+
+    expect(previewUrl).toMatch(/^https:\/\/ethereal\.email/)
+  })
+})

package/tests/mailer.unit.test.js

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+const mockTransport = {
+  sendMail: vi.fn(),
+}
+
+// Dynamically mock the TransportFactory module and turn .create into a spy
+vi.mock('../src/mailer/transport.factory.js', async () => {
+  const actual = await vi.importActual('../src/mailer/transport.factory.js')
+  return {
+    ...actual,
+    TransportFactory: {
+      create: vi.fn(() => mockTransport),
+    },
+  }
+})
+
+// Mock Mailer class
+vi.mock('../src/mailer/mailer.service.js', async () => {
+  const Mailer = vi.fn().mockImplementation((transport) => ({
+    send: vi.fn((opts) => transport.sendMail(opts)),
+  }))
+  return { Mailer }
+})
+
+// Only now import code under test
+import { initMailer } from '../src/mailer/index.js'
+import { TransportFactory } from '../src/mailer/transport.factory.js'
+import { Mailer } from '../src/mailer/mailer.service.js'
+
+describe('initMailer', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('should create a Mailer instance with correct transport', () => {
+    const config = {
+      type: 'smtp',
+      host: 'host',
+      port: 587,
+      secure: false,
+      auth: { user: 'u', pass: 'p' },
+    }
+
+    const mailer = initMailer(config)
+
+    // Ensure TransportFactory.create was called
+    expect(TransportFactory.create).toHaveBeenCalledWith(config)
+
+    // Ensure Mailer was created with the mock transport
+    expect(Mailer).toHaveBeenCalledWith(mockTransport)
+
+    const emailOptions = {
+      to: 'a@b.com',
+      subject: 'Test',
+      html: '<b>Test</b>',
+      from: '"My App" <no-reply@example.com>',
+      cc: '',
+      bcc: '',
+      text: '',
+      replyTo: '',
+      attachments: '',
+    }
+
+    mailer.send(emailOptions)
+    expect(mockTransport.sendMail).toHaveBeenCalledWith(emailOptions)
+  })
+})

package/tests/template-loader.integration.test.js

@@ -0,0 +1,49 @@
+import { join } from 'path'
+import { tmpdir } from 'os'
+import { writeFile, rm, mkdir } from 'fs/promises'
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+
+import { loadTemplates } from '../src/templates/template-loader.js'
+
+const tempDir = join(tmpdir(), 'template-tests')
+
+const createTempTemplateFile = async (filename, content) => {
+  const filePath = join(tempDir, filename)
+  await writeFile(filePath, content, 'utf-8')
+  return filePath
+}
+
+describe('loadTemplates with real files', () => {
+  let subjectPath, htmlPath
+
+  beforeAll(async () => {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => {})
+    await mkdir(tempDir, { recursive: true })
+
+    subjectPath = await createTempTemplateFile(
+      'subject.dot',
+      'Hello {{=it.name}}',
+    )
+    htmlPath = await createTempTemplateFile(
+      'body.dot',
+      '<div>{{=it.body}}</div>',
+    )
+  })
+
+  afterAll(async () => {
+    await rm(tempDir, { recursive: true, force: true })
+  })
+
+  it('should correctly read and compile templates from file paths', async () => {
+    const templates = await loadTemplates({
+      subject: subjectPath,
+      html: htmlPath,
+    })
+
+    const subjectResult = templates.subject({ name: 'Alice' })
+    const htmlResult = templates.html({ body: 'Welcome!' })
+
+    expect(subjectResult).toBe('Hello Alice')
+    expect(htmlResult).toBe('<div>Welcome!</div>')
+  })
+})

package/tests/template-loader.unit.test.js

@@ -0,0 +1,63 @@
+import dot from 'dot'
+import * as fs from 'fs/promises'
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+import { loadTemplates } from '../src/templates/template-loader.js'
+
+vi.mock('fs/promises')
+
+describe('loadTemplates', () => {
+  // @ts-ignore
+  const mockCompile = vi.spyOn(dot, 'compile')
+
+  beforeEach(() => {
+    vi.resetAllMocks()
+  })
+
+  it('should compile inline template strings correctly', async () => {
+    const templates = {
+      subject: 'Hello {{=it.name}}',
+      html: '<div>{{=it.body}}</div>',
+    }
+
+    const compiled = await loadTemplates(templates)
+
+    expect(typeof compiled.subject).toBe('function')
+    expect(typeof compiled.html).toBe('function')
+
+    // test compiled output
+    const result = compiled.subject({ name: 'Haim' })
+    expect(result).toBe('Hello Haim')
+  })
+
+  it('should read from file path if input is a file', async () => {
+    const fakeFileContent = 'Welcome {{=it.username}}'
+
+    // @ts-ignore
+    fs.lstat.mockResolvedValueOnce({
+      isFile: () => true,
+    })
+    // @ts-ignore
+    fs.readFile.mockResolvedValueOnce(fakeFileContent)
+
+    const compiled = await loadTemplates({
+      subject: '/path/to/template.dot',
+    })
+
+    expect(fs.readFile).toHaveBeenCalledWith('/path/to/template.dot', 'utf-8')
+    expect(typeof compiled.subject).toBe('function')
+    expect(compiled.subject({ username: 'DotUser' })).toBe('Welcome DotUser')
+  })
+
+  it('should treat string as content if path is invalid', async () => {
+    // @ts-ignore
+    fs.lstat.mockRejectedValueOnce(new Error('File not found'))
+
+    const compiled = await loadTemplates({
+      subject: 'Hi {{=it.x}}',
+    })
+
+    expect(typeof compiled.subject).toBe('function')
+    expect(compiled.subject({ x: 'there' })).toBe('Hi there')
+  })
+})

package/tests/transport.factory.unit.test.js

@@ -0,0 +1,97 @@
+import aws from 'aws-sdk'
+import nodemailer from 'nodemailer'
+import { describe, it, expect, vi } from 'vitest'
+import sgTransport from 'nodemailer-sendgrid-transport'
+
+vi.mock('nodemailer', () => {
+  return {
+    default: {
+      createTransport: vi.fn(() => ({ type: 'mock-transport' })),
+    },
+  }
+})
+
+vi.mock('aws-sdk', async () => {
+  const actual = await vi.importActual('aws-sdk')
+  return {
+    ...actual,
+    SES: vi.fn().mockImplementation(() => 'mocked-ses'),
+  }
+})
+
+vi.mock('nodemailer-sendgrid-transport', () => ({
+  __esModule: true,
+  default: vi.fn().mockImplementation((opts) => {
+    const transport = { sendgrid: true, options: opts }
+    return transport
+  }),
+}))
+
+import { TransportFactory } from '../src/mailer/transport.factory.js'
+describe('TransportFactory', () => {
+  it('should create smtp transport', () => {
+    const config = {
+      type: 'smtp',
+      host: 'smtp.example.com',
+      port: 587,
+      secure: false,
+      auth: { user: 'user', pass: 'pass' },
+    }
+
+    const transport = TransportFactory.create(config)
+    expect(nodemailer.createTransport).toHaveBeenCalledWith({
+      host: config.host,
+      port: config.port,
+      secure: config.secure,
+      auth: config.auth,
+    })
+    expect(transport.type).toBe('mock-transport')
+  })
+
+  it('should create gmail transport', () => {
+    const config = {
+      type: 'gmail',
+      auth: { user: 'user@gmail.com', pass: 'pass' },
+    }
+
+    const transport = TransportFactory.create(config)
+    expect(nodemailer.createTransport).toHaveBeenCalledWith({
+      service: 'gmail',
+      auth: config.auth,
+    })
+    expect(transport.type).toBe('mock-transport')
+  })
+
+  it('should create sendgrid transport', () => {
+    const config = {
+      type: 'sendgrid',
+      apiKey: 'SG.xxxx',
+    }
+
+    const transport = TransportFactory.create(config)
+    expect(transport.sendgrid).toBe(true)
+    expect(transport.options.auth.api_key).toBe(config.apiKey)
+  })
+
+  it('should create ses transport', () => {
+    const config = {
+      type: 'ses',
+      accessKeyId: 'AKIA...',
+      secretAccessKey: 'secret',
+      region: 'us-west-2',
+    }
+
+    const transport = TransportFactory.create(config)
+    expect(nodemailer.createTransport).toHaveBeenCalled()
+
+    expect(nodemailer.createTransport.mock.calls[0][0]).toHaveProperty(
+      'SES.ses',
+    )
+  })
+
+  it('should throw error for unsupported type', () => {
+    expect(() => {
+      TransportFactory.create({ type: 'unsupported' })
+    }).toThrow('Unsupported transport type: unsupported')
+  })
+})