core-services-sdk 1.3.86 → 1.3.88

package/package.json

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

package/src/http/http.js

@@ -183,6 +183,135 @@ 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.
+ *
+ * Ensures backward compatibility while allowing additional body types.
+ * - undefined/null → no body sent
+ * - string → sent as-is
+ * - 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
+ * @param {Record<string,string>} headers
+ * @returns {{ body:any, headers:Record<string,string> }}
+ */
+const prepareRequestBody = (body, headers = {}) => {
+  if (body === undefined || body === null) {
+    return { body: undefined, headers }
+  }
+
+  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 {
+    ...defaultHeaders,
+    ...preparedHeaders,
+  }
+}
+
 /**
  * Sends an HTTP GET request.
  *
@@ -199,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)
@@ -219,11 +351,15 @@ export const post = async ({
   extraParams = {},
   expectedType = ResponseType.json,
 }) => {
+  const { body: preparedBody, headers: preparedHeaders } = prepareRequestBody(
+    body,
+    headers,
+  )
   const response = await fetch(url, {
     ...extraParams,
     method: HTTP_METHODS.POST,
-    headers: { ...JSON_HEADER, ...headers },
-    body: JSON.stringify(body),
+    headers: resolveHeaders(preparedHeaders, body),
+    body: preparedBody,
   })
   await checkStatus(response)
   return getResponsePayload(response, expectedType)
@@ -243,11 +379,15 @@ export const put = async ({
   extraParams = {},
   expectedType = ResponseType.json,
 }) => {
+  const { body: preparedBody, headers: preparedHeaders } = prepareRequestBody(
+    body,
+    headers,
+  )
   const response = await fetch(url, {
     ...extraParams,
     method: HTTP_METHODS.PUT,
-    headers: { ...JSON_HEADER, ...headers },
-    body: expectedType === ResponseType.json ? JSON.stringify(body) : body,
+    headers: resolveHeaders(preparedHeaders, body),
+    body: preparedBody,
   })
   await checkStatus(response)
   return getResponsePayload(response, expectedType)
@@ -267,11 +407,15 @@ export const patch = async ({
   extraParams = {},
   expectedType = ResponseType.json,
 }) => {
+  const { body: preparedBody, headers: preparedHeaders } = prepareRequestBody(
+    body,
+    headers,
+  )
   const response = await fetch(url, {
     ...extraParams,
     method: HTTP_METHODS.PATCH,
-    headers: { ...JSON_HEADER, ...headers },
-    body: JSON.stringify(body),
+    headers: resolveHeaders(preparedHeaders, body),
+    body: preparedBody,
   })
   await checkStatus(response)
   return getResponsePayload(response, expectedType)
@@ -291,11 +435,15 @@ export const deleteApi = async ({
   extraParams = {},
   expectedType = ResponseType.json,
 }) => {
+  const { body: preparedBody, headers: preparedHeaders } = prepareRequestBody(
+    body,
+    headers,
+  )
   const response = await fetch(url, {
     ...extraParams,
     method: HTTP_METHODS.DELETE,
-    headers: { ...JSON_HEADER, ...headers },
-    ...(body ? { body: JSON.stringify(body) } : {}),
+    headers: resolveHeaders(preparedHeaders, body),
+    ...(preparedBody ? { body: preparedBody } : {}),
   })
   await checkStatus(response)
   return getResponsePayload(response, expectedType)
@@ -312,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)
@@ -328,8 +476,9 @@ export const head = async ({ url, headers = {}, extraParams = {} }) => {
  *   put: (options: HttpPutOptions) => Promise<any>,
  *   post: (options: HttpPostOptions) => Promise<any>,
  *   patch: (options: HttpPatchOptions) => Promise<any>,
- *   deleteApi: (options: HttpDeleteOptions) => Promise<any>,
- *   head: (options: HttpHeadOptions) => Promise<Response>
+ *   head: (options: HttpHeadOptions) => Promise<Response>,
+ *   deleteApi: (options: HttpDeleteOptions) => Promise<any>
+ *
  * }}
  */
 
@@ -337,7 +486,7 @@ export const http = {
   get,
   put,
   post,
+  head,
   patch,
   deleteApi,
-  head,
 }

package/src/postgresql/start-stop-postgres-docker.js

