core-services-sdk 1.3.83 → 1.3.84

package/package.json

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

package/src/http/http-method.js

@@ -1,7 +1,8 @@
 export const HTTP_METHODS = Object.freeze({
   GET: 'GET',
-  POST: 'POST',
   PUT: 'PUT',
+  HEAD: 'HEAD',
+  POST: 'POST',
   PATCH: 'PATCH',
   DELETE: 'DELETE',
 })

package/src/http/http.js

@@ -55,6 +55,13 @@
  * @property {ResponseTypeValue} [expectedType] - Expected response type.
  */
 
+/**
+ * @typedef {Object} HttpHeadOptions
+ * @property {string} url - The URL to send the request to.
+ * @property {Record<string, string>} [headers] - Optional HTTP headers.
+ * @property {RequestInit} [extraParams] - Additional fetch options.
+ */
+
 import httpStatus from 'http-status'
 import { parseStringPromise } from 'xml2js'
 
@@ -294,6 +301,25 @@ export const deleteApi = async ({
   return getResponsePayload(response, expectedType)
 }
 
+/**
+ * Sends an HTTP HEAD request.
+ *
+ * @param {HttpHeadOptions} options - The request options.
+ * @returns {Promise<Response>} The raw fetch response (headers only).
+ * @throws {HttpError} If the response status is not successful.
+ */
+export const head = async ({ url, headers = {}, extraParams = {} }) => {
+  const response = await fetch(url, {
+    ...extraParams,
+    method: HTTP_METHODS.HEAD,
+    headers: { ...JSON_HEADER, ...headers },
+  })
+
+  await checkStatus(response)
+
+  return response
+}
+
 /**
  * Consolidated HTTP client with methods for common HTTP operations.
  *
@@ -302,13 +328,16 @@ export const deleteApi = async ({
  *   put: (options: HttpPutOptions) => Promise<any>,
  *   post: (options: HttpPostOptions) => Promise<any>,
  *   patch: (options: HttpPatchOptions) => Promise<any>,
- *   deleteApi: (options: HttpDeleteOptions) => Promise<any>
+ *   deleteApi: (options: HttpDeleteOptions) => Promise<any>,
+ *   head: (options: HttpHeadOptions) => Promise<Response>
  * }}
  */
+
 export const http = {
   get,
   put,
   post,
   patch,
   deleteApi,
+  head,
 }

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

@@ -6,9 +6,10 @@ import { HTTP_METHODS } from '../../src/http/http-method.js'
 describe('HTTP_METHODS constant', () => {
   it('should include all standard HTTP methods', () => {
     expect(HTTP_METHODS).toEqual({
+      PUT: 'PUT',
       GET: 'GET',
+      HEAD: 'HEAD',
       POST: 'POST',
-      PUT: 'PUT',
       PATCH: 'PATCH',
       DELETE: 'DELETE',
     })

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

@@ -20,6 +20,7 @@ const createMockResponse = ({
     statusText,
     text: vi.fn().mockResolvedValue(body),
     headers: {
+      // @ts-ignore
       get: vi.fn().mockImplementation((k) => headers[k]),
     },
   }
@@ -255,3 +256,143 @@ describe('extraParams support', () => {
     )
   })
 })
+
+describe('HEAD', () => {
+  it('should send a HEAD request and return response object', async () => {
+    const mockResponse = createMockResponse({
+      status: 200,
+      headers: { 'content-length': '1234' },
+    })
+
+    mockFetch.mockResolvedValueOnce(mockResponse)
+
+    const result = await http.head({
+      url: 'http://test.com',
+    })
+
+    expect(result).toBe(mockResponse)
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'http://test.com',
+      expect.objectContaining({
+        method: HTTP_METHODS.HEAD,
+      }),
+    )
+  })
+
+  it('should expose response headers', async () => {
+    const mockResponse = createMockResponse({
+      headers: { etag: 'abc123' },
+    })
+
+    mockFetch.mockResolvedValueOnce(mockResponse)
+
+    const result = await http.head({
+      url: 'http://test.com',
+    })
+
+    expect(result.headers.get('etag')).toBe('abc123')
+  })
+
+  it('should throw HttpError on non-2xx status', async () => {
+    mockFetch.mockResolvedValueOnce(
+      createMockResponse({
+        status: 500,
+        body: 'server error',
+      }),
+    )
+
+    await expect(
+      http.head({
+        url: 'http://test.com',
+      }),
+    ).rejects.toThrow(HttpError)
+  })
+})
+
+describe('edge cases', () => {
+  it('should fallback to text when JSON parsing fails', async () => {
+    const invalidJson = '{invalid json'
+
+    mockFetch.mockResolvedValueOnce(createMockResponse({ body: invalidJson }))
+
+    const result = await http.get({
+      url: 'http://test.com',
+      expectedType: ResponseType.json,
+    })
+
+    expect(result).toBe(invalidJson)
+  })
+
+  it('should fallback to text when XML parsing fails', async () => {
+    const invalidXml = '<note><invalid></note>'
+
+    mockFetch.mockResolvedValueOnce(createMockResponse({ body: invalidXml }))
+
+    const result = await http.get({
+      url: 'http://test.com',
+      expectedType: ResponseType.xml,
+    })
+
+    expect(result).toBe(invalidXml)
+  })
+
+  it('should allow overriding headers', async () => {
+    mockFetch.mockResolvedValueOnce(
+      createMockResponse({ body: JSON.stringify({ ok: true }) }),
+    )
+
+    await http.get({
+      url: 'http://test.com',
+      headers: {
+        Authorization: 'Bearer token123',
+      },
+    })
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'http://test.com',
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Authorization: 'Bearer token123',
+        }),
+      }),
+    )
+  })
+
+  it('should send DELETE request without body', async () => {
+    mockFetch.mockResolvedValueOnce(
+      createMockResponse({ body: JSON.stringify({ ok: true }) }),
+    )
+
+    await http.deleteApi({
+      url: 'http://test.com',
+    })
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'http://test.com',
+      expect.objectContaining({
+        method: HTTP_METHODS.DELETE,
+      }),
+    )
+  })
+
+  it('should include default JSON content-type header', async () => {
+    mockFetch.mockResolvedValueOnce(
+      createMockResponse({ body: JSON.stringify({ ok: true }) }),
+    )
+
+    await http.post({
+      url: 'http://test.com',
+      body: { a: 1 },
+    })
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'http://test.com',
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'Content-Type': 'application/json',
+        }),
+      }),
+    )
+  })
+})

