@feathers-baas/plugin-notifications 0.1.0

package/test/drivers/sendgrid.driver.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+// ─── Mock @sendgrid/mail ──────────────────────────────────────────────────────
+
+const { mockSend, mockSetApiKey } = vi.hoisted(() => ({
+  mockSend: vi.fn(),
+  mockSetApiKey: vi.fn(),
+}))
+
+vi.mock('@sendgrid/mail', () => ({
+  default: {
+    setApiKey: mockSetApiKey,
+    send: mockSend,
+  },
+}))
+
+// ─── Imports after mocking ────────────────────────────────────────────────────
+
+import { SendGridDriver } from '../../src/drivers/sendgrid.driver.js'
+import type { Notification } from '../../src/types.js'
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe('SendGridDriver', () => {
+  let driver: SendGridDriver
+
+  beforeEach(() => {
+    mockSend.mockReset()
+    mockSetApiKey.mockReset()
+    mockSend.mockResolvedValue([{ statusCode: 202 }, {}])
+    driver = new SendGridDriver({
+      apiKey: 'SG.test_key',
+      fromName: 'Feathers BaaS',
+      fromAddress: 'no-reply@example.com',
+    })
+  })
+
+  it('has the correct driver name', () => {
+    expect(driver.name).toBe('sendgrid')
+  })
+
+  it('sets the API key on construction', () => {
+    expect(mockSetApiKey).toHaveBeenCalledWith('SG.test_key')
+  })
+
+  describe('send', () => {
+    it('calls sgMail.send with rendered HTML and correct fields', async () => {
+      const notification: Notification = {
+        to: 'recipient@example.com',
+        channel: 'email',
+        subject: 'Welcome!',
+        bodyTemplate: '<h1>Hello, <%= name %></h1>',
+        data: { name: 'Alice' },
+      }
+
+      await driver.send(notification)
+
+      expect(mockSend).toHaveBeenCalledOnce()
+      const arg = mockSend.mock.calls[0]?.[0] as Record<string, unknown>
+      expect(arg['to']).toBe('recipient@example.com')
+      expect(arg['from']).toEqual({ name: 'Feathers BaaS', email: 'no-reply@example.com' })
+      expect(arg['subject']).toBe('Welcome!')
+      expect(arg['html']).toBe('<h1>Hello, Alice</h1>')
+    })
+
+    it('includes text when textTemplate is provided', async () => {
+      const notification: Notification = {
+        to: 'user@example.com',
+        channel: 'email',
+        bodyTemplate: '<p><%= msg %></p>',
+        textTemplate: 'Plain: <%= msg %>',
+        data: { msg: 'test' },
+      }
+
+      await driver.send(notification)
+
+      const arg = mockSend.mock.calls[0]?.[0] as Record<string, unknown>
+      expect(arg['text']).toBe('Plain: test')
+    })
+
+    it('omits text when no textTemplate is given', async () => {
+      const notification: Notification = {
+        to: 'user@example.com',
+        channel: 'email',
+        bodyTemplate: '<p>HTML only</p>',
+        data: {},
+      }
+
+      await driver.send(notification)
+
+      const arg = mockSend.mock.calls[0]?.[0] as Record<string, unknown>
+      expect(arg['text']).toBeUndefined()
+    })
+
+    it('falls back to "(no subject)" when subject is not provided', async () => {
+      const notification: Notification = {
+        to: 'user@example.com',
+        channel: 'email',
+        bodyTemplate: 'body',
+        data: {},
+      }
+
+      await driver.send(notification)
+
+      const arg = mockSend.mock.calls[0]?.[0] as Record<string, unknown>
+      expect(arg['subject']).toBe('(no subject)')
+    })
+  })
+})