@@ -39,6 +39,16 @@ export function startPostgres({
 
   stopPostgres(containerName)
 
+  // Kill any container that might still be holding the port
+  try {
+    const containerId = execSync(`docker ps -q --filter "publish=${port}"`, {
+      encoding: 'utf8',
+    }).trim()
+    if (containerId) {
+      execSync(`docker rm -f ${containerId}`, { stdio: 'ignore' })
+    }
+  } catch {}
+
   execSync(
     `docker run -d \
       --name ${containerName} \

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

@@ -35,6 +35,18 @@ export function startRabbit({ containerName, ...rest }) {
     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 \
         --name ${containerName} \
@@ -42,6 +54,7 @@ export function startRabbit({ containerName, ...rest }) {
         -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 \

package/tests/http/http.int.test.js

@@ -0,0 +1,310 @@
+// @ts-nocheck
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import httpServer from 'node:http'
+import { http } from '../../src/http/http.js'
+
+let server
+let baseUrl
+
+function collectRaw(req) {
+  return new Promise((resolve) => {
+    const chunks = []
+
+    req.on('data', (chunk) => {
+      chunks.push(chunk)
+    })
+
+    req.on('end', () => {
+      const buffer = Buffer.concat(chunks)
+      resolve(buffer)
+    })
+  })
+}
+
+beforeAll(async () => {
+  server = httpServer.createServer(async (req, res) => {
+    const raw = await collectRaw(req)
+
+    res.setHeader('content-type', 'application/json')
+
+    res.end(
+      JSON.stringify({
+        method: req.method,
+        headers: req.headers,
+        body: raw.toString(),
+        bodyLength: raw.length,
+      }),
+    )
+  })
+
+  await new Promise((resolve) => {
+    server.listen(0, () => {
+      const { port } = server.address()
+      baseUrl = `http://localhost:${port}`
+      resolve()
+    })
+  })
+})
+
+afterAll(async () => {
+  await new Promise((resolve) => server.close(resolve))
+})
+
+describe('http util integration', () => {
+  it('should send JSON body', async () => {
+    const result = await http.post({
+      url: `${baseUrl}/json`,
+      body: { hello: 'world' },
+    })
+
+    expect(result.method).toBe('POST')
+    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`,
+      body: 'plain-text',
+    })
+
+    expect(result.body).toBe('plain-text')
+  })
+
+  it('should support base64 string', async () => {
+    const base64 = Buffer.from('hello').toString('base64')
+
+    const result = await http.post({
+      url: `${baseUrl}/base64`,
+      body: base64,
+    })
+
+    expect(result.body).toBe(base64)
+  })
+
+  it('should support URLSearchParams', async () => {
+    const params = new URLSearchParams({
+      grant_type: 'client_credentials',
+      scope: 'read',
+    })
+
+    const result = await http.post({
+      url: `${baseUrl}/form`,
+      body: params,
+    })
+
+    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`,
+      body: { a: 1 },
+    })
+
+    expect(result.method).toBe('PUT')
+    expect(result.body).toBe(JSON.stringify({ a: 1 }))
+  })
+
+  it('should support PATCH with JSON', async () => {
+    const result = await http.patch({
+      url: `${baseUrl}/patch`,
+      body: { b: 2 },
+    })
+
+    expect(result.method).toBe('PATCH')
+    expect(result.body).toBe(JSON.stringify({ b: 2 }))
+  })
+
+  it('should support DELETE with body', async () => {
+    const result = await http.deleteApi({
+      url: `${baseUrl}/delete`,
+      body: { remove: true },
+    })
+
+    expect(result.method).toBe('DELETE')
+    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`,
+    })
+
+    expect(result.method).toBe('GET')
+  })
+
+  it('should support HEAD request', async () => {
+    const response = await http.head({
+      url: `${baseUrl}/head`,
+    })
+
+    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

@@ -20,7 +20,7 @@ const log = pino({
   level: 'silent',
 })
 // @ts-ignore
-async function waitForRabbitConnection({ uri, log, timeoutMs = 10000 }) {
+async function waitForRabbitConnection({ uri, log, timeoutMs = 30000 }) {
   const start = Date.now()
 
   while (Date.now() - start < timeoutMs) {

package/tests/repositories/BaseRepository.int.test.js

@@ -11,11 +11,11 @@ import {
 import { BaseRepository } from '../../src/postgresql/repositories/BaseRepository.js'
 
 const PG_OPTIONS = {
-  port: 5445,
+  port: 5449,
   db: 'testdb',
   user: 'testuser',
   pass: 'testpass',
-  containerName: 'postgres-base-repo-test-5445',
+  containerName: 'postgres-base-repo-test-5449',
 }
 
 const DATABASE_URI = buildPostgresUri(PG_OPTIONS)

package/tests/repositories/TenantScopedRepository.int.test.js

@@ -11,11 +11,11 @@ import {
 import { TenantScopedRepository } from '../../src/postgresql/repositories/TenantScopedRepository.js'
 
 const PG_OPTIONS = {
-  port: 5446,
+  port: 5448,
   db: 'testdb',
   user: 'testuser',
   pass: 'testpass',
-  containerName: 'postgres-tenant-repo-test-5446',
+  containerName: 'postgres-tenant-repo-test-5448',
 }
 
 const DATABASE_URI = buildPostgresUri(PG_OPTIONS)

package/types/http/http.d.ts

@@ -45,8 +45,9 @@ export function head({
  *   put: (options: HttpPutOptions) => Promise<any>,
  *   post: (options: HttpPostOptions) => Promise<any>,
  *   patch: (options: HttpPatchOptions) => Promise<any>,
- *   deleteApi: (options: HttpDeleteOptions) => Promise<any>,
- *   head: (options: HttpHeadOptions) => Promise<Response>
+ *   head: (options: HttpHeadOptions) => Promise<Response>,
+ *   deleteApi: (options: HttpDeleteOptions) => Promise<any>
+ *
  * }}
  */
 export const http: {
@@ -54,8 +55,8 @@ export const http: {
   put: (options: HttpPutOptions) => Promise<any>
   post: (options: HttpPostOptions) => Promise<any>
   patch: (options: HttpPatchOptions) => Promise<any>
-  deleteApi: (options: HttpDeleteOptions) => Promise<any>
   head: (options: HttpHeadOptions) => Promise<Response>
+  deleteApi: (options: HttpDeleteOptions) => Promise<any>
 }
 export type ResponseTypeValue = 'json' | 'xml' | 'text' | 'raw' | 'file'
 export type HttpGetOptions = {

package/vitest.config.js

@@ -3,7 +3,7 @@ import { defineConfig } from 'vitest/config'
 export default defineConfig({
   test: {
     testTimeout: 30000,
-    hookTimeout: 30000,
+    hookTimeout: 90000,
     exclude: [
       'node_modules',
       'types/**',