package/types/http/http-method.d.ts

@@ -1,7 +1,8 @@
 export const HTTP_METHODS: Readonly<{
   GET: 'GET'
-  POST: 'POST'
   PUT: 'PUT'
+  HEAD: 'HEAD'
+  POST: 'POST'
   PATCH: 'PATCH'
   DELETE: 'DELETE'
 }>

package/types/http/http.d.ts

@@ -32,6 +32,11 @@ export function deleteApi({
   extraParams,
   expectedType,
 }: HttpDeleteOptions): Promise<any>
+export function head({
+  url,
+  headers,
+  extraParams,
+}: HttpHeadOptions): Promise<Response>
 /**
  * Consolidated HTTP client with methods for common HTTP operations.
  *
@@ -40,7 +45,8 @@ export function deleteApi({
  *   put: (options: HttpPutOptions) => Promise<any>,
  *   post: (options: HttpPostOptions) => Promise<any>,
  *   patch: (options: HttpPatchOptions) => Promise<any>,
- *   deleteApi: (options: HttpDeleteOptions) => Promise<any>
+ *   deleteApi: (options: HttpDeleteOptions) => Promise<any>,
+ *   head: (options: HttpHeadOptions) => Promise<Response>
  * }}
  */
 export const http: {
@@ -49,6 +55,7 @@ export const http: {
   post: (options: HttpPostOptions) => Promise<any>
   patch: (options: HttpPatchOptions) => Promise<any>
   deleteApi: (options: HttpDeleteOptions) => Promise<any>
+  head: (options: HttpHeadOptions) => Promise<Response>
 }
 export type ResponseTypeValue = 'json' | 'xml' | 'text' | 'raw' | 'file'
 export type HttpGetOptions = {
@@ -157,3 +164,17 @@ export type HttpDeleteOptions = {
    */
   expectedType?: ResponseTypeValue
 }
+export type HttpHeadOptions = {
+  /**
+   * - The URL to send the request to.
+   */
+  url: string
+  /**
+   * - Optional HTTP headers.
+   */
+  headers?: Record<string, string>
+  /**
+   * - Additional fetch options.
+   */
+  extraParams?: RequestInit
+}