core-services-sdk 1.3.7 → 1.3.8

package/tests/mailer/mailer.integration.test.js

@@ -0,0 +1,95 @@
+import nodemailer from 'nodemailer'
+import { describe, it, expect, beforeAll } from 'vitest'
+
+import { Mailer } from '../../src/mailer/mailer.service.js'
+
+describe('Mailer (integration)', () => {
+  let transporter
+  let mailer
+  let testAccount
+
+  beforeAll(async () => {
+    testAccount = await nodemailer.createTestAccount()
+
+    transporter = nodemailer.createTransport({
+      host: testAccount.smtp.host,
+      port: testAccount.smtp.port,
+      secure: testAccount.smtp.secure,
+      auth: {
+        user: testAccount.user,
+        pass: testAccount.pass,
+      },
+    })
+
+    mailer = new Mailer(transporter)
+  })
+
+  it('should send email with HTML + text', async () => {
+    const result = await mailer.send({
+      to: 'recipient@example.com',
+      from: '"My App" <no-reply@example.com>',
+      subject: 'Integration Test: HTML + text',
+      text: 'Hello from plain text',
+      html: '<strong>Hello HTML</strong>',
+      cc: '',
+      bcc: '',
+      replyTo: '',
+      attachments: '',
+    })
+
+    expect(result.messageId).toBeDefined()
+    expect(result.envelope).toBeDefined()
+    expect(result.accepted).toContain('recipient@example.com')
+
+    const previewUrl = nodemailer.getTestMessageUrl(result)
+    console.log(`📨 Preview (HTML+text): ${previewUrl}`)
+    expect(previewUrl).toMatch(/^https:\/\/ethereal\.email/)
+  })
+
+  it('should send HTML-only email', async () => {
+    const result = await mailer.send({
+      to: 'recipient2@example.com',
+      from: '"My App" <no-reply@example.com>',
+      subject: 'Integration Test: HTML only',
+      html: '<h2>Only HTML</h2>',
+      cc: '',
+      bcc: '',
+      text: '',
+      replyTo: '',
+      attachments: '',
+    })
+
+    expect(result.messageId).toBeDefined()
+    expect(result.accepted).toContain('recipient2@example.com')
+
+    const previewUrl = nodemailer.getTestMessageUrl(result)
+    console.log(`📨 Preview (HTML only): ${previewUrl}`)
+    expect(previewUrl).toMatch(/^https:\/\/ethereal\.email/)
+  })
+
+  it('should send email with attachment', async () => {
+    const result = await mailer.send({
+      to: 'recipient3@example.com',
+      from: '"My App" <no-reply@example.com>',
+      subject: 'Integration Test: With Attachment',
+      text: 'See attached file.',
+      html: '<p>See attached file.</p>',
+      attachments: [
+        {
+          filename: 'test.txt',
+          content: 'This is the content of the attachment.',
+        },
+      ],
+      cc: '',
+      bcc: '',
+      replyTo: '',
+    })
+
+    expect(result.messageId).toBeDefined()
+    expect(result.accepted).toContain('recipient3@example.com')
+
+    const previewUrl = nodemailer.getTestMessageUrl(result)
+    console.log(`📨 Preview (With Attachment): ${previewUrl}`)
+    expect(previewUrl).toMatch(/^https:\/\/ethereal\.email/)
+  })
+})

package/tests/{mailer.unit.test.js → mailer/mailer.unit.test.js}

