core-services-sdk 1.3.87 → 1.3.89

package/package.json

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

package/src/http/http.js

@@ -183,6 +183,26 @@ const getResponsePayload = async (response, responseType) => {
   }
 }
 
+/**
+ * Checks if value is a Node.js Readable stream.
+ *
+ * @param {any} value
+ * @returns {boolean}
+ */
+const isReadableStream = (value) => {
+  return value && typeof value === 'object' && typeof value.pipe === 'function'
+}
+
+/**
+ * Checks if value is a TypedArray (Uint8Array, etc).
+ *
+ * @param {any} value
+ * @returns {boolean}
+ */
+const isTypedArray = (value) => {
+  return ArrayBuffer.isView(value)
+}
+
 /**
  * Normalizes the request body before sending it via fetch.
  *
@@ -192,6 +212,9 @@ const getResponsePayload = async (response, responseType) => {
  * - URLSearchParams → sent as-is (fetch serializes automatically)
  * - FormData → sent as-is (fetch sets multipart boundary automatically)
  * - ArrayBuffer / Blob → sent as-is
+ * - Buffer → sent as-is
+ * - TypedArray → sent as-is
+ * - Readable stream → sent as-is
  * - object / array → JSON.stringify applied and Content-Type ensured
  *
  * @param {any} body
@@ -203,22 +226,89 @@ const prepareRequestBody = (body, headers = {}) => {
     return { body: undefined, headers }
   }
 
-  if (
-    typeof body === 'string' ||
-    body instanceof URLSearchParams ||
-    body instanceof FormData ||
-    body instanceof ArrayBuffer ||
-    body instanceof Blob
-  ) {
+  if (typeof body === 'string') {
+    return { body, headers }
+  }
+
+  if (body instanceof URLSearchParams) {
+    return { body, headers }
+  }
+
+  if (body instanceof FormData) {
+    return { body, headers }
+  }
+
+  if (Buffer.isBuffer(body)) {
+    return { body, headers }
+  }
+
+  if (body instanceof ArrayBuffer) {
+    return { body, headers }
+  }
+
+  if (isTypedArray(body)) {
+    return { body, headers }
+  }
+
+  if (typeof Blob !== 'undefined' && body instanceof Blob) {
     return { body, headers }
   }
 
+  if (isReadableStream(body)) {
+    return { body, headers }
+  }
+
+  if (typeof body === 'object') {
+    return {
+      body: JSON.stringify(body),
+      headers: {
+        'Content-Type': 'application/json',
+        ...headers,
+      },
+    }
+  }
+
+  return { body, headers }
+}
+
+/**
+ * Resolves headers safely based on body type.
+ *
+ * Adds default headers only when no Content-Type is provided
+ * AND the body is a plain JSON object or array.
+ *
+ * @param {Record<string,string>} preparedHeaders
+ * @param {any} body
+ * @param {Record<string,string>} defaultHeaders
+ * @returns {Record<string,string>}
+ */
+const resolveHeaders = (
+  preparedHeaders = {},
+  body,
+  defaultHeaders = JSON_HEADER,
+) => {
+  const hasContentType = Object.keys(preparedHeaders).some(
+    (key) => key.toLowerCase() === 'content-type',
+  )
+
+  if (hasContentType) {
+    return preparedHeaders
+  }
+
+  const isPlainObject =
+    body !== null && typeof body === 'object' && body.constructor === Object
+
+  const isArray = Array.isArray(body)
+
+  const isJsonCandidate = isPlainObject || isArray
+
+  if (!isJsonCandidate) {
+    return preparedHeaders
+  }
+
   return {
-    body: JSON.stringify(body),
-    headers: {
-      'Content-Type': 'application/json',
-      ...headers,
-    },
+    ...defaultHeaders,
+    ...preparedHeaders,
   }
 }
 