package/test/drivers/smtp.driver.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+// ─── Hoist mock variables so they're available inside vi.mock factories ───────
+const { mockSendMail, mockVerify, mockClose } = vi.hoisted(() => ({
+  mockSendMail: vi.fn(),
+  mockVerify: vi.fn(),
+  mockClose: vi.fn(),
+}))
+
+vi.mock('nodemailer', () => ({
+  default: {
+    createTransport: vi.fn().mockReturnValue({
+      sendMail: mockSendMail,
+      verify: mockVerify,
+      close: mockClose,
+    }),
+  },
+}))
+
+// ─── Imports after mocking ────────────────────────────────────────────────────
+import { SMTPDriver } from '../../src/drivers/smtp.driver.js'
+import type { Notification } from '../../src/types.js'
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe('SMTPDriver', () => {
+  let driver: SMTPDriver
+
+  beforeEach(() => {
+    mockSendMail.mockReset()
+    mockSendMail.mockResolvedValue({ messageId: 'msg-123' })
+    driver = new SMTPDriver({
+      url: 'smtp://user:pass@localhost:1025',
+      fromName: 'Feathers BaaS',
+      fromAddress: 'no-reply@example.com',
+    })
+  })
+
+  it('has the correct driver name', () => {
+    expect(driver.name).toBe('smtp')
+  })
+
+  describe('send', () => {
+    it('calls sendMail with rendered HTML', async () => {
+      const notification: Notification = {
+        to: 'recipient@example.com',
+        channel: 'email',
+        subject: 'Welcome, <%= name %>!',
+        bodyTemplate: '<h1>Hello, <%= name %></h1>',
+        data: { name: 'Alice' },
+      }
+
+      await driver.send(notification)
+
+      expect(mockSendMail).toHaveBeenCalledOnce()
+      const mailArg = mockSendMail.mock.calls[0]?.[0] as Record<string, unknown>
+      expect(mailArg['to']).toBe('recipient@example.com')
+      // subject is passed as-is (not EJS-rendered)
+      expect(mailArg['subject']).toBe('Welcome, <%= name %>!')
+      // HTML body should have EJS rendered
+      expect(mailArg['html']).toBe('<h1>Hello, Alice</h1>')
+    })
+
+    it('renders the text template when provided', async () => {
+      const notification: Notification = {
+        to: 'user@example.com',
+        channel: 'email',
+        bodyTemplate: '<p><%= msg %></p>',
+        textTemplate: 'Plain: <%= msg %>',
+        data: { msg: 'test message' },
+      }
+
+      await driver.send(notification)
+
+      const mailArg = mockSendMail.mock.calls[0]?.[0] as Record<string, unknown>
+      expect(mailArg['text']).toBe('Plain: test message')
+    })
+
+    it('sets text to undefined when no textTemplate is given', async () => {
+      const notification: Notification = {
+        to: 'user@example.com',
+        channel: 'email',
+        bodyTemplate: '<p>HTML only</p>',
+        data: {},
+      }
+
+      await driver.send(notification)
+
+      const mailArg = mockSendMail.mock.calls[0]?.[0] as Record<string, unknown>
+      expect(mailArg['text']).toBeUndefined()
+    })
+
+    it('uses the configured from address', async () => {
+      const notification: Notification = {
+        to: 'user@example.com',
+        channel: 'email',
+        bodyTemplate: 'hi',
+        data: {},
+      }
+
+      await driver.send(notification)
+
+      const mailArg = mockSendMail.mock.calls[0]?.[0] as Record<string, unknown>
+      expect(mailArg['from']).toBe('"Feathers BaaS" <no-reply@example.com>')
+    })
+
+    it('falls back to "(no subject)" when subject is not provided', async () => {
+      const notification: Notification = {
+        to: 'user@example.com',
+        channel: 'email',
+        bodyTemplate: 'body',
+        data: {},
+      }
+
+      await driver.send(notification)
+
+      const mailArg = mockSendMail.mock.calls[0]?.[0] as Record<string, unknown>
+      expect(mailArg['subject']).toBe('(no subject)')
+    })
+  })
+})

