core-services-sdk 1.3.25 → 1.3.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-services-sdk",
-  "version": "1.3.25",
+  "version": "1.3.27",
   "main": "src/index.js",
   "type": "module",
   "types": "types/index.d.ts",
@@ -35,6 +35,7 @@
     "http-status": "^2.1.0",
     "mongodb": "^6.18.0",
     "nodemailer": "^7.0.5",
+    "p-retry": "^7.0.0",
     "pino": "^9.7.0",
     "ulid": "^3.0.1",
     "uuid": "^11.1.0",

package/src/mongodb/connect.js

@@ -1,23 +1,56 @@
+import pRetry from 'p-retry'
 import { MongoClient, ServerApiVersion } from 'mongodb'
 
 /**
- * Connects to MongoDB.
+ * Connects to MongoDB with retry and timeout support.
  *
  * @param {Object} options
  * @param {string} options.uri - MongoDB connection URI.
  * @param {object} [options.serverApi] - Optional serverApi configuration.
- * @returns {Promise<import('mongodb').MongoClient>}
+ * @param {number} [options.timeout=5000] - Timeout in ms for each attempt.
+ * @param {number} [options.retries=3] - Number of retry attempts.
+ * @returns {Promise<MongoClient>}
  */
+export const mongoConnect = async ({
+  uri,
+  serverApi,
+  timeout = 5000,
+  retries = 3,
+}) => {
+  const attemptConnect = async () => {
+    const connectPromise = MongoClient.connect(uri, {
+      serverApi: {
+        version: ServerApiVersion.v1,
+        strict: true,
+        deprecationErrors: true,
+        ...serverApi,
+      },
+      connectTimeoutMS: timeout,
+      socketTimeoutMS: timeout,
+    })
 
-export const mongoConnect = async ({ uri, serverApi }) => {
-  const client = await MongoClient.connect(uri, {
-    serverApi: {
-      version: ServerApiVersion.v1,
-      strict: true,
-      deprecationErrors: true,
-      ...serverApi,
+    // Race connection vs timeout
+    const timeoutPromise = new Promise((_, reject) =>
+      setTimeout(
+        () =>
+          reject(new Error(`MongoDB connection timed out after ${timeout}ms`)),
+        timeout,
+      ),
+    )
+
+    return Promise.race([connectPromise, timeoutPromise])
+  }
+
+  return pRetry(attemptConnect, {
+    retries,
+    factor: 2, // exponential backoff multiplier
+    minTimeout: 500, // wait 500ms before first retry
+    maxTimeout: timeout, // cap backoff at timeout value
+    onFailedAttempt: (error) => {
+      console.warn(
+        `MongoDB connection attempt ${error.attemptNumber} failed. ` +
+          `There are ${error.retriesLeft} retries left. Reason: ${error.message}`,
+      )
     },
   })
-
-  return client
 }

package/src/mongodb/index.js

@@ -1,4 +1,5 @@
 export * from './connect.js'
+export * from './paginate.js'
 export * from './dsl-to-mongo.js'
 export * from './initialize-mongodb.js'
 export * from './validate-mongo-uri.js'

package/src/mongodb/paginate.js

@@ -0,0 +1,48 @@
+import { ObjectId } from 'mongodb'
+
+/**
+ * Pagination with SQL-like ascending/descending
+ *
+ * @param {import('mongodb').Collection} collection
+ * @param {Object} options
+ * @param {Object} [options.filter={}]
+ * @param {string} [options.cursorField='_id']
+ * @param {string|Date|ObjectId} [options.cursor]
+ * @param {'asc'|'desc'} [options.order='asc']
+ * @param {number} [options.limit=10]
+ */
+export async function paginate(
+  collection,
+  {
+    limit = 10,
+    projection,
+    filter = {},
+    cursor = null,
+    order = 'desc',
+    cursorField = '_id',
+  } = {},
+) {
+  const query = { ...filter }
+  const sort = { [cursorField]: order === 'asc' ? 1 : -1 }
+
+  if (cursor) {
+    if (cursorField === '_id') {
+      cursor = new ObjectId(cursor)
+    }
+
+    query[cursorField] = order === 'asc' ? { $gt: cursor } : { $lt: cursor }
+  }
+
+  const results = await collection
+    .find(query, { projection })
+    .sort(sort)
+    .limit(limit)
+    .toArray()
+
+  return {
+    order,
+    list: results,
+    previous: results.length ? results[0][cursorField] : null,
+    next: results.length ? results[results.length - 1][cursorField] : null,
+  }
+}

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

@@ -0,0 +1,62 @@
+// @ts-nocheck
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { mongoConnect } from '../../src/mongodb/connect.js'
+import { startMongo, stopMongo } from '../resources/docker-mongo-test.js'
+
+const MONGO_PORT = 29060
+const CONTAINER_NAME = 'mongo-connect-integration-test'
+
+describe('mongoConnect - Integration', () => {
+  let client
+
+  beforeAll(async () => {
+    // Start a fresh Mongo container
+    startMongo(MONGO_PORT, CONTAINER_NAME)
+  })
+
+  afterAll(async () => {
+    if (client) {
+      await client.close()
+    }
+    stopMongo(CONTAINER_NAME)
+  })
+
+  it('successfully connects to a running MongoDB container', async () => {
+    client = await mongoConnect({
+      uri: `mongodb://0.0.0.0:${MONGO_PORT}`,
+    })
+
+    const db = client.db('integration-test')
+    const col = db.collection('docs')
+
+    await col.insertOne({ name: 'hello' })
+    const found = await col.findOne({ name: 'hello' })
+
+    expect(found).toMatchObject({ name: 'hello' })
+  })
+
+  it('respects custom timeout', async () => {
+    // should connect quickly
+    client = await mongoConnect({
+      uri: `mongodb://0.0.0.0:${MONGO_PORT}`,
+      timeout: 2000,
+    })
+
+    expect(client).toBeDefined()
+  })
+
+  it('fails to connect to an invalid port with retries', async () => {
+    const badPort = 29999 // unused port
+
+    await expect(
+      mongoConnect({
+        uri: `mongodb://0.0.0.0:${badPort}`,
+        timeout: 1000,
+        retries: 2,
+      }),
+    ).rejects.toThrow()
+
+    // should try initial + retries
+    // we don’t assert number of attempts here because it’s handled by p-retry
+  })
+})

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

@@ -23,7 +23,7 @@ describe('mongoConnect', () => {
     MongoClient.connect.mockResolvedValue(fakeClient)
   })
 
-  it('should call MongoClient.connect with default serverApi options', async () => {
+  it('should call MongoClient.connect with default serverApi options and default timeouts', async () => {
     const uri = 'mongodb://localhost:27017'
     await mongoConnect({ uri })
 
@@ -33,6 +33,8 @@ describe('mongoConnect', () => {
         strict: true,
         deprecationErrors: true,
       },
+      connectTimeoutMS: 5000,
+      socketTimeoutMS: 5000,
     })
   })
 
@@ -48,13 +50,53 @@ describe('mongoConnect', () => {
         strict: false,
         deprecationErrors: true,
       },
+      connectTimeoutMS: 5000,
+      socketTimeoutMS: 5000,
     })
   })
 
+  it('should honor custom timeout value', async () => {
+    const uri = 'mongodb://localhost:27017'
+    await mongoConnect({ uri, timeout: 2000 })
+
+    expect(MongoClient.connect).toHaveBeenCalledWith(
+      uri,
+      expect.objectContaining({
+        connectTimeoutMS: 2000,
+        socketTimeoutMS: 2000,
+      }),
+    )
+  })
+
   it('should return the connected client', async () => {
     const uri = 'mongodb://localhost:27017'
     const client = await mongoConnect({ uri })
 
     expect(client).toBe(fakeClient)
   })
+
+  it('should retry when connection fails initially', async () => {
+    const uri = 'mongodb://localhost:27017'
+
+    // fail first attempt, succeed second
+    MongoClient.connect
+      .mockRejectedValueOnce(new Error('temporary error'))
+      .mockResolvedValueOnce(fakeClient)
+
+    const client = await mongoConnect({ uri, retries: 2 })
+
+    expect(client).toBe(fakeClient)
+    expect(MongoClient.connect).toHaveBeenCalledTimes(2)
+  })
+
+  it('should throw after exceeding retries', async () => {
+    const uri = 'mongodb://localhost:27017'
+    MongoClient.connect.mockRejectedValue(new Error('always fails'))
+
+    await expect(
+      mongoConnect({ uri, retries: 2, timeout: 100 }),
+    ).rejects.toThrow(/always fails/)
+
+    expect(MongoClient.connect).toHaveBeenCalledTimes(3) // initial + 2 retries
+  })
 })