@@ -4,9 +4,9 @@ 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')
+// Mock the TransportFactory with a spy
+vi.mock('../../src/mailer/transport.factory.js', async () => {
+  const actual = await vi.importActual('../../src/mailer/transport.factory.js') // fixed path
   return {
     ...actual,
     TransportFactory: {
@@ -16,17 +16,16 @@ vi.mock('../src/mailer/transport.factory.js', async () => {
 })
 
 // Mock Mailer class
-vi.mock('../src/mailer/mailer.service.js', async () => {
+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'
+import { initMailer } from '../../src/mailer/index.js'
+import { Mailer } from '../../src/mailer/mailer.service.js'
+import { TransportFactory } from '../../src/mailer/transport.factory.js'
 
 describe('initMailer', () => {
   beforeEach(() => {
@@ -44,10 +43,7 @@ describe('initMailer', () => {
 
     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 = {

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

@@ -0,0 +1,204 @@
+import nodemailer from 'nodemailer'
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+// ===================
+// SAFELY MOCK MODULES
+// ===================
+
+vi.mock('nodemailer', () => {
+  const createTransport = vi.fn((options) => ({
+    type: 'mock-transport',
+    options,
+  }))
+  return {
+    __esModule: true,
+    default: { createTransport },
+    createTransport,
+  }
+})
+
+vi.mock('nodemailer-sendgrid-transport', () => ({
+  __esModule: true,
+  default: vi.fn((opts) => ({
+    sendgrid: true,
+    options: opts,
+  })),
+}))
+
+vi.mock('@aws-sdk/client-ses', () => {
+  const mockSesInstance = { mocked: true } // consistent reference
+  const sesClient = vi.fn(() => mockSesInstance)
+
+  globalThis.__mockedSesClient__ = sesClient
+  globalThis.__mockedSesInstance__ = mockSesInstance
+
+  return {
+    SESClient: sesClient,
+    SendRawEmailCommand: 'mocked-command',
+  }
+})
+
+vi.mock('@aws-sdk/credential-provider-node', () => {
+  const defaultProvider = vi.fn(() => 'mocked-default-provider')
+  globalThis.__mockedDefaultProvider__ = defaultProvider
+  return {
+    defaultProvider,
+  }
+})
+
+// ==========================
+// NOW IMPORT MODULE UNDER TEST
+// ==========================
+
+import { TransportFactory } from '../../src/mailer/transport.factory.js'
+
+describe('TransportFactory', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('should create smtp transport', () => {
+    const config = {
+      type: 'smtp',
+      host: 'smtp.example.com',
+      port: 587,
+      secure: false,
+      auth: { user: 'user', pass: 'pass' },
+    }
+
+    // @ts-ignore
+    const transport = TransportFactory.create(config)
+
+    expect(nodemailer.createTransport).toHaveBeenCalledWith({
+      host: config.host,
+      port: config.port,
+      secure: config.secure,
+      auth: config.auth,
+    })
+
+    // @ts-ignore
+    expect(transport.type).toBe('mock-transport')
+  })
+
+  it('should create gmail transport', () => {
+    const config = {
+      type: 'gmail',
+      auth: { user: 'user@gmail.com', pass: 'pass' },
+    }
+
+    // @ts-ignore
+    const transport = TransportFactory.create(config)
+
+    expect(nodemailer.createTransport).toHaveBeenCalledWith({
+      service: 'gmail',
+      auth: config.auth,
+    })
+
+    // @ts-ignore
+    expect(transport.type).toBe('mock-transport')
+  })
+
+  it('should create sendgrid transport', () => {
+    const config = {
+      type: 'sendgrid',
+      apiKey: 'SG.xxxx',
+    }
+
+    // @ts-ignore
+    const transport = TransportFactory.create(config)
+
+    // @ts-ignore
+    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 with credentials', () => {
+    const config = {
+      type: 'ses',
+      accessKeyId: 'AKIA...',
+      secretAccessKey: 'secret',
+      region: 'us-west-2',
+    }
+
+    // @ts-ignore
+    const transport = TransportFactory.create(config)
+
+    expect(globalThis.__mockedSesClient__).toHaveBeenCalledWith({
+      region: config.region,
+      credentials: {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey,
+      },
+    })
+
+    // @ts-ignore
+    const args = nodemailer.createTransport.mock.calls[0][0]
+
+    expect(args).toEqual({
+      SES: {
+        ses: globalThis.__mockedSesInstance__,
+        aws: {
+          SendRawEmailCommand: 'mocked-command',
+        },
+      },
+    })
+
+    // @ts-ignore
+    expect(transport.type).toBe('mock-transport')
+  })
+
+  it('should create ses transport with defaultProvider fallback', () => {
+    const config = {
+      type: 'ses',
+      region: 'us-east-1',
+    }
+
+    // @ts-ignore
+    const transport = TransportFactory.create(config)
+
+    expect(globalThis.__mockedDefaultProvider__).toHaveBeenCalled()
+
+    expect(globalThis.__mockedSesClient__).toHaveBeenCalledWith({
+      region: config.region,
+      credentials: 'mocked-default-provider',
+    })
+
+    // @ts-ignore
+    const args = nodemailer.createTransport.mock.calls[0][0]
+
+    expect(args).toEqual({
+      SES: {
+        ses: globalThis.__mockedSesInstance__,
+        aws: {
+          SendRawEmailCommand: 'mocked-command',
+        },
+      },
+    })
+
+    // @ts-ignore
+    expect(transport.type).toBe('mock-transport')
+  })
+
+  it('should throw error for unsupported type', () => {
+    expect(() => {
+      // @ts-ignore
+      TransportFactory.create({ type: 'invalid' })
+    }).toThrow('Unsupported transport type: invalid')
+  })
+})

package/tests/mongodb/connect.unit.test.js

@@ -0,0 +1,60 @@
+// @ts-nocheck
+import { MongoClient, ServerApiVersion } from 'mongodb'
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+import { mongoConnect } from '../../src/mongodb/connect.js'
+
+vi.mock('mongodb', async () => {
+  const actual = await vi.importActual('mongodb')
+  return {
+    ...actual,
+    MongoClient: {
+      connect: vi.fn(),
+    },
+    ServerApiVersion: actual.ServerApiVersion, // use real enum
+  }
+})
+
+describe('mongoConnect', () => {
+  const fakeClient = { db: vi.fn() }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    MongoClient.connect.mockResolvedValue(fakeClient)
+  })
+
+  it('should call MongoClient.connect with default serverApi options', async () => {
+    const uri = 'mongodb://localhost:27017'
+    await mongoConnect({ uri })
+
+    expect(MongoClient.connect).toHaveBeenCalledWith(uri, {
+      serverApi: {
+        version: ServerApiVersion.v1,
+        strict: true,
+        deprecationErrors: true,
+      },
+    })
+  })
+
+  it('should merge custom serverApi options', async () => {
+    const uri = 'mongodb://localhost:27017'
+    const serverApi = { strict: false }
+
+    await mongoConnect({ uri, serverApi })
+
+    expect(MongoClient.connect).toHaveBeenCalledWith(uri, {
+      serverApi: {
+        version: ServerApiVersion.v1,
+        strict: false,
+        deprecationErrors: true,
+      },
+    })
+  })
+
+  it('should return the connected client', async () => {
+    const uri = 'mongodb://localhost:27017'
+    const client = await mongoConnect({ uri })
+
+    expect(client).toBe(fakeClient)
+  })
+})

package/tests/mongodb/initialize-mongodb.unit.test.js

@@ -0,0 +1,98 @@
+// @ts-nocheck
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+import { initializeMongoDb } from '../../src/mongodb/initialize-mongodb.js'
+
+// Shared session spy
+const sessionSpy = {
+  startTransaction: vi.fn(),
+  commitTransaction: vi.fn(),
+  abortTransaction: vi.fn(),
+  endSession: vi.fn(),
+}
+
+// ✅ Mock path must match actual import in initializeMongoDb
+vi.mock('../../src/mongodb/connect.js', () => {
+  const fakeCollection = (name) => ({
+    name,
+    insertOne: vi.fn(),
+  })
+
+  const fakeDb = {
+    collection: vi.fn((name) => fakeCollection(name)),
+  }
+
+  const fakeClient = {
+    db: vi.fn(() => fakeDb),
+    startSession: () => sessionSpy,
+    close: vi.fn(),
+  }
+
+  return {
+    mongoConnect: vi.fn(async () => fakeClient),
+  }
+})
+
+import { mongoConnect } from '../../src/mongodb/connect.js'
+
+describe('initializeMongoDb', () => {
+  const config = {
+    uri: 'mongodb://localhost:27017',
+    options: { dbName: 'testdb' },
+  }
+
+  const collectionNames = {
+    users: 'users_collection',
+    logs: 'logs_collection',
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('should initialize collections correctly', async () => {
+    const db = await initializeMongoDb({ config, collectionNames })
+
+    expect(mongoConnect).toHaveBeenCalledWith(config)
+    expect(db.users.name).toBe('users_collection')
+    expect(db.logs.name).toBe('logs_collection')
+  })
+
+  it('should expose the mongo client via getter', async () => {
+    const db = await initializeMongoDb({ config, collectionNames })
+    expect(db.client).toBeDefined()
+    expect(db.client.db).toBeTypeOf('function')
+  })
+
+  it('should run actions within a transaction and commit on success', async () => {
+    const db = await initializeMongoDb({ config, collectionNames })
+
+    const actionMock = vi.fn(async ({ session }) => {
+      expect(session).toBe(sessionSpy)
+    })
+
+    await db.withTransaction(actionMock)
+
+    expect(sessionSpy.startTransaction).toHaveBeenCalled()
+    expect(sessionSpy.commitTransaction).toHaveBeenCalled()
+    expect(sessionSpy.abortTransaction).not.toHaveBeenCalled()
+    expect(sessionSpy.endSession).toHaveBeenCalled()
+  })
+
+  it('should abort transaction on error', async () => {
+    const db = await initializeMongoDb({ config, collectionNames })
+
+    const actionMock = vi.fn(async () => {
+      throw new Error('Intentional failure')
+    })
+
+    await expect(db.withTransaction(actionMock)).rejects.toThrow(
+      'Intentional failure',
+    )
+
+    expect(sessionSpy.startTransaction).toHaveBeenCalled()
+    expect(sessionSpy.commitTransaction).not.toHaveBeenCalled()
+    expect(sessionSpy.abortTransaction).toHaveBeenCalled()
+    expect(sessionSpy.endSession).toHaveBeenCalled()
+  })
+})

package/tests/mongodb/validate-mongo-uri.unit.test.js

@@ -0,0 +1,52 @@
+// @ts-nocheck
+import { describe, it, expect } from 'vitest'
+
+import { isValidMongoUri } from '../../src/mongodb/validate-mongo-uri.js'
+
+describe('isValidMongoUri', () => {
+  it('should return true for a valid mongodb:// URI', () => {
+    expect(isValidMongoUri('mongodb://localhost:27017/mydb')).toBe(true)
+  })
+
+  it('should return true for a valid mongodb+srv:// URI', () => {
+    expect(isValidMongoUri('mongodb+srv://cluster.example.com/test')).toBe(true)
+  })
+
+  it('should return false for non-MongoDB protocol (http)', () => {
+    expect(isValidMongoUri('http://localhost')).toBe(false)
+  })
+
+  it('should return false for empty string', () => {
+    expect(isValidMongoUri('')).toBe(false)
+  })
+
+  it('should return false for whitespace string', () => {
+    expect(isValidMongoUri('   ')).toBe(false)
+  })
+
+  it('should return false for non-string input', () => {
+    expect(isValidMongoUri(null)).toBe(false)
+    expect(isValidMongoUri(undefined)).toBe(false)
+    expect(isValidMongoUri(12345)).toBe(false)
+    expect(isValidMongoUri({})).toBe(false)
+  })
+
+  it('should return false for malformed URI', () => {
+    expect(isValidMongoUri('mongodb://')).toBe(false)
+    expect(isValidMongoUri('mongodb+srv://')).toBe(false)
+    expect(isValidMongoUri('mongodb:/localhost')).toBe(false)
+  })
+
+  it('should allow valid URIs with credentials and options', () => {
+    expect(
+      isValidMongoUri(
+        'mongodb://user:pass@localhost:27017/mydb?retryWrites=true',
+      ),
+    ).toBe(true)
+    expect(
+      isValidMongoUri(
+        'mongodb+srv://user:pass@cluster0.example.mongodb.net/mydb',
+      ),
+    ).toBe(true)
+  })
+})

package/tests/{rabbit-mq.test.js → rabbit-mq/rabbit-mq.test.js}

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeAll } from 'vitest'
-import { initializeQueue, rabbitUriFromEnv } from '../src/rabbit-mq/index.js'
+
+import { initializeQueue, rabbitUriFromEnv } from '../../src/rabbit-mq/index.js'
 
 const sleep = (ms) => new Promise((res) => setTimeout(res, ms))
 
@@ -37,8 +38,8 @@ describe('RabbitMQ SDK', () => {
 describe('rabbitUriFromEnv', () => {
   it('should build valid amqp URI from env', () => {
     const env = {
-      RABBIT_HOST: '0.0.0.0',
       RABBIT_PORT: 5672,
+      RABBIT_HOST: '0.0.0.0',
       RABBIT_USERNAME: 'botq',
       RABBIT_PASSWORD: 'botq',
       _RABBIT_HOST: '0.0.0.0',

package/tests/{template-loader.integration.test.js → templates/template-loader.integration.test.js}

@@ -3,7 +3,7 @@ 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'
+import { loadTemplates } from '../../src/templates/template-loader.js'
 
 const tempDir = join(tmpdir(), 'template-tests')
 

package/tests/{template-loader.unit.test.js → templates/template-loader.unit.test.js}

@@ -2,7 +2,7 @@ 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'
+import { loadTemplates } from '../../src/templates/template-loader.js'
 
 vi.mock('fs/promises')
 

package/vitest.config.js

@@ -2,5 +2,8 @@ export default {
   test: {
     testTimeout: 30000,
     hookTimeout: 30000,
+    coverage: {
+      exclude: ['**/index.js', 'vitest.config.js'],
+    },
   },
 }

package/index.js

@@ -1,3 +0,0 @@
-import { HttpError } from './src/index.js'
-
-throw new HttpError({ code: '2', httpStatusCode: 22 })

package/tests/HttpError.test.js

@@ -1,80 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { HttpError } from '../src/http/HttpError.js'
-import httpStatus from 'http-status'
-
-describe('HttpError', () => {
-  it('creates an error with all fields explicitly set', () => {
-    const err = new HttpError({
-      code: 'SOME_ERROR',
-      message: 'Something went wrong',
-      httpStatusCode: httpStatus.BAD_REQUEST,
-      httpStatusText: httpStatus[httpStatus.BAD_REQUEST],
-    })
-
-    expect(err).toBeInstanceOf(HttpError)
-    expect(err.message).toBe('Something went wrong')
-    expect(err.code).toBe('SOME_ERROR')
-    expect(err.httpStatusCode).toBe(httpStatus.BAD_REQUEST)
-    expect(err.httpStatusText).toBe(httpStatus[httpStatus.BAD_REQUEST])
-  })
-
-  it('falls back to code if message and httpStatusCode are missing', () => {
-    const err = new HttpError({ code: 'MY_CODE' })
-    expect(err.message).toBe('MY_CODE')
-    expect(err.code).toBe('MY_CODE')
-  })
-
-  it('falls back to status text if only httpStatusCode is provided', () => {
-    const err = new HttpError({ httpStatusCode: httpStatus.NOT_FOUND })
-    expect(err.message).toBe(httpStatus[httpStatus.NOT_FOUND])
-    expect(err.httpStatusText).toBe(httpStatus[httpStatus.NOT_FOUND])
-    expect(err.httpStatusCode).toBe(httpStatus.NOT_FOUND)
-  })
-
-  it('falls back to "Unknown error" if nothing is provided', () => {
-    const err = new HttpError()
-    expect(err.message).toBe('Unknown error')
-    expect(err.code).toBeUndefined()
-    expect(err.httpStatusCode).toBeUndefined()
-    expect(err.httpStatusText).toBeUndefined()
-  })
-
-  it('uses httpStatusText if not explicitly set but httpStatusCode is present', () => {
-    const err = new HttpError({ httpStatusCode: httpStatus.UNAUTHORIZED })
-    expect(err.httpStatusText).toBe(httpStatus[httpStatus.UNAUTHORIZED])
-  })
-
-  it('supports static isInstanceOf check', () => {
-    const err = new HttpError()
-    expect(HttpError.isInstanceOf(err)).toBe(true)
-    expect(HttpError.isInstanceOf(new Error())).toBe(false)
-  })
-
-  it('supports Symbol.hasInstance (dynamic instanceof)', () => {
-    const fake = {
-      code: 'FAKE',
-      message: 'Fake error',
-      httpStatusCode: httpStatus.UNAUTHORIZED,
-      httpStatusText: httpStatus[httpStatus.UNAUTHORIZED],
-    }
-
-    expect(fake instanceof HttpError).toBe(true)
-  })
-
-  it('serializes correctly via toJSON', () => {
-    const err = new HttpError({
-      code: 'TOO_FAST',
-      message: 'You are too fast',
-      httpStatusCode: httpStatus.TOO_MANY_REQUESTS,
-      httpStatusText: httpStatus[httpStatus.TOO_MANY_REQUESTS],
-    })
-
-    const json = JSON.stringify(err)
-    expect(JSON.parse(json)).toEqual({
-      code: 'TOO_FAST',
-      message: 'You are too fast',
-      httpStatusCode: httpStatus.TOO_MANY_REQUESTS,
-      httpStatusText: httpStatus[httpStatus.TOO_MANY_REQUESTS],
-    })
-  })
-})