core-services-sdk 1.3.86 → 1.3.87

package/package.json

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

package/src/http/http.js

@@ -183,6 +183,45 @@ const getResponsePayload = async (response, responseType) => {
   }
 }
 
+/**
+ * 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
+ * - 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' ||
+    body instanceof URLSearchParams ||
+    body instanceof FormData ||
+    body instanceof ArrayBuffer ||
+    body instanceof Blob
+  ) {
+    return { body, headers }
+  }
+
+  return {
+    body: JSON.stringify(body),
+    headers: {
+      'Content-Type': 'application/json',
+      ...headers,
+    },
+  }
+}
+
 /**
  * Sends an HTTP GET request.
  *
@@ -219,11 +258,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: { ...JSON_HEADER, ...preparedHeaders },
+    body: preparedBody,
   })
   await checkStatus(response)
   return getResponsePayload(response, expectedType)
@@ -243,11 +286,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: { ...JSON_HEADER, ...preparedHeaders },
+    body: preparedBody,
   })
   await checkStatus(response)
   return getResponsePayload(response, expectedType)
@@ -267,11 +314,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: { ...JSON_HEADER, ...preparedHeaders },
+    body: preparedBody,
   })
   await checkStatus(response)
   return getResponsePayload(response, expectedType)
@@ -291,11 +342,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: { ...JSON_HEADER, ...preparedHeaders },
+    ...(preparedBody ? { body: preparedBody } : {}),
   })
   await checkStatus(response)
   return getResponsePayload(response, expectedType)
@@ -328,8 +383,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 +393,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,141 @@
+// @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 collectBody(req) {
+  return new Promise((resolve) => {
+    const chunks = []
+
+    req.on('data', (chunk) => {
+      chunks.push(chunk)
+    })
+
+    req.on('end', () => {
+      resolve(Buffer.concat(chunks).toString())
+    })
+  })
+}
+
+beforeAll(async () => {
+  server = httpServer.createServer(async (req, res) => {
+    const body = await collectBody(req)
+
+    res.setHeader('content-type', 'application/json')
+
+    res.end(
+      JSON.stringify({
+        method: req.method,
+        headers: req.headers,
+        body,
+      }),
+    )
+  })
+
+  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 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 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 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)
+  })
+})

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/**',