package/tests/mongodb/paginate.helper.integration.test.js

@@ -0,0 +1,151 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest'
+
+import { paginate } from '../../src/mongodb/paginate.js'
+import { startMongo, stopMongo } from '../resources/docker-mongo-test.js'
+import { initializeMongoDb } from '../../src/mongodb/initialize-mongodb.js'
+
+const MONGO_PORT = 29050
+const CONTAINER_NAME = 'mongo-auth-attempts-paginate-test'
+
+let db
+let collection
+describe('paginate - Integration', () => {
+  beforeAll(async () => {
+    startMongo(MONGO_PORT, CONTAINER_NAME)
+
+    db = await initializeMongoDb({
+      config: {
+        uri: `mongodb://0.0.0.0:${MONGO_PORT}`,
+        options: { dbName: 'users-management' },
+      },
+      collectionNames: {
+        TestDocs: 'test_docs',
+      },
+    })
+
+    collection = db.TestDocs
+  })
+  afterAll(() => {
+    stopMongo(CONTAINER_NAME)
+  })
+
+  beforeEach(async () => {
+    await collection.deleteMany({})
+  })
+
+  const seedDocs = async (count = 12) => {
+    const docs = Array.from({ length: count }).map((_, i) => ({
+      name: `doc_${i}`,
+      createdAt: new Date(Date.now() + i * 1000),
+    }))
+    await collection.insertMany(docs)
+    return docs
+  }
+
+  it('returns first page with limit', async () => {
+    await seedDocs(12)
+
+    const result = await paginate(collection, {
+      filter: {},
+      limit: 5,
+      order: 'desc',
+      cursorField: 'createdAt',
+    })
+
+    expect(result.list).toHaveLength(5)
+    expect(result.next).toBeDefined()
+    expect(result.previous).toBeDefined()
+  })
+
+  it('returns empty when no docs match filter', async () => {
+    const result = await paginate(collection, {
+      filter: { name: 'not-exist' },
+      limit: 5,
+      order: 'desc',
+    })
+
+    expect(result.list).toHaveLength(0)
+    expect(result.next).toBeNull()
+  })
+
+  it('supports ascending order', async () => {
+    const docs = await seedDocs(3)
+
+    const ascResult = await paginate(collection, {
+      filter: {},
+      limit: 3,
+      order: 'asc',
+      cursorField: 'createdAt',
+    })
+
+    expect(ascResult.list[0].name).toBe(docs[0].name)
+  })
+
+  it('supports descending order', async () => {
+    const docs = await seedDocs(3)
+
+    const descResult = await paginate(collection, {
+      filter: {},
+      limit: 3,
+      order: 'desc',
+      cursorField: 'createdAt',
+    })
+
+    expect(descResult.list[0].name).toBe(docs[2].name)
+  })
+
+  it('paginates with cursor (next page)', async () => {
+    await seedDocs(7)
+
+    // first page
+    const firstPage = await paginate(collection, {
+      filter: {},
+      limit: 3,
+      order: 'asc',
+      cursorField: 'createdAt',
+    })
+
+    expect(firstPage.list).toHaveLength(3)
+    expect(firstPage.next).toBeDefined()
+
+    // second page using cursor
+    const secondPage = await paginate(collection, {
+      filter: {},
+      limit: 3,
+      order: 'asc',
+      cursorField: 'createdAt',
+      cursor: firstPage.next,
+    })
+
+    expect(secondPage.list).toHaveLength(3)
+    // validate no overlap between first and second page
+    expect(secondPage.list[0]._id.toString()).not.toBe(
+      firstPage.list[0]._id.toString(),
+    )
+    expect(secondPage.list.map((d) => d._id.toString())).not.toEqual(
+      firstPage.list.map((d) => d._id.toString()),
+    )
+  })
+
+  it('paginates with stringified ObjectId as cursor', async () => {
+    const docs = await seedDocs(5)
+
+    // @ts-ignore
+    const stringCursor = docs[2]._id.toString()
+
+    const page = await paginate(collection, {
+      filter: {},
+      limit: 2,
+      order: 'asc',
+      cursorField: '_id',
+      cursor: stringCursor,
+    })
+
+    expect(page.list).toHaveLength(2)
+
+    // @ts-ignore
+    expect(page.list[0]._id.toString()).toBe(docs[3]._id.toString())
+    // @ts-ignore
+    expect(page.list[1]._id.toString()).toBe(docs[4]._id.toString())
+  })
+})

