core-services-sdk 1.3.88 → 1.3.89

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-services-sdk",
-  "version": "1.3.88",
+  "version": "1.3.89",
   "main": "src/index.js",
   "type": "module",
   "types": "types/index.d.ts",

package/src/rabbit-mq/rabbit-mq.js

@@ -13,6 +13,18 @@ import { mask } from '../util/mask-sensitive.js'
 
 const generateMsgId = () => `rbt_${ulid()}`
 
+/**
+ * Validates a RabbitMQ queue name.
+ *
+ * @param {string} queue
+ * @throws {Error} If queue name is invalid
+ */
+const assertValidQueueName = (queue) => {
+  if (!queue || typeof queue !== 'string' || !queue.trim()) {
+    throw new Error(`Invalid queue name: "${queue}"`)
+  }
+}
+
 /**
  * Connects to a RabbitMQ server.
  *
@@ -191,19 +203,15 @@ export const subscribeToQueue = async ({
 }) => {
   const logger = log.child({ op: 'subscribeToQueue', queue })
 
-  if (!queue || !queue.trim()) {
-    const message = 'Cannot subscribe to RabbitMQ with an empty queue name'
-    logger.error({ error: message })
-    throw new Error(message)
-  }
+  try {
+    assertValidQueueName(queue)
 
-  if (typeof onReceive !== 'function') {
-    const message = `Cannot subscribe to queue "${queue}" because onReceive is not a function`
-    logger.error({ error: message })
-    throw new Error(message)
-  }
+    if (typeof onReceive !== 'function') {
+      const message = `Cannot subscribe to queue "${queue}" because onReceive is not a function`
+      logger.error({ error: message })
+      throw new Error(message)
+    }
 
-  try {
     await channel.assertQueue(queue, { durable: true })
 
     if (prefetch) {
@@ -282,6 +290,8 @@ export const initializeQueue = async ({ host, log }) => {
    * @returns {Promise<boolean>} True if the message was sent successfully
    */
   const publish = async (queue, data, correlationId) => {
+    assertValidQueueName(queue)
+
     const msgId = generateMsgId()
     const t0 = Date.now()
     const logChild = logger.child({
@@ -296,6 +306,7 @@ export const initializeQueue = async ({ host, log }) => {
 
       await channel.assertQueue(queue, { durable: true })
       const payload = { msgId, data, correlationId }
+
       const sent = channel.sendToQueue(
         queue,
         Buffer.from(JSON.stringify(payload)),

package/src/rabbit-mq/start-stop-rabbitmq.js

@@ -31,39 +31,24 @@ import { execSync } from 'node:child_process'
 export function startRabbit({ containerName, ...rest }) {
   console.log(`[RabbitTest] Starting RabbitMQ...`)
 
-  try {
-    execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' })
-  } catch {}
-
-  // Kill any containers that might still be holding the ports
-  for (const port of [rest.amqpPort, rest.uiPort]) {
-    try {
-      const id = execSync(`docker ps -q --filter "publish=${port}"`, {
-        encoding: 'utf8',
-      }).trim()
-      if (id) {
-        execSync(`docker rm -f ${id}`, { stdio: 'ignore' })
-      }
-    } catch {}
-  }
-
-  execSync(
-    `docker run -d \
+  const dockerRunCmd = `docker run -d \
         --name ${containerName} \
         -e RABBITMQ_DEFAULT_USER=${rest.user} \
         -e RABBITMQ_DEFAULT_PASS=${rest.pass} \
         -p ${rest.amqpPort}:5672 \
         -p ${rest.uiPort}:15672 \
-        --tmpfs /var/lib/rabbitmq \
         --health-cmd="rabbitmq-diagnostics -q ping" \
         --health-interval=5s \
         --health-timeout=5s \
         --health-retries=10 \
-        rabbitmq:3-management`,
-    { stdio: 'inherit' },
-  )
+        rabbitmq:3-management`
 
-  waitForRabbitHealthy(containerName)
+  cleanupContainer(containerName, [rest.amqpPort, rest.uiPort])
+  execSync(dockerRunCmd, { stdio: 'ignore' })
+  waitForRabbitHealthy(containerName, dockerRunCmd, [
+    rest.amqpPort,
+    rest.uiPort,
+  ])
 }
 
 /**
@@ -79,53 +64,92 @@ export function startRabbit({ containerName, ...rest }) {
 export function stopRabbit(containerName = 'rabbit-test') {
   console.log(`[RabbitTest] Stopping RabbitMQ...`)
   try {
-    execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' })
+    execSync(`docker rm -fv ${containerName}`, { stdio: 'ignore' })
   } catch (error) {
     console.error(`[RabbitTest] Failed to stop RabbitMQ: ${error}`)
   }
 }
 
+function cleanupContainer(containerName, ports = []) {
+  try {
+    execSync(`docker rm -fv ${containerName}`, { stdio: 'ignore' })
+  } catch {}
+
+  for (const port of ports) {
+    try {
+      const id = execSync(`docker ps -q --filter "publish=${port}"`, {
+        encoding: 'utf8',
+      }).trim()
+      if (id) {
+        execSync(`docker rm -fv ${id}`, { stdio: 'ignore' })
+      }
+    } catch {}
+  }
+}
+
 /**
  * Waits until the RabbitMQ Docker container reports a healthy status.
  *
- * Polls the container health status using `docker inspect` and retries
- * for a fixed amount of time before failing.
+ * If the container crashes (e.g. due to Docker volume initialization race
+ * on macOS), it is automatically recreated and retried.
  *
  * @param {string} containerName
  *   Docker container name.
  *
+ * @param {string} dockerRunCmd
+ *   The docker run command to recreate the container if it crashes.
+ *
+ * @param {number[]} ports
+ *   Host ports to clean up when recreating.
+ *
  * @returns {void}
  *
  * @throws {Error}
  *   Throws if the container does not become healthy within the timeout.
  */
-function waitForRabbitHealthy(containerName) {
+function waitForRabbitHealthy(containerName, dockerRunCmd, ports) {
   console.log(`[RabbitTest] Waiting for RabbitMQ to be healthy...`)
 
-  const maxRetries = 60
+  const maxRetries = 90
+  const maxRestarts = 3
   let retries = 0
+  let restarts = 0
 
   while (retries < maxRetries) {
+    // Check if the container has crashed
     try {
-      const output = execSync(
-        `docker inspect --format='{{.State.Health.Status}}' ${containerName}`,
+      const status = execSync(
+        `docker inspect --format='{{.State.Status}}' ${containerName}`,
         { encoding: 'utf8' },
       ).trim()
 
-      if (output === 'healthy') {
-        console.log(`[RabbitTest] RabbitMQ is ready.`)
-        return
-      }
-
-      if (retries % 10 === 0 && retries > 0) {
+      if (status === 'exited' || status === 'dead') {
+        if (restarts >= maxRestarts) {
+          break
+        }
+        restarts++
         console.log(
-          `[RabbitTest] Still waiting... Status: ${output} (${retries}/${maxRetries})`,
+          `[RabbitTest] Container crashed, restarting (${restarts}/${maxRestarts})...`,
         )
+        cleanupContainer(containerName, ports)
+        execSync(dockerRunCmd, { stdio: 'ignore' })
+        execSync('sleep 2')
+        retries++
+        continue
       }
+    } catch {}
+
+    try {
+      execSync(
+        `docker exec ${containerName} rabbitmq-diagnostics -q ping`,
+        { stdio: 'ignore' },
+      )
+      console.log(`[RabbitTest] RabbitMQ is ready.`)
+      return
     } catch {
       if (retries % 10 === 0 && retries > 0) {
         console.log(
-          `[RabbitTest] Container not ready yet (${retries}/${maxRetries})`,
+          `[RabbitTest] Still waiting... (${retries}/${maxRetries})`,
         )
       }
     }

package/tests/rabbit-mq/rabbit-mq.test.js

@@ -14,11 +14,13 @@ const AMQP_PORT = 5679
 const UI_PORT = 15679
 const USER = 'test'
 const PASS = 'test'
-const QUEUE = 'integration-test-queue'
 
 const log = pino({
   level: 'silent',
 })
+
+const uniqueQueue = (name) => `${name}-${Date.now()}-${Math.random()}`
+
 // @ts-ignore
 async function waitForRabbitConnection({ uri, log, timeoutMs = 30000 }) {
   const start = Date.now()
@@ -36,12 +38,7 @@ async function waitForRabbitConnection({ uri, log, timeoutMs = 30000 }) {
 }
 
 describe('RabbitMQ integration', () => {
-  // @ts-ignore
   let rabbit
-  // @ts-ignore
-  let unsubscribe
-  // @ts-ignore
-  let receivedMessages
 
   beforeAll(async () => {
     startRabbit({
@@ -66,11 +63,6 @@ describe('RabbitMQ integration', () => {
 
   afterAll(async () => {
     try {
-      // @ts-ignore
-      if (unsubscribe) {
-        await unsubscribe()
-      }
-      // @ts-ignore
       if (rabbit) {
         await rabbit.close()
       }
@@ -80,42 +72,81 @@ describe('RabbitMQ integration', () => {
   })
 
   it('should publish, consume, unsubscribe, and stop consuming', async () => {
-    receivedMessages = []
+    const queue = uniqueQueue('integration')
+    const receivedMessages = []
 
-    // @ts-ignore
-    unsubscribe = await rabbit.subscribe({
-      queue: QUEUE,
-      // @ts-ignore
+    const unsubscribe = await rabbit.subscribe({
+      queue,
       onReceive: async (data) => {
         receivedMessages.push(data)
       },
     })
 
-    // @ts-ignore
-    await rabbit.publish(QUEUE, { step: 1 })
+    await rabbit.publish(queue, { step: 1 })
     await waitFor(() => receivedMessages.length === 1)
 
-    // @ts-ignore
     expect(receivedMessages).toEqual([{ step: 1 }])
 
     await unsubscribe()
 
-    // @ts-ignore
-    await rabbit.publish(QUEUE, { step: 2 })
+    await rabbit.publish(queue, { step: 2 })
 
-    await sleep(1000)
+    await sleep(500)
 
-    // @ts-ignore
     expect(receivedMessages).toEqual([{ step: 1 }])
   })
+
+  describe('RabbitMQ queue name validation', () => {
+    it('should throw when subscribing with invalid queues', async () => {
+      const cases = [undefined, '', '   ']
+
+      for (const queue of cases) {
+        await expect(
+          rabbit.subscribe({
+            queue,
+            onReceive: async () => {},
+          }),
+        ).rejects.toThrow('Invalid queue name')
+      }
+    })
+
+    it('should throw when publishing with invalid queues', async () => {
+      const cases = [undefined, '', '   ']
+
+      for (const queue of cases) {
+        await expect(rabbit.publish(queue, { test: true })).rejects.toThrow(
+          'Invalid queue name',
+        )
+      }
+    })
+
+    it('should not affect valid queue when invalid publish is attempted', async () => {
+      const queue = uniqueQueue('validation')
+      const messages = []
+
+      const unsub = await rabbit.subscribe({
+        queue,
+        onReceive: async (data) => {
+          messages.push(data)
+        },
+      })
+
+      await rabbit.publish(queue, { ok: true })
+      await waitFor(() => messages.length === 1)
+
+      expect(messages).toEqual([{ ok: true }])
+
+      await expect(rabbit.publish(undefined, { bad: true })).rejects.toThrow()
+
+      await sleep(300)
+
+      expect(messages).toEqual([{ ok: true }])
+
+      await unsub()
+    })
+  })
 })
 
-/**
- * Waits until a condition becomes true or times out.
- *
- * @param {() => boolean} predicate
- * @param {number} timeoutMs
- */
 async function waitFor(predicate, timeoutMs = 5000) {
   const start = Date.now()
 
@@ -129,11 +160,6 @@ async function waitFor(predicate, timeoutMs = 5000) {
   throw new Error('Condition not met within timeout')
 }
 
-/**
- * Sleeps for the given number of milliseconds.
- *
- * @param {number} ms
- */
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms))
 }

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

@@ -15,7 +15,7 @@ export function startMongo(port = 27027, containerName = 'mongo-test') {
     stdio: 'inherit',
   })
 
-  waitForMongo(port)
+  waitForMongo(port, containerName)
 }
 
 /**
@@ -40,7 +40,7 @@ export function startMongoReplicaSet(
       { stdio: 'inherit' },
     )
 
-    waitForMongo(port)
+    waitForMongo(port, containerName)
 
     // Initialize replica set
     console.log(`[MongoTest] Initializing replica set "${replSet}"...`)
@@ -60,15 +60,16 @@ export function startMongoReplicaSet(
 export function stopMongo(containerName = 'mongo-test') {
   console.log(`[MongoTest] Stopping MongoDB...`)
   try {
-    execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' })
+    execSync(`docker rm -fv ${containerName}`, { stdio: 'ignore' })
   } catch {}
 }
 
-function isConnected(port) {
+function isConnected(port, containerName) {
   try {
-    execSync(`mongosh --port ${port} --eval "db.runCommand({ ping: 1 })"`, {
-      stdio: 'ignore',
-    })
+    execSync(
+      `docker exec ${containerName} mongosh --port 27017 --eval "db.runCommand({ ping: 1 })"`,
+      { stdio: 'ignore' },
+    )
     return true
   } catch {
     return false
@@ -78,14 +79,14 @@ function isConnected(port) {
  * Wait until MongoDB is ready to accept connections
  * @param {number} port
  */
-function waitForMongo(port) {
+function waitForMongo(port, containerName) {
   console.log(`[MongoTest] Waiting for MongoDB to be ready...`)
   const maxRetries = 60
   let retries = 0
   let connected = false
 
   while (!connected && retries < maxRetries) {
-    connected = isConnected(port)
+    connected = isConnected(port, containerName)
     if (!connected) {
       retries++
       execSync(`sleep 1`)