@mojaloop/central-services-shared 18.30.7 → 18.30.8

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [18.30.8](https://github.com/mojaloop/central-services-shared/compare/v18.30.7...v18.30.8) (2025-09-01)
+
+
+### Bug Fixes
+
+* issue 4198 503 error handling ([#474](https://github.com/mojaloop/central-services-shared/issues/474)) ([8974f81](https://github.com/mojaloop/central-services-shared/commit/8974f81a5a3ee478d8014cff82f3329f51b9c654))
+
 ### [18.30.7](https://github.com/mojaloop/central-services-shared/compare/v18.30.6...v18.30.7) (2025-08-08)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/central-services-shared",
-  "version": "18.30.7",
+  "version": "18.30.8",
   "description": "Shared code for mojaloop central services",
   "license": "Apache-2.0",
   "author": "ModusBox",
@@ -65,7 +65,7 @@
   "dependencies": {
     "@hapi/catbox": "12.1.1",
     "@hapi/catbox-memory": "5.0.1",
-    "@hapi/hapi": "21.4.2",
+    "@hapi/hapi": "21.4.3",
     "@hapi/joi-date": "2.0.1",
     "@mojaloop/inter-scheme-proxy-cache-lib": "2.6.0",
     "@opentelemetry/api": "1.9.0",
@@ -80,10 +80,10 @@
     "fast-safe-stringify": "2.1.1",
     "immutable": "5.1.3",
     "ioredis": "5.7.0",
-    "joi": "18.0.0",
+    "joi": "18.0.1",
     "lodash": "4.17.21",
     "mustache": "4.2.0",
-    "openapi-backend": "5.13.0",
+    "openapi-backend": "5.15.0",
     "raw-body": "3.0.0",
     "rc": "1.2.8",
     "redlock": "5.0.0-beta.2",
@@ -95,11 +95,11 @@
   },
   "devDependencies": {
     "@mojaloop/central-services-error-handling": "13.1.0",
-    "@mojaloop/central-services-logger": "11.9.0",
+    "@mojaloop/central-services-logger": "11.9.1",
     "@mojaloop/central-services-metrics": "12.6.0",
     "@mojaloop/event-sdk": "14.6.1",
-    "@mojaloop/sdk-standard-components": "19.16.4",
-    "@opentelemetry/auto-instrumentations-node": "^0.62.0",
+    "@mojaloop/sdk-standard-components": "19.16.7",
+    "@opentelemetry/auto-instrumentations-node": "^0.62.1",
     "@types/hapi__joi": "17.1.15",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
@@ -107,13 +107,13 @@
     "audit-ci": "7.1.0",
     "base64url": "3.0.1",
     "chance": "1.1.13",
-    "npm-check-updates": "18.0.2",
+    "npm-check-updates": "18.0.3",
     "nyc": "17.1.0",
     "portfinder": "1.0.37",
     "pre-commit": "1.2.2",
     "proxyquire": "2.1.3",
     "replace": "1.2.2",
-    "rewire": "9.0.0",
+    "rewire": "9.0.1",
     "sinon": "21.0.0",
     "standard": "17.1.2",
     "standard-version": "9.5.0",

package/src/util/request.js

@@ -162,6 +162,59 @@ const sendRequest = async ({
       status: error.response?.status,
       data: error.response?.data
     })
+
+    // Check if this is an HTTP response error (4xx or 5xx) vs a network/connection error
+    if (error.response) {
+      // For HTTP errors, check if the response contains FSPIOP error information
+      const responseData = error.response.data
+
+      // If the response contains a valid errorInformation object, use it directly
+      if (responseData?.errorInformation) {
+        const fspiopError = ErrorHandler.Factory.createFSPIOPErrorFromErrorInformation(responseData.errorInformation)
+        if (sendRequestSpan) {
+          const state = new EventSdk.EventStateMetadata(EventSdk.EventStatusType.failed, fspiopError.apiErrorCode.code, fspiopError.apiErrorCode.message)
+          await sendRequestSpan.error(fspiopError, state)
+          await sendRequestSpan.finish(fspiopError.message, state)
+        }
+        histTimerEnd({ success: false, source, destination, method })
+        throw fspiopError
+      }
+
+      // For other 4xx errors without errorInformation, create appropriate FSPIOP error
+      if (error.response.status >= 400 && error.response.status < 500) {
+        let errorCode = ErrorHandler.Enums.FSPIOPErrorCodes.CLIENT_ERROR
+        let errorMessage = 'Client error'
+
+        // Map specific HTTP status codes to FSPIOP error codes
+        if (error.response.status === 400) {
+          errorCode = ErrorHandler.Enums.FSPIOPErrorCodes.CLIENT_ERROR
+          errorMessage = responseData?.message || 'Bad Request'
+        } else if (error.response.status === 404) {
+          errorCode = ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND
+          errorMessage = responseData?.message || 'The requested resource could not be found'
+        } else if (error.response.status === 403) {
+          errorCode = ErrorHandler.Enums.FSPIOPErrorCodes.CLIENT_ERROR
+          errorMessage = responseData?.message || 'Permission denied'
+        }
+
+        const extensions = [
+          { key: 'url', value: url },
+          { key: 'status', value: error.response.status },
+          { key: 'response', value: stringify(responseData) }
+        ]
+
+        const fspiopError = ErrorHandler.Factory.createFSPIOPError(errorCode, errorMessage, error, source, extensions)
+        if (sendRequestSpan) {
+          const state = new EventSdk.EventStateMetadata(EventSdk.EventStatusType.failed, fspiopError.apiErrorCode.code, fspiopError.apiErrorCode.message)
+          await sendRequestSpan.error(fspiopError, state)
+          await sendRequestSpan.finish(fspiopError.message, state)
+        }
+        histTimerEnd({ success: false, source, destination, method })
+        throw fspiopError
+      }
+    }
+
+    // For network errors or 5xx errors, use DESTINATION_COMMUNICATION_ERROR
     const extensionArray = [
       { key: 'url', value: url },
       { key: 'sourceFsp', value: source },

package/test/unit/util/request.test.js

@@ -73,6 +73,111 @@ Test('ParticipantEndpoint Model Test', modelTest => {
   })
 
   modelTest.test('sendRequest should', async (getEndpointTest) => {
+    // Factory for creating spans with common setup
+    const createSpan = (overrides = {}) => {
+      const spanFinishStub = sandbox.stub()
+      const spanAuditStub = sandbox.stub()
+      const spanErrorStub = sandbox.stub()
+      const sendRequestSpan = {
+        setTags: sandbox.stub(),
+        finish: spanFinishStub,
+        error: spanErrorStub,
+        ...overrides.sendRequestSpan
+      }
+      return {
+        span: {
+          getChild: sandbox.stub().returns(sendRequestSpan),
+          getContext: sandbox.stub().returns({ service: 'test' }),
+          injectContextToHttpRequest: sandbox.stub(requestOptions => requestOptions),
+          audit: spanAuditStub,
+          ...overrides.span
+        },
+        stubs: { spanFinishStub, spanAuditStub, spanErrorStub, sendRequestSpan }
+      }
+    }
+
+    // Factory for creating request options
+    const createRequestOptions = (fsp = 'fsp1', method = 'get') => ({
+      url: Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET, { fsp }),
+      method
+    })
+
+    // Generic sendRequest caller
+    const callSendRequest = async (options = {}) => {
+      const { url, headers, source = hubName, destination = hubName, ...rest } = options
+      return Model.sendRequest({
+        url: url || createRequestOptions().url,
+        headers: headers || Helper.defaultHeaders(hubName, Enum.Http.HeaderResources.PARTICIPANTS, hubName),
+        source,
+        destination,
+        hubNameRegex,
+        ...rest
+      })
+    }
+
+    // Helper function to test error handling scenarios
+    const testErrorHandling = async (test, errorConfig, expectations) => {
+      const { fsp = 'fsp1', errorMessage, errorCode, responseData } = errorConfig
+      const customError = new Error(errorMessage)
+      customError.code = errorCode
+      if (responseData) customError.response = responseData
+
+      request = sandbox.stub().throws(customError)
+      Model = proxyquire('../../../src/util/request', { axios: request })
+
+      try {
+        await callSendRequest({ url: createRequestOptions(fsp).url })
+        test.fail('should throw error')
+      } catch (e) {
+        test.ok(e instanceof Error, 'Error was thrown')
+        Object.entries(expectations).forEach(([key, value]) => {
+          if (key === 'notEqual') {
+            test.notEqual(e.apiErrorCode.code, value.code, value.message)
+          } else if (key === 'apiErrorCode') {
+            test.equal(e.apiErrorCode.code, value, expectations.apiErrorCodeMessage || 'Error code matches expected')
+          } else if (key === 'message') {
+            test.equal(e.message, value, expectations.messageDescription || 'Error message matches expected')
+          }
+        })
+      }
+      test.end()
+    }
+
+    // Helper function to test span string payload handling
+    const testSpanStringPayload = async (test, payloadStr, expectedPayload, description) => {
+      const { span, stubs } = createSpan()
+      request = sandbox.stub().returns(Helper.getEndPointsResponse)
+      Model = proxyquire('../../../src/util/request', { axios: request })
+
+      await callSendRequest({ method: 'post', payload: payloadStr, span })
+
+      test.ok(stubs.spanAuditStub.calledOnce, 'Span audit is called')
+      const auditCallArgs = stubs.spanAuditStub.getCall(0).args[0]
+      const assertion = typeof expectedPayload === 'object' ? 'deepEqual' : 'equal'
+      test[assertion](auditCallArgs.payload, expectedPayload, description)
+      test.end()
+    }
+
+    // Helper function to test error handling with span
+    const testErrorWithSpan = async (test, errorConfig, expectedCode) => {
+      const { span, stubs } = createSpan()
+      request = sandbox.stub().throws(errorConfig)
+      Model = proxyquire('../../../src/util/request', { axios: request })
+
+      try {
+        await callSendRequest({ span })
+        test.fail('should throw error')
+      } catch (e) {
+        test.ok(stubs.spanErrorStub.called, 'Span error is called')
+        test.ok(stubs.spanFinishStub.called, 'Span finish is called')
+        if (stubs.spanErrorStub.callCount > 0) {
+          const errorArg = stubs.spanErrorStub.getCall(0).args[0]
+          test.equal(errorArg.apiErrorCode.code, expectedCode, `Error code ${expectedCode} passed to span`)
+        }
+      }
+      test.end()
+    }
+
     getEndpointTest.test('return the object of endpoints', async (test) => {
       const fsp = 'fsp'
       const requestOptions = {
@@ -293,6 +398,80 @@ Test('ParticipantEndpoint Model Test', modelTest => {
       }
     })
 
+    getEndpointTest.test('preserve 400 error with errorInformation from downstream service', async (test) => {
+      await testErrorHandling(test, {
+        fsp: 'nonexistentfsp',
+        errorMessage: 'Request failed with status code 400',
+        errorCode: 'ERR_BAD_REQUEST',
+        responseData: {
+          status: 400,
+          data: {
+            errorInformation: {
+              errorCode: '3200',
+              errorDescription: 'FSP not found'
+            }
+          }
+        }
+      }, {
+        apiErrorCode: '3200',
+        apiErrorCodeMessage: 'Error code is preserved from errorInformation',
+        message: 'FSP not found',
+        messageDescription: 'Error message is preserved from errorInformation',
+        notEqual: { code: '1001', message: 'Error is not converted to DESTINATION_COMMUNICATION_ERROR' }
+      })
+    })
+
+    getEndpointTest.test('handle 404 error without errorInformation', async (test) => {
+      await testErrorHandling(test, {
+        fsp: 'notfound',
+        errorMessage: 'Request failed with status code 404',
+        errorCode: 'ERR_BAD_REQUEST',
+        responseData: {
+          status: 404,
+          data: {
+            message: 'Resource not found'
+          }
+        }
+      }, {
+        apiErrorCode: '3200',
+        apiErrorCodeMessage: 'Error code is ID_NOT_FOUND for 404',
+        message: 'Resource not found',
+        messageDescription: 'Error message is preserved',
+        notEqual: { code: '1001', message: 'Error is not converted to DESTINATION_COMMUNICATION_ERROR' }
+      })
+    })
+
+    getEndpointTest.test('handle network error as DESTINATION_COMMUNICATION_ERROR', async (test) => {
+      await testErrorHandling(test, {
+        errorMessage: 'ECONNREFUSED',
+        errorCode: 'ECONNREFUSED'
+        // No response property for network errors
+      }, {
+        apiErrorCode: '1001',
+        apiErrorCodeMessage: 'Network error is converted to DESTINATION_COMMUNICATION_ERROR',
+        message: 'Failed to send HTTP request to host',
+        messageDescription: 'Generic error message for network errors'
+      })
+    })
+
+    getEndpointTest.test('handle 500 error as DESTINATION_COMMUNICATION_ERROR', async (test) => {
+      await testErrorHandling(test, {
+        errorMessage: 'Request failed with status code 500',
+        errorCode: 'ERR_BAD_RESPONSE',
+        responseData: {
+          status: 500,
+          data: {
+            message: 'Internal Server Error'
+          }
+        }
+      }, {
+        apiErrorCode: '1001',
+        apiErrorCodeMessage: '5xx error is converted to DESTINATION_COMMUNICATION_ERROR',
+        message: 'Failed to send HTTP request to host',
+        messageDescription: 'Generic error message for server errors'
+      })
+    })
+
     getEndpointTest.test('sign with JWS signature when JwsSigner object is passed', async (test) => {
       const fsp = 'payerfsp'
       const payeefsp = 'payeefsp'
@@ -359,6 +538,71 @@ Test('ParticipantEndpoint Model Test', modelTest => {
       test.end()
     })
 
+    getEndpointTest.test('handle span with string payload that can be parsed as JSON', async (test) => {
+      await testSpanStringPayload(test, '{"test": "data"}', { test: 'data' }, 'String payload is parsed to JSON for audit')
+    })
+
+    getEndpointTest.test('handle span with string payload that cannot be parsed as JSON', async (test) => {
+      await testSpanStringPayload(test, 'not valid json', 'not valid json', 'String payload remains as string when not parseable')
+    })
+
+    getEndpointTest.test('handle 403 error without errorInformation', async (test) => {
+      await testErrorHandling(test, {
+        fsp: 'forbidden',
+        errorMessage: 'Request failed with status code 403',
+        responseData: {
+          status: 403,
+          data: { message: 'You do not have permission' }
+        }
+      }, {
+        apiErrorCode: '3000',
+        message: 'You do not have permission'
+      })
+    })
+
+    getEndpointTest.test('handle 400 error without errorInformation and without message', async (test) => {
+      await testErrorHandling(test, {
+        fsp: 'badrequest',
+        errorMessage: 'Request failed with status code 400',
+        responseData: {
+          status: 400,
+          data: {}
+        }
+      }, {
+        apiErrorCode: '3000',
+        message: 'Bad Request'
+      })
+    })
+
+    getEndpointTest.test('handle error with errorInformation and span', async (test) => {
+      const customError = new Error('Request failed with status code 400')
+      customError.response = {
+        status: 400,
+        data: {
+          errorInformation: {
+            errorCode: '3200',
+            errorDescription: 'FSP not found'
+          }
+        }
+      }
+      await testErrorWithSpan(test, customError, '3200')
+    })
+
+    getEndpointTest.test('handle 4xx error without errorInformation and with span', async (test) => {
+      const customError = new Error('Request failed with status code 403')
+      customError.response = {
+        status: 403,
+        data: { message: 'Forbidden' }
+      }
+      await testErrorWithSpan(test, customError, '3000')
+    })
+
+    getEndpointTest.test('handle network error with span', async (test) => {
+      const customError = new Error('ECONNREFUSED')
+      customError.code = 'ECONNREFUSED'
+      await testErrorWithSpan(test, customError, '1001')
+    })
+
     getEndpointTest.end()
   })