package/tests/resources/docker-mongo-test.js

@@ -0,0 +1,103 @@
+import { execSync } from 'node:child_process'
+
+/**
+ * Start a MongoDB Docker container for testing (standalone)
+ * @param {number} port - Host port for MongoDB
+ * @param {string} containerName - Name of the Docker container
+ */
+export function startMongo(port = 27027, containerName = 'mongo-test') {
+  console.log(`[MongoTest] Starting MongoDB on port ${port}...`)
+
+  stopMongo(containerName)
+
+  // Start MongoDB detached
+  execSync(`docker run -d --name ${containerName} -p ${port}:27017 mongo:6.0`, {
+    stdio: 'inherit',
+  })
+
+  waitForMongo(port)
+}
+
+/**
+ * Start a MongoDB Replica Set Docker container for testing
+ * @param {number} port - Host port for MongoDB
+ * @param {string} containerName - Name of the Docker container
+ * @param {string} replSet - Replica set name
+ */
+export function startMongoReplicaSet(
+  port = 27027,
+  containerName = 'mongo-rs-test',
+  replSet = 'rs0',
+) {
+  console.log(
+    `[MongoTest] Starting MongoDB Replica Set "${replSet}" on port ${port}...`,
+  )
+
+  try {
+    // Run mongo with replica set enabled
+    execSync(
+      `docker run -d --name ${containerName} -p ${port}:27017 mongo:6.0 mongod --replSet ${replSet} --bind_ip_all`,
+      { stdio: 'inherit' },
+    )
+
+    waitForMongo(port)
+
+    // Initialize replica set
+    console.log(`[MongoTest] Initializing replica set "${replSet}"...`)
+    execSync(
+      `docker exec ${containerName} mongosh --eval "rs.initiate({_id: '${replSet}', members:[{ _id:0, host: 'localhost:${port}' }]})"`,
+      { stdio: 'inherit' },
+    )
+  } catch {
+    console.warn(`[MongoTest] Replica set may already be initiated.`)
+  }
+}
+
+/**
+ * Stop and remove the MongoDB Docker container
+ * @param {string} containerName
+ */
+export function stopMongo(containerName = 'mongo-test') {
+  console.log(`[MongoTest] Stopping MongoDB...`)
+  try {
+    execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' })
+  } catch {}
+}
+
+function isConnected(port) {
+  try {
+    execSync(`mongosh --port ${port} --eval "db.runCommand({ ping: 1 })"`, {
+      stdio: 'ignore',
+    })
+    return true
+  } catch {
+    return false
+  }
+}
+/**
+ * Wait until MongoDB is ready to accept connections
+ * @param {number} port
+ */
+function waitForMongo(port) {
+  console.log(`[MongoTest] Waiting for MongoDB to be ready...`)
+  const maxRetries = 20
+  let retries = 0
+  let connected = false
+
+  while (!connected && retries < maxRetries) {
+    try {
+      connected = isConnected(port)
+      retries++
+    } catch {
+      retries++
+      execSync(`sleep 1`)
+    }
+  }
+
+  if (!connected) {
+    throw new Error(
+      `[MongoTest] MongoDB failed to start within ${maxRetries} seconds`,
+    )
+  }
+  console.log(`[MongoTest] MongoDB is ready.`)
+}

package/tests/resources/server-to-mongo.js

@@ -18,6 +18,7 @@ export function buildServer() {
 
   // POST /search with body { where: {...} }
   app.post('/search', async (req) => {
+    // @ts-ignore
     const dsl = normalizeOperators(req.body?.where || {})
     const mongo = toMongo(dsl)
     return { dsl, mongo }