feat: catch the expections from response.text()

Author: Camille Croci

packages/fetch-error-handler/README.md

@@ -14,6 +14,7 @@ Properly handle fetch errors and avoid a lot of boilerplate in your app. This mo
     * [Abort and timeout errors](#abort-and-timeout-errors)
     * [Socket errors](#socket-errors)
     * [Invalid JSON errors](#invalid-json-errors)
+    * [Invalid body errors](#invalid-body-errors)
     * [Unknown errors](#unknown-errors)
   * [Creating your own handler](#creating-your-own-handler)
   * [`createFetchErrorHandler` configuration options](#createfetcherrorhandler-configuration-options)
@@ -158,6 +159,17 @@ error.data.responseBody // The body of the initial response
 > [!IMPORTANT]<br />
 > If the body is too long, we are truncating it because Splunk has a limit of characters to log.
 
+#### Invalid body errors
+
+When decrypting the body of the reponse, it is possible that the .text() method throw an [exception](https://developer.mozilla.org/en-US/docs/Web/API/Response/text#exceptions). In that case, we will throw an [`OperationalError`](https://github.com/Financial-Times/dotcom-reliability-kit/tree/main/packages/errors#operationalerror). This error will have the following properties to help you debug:
+
+```js
+error.statusCode // 502
+error.code // FETCH_BODY_ABORT_ERROR or FETCH_BODY_TYPE_ERROR depending on the cause
+error.message // A more human readable explaination of the exception
+error.cause // The cause of the error parsing the body
+```
+
 #### Unknown errors
 
 If the URL you fetched responds with an `ok` property of `false` and a status code outside of the `400–599` range, then it's unclear what's happened but we reject with an error anyway to make sure we're able to debug. We output an [`HTTPError`](https://github.com/Financial-Times/dotcom-reliability-kit/tree/main/packages/errors#httperror):

packages/fetch-error-handler/lib/create-handler.js

@@ -177,11 +177,38 @@ function createFetchErrorHandler(options = {}) {
 				// And we want the consuming apps to still be able to read it if necessary
 				const clonedResponse = response.clone();
 
-				const contentType = clonedResponse.headers?.get('content-type');
-				const rawResponseBody = await clonedResponse.text();
+				let rawResponseBody;
+				try {
+					rawResponseBody = await clonedResponse.text();
+				} catch (/** @type {any} */ error) {
+					if (error?.name === 'AbortError') {
+						throw new OperationalError({
+							code: 'FETCH_BODY_ABORT_ERROR',
+							message:
+								'The request was cancelled or the connection was closed before the full body could be read.',
+							relatesToSystems,
+							cause: error
+						});
+					}
+
+					if (error?.name === 'TypeError') {
+						throw new OperationalError({
+							code: 'FETCH_BODY_TYPE_ERROR',
+							message:
+								'The body might be distubed or locked, or the content encoding was invalid',
+							relatesToSystems,
+							cause: error
+						});
+					}
+
+					// We don't know what to do with this error so
+					// we throw it as-is
+					throw error;
+				}
 
+				const contentType = clonedResponse.headers?.get('content-type');
 				let bodyIsInvalidJson = false;
-				if (contentType?.includes('application/json')) {
+				if (contentType?.includes('application/json') && rawResponseBody) {
 					try {
 						// Attempt to parse the response body as JSON...
 						responseBody = JSON.parse(rawResponseBody);

packages/fetch-error-handler/test/unit/lib/create-handler.spec.js

@@ -292,6 +292,58 @@ describe('@dotcom-reliability-kit/fetch-error-handler/lib/create-handler', () =>
 					}
 				});
 			});
+
+			describe('when `response.text()` throws an AbortError exception', () => {
+				it('rejects with an augmented error', async () => {
+					const mockError = Object.assign(new Error('mock abort error'), {
+						name: 'AbortError'
+					});
+
+					const mockResponse = {
+						ok: true,
+						status: 200,
+						url: 'https://mock.com/example',
+						headers: {
+							get: jest.fn(() => 'application/json')
+						},
+						clone: jest.fn(() => mockResponse),
+						text: jest.fn().mockRejectedValue(mockError)
+					};
+					expect.assertions(4);
+					try {
+						await fetchErrorHandler(mockResponse);
+					} catch (error) {
+						expect(error).toBeInstanceOf(Error);
+						expect(error.name).toStrictEqual('OperationalError');
+						expect(error.code).toStrictEqual('FETCH_BODY_ABORT_ERROR');
+						expect(error.cause).toStrictEqual(mockError);
+					}
+				});
+			});
+
+			describe('when `response.text()` throws an TypeError exception', () => {
+				it('rejects with an augmented error', async () => {
+					const mockResponse = {
+						ok: true,
+						status: 200,
+						url: 'https://mock.com/example',
+						headers: {
+							get: jest.fn(() => 'application/json')
+						},
+						clone: jest.fn(() => mockResponse),
+						text: jest.fn().mockRejectedValue(new TypeError('mock body lock'))
+					};
+					expect.assertions(4);
+					try {
+						await fetchErrorHandler(mockResponse);
+					} catch (error) {
+						expect(error).toBeInstanceOf(Error);
+						expect(error.name).toStrictEqual('OperationalError');
+						expect(error.code).toStrictEqual('FETCH_BODY_TYPE_ERROR');
+						expect(error.cause.message).toStrictEqual('mock body lock');
+					}
+				});
+			});
 		});
 
 		describe('fetchErrorHandler(responsePromise)', () => {