core-services-sdk 1.3.7 → 1.3.9

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],
-    })
-  })
-})

package/tests/core-util.js

@@ -1,24 +0,0 @@
-import { exec } from 'child_process'
-/**
- * Starts a MongoDB Docker container on the specified port.
- * @param {string} command - Command to run, like: 'docker run -d --name mongo-test -p 2730:27017 mongo'.
- * @returns {Promise<void>}
- */
-export const runInTerminal = async (command) => {
-  return new Promise((resolve, reject) => {
-    exec(command, (error, stdout, stderr) => {
-      if (error) {
-        console.error('Error starting command:', error.message)
-        return reject(error)
-      }
-      if (stderr) {
-        console.warn('stderr:', stderr)
-      }
-      console.log('Command started:', stdout.trim())
-      resolve()
-    })
-  })
-}
-
-export const sleep = async (milliseconds) =>
-  new Promise((res) => setTimeout(res, milliseconds))

package/tests/mailer.integration.test.js

@@ -1,46 +0,0 @@
-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/mongodb.test.js

@@ -1,70 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import { runInTerminal, sleep } from './core-util.js'
-import { initializeMongoDb } from '../src/mongodb/index.js'
-
-const port = 2730
-const dbName = 'testdb'
-const host = 'localhost'
-const mongoUri = `mongodb://${host}:${port}/?replicaSet=rs0`
-const dockerStopCommand = `docker stop ${dbName} && docker rm ${dbName}`
-const dockerCreateCommant = `docker run -d --name ${dbName} -p ${port}:27017 mongo --replSet rs0`
-const dockerReplicaSetCommand = `docker exec -i ${dbName} mongosh --eval "rs.initiate()"`
-
-describe('MongoDB Init & Transaction SDK', () => {
-  let collections
-
-  beforeAll(async () => {
-    try {
-      await runInTerminal(dockerStopCommand)
-    } catch (error) {
-      console.log('No existing container to stop.')
-    }
-
-    await runInTerminal(dockerCreateCommant)
-    await sleep(5000)
-    await runInTerminal(dockerReplicaSetCommand)
-
-    collections = await initializeMongoDb({
-      config: {
-        uri: mongoUri,
-        options: { dbName },
-      },
-      collectionNames: {
-        users: 'users',
-        logs: 'logs',
-      },
-    })
-
-    await collections.users.deleteMany({})
-    await collections.logs.deleteMany({})
-  }, 60000)
-
-  afterAll(async () => {
-    if (collections?.client) {
-      await collections.client.db(dbName).dropDatabase()
-      await collections.client.close()
-    }
-  }, 20000)
-
-  it.skip('should insert into multiple collections within a transaction', async () => {
-    if (!collections) throw new Error('collections not initialized')
-
-    await collections.withTransaction(async ({ session }) => {
-      const userInsert = collections.users.insertOne(
-        { name: 'Alice' },
-        { session },
-      )
-      const logInsert = collections.logs.insertOne(
-        { action: 'UserCreated', user: 'Alice' },
-        { session },
-      )
-      await Promise.all([userInsert, logInsert])
-    })
-
-    const insertedUser = await collections.users.findOne({ name: 'Alice' })
-    const insertedLog = await collections.logs.findOne({ user: 'Alice' })
-
-    expect(insertedUser).not.toBeNull()
-    expect(insertedLog).not.toBeNull()
-  }, 20000)
-}, 60000)

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

@@ -1,128 +0,0 @@
-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')
-  })
-})