core-services-sdk 1.3.0 → 1.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-services-sdk",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "main": "src/index.js",
   "type": "module",
   "scripts": {
@@ -21,6 +21,7 @@
   "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",

package/src/index.js

@@ -8,3 +8,8 @@ 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/rabbit-mq/index.js

@@ -47,25 +47,30 @@ const parseMessage = (msgInfo) => {
 
 /**
  * Subscribes to a queue to receive messages.
- * @param {{
- *   channel: amqp.Channel,
- *   queue: string,
- *   onReceive: (data: any) => Promise<void>,
- *   log: Log,
- *   nackOnError?: boolean
- * }} options
+ *
+ * @param {Object} options
+ * @param {import('amqplib').Channel} options.channel - RabbitMQ channel
+ * @param {string} options.queue - Queue name to subscribe to
+ * @param {(data: any) => Promise<void>} options.onReceive - Async handler for incoming message
+ * @param {Log} options.log - Logging utility
+ * @param {boolean} [options.nackOnError=false] - Whether to nack the message on error (default: false)
+ * @param {number} [options.prefetch=1] - Max unacked messages per consumer (default: 1)
+ *
  * @returns {Promise<void>}
  */
 export const subscribeToQueue = async ({
   log,
   queue,
   channel,
+  prefetch = 1,
   onReceive,
   nackOnError = false,
 }) => {
   try {
     await channel.assertQueue(queue, { durable: true })
 
+    !!prefetch && (await channel.prefetch(prefetch))
+
     channel.consume(queue, async (msgInfo) => {
       if (!msgInfo) return
 

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/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,128 @@
+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', () => {
+  const createTransport = vi.fn((options) => ({
+    type: 'mock-transport',
+    options,
+  }))
+  return {
+    __esModule: true,
+    default: { createTransport },
+    createTransport,
+  }
+})
+
+vi.mock('aws-sdk', () => {
+  return {
+    __esModule: true,
+    default: {
+      SES: vi.fn(() => 'mocked-ses'),
+    },
+  }
+})
+
+vi.mock('nodemailer-sendgrid-transport', () => {
+  return {
+    __esModule: true,
+    default: vi.fn((opts) => ({
+      sendgrid: true,
+      options: opts,
+    })),
+  }
+})
+
+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(nodemailer.createTransport).toHaveBeenCalled()
+
+    const args = nodemailer.createTransport.mock.calls[0][0]
+
+    expect(args).toEqual({
+      sendgrid: true,
+      options: {
+        auth: { api_key: config.apiKey },
+      },
+    })
+
+    expect(transport).toEqual({
+      type: 'mock-transport',
+      options: {
+        sendgrid: true,
+        options: {
+          auth: { api_key: config.apiKey },
+        },
+      },
+    })
+  })
+
+  it('should create ses transport', () => {
+    const config = {
+      type: 'ses',
+      accessKeyId: 'AKIA...',
+      secretAccessKey: 'secret',
+      region: 'us-west-2',
+    }
+
+    TransportFactory.create(config)
+
+    expect(nodemailer.createTransport).toHaveBeenCalled()
+    const args = nodemailer.createTransport.mock.calls[0][0]
+
+    expect(args).toEqual({
+      SES: {
+        ses: 'mocked-ses',
+        aws: expect.anything(),
+      },
+    })
+  })
+
+  it('should throw error for unsupported type', () => {
+    expect(() => {
+      TransportFactory.create({ type: 'unsupported' })
+    }).toThrow('Unsupported transport type: unsupported')
+  })
+})