package/test/queue.test.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import type { NotificationJob, Notification } from '../src/types.js'
+
+// ─── Mock ioredis with ioredis-mock ───────────────────────────────────────────
+vi.mock('ioredis', async () => {
+  const IORedisMock = (await import('ioredis-mock')).default
+  return { default: IORedisMock, Redis: IORedisMock }
+})
+
+// ─── Mock BullMQ ─────────────────────────────────────────────────────────────
+const mockQueueAdd = vi.fn().mockResolvedValue({ id: 'job-1' })
+const mockQueueClose = vi.fn().mockResolvedValue(undefined)
+const mockWorkerClose = vi.fn().mockResolvedValue(undefined)
+let capturedProcessor: ((job: { data: NotificationJob }) => Promise<void>) | undefined
+
+vi.mock('bullmq', () => ({
+  Queue: vi.fn().mockImplementation(() => ({
+    add: mockQueueAdd,
+    close: mockQueueClose,
+  })),
+  Worker: vi.fn().mockImplementation((_name: string, processor: (job: { data: NotificationJob }) => Promise<void>) => {
+    capturedProcessor = processor
+    return {
+      on: vi.fn(),
+      close: mockWorkerClose,
+    }
+  }),
+}))
+
+// ─── Imports after mocking ────────────────────────────────────────────────────
+import { createNotificationQueue, enqueueNotification, NOTIFICATION_QUEUE_NAME } from '../src/queue/producer.js'
+import { createNotificationWorker } from '../src/queue/worker.js'
+import { DriverRegistry } from '../src/registry.js'
+import type { NotifierDriver } from '../src/types.js'
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+const fakeNotification: Notification = {
+  to: 'user@example.com',
+  channel: 'email',
+  subject: 'Test',
+  bodyTemplate: '<p>Hello <%= name %></p>',
+  data: { name: 'Alice' },
+}
+
+describe('createNotificationQueue', () => {
+  it('creates a BullMQ Queue with the correct name', async () => {
+    const { Queue } = await import('bullmq')
+    const Redis = (await import('ioredis')).default
+    const redis = new Redis() as unknown as import('ioredis').Redis
+    createNotificationQueue(redis)
+    expect(vi.mocked(Queue)).toHaveBeenCalledWith(
+      NOTIFICATION_QUEUE_NAME,
+      expect.objectContaining({
+        defaultJobOptions: expect.objectContaining({
+          attempts: 5,
+          backoff: expect.objectContaining({ type: 'exponential' }),
+        }),
+      }),
+    )
+  })
+})
+
+describe('enqueueNotification', () => {
+  beforeEach(() => mockQueueAdd.mockClear())
+
+  it('adds a job with the correct payload', async () => {
+    const { Queue } = await import('bullmq')
+    const Redis = (await import('ioredis')).default
+    const redis = new Redis() as unknown as import('ioredis').Redis
+    const queue = createNotificationQueue(redis) as unknown as Parameters<typeof enqueueNotification>[0]
+
+    const job: NotificationJob = { driverName: 'smtp', notification: fakeNotification }
+    await enqueueNotification(queue, job)
+
+    expect(mockQueueAdd).toHaveBeenCalledWith('send', job)
+  })
+})
+
+describe('createNotificationWorker', () => {
+  let registry: DriverRegistry
+
+  beforeEach(() => {
+    capturedProcessor = undefined
+    registry = new DriverRegistry()
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('creates a BullMQ Worker with the correct queue name', async () => {
+    const { Worker } = await import('bullmq')
+    const Redis = (await import('ioredis')).default
+    const redis = new Redis() as unknown as import('ioredis').Redis
+    createNotificationWorker(registry, redis, { concurrency: 3 })
+    expect(vi.mocked(Worker)).toHaveBeenCalledWith(
+      NOTIFICATION_QUEUE_NAME,
+      expect.any(Function),
+      expect.objectContaining({ concurrency: 3 }),
+    )
+  })
+
+  it('calls the driver.send() when a job is processed', async () => {
+    const Redis = (await import('ioredis')).default
+    const redis = new Redis() as unknown as import('ioredis').Redis
+
+    const mockSend = vi.fn().mockResolvedValue(undefined)
+    const fakeDriver: NotifierDriver = { name: 'smtp', send: mockSend }
+    registry.registerDriver(fakeDriver)
+
+    createNotificationWorker(registry, redis)
+
+    expect(capturedProcessor).toBeDefined()
+
+    const job: NotificationJob = { driverName: 'smtp', notification: fakeNotification }
+    await capturedProcessor!({ data: job })
+
+    expect(mockSend).toHaveBeenCalledOnce()
+    expect(mockSend).toHaveBeenCalledWith(fakeNotification)
+  })
+
+  it('throws when the driver is not registered', async () => {
+    const Redis = (await import('ioredis')).default
+    const redis = new Redis() as unknown as import('ioredis').Redis
+    createNotificationWorker(registry, redis)
+
+    const job: NotificationJob = { driverName: 'unknown-driver', notification: fakeNotification }
+    await expect(capturedProcessor!({ data: job })).rejects.toThrow(/not registered/)
+  })
+})

package/test/setup.ts

@@ -0,0 +1,2 @@
+// Test setup for @feathers-baas/plugin-notifications
+// No global setup needed — each test file manages its own mocks and fixtures.

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "outDir": "dist"
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "test"]
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm', 'cjs'],
+  dts: true,
+  splitting: false,
+  clean: true,
+  sourcemap: true,
+})

package/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    globals: false,
+    setupFiles: ['./test/setup.ts'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'lcov'],
+    },
+  },
+})