[Feat][DEVX-619]: Add Custom headersWithStringBody to HttpMiddlewareOptions (#1129)

* feat(sdk-client-v3): implement custom header option

- add httpMiddleware option to stringify request body on demand
- add validation to ensure provided option is correct
- add unit tests to validate new functionality and also no regression

* Create sharp-files-end.md

Add release changeset

* chore(sdk-client-v3): implement feedback

- rename the option to

Author: ajimae

.changeset/sharp-files-end.md

@@ -0,0 +1,8 @@
+---
+'@commercetools/ts-client': minor
+---
+
+Add custom `stringBodyContentTypes` to `HttpMiddlewareOptions`
+Sometimes we might want to `stringify` a request body before sending it over to
+server, this functionality allows the user to add custom `header` entries that
+forces the request body to be `stringified` before it's sent over to the backend.

packages/sdk-client-v3/src/middleware/create-http-middleware.ts

@@ -22,6 +22,7 @@ import {
   isBuffer,
   maskAuthData,
   validateHttpClientOptions,
+  validateStringBodyHeaderOptions,
 } from '../utils'
 
 async function executeRequest({
@@ -132,7 +133,7 @@ async function executeRequest({
 export default function createHttpMiddleware(
   options: HttpMiddlewareOptions
 ): Middleware {
-  // validate response
+  // validate options
   validateHttpClientOptions(options)
 
   const {
@@ -148,13 +149,17 @@ export default function createHttpMiddleware(
     includeResponseHeaders = true,
     maskSensitiveHeaderData,
     httpClientOptions,
+    stringBodyContentTypes = [],
   } = options
 
   return (next: Next) => {
     return async (request: MiddlewareRequest): Promise<MiddlewareResponse> => {
       const url = host.replace(/\/$/, '') + request.uri
       const requestHeader: JsonObject<QueryParam> = { ...request.headers }
 
+      // validate custom header
+      validateStringBodyHeaderOptions(stringBodyContentTypes)
+
       // validate header
       if (
         !(
@@ -172,9 +177,10 @@ export default function createHttpMiddleware(
 
       // Ensure body is a string if content type is application/{json|graphql}
       const body: Record<string, any> | string | Uint8Array =
-        (constants.HEADERS_CONTENT_TYPES.indexOf(
-          requestHeader['Content-Type'] as string
-        ) > -1 &&
+        ([
+          ...constants.HEADERS_CONTENT_TYPES,
+          ...stringBodyContentTypes,
+        ].indexOf(requestHeader['Content-Type'] as string) > -1 &&
           typeof request.body === 'string') ||
         isBuffer(request.body)
           ? request.body

packages/sdk-client-v3/src/types/types.d.ts

@@ -218,6 +218,7 @@ export type HttpMiddlewareOptions = {
   enableRetry?: boolean
   retryConfig?: RetryOptions
   httpClient?: Function
+  stringBodyContentTypes?: Array<string>
   httpClientOptions?: object // will be passed as a second argument to your httpClient function for configuration
   getAbortController?: () => AbortController
 }

packages/sdk-client-v3/src/utils/index.ts

@@ -20,5 +20,6 @@ export { default as userAgent } from './userAgent'
 export {
     validate,
     // validateUserAgentOptions,
+    validateStringBodyHeaderOptions,
     validateClient, validateHttpClientOptions, validateRetryCodes
 } from './validate'

packages/sdk-client-v3/src/utils/validate.ts

@@ -84,3 +84,16 @@ export function validate(
       `The "${funcName}" Request object requires a valid method. See https://commercetools.github.io/nodejs/sdk/Glossary.html#clientrequest`
     )
 }
+
+/**
+ * @param option
+ */
+export function validateStringBodyHeaderOptions(
+  stringBodyContentTypes: string[]
+) {
+  if (!Array.isArray(stringBodyContentTypes)) {
+    throw new Error(
+      '`stringBodyContentTypes` option must be an array of strings'
+    )
+  }
+}

packages/sdk-client-v3/tests/http.test/http-middleware.test.ts

@@ -95,6 +95,29 @@ describe('Http Middleware.', () => {
     )
   })
 
+  // test('should throw if httpClient is provided but not a function.', async () => {
+  test('throw when a non-array option is passed as stringBodyContentTypes in the httpMiddlewareOptions', async () => {
+    const response = createTestResponse({})
+
+    const httpMiddlewareOptions = {
+      host: 'http://api-host.com',
+      httpClient: jest.fn(() => response),
+      stringBodyContentTypes: null,
+    }
+
+    try {
+      const next = () => response
+      await createHttpMiddleware(httpMiddlewareOptions)(next)(
+        createTestRequest({})
+      )
+    } catch (err) {
+      expect(err).toBeDefined()
+      expect(err.message).toMatch(
+        '`stringBodyContentTypes` option must be an array of strings'
+      )
+    }
+  })
+
   test('should execute a GET request and return a json body.', async () => {
     const response = createTestResponse({
       body: {},
@@ -469,6 +492,89 @@ describe('Http Middleware.', () => {
     }
   })
 
+  test('should have no effect on a string body.', async () => {
+    const _response = {
+      data: { id: 'resource-id-123' },
+      statusCode: 200,
+    }
+
+    const response = createTestResponse({
+      text: () => Promise.resolve(JSON.stringify(_response)), // this is not a text response
+    })
+
+    const request = createTestRequest({
+      uri: '/test-custom-header',
+      method: 'POST',
+      body: 'this is a string body',
+      headers: {
+        'Content-Type': 'foo',
+      },
+    })
+
+    const httpMiddlewareOptions: HttpMiddlewareOptions = {
+      host: 'http://api-host.com',
+      httpClient: jest.fn(() => response),
+      stringBodyContentTypes: ['foo'],
+    }
+
+    const next = (req: MiddlewareRequest) => {
+      expect(req.body).toBeDefined()
+      expect(typeof req.body).toEqual('string')
+      return response
+    }
+
+    await createHttpMiddleware(httpMiddlewareOptions)(next)(request)
+  })
+
+  test('should stringify request body if header is included and body is not a string.', async () => {
+    const _response = {
+      data: { id: 'resource-id-123' },
+      statusCode: 200,
+    }
+
+    const response = createTestResponse({
+      text: () => Promise.resolve(JSON.stringify(_response)),
+    })
+
+    function _fetch(url: string, options: ResponseInit) {
+      expect(url).toBeDefined()
+      expect(options).toBeDefined()
+      return response
+    }
+
+    const request = createTestRequest({
+      uri: '/test-custom-header',
+      method: 'POST',
+      body: { text: 'this is not a string body' },
+      headers: {
+        'Content-Type': 'bar',
+      },
+    })
+
+    const httpMiddlewareOptions: HttpMiddlewareOptions = {
+      host: 'http://api-host.com',
+      stringBodyContentTypes: ['bar'],
+      httpClient: jest
+        .fn()
+        .mockImplementation((url: string, fetchOptions: RequestInit) => {
+          /**
+           * just before the request is sent over to the
+           * server the string should already be stringified
+           */
+          expect(fetchOptions.body).toBe('{"text":"this is not a string body"}')
+          return _fetch(url, fetchOptions)
+        }),
+    }
+
+    const next = (req: MiddlewareRequest) => {
+      expect(req.body).toBeDefined()
+      expect(typeof req.body).toEqual('object')
+      return response
+    }
+
+    await createHttpMiddleware(httpMiddlewareOptions)(next)(request)
+  })
+
   describe('::retry test', () => {
     test('should throw if `retryCode` is not an array', async () => {
       const response = createTestResponse({