@mojaloop/central-services-shared 18.30.7-snapshot.2 → 18.30.8

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 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)
+
+
+### Bug Fixes
+
+* http keep alive new object ([#473](https://github.com/mojaloop/central-services-shared/issues/473)) ([ef4b287](https://github.com/mojaloop/central-services-shared/commit/ef4b2871d6f0c39319d55efa8e512de5d9483cff))
+
 ### [18.30.6](https://github.com/mojaloop/central-services-shared/compare/v18.30.5...v18.30.6) (2025-07-23)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/central-services-shared",
-  "version": "18.30.7-snapshot.2",
+  "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/healthCheck/HealthCheck.js

@@ -28,8 +28,10 @@
 
 'use strict'
 
-const { logger } = require('../logger')
-const { statusEnum } = require('./HealthCheckEnums')
+const {
+  statusEnum
+} = require('./HealthCheckEnums')
+const Logger = require('@mojaloop/central-services-logger')
 
 /**
  * @class HealthCheck
@@ -80,7 +82,6 @@ class HealthCheck {
   constructor (packageJson, serviceChecks) {
     this.packageJson = packageJson
     this.serviceChecks = serviceChecks
-    this.log = logger.child({ component: this.constructor.name })
 
     this.getHealth = this.getHealth.bind(this)
   }
@@ -109,7 +110,7 @@ class HealthCheck {
         services
       }
     } catch (err) {
-      this.log.warn(`HealthCheck.getHealth failed with error: ${err?.message}`)
+      Logger.isErrorEnabled && Logger.error(`HealthCheck.getSubServiceHealth failed with error: ${err.message}`)
       isHealthy = false
     }
 

package/src/index.d.ts

@@ -778,7 +778,7 @@ declare namespace CentralServicesShared {
     RedisCache: RedisCache;
   }
 
-  type RedisInstanceConfig =
+  type RedisInstanceConfig = 
     | {
         type: 'redis';
         host: string;
@@ -830,69 +830,7 @@ declare namespace CentralServicesShared {
 
   const Enum: Enum
   const Util: Util
-
-  namespace HealthCheck {
-    enum StatusEnum {
-      OK = 'OK',
-      DOWN = 'DOWN'
-    }
-
-    enum ServiceNameEnum {
-      participantEndpointService = 'participantEndpointService',
-      smtpServer = 'smtpServer',
-      datastore = 'datastore',
-      broker = 'broker',
-      sidecar = 'sidecar',
-      cache = 'cache',
-      proxyCache = 'proxyCache'
-    }
-
-    enum ResponseCodeEnum {
-      success = 200,
-      gatewayTimeout = 502
-    }
-
-    interface SubServiceHealth {
-      status: StatusEnum;
-      service: ServiceNameEnum;
-    }
-
-    type ServiceCheckerFunc = (context?: any) => Promise<SubServiceHealth>;
-
-    interface HealthCheckResult {
-      status: StatusEnum;
-      uptime: number;
-      startTime: string;
-      versionNumber: string;
-      services?: SubServiceHealth[];
-    }
-
-    export const HealthCheckEnums: {
-      responseCode: {
-        success: ResponseCodeEnum.success;
-        gatewayTimeout: ResponseCodeEnum.gatewayTimeout;
-      };
-      serviceName: {
-        participantEndpointService: ServiceNameEnum.participantEndpointService;
-        smtpServer: ServiceNameEnum.smtpServer;
-        datastore: ServiceNameEnum.datastore;
-        broker: ServiceNameEnum.broker;
-        sidecar: ServiceNameEnum.sidecar;
-        cache: ServiceNameEnum.cache;
-        proxyCache: ServiceNameEnum.proxyCache;
-      };
-      statusEnum: {
-        OK: StatusEnum.OK;
-        DOWN: StatusEnum.DOWN;
-      };
-    }
-
-    export class HealthCheck {
-      constructor(packageJson: { version: string }, serviceChecks: ServiceCheckerFunc[]);
-      getHealth(context?: any): Promise<HealthCheckResult>;
-      static evaluateServiceHealth(services: SubServiceHealth[]): boolean;
-    }
-  }
+  const HealthCheck: any
 
   namespace mysql {
     class KnexWrapper {

package/src/util/request.js

@@ -125,10 +125,8 @@ const sendRequest = async ({
       data: payload, // todo: think, if it's better to transform to ISO format here (based on apiType)
       params,
       responseType,
-      httpAgent: new http.Agent({ keepAlive: true }),
       ...axiosRequestOptionsOverride
     }
-    requestOptions.httpAgent.toJSON = () => ({})
     // if jwsSigner is passed then sign the request
     if (jwsSigner != null && typeof (jwsSigner) === 'object') {
       requestOptions.headers['fspiop-signature'] = jwsSigner.getSignature(requestOptions)
@@ -164,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()
   })