core-services-sdk 1.3.87 → 1.3.88

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-services-sdk",
-  "version": "1.3.87",
+  "version": "1.3.88",
   "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/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: {},
+      }),
+    )
+  })
 })