@@ -238,7 +328,10 @@ export const get = async ({
   const response = await fetch(url, {
     ...extraParams,
     method: HTTP_METHODS.GET,
-    headers: { ...JSON_HEADER, ...headers },
+    headers: {
+      Accept: 'application/json',
+      ...headers,
+    },
   })
   await checkStatus(response)
   return getResponsePayload(response, expectedType)
@@ -265,7 +358,7 @@ export const post = async ({
   const response = await fetch(url, {
     ...extraParams,
     method: HTTP_METHODS.POST,
-    headers: { ...JSON_HEADER, ...preparedHeaders },
+    headers: resolveHeaders(preparedHeaders, body),
     body: preparedBody,
   })
   await checkStatus(response)
@@ -293,7 +386,7 @@ export const put = async ({
   const response = await fetch(url, {
     ...extraParams,
     method: HTTP_METHODS.PUT,
-    headers: { ...JSON_HEADER, ...preparedHeaders },
+    headers: resolveHeaders(preparedHeaders, body),
     body: preparedBody,
   })
   await checkStatus(response)
@@ -321,7 +414,7 @@ export const patch = async ({
   const response = await fetch(url, {
     ...extraParams,
     method: HTTP_METHODS.PATCH,
-    headers: { ...JSON_HEADER, ...preparedHeaders },
+    headers: resolveHeaders(preparedHeaders, body),
     body: preparedBody,
   })
   await checkStatus(response)
@@ -349,7 +442,7 @@ export const deleteApi = async ({
   const response = await fetch(url, {
     ...extraParams,
     method: HTTP_METHODS.DELETE,
-    headers: { ...JSON_HEADER, ...preparedHeaders },
+    headers: resolveHeaders(preparedHeaders, body),
     ...(preparedBody ? { body: preparedBody } : {}),
   })
   await checkStatus(response)
@@ -367,7 +460,7 @@ export const head = async ({ url, headers = {}, extraParams = {} }) => {
   const response = await fetch(url, {
     ...extraParams,
     method: HTTP_METHODS.HEAD,
-    headers: { ...JSON_HEADER, ...headers },
+    headers,
   })
 
   await checkStatus(response)

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/http/http.int.test.js

@@ -6,7 +6,7 @@ import { http } from '../../src/http/http.js'
 let server
 let baseUrl
 
-function collectBody(req) {
+function collectRaw(req) {
   return new Promise((resolve) => {
     const chunks = []
 
@@ -15,14 +15,15 @@ function collectBody(req) {
     })
 
     req.on('end', () => {
-      resolve(Buffer.concat(chunks).toString())
+      const buffer = Buffer.concat(chunks)
+      resolve(buffer)
     })
   })
 }
 
 beforeAll(async () => {
   server = httpServer.createServer(async (req, res) => {
-    const body = await collectBody(req)
+    const raw = await collectRaw(req)
 
     res.setHeader('content-type', 'application/json')
 
@@ -30,7 +31,8 @@ beforeAll(async () => {
       JSON.stringify({
         method: req.method,
         headers: req.headers,
-        body,
+        body: raw.toString(),
+        bodyLength: raw.length,
       }),
     )
   })
@@ -59,6 +61,15 @@ describe('http util integration', () => {
     expect(result.body).toBe(JSON.stringify({ hello: 'world' }))
   })
 
+  it('should send array JSON correctly', async () => {
+    const result = await http.post({
+      url: `${baseUrl}/array`,
+      body: [1, 2, 3],
+    })
+
+    expect(result.body).toBe(JSON.stringify([1, 2, 3]))
+  })
+
   it('should send string body without stringify', async () => {
     const result = await http.post({
       url: `${baseUrl}/string`,
@@ -93,6 +104,43 @@ describe('http util integration', () => {
     expect(result.body).toBe(params.toString())
   })
 
+  it('should support Buffer (binary)', async () => {
+    const buffer = Buffer.from('PDF-DATA-TEST')
+
+    const result = await http.post({
+      url: `${baseUrl}/buffer`,
+      body: buffer,
+      headers: {
+        'Content-Type': 'application/pdf',
+      },
+    })
+
+    expect(result.bodyLength).toBe(buffer.length)
+    expect(result.body).toBe(buffer.toString())
+  })
+
+  it('should support Uint8Array (TypedArray)', async () => {
+    const uint8 = new Uint8Array([1, 2, 3, 4])
+
+    const result = await http.post({
+      url: `${baseUrl}/typed`,
+      body: uint8,
+    })
+
+    expect(result.bodyLength).toBe(uint8.length)
+  })
+
+  it('should support ArrayBuffer', async () => {
+    const buffer = new Uint8Array([5, 6, 7]).buffer
+
+    const result = await http.post({
+      url: `${baseUrl}/arraybuffer`,
+      body: buffer,
+    })
+
+    expect(result.bodyLength).toBe(3)
+  })
+
   it('should support PUT with JSON', async () => {
     const result = await http.put({
       url: `${baseUrl}/put`,
@@ -123,6 +171,14 @@ describe('http util integration', () => {
     expect(result.body).toBe(JSON.stringify({ remove: true }))
   })
 
+  it('should not send body when undefined', async () => {
+    const result = await http.post({
+      url: `${baseUrl}/empty`,
+    })
+
+    expect(result.bodyLength).toBe(0)
+  })
+
   it('should support GET request', async () => {
     const result = await http.get({
       url: `${baseUrl}/get`,
@@ -138,4 +194,117 @@ describe('http util integration', () => {
 
     expect(response.status).toBe(200)
   })
+
+  it('should set JSON content-type by default', async () => {
+    const result = await http.post({
+      url: `${baseUrl}/json-header`,
+      body: { a: 1 },
+    })
+
+    expect(result.headers['content-type']).toContain('application/json')
+  })
+
+  it('should allow overriding content-type', async () => {
+    const result = await http.post({
+      url: `${baseUrl}/override-header`,
+      body: { a: 1 },
+      headers: {
+        'Content-Type': 'application/custom+json',
+      },
+    })
+
+    expect(result.headers['content-type']).toContain('application/custom+json')
+  })
+
+  it('should preserve binary content-type', async () => {
+    const buffer = Buffer.from('file')
+
+    const result = await http.post({
+      url: `${baseUrl}/pdf`,
+      body: buffer,
+      headers: {
+        'Content-Type': 'application/pdf',
+      },
+    })
+
+    expect(result.headers['content-type']).toContain('application/pdf')
+  })
+
+  it('should not force JSON content-type for URLSearchParams', async () => {
+    const params = new URLSearchParams({ a: '1' })
+
+    const result = await http.post({
+      url: `${baseUrl}/urlencoded`,
+      body: params,
+    })
+
+    expect(result.headers['content-type']).toContain(
+      'application/x-www-form-urlencoded',
+    )
+  })
+
+  it('should not override multipart content-type for FormData', async () => {
+    const form = new FormData()
+    form.append('field', 'value')
+
+    const result = await http.post({
+      url: `${baseUrl}/multipart`,
+      body: form,
+    })
+
+    expect(result.headers['content-type']).toContain('multipart/form-data')
+  })
+
+  it('should respect content-type for string body', async () => {
+    const result = await http.post({
+      url: `${baseUrl}/text`,
+      body: 'hello',
+      headers: {
+        'Content-Type': 'text/plain',
+      },
+    })
+
+    expect(result.headers['content-type']).toContain('text/plain')
+  })
+
+  it('GET should NOT send content-type header', async () => {
+    const result = await http.get({
+      url: `${baseUrl}/get-no-content-type`,
+    })
+
+    expect(result.headers['content-type']).toBeUndefined()
+  })
+
+  it('should NOT add JSON content-type for Buffer without headers', async () => {
+    const buffer = Buffer.from('binary')
+
+    const result = await http.post({
+      url: `${baseUrl}/buffer-no-header`,
+      body: buffer,
+    })
+
+    expect(result.headers['content-type']).toBeUndefined()
+  })
+
+  it('should NOT add JSON content-type for TypedArray', async () => {
+    const uint8 = new Uint8Array([1, 2, 3])
+
+    const result = await http.post({
+      url: `${baseUrl}/typed-no-header`,
+      body: uint8,
+    })
+
+    expect(result.headers['content-type']).toBeUndefined()
+  })
+
+  it('should NOT add JSON content-type for ArrayBuffer', async () => {
+    const buffer = new Uint8Array([1, 2]).buffer
+
+    const result = await http.post({
+      url: `${baseUrl}/arraybuffer-no-header`,
+      body: buffer,
+    })
+
+    expect(result.headers['content-type']).toBeUndefined()
+  })
 })

package/tests/http/http.unit.test.js

@@ -166,14 +166,13 @@ describe('http client (native fetch)', () => {
   })
 
   describe('PUT with non-JSON body', () => {
-    it('should not stringify body when expectedType is not json', async () => {
+    it('should not stringify string body', async () => {
       const rawBody = 'plain text body'
       mockFetch.mockResolvedValueOnce(createMockResponse({ body: 'OK' }))
 
       await http.put({
         url: 'http://test.com',
         body: rawBody,
-        expectedType: ResponseType.text,
       })
 
       expect(mockFetch).toHaveBeenCalledWith(
@@ -395,4 +394,104 @@ describe('edge cases', () => {
       }),
     )
   })
+
+  it('should NOT add JSON content-type for Buffer', async () => {
+    const buffer = Buffer.from('binary')
+
+    mockFetch.mockResolvedValueOnce(
+      createMockResponse({ body: JSON.stringify({ ok: true }) }),
+    )
+
+    await http.post({
+      url: 'http://test.com',
+      body: buffer,
+    })
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'http://test.com',
+      expect.objectContaining({
+        headers: expect.not.objectContaining({
+          'Content-Type': 'application/json',
+        }),
+      }),
+    )
+  })
+
+  it('should NOT add JSON content-type for TypedArray', async () => {
+    const uint8 = new Uint8Array([1, 2, 3])
+
+    mockFetch.mockResolvedValueOnce(
+      createMockResponse({ body: JSON.stringify({ ok: true }) }),
+    )
+
+    await http.post({
+      url: 'http://test.com',
+      body: uint8,
+    })
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'http://test.com',
+      expect.objectContaining({
+        headers: expect.not.objectContaining({
+          'Content-Type': 'application/json',
+        }),
+      }),
+    )
+  })
+
+  it('should NOT add JSON content-type for ArrayBuffer', async () => {
+    const buffer = new Uint8Array([1, 2]).buffer
+
+    mockFetch.mockResolvedValueOnce(
+      createMockResponse({ body: JSON.stringify({ ok: true }) }),
+    )
+
+    await http.post({
+      url: 'http://test.com',
+      body: buffer,
+    })
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'http://test.com',
+      expect.objectContaining({
+        headers: expect.not.objectContaining({
+          'Content-Type': 'application/json',
+        }),
+      }),
+    )
+  })
+
+  it('should include default Accept header in GET', async () => {
+    mockFetch.mockResolvedValueOnce(
+      createMockResponse({ body: JSON.stringify({ ok: true }) }),
+    )
+
+    await http.get({
+      url: 'http://test.com',
+    })
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'http://test.com',
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Accept: 'application/json',
+        }),
+      }),
+    )
+  })
+
+  it('HEAD should NOT include content-type header', async () => {
+    mockFetch.mockResolvedValueOnce(createMockResponse())
+
+    await http.head({
+      url: 'http://test.com',
+    })
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'http://test.com',
+      expect.objectContaining({
+        headers: {},
+      }),
+    )
+  })
 })

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`)