@mojaloop/central-ledger 17.7.8 → 17.8.0-orb.1

package/src/handlers/timeouts/handler.js

@@ -35,20 +35,206 @@ that actually holds the copyright for their contributions (see the
   */
 
 const CronJob = require('cron').CronJob
-const Config = require('../../lib/config')
-const TimeoutService = require('../../domain/timeout')
 const Enum = require('@mojaloop/central-services-shared').Enum
-const Kafka = require('@mojaloop/central-services-shared').Util.Kafka
-const Producer = require('@mojaloop/central-services-stream').Util.Producer
 const Utility = require('@mojaloop/central-services-shared').Util
+const Producer = require('@mojaloop/central-services-stream').Util.Producer
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const EventSdk = require('@mojaloop/event-sdk')
-const resourceVersions = require('@mojaloop/central-services-shared').Util.resourceVersions
-const Logger = require('@mojaloop/central-services-logger')
+
+const Config = require('../../lib/config')
+const TimeoutService = require('../../domain/timeout')
+const { logger } = require('../../shared/logger')
+
+const { Kafka, resourceVersions } = Utility
+const { Action, Type } = Enum.Events.Event
+
 let timeoutJob
 let isRegistered
 let running = false
 
+/**
+ * Processes timedOut transfers
+ *
+ * @param {TimedOutTransfer[]} transferTimeoutList
+ * @returns {Promise<void>}
+ */
+const _processTimedOutTransfers = async (transferTimeoutList) => {
+  const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_EXPIRED).toApiErrorObject(Config.ERROR_HANDLING)
+  if (!Array.isArray(transferTimeoutList)) {
+    transferTimeoutList = [
+      { ...transferTimeoutList }
+    ]
+  }
+
+  for (const TT of transferTimeoutList) {
+    const span = EventSdk.Tracer.createSpan('cl_transfer_timeout')
+    try {
+      const state = Utility.StreamingProtocol.createEventState(Enum.Events.EventStatus.FAILURE.status, fspiopError.errorInformation.errorCode, fspiopError.errorInformation.errorDescription)
+      const metadata = Utility.StreamingProtocol.createMetadataWithCorrelatedEvent(TT.transferId, Enum.Kafka.Topics.NOTIFICATION, Action.TIMEOUT_RECEIVED, state)
+      const destination = TT.externalPayerName || TT.payerFsp
+      const source = TT.externalPayeeName || TT.payeeFsp
+      const headers = Utility.Http.SwitchDefaultHeaders(destination, Enum.Http.HeaderResources.TRANSFERS, Config.HUB_NAME, resourceVersions[Enum.Http.HeaderResources.TRANSFERS].contentVersion)
+      const message = Utility.StreamingProtocol.createMessage(TT.transferId, destination, source, metadata, headers, fspiopError, { id: TT.transferId }, `application/vnd.interoperability.${Enum.Http.HeaderResources.TRANSFERS}+json;version=${resourceVersions[Enum.Http.HeaderResources.TRANSFERS].contentVersion}`)
+
+      span.setTags(Utility.EventFramework.getTransferSpanTags({ payload: message.content.payload, headers }, Type.TRANSFER, Action.TIMEOUT_RECEIVED))
+      await span.audit({
+        state,
+        metadata,
+        headers,
+        message
+      }, EventSdk.AuditEventAction.start)
+
+      if (TT.bulkTransferId === null) { // regular transfer
+        if (TT.transferStateId === Enum.Transfers.TransferInternalState.EXPIRED_PREPARED) {
+          message.from = Config.HUB_NAME
+          // event & type set above when `const metadata` is initialized to NOTIFICATION / TIMEOUT_RECEIVED
+          await Kafka.produceGeneralMessage(
+            Config.KAFKA_CONFIG,
+            Producer,
+            Enum.Kafka.Topics.NOTIFICATION,
+            Action.TIMEOUT_RECEIVED,
+            message,
+            state,
+            null,
+            span
+          )
+        } else if (TT.transferStateId === Enum.Transfers.TransferInternalState.RESERVED_TIMEOUT) {
+          message.metadata.event.type = Type.POSITION
+          message.metadata.event.action = Action.TIMEOUT_RESERVED
+          // Key position timeouts with payer account id
+          await Kafka.produceGeneralMessage(
+            Config.KAFKA_CONFIG,
+            Producer,
+            Enum.Kafka.Topics.POSITION,
+            Action.TIMEOUT_RESERVED,
+            message,
+            state,
+            TT.effectedParticipantCurrencyId?.toString(),
+            span,
+            Config.KAFKA_CONFIG.EVENT_TYPE_ACTION_TOPIC_MAP?.POSITION?.TIMEOUT_RESERVED
+          )
+        }
+      } else { // individual transfer from a bulk
+        if (TT.transferStateId === Enum.Transfers.TransferInternalState.EXPIRED_PREPARED) {
+          message.from = Config.HUB_NAME
+          message.metadata.event.type = Type.BULK_PROCESSING
+          message.metadata.event.action = Action.BULK_TIMEOUT_RECEIVED
+          await Kafka.produceGeneralMessage(
+            Config.KAFKA_CONFIG,
+            Producer,
+            Enum.Kafka.Topics.BULK_PROCESSING,
+            Action.BULK_TIMEOUT_RECEIVED,
+            message,
+            state,
+            null,
+            span
+          )
+        } else if (TT.transferStateId === Enum.Transfers.TransferInternalState.RESERVED_TIMEOUT) {
+          message.metadata.event.type = Type.POSITION
+          message.metadata.event.action = Action.BULK_TIMEOUT_RESERVED
+          // Key position timeouts with payer account id
+          await Kafka.produceGeneralMessage(
+            Config.KAFKA_CONFIG,
+            Producer,
+            Enum.Kafka.Topics.POSITION,
+            Action.BULK_TIMEOUT_RESERVED,
+            message,
+            state,
+            TT.payerParticipantCurrencyId?.toString(),
+            span
+          )
+        }
+      }
+    } catch (err) {
+      logger.error('error in _processTimedOutTransfers:', err)
+      const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err)
+      const state = new EventSdk.EventStateMetadata(EventSdk.EventStatusType.failed, fspiopError.apiErrorCode.code, fspiopError.apiErrorCode.message)
+      await span.error(fspiopError, state)
+      await span.finish(fspiopError.message, state)
+      throw fspiopError
+    } finally {
+      if (!span.isFinished) {
+        await span.finish()
+      }
+    }
+  }
+}
+
+/**
+ * Processes timedOut fxTransfers
+ *
+ * @param {TimedOutFxTransfer[]} fxTransferTimeoutList
+ * @returns {Promise<void>}
+ */
+const _processFxTimedOutTransfers = async (fxTransferTimeoutList) => {
+  const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_EXPIRED).toApiErrorObject(Config.ERROR_HANDLING)
+  if (!Array.isArray(fxTransferTimeoutList)) {
+    fxTransferTimeoutList = [
+      { ...fxTransferTimeoutList }
+    ]
+  }
+  for (const fTT of fxTransferTimeoutList) {
+    const span = EventSdk.Tracer.createSpan('cl_fx_transfer_timeout')
+    try {
+      const state = Utility.StreamingProtocol.createEventState(Enum.Events.EventStatus.FAILURE.status, fspiopError.errorInformation.errorCode, fspiopError.errorInformation.errorDescription)
+      const metadata = Utility.StreamingProtocol.createMetadataWithCorrelatedEvent(fTT.commitRequestId, Enum.Kafka.Topics.NOTIFICATION, Action.TIMEOUT_RECEIVED, state)
+      const destination = fTT.externalInitiatingFspName || fTT.initiatingFsp
+      const source = fTT.externalCounterPartyFspName || fTT.counterPartyFsp
+      const headers = Utility.Http.SwitchDefaultHeaders(destination, Enum.Http.HeaderResources.FX_TRANSFERS, Config.HUB_NAME, resourceVersions[Enum.Http.HeaderResources.FX_TRANSFERS].contentVersion)
+      const message = Utility.StreamingProtocol.createMessage(fTT.commitRequestId, destination, source, metadata, headers, fspiopError, { id: fTT.commitRequestId }, `application/vnd.interoperability.${Enum.Http.HeaderResources.FX_TRANSFERS}+json;version=${resourceVersions[Enum.Http.HeaderResources.FX_TRANSFERS].contentVersion}`)
+
+      span.setTags(Utility.EventFramework.getTransferSpanTags({ payload: message.content.payload, headers }, Type.FX_TRANSFER, Action.TIMEOUT_RECEIVED))
+      await span.audit({
+        state,
+        metadata,
+        headers,
+        message
+      }, EventSdk.AuditEventAction.start)
+
+      if (fTT.transferStateId === Enum.Transfers.TransferInternalState.EXPIRED_PREPARED) {
+        message.from = Config.HUB_NAME
+        // event & type set above when `const metadata` is initialized to NOTIFICATION / TIMEOUT_RECEIVED
+        await Kafka.produceGeneralMessage(
+          Config.KAFKA_CONFIG,
+          Producer,
+          Enum.Kafka.Topics.NOTIFICATION,
+          Action.FX_TIMEOUT_RESERVED,
+          message,
+          state,
+          null,
+          span
+        )
+      } else if (fTT.transferStateId === Enum.Transfers.TransferInternalState.RESERVED_TIMEOUT) {
+        message.metadata.event.type = Type.POSITION
+        message.metadata.event.action = Action.FX_TIMEOUT_RESERVED
+        // Key position timeouts with payer account id
+        await Kafka.produceGeneralMessage(
+          Config.KAFKA_CONFIG,
+          Producer,
+          Enum.Kafka.Topics.POSITION,
+          Action.FX_TIMEOUT_RESERVED,
+          message,
+          state,
+          fTT.effectedParticipantCurrencyId?.toString(),
+          span,
+          Config.KAFKA_CONFIG.EVENT_TYPE_ACTION_TOPIC_MAP?.POSITION?.FX_TIMEOUT_RESERVED
+        )
+      }
+    } catch (err) {
+      logger.error('error in _processFxTimedOutTransfers:', err)
+      const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err)
+      const state = new EventSdk.EventStateMetadata(EventSdk.EventStatusType.failed, fspiopError.apiErrorCode.code, fspiopError.apiErrorCode.message)
+      await span.error(fspiopError, state)
+      await span.finish(fspiopError.message, state)
+      throw fspiopError
+    } finally {
+      if (!span.isFinished) {
+        await span.finish()
+      }
+    }
+  }
+}
+
 /**
   * @function TransferTimeoutHandler
   *
@@ -70,73 +256,31 @@ const timeout = async () => {
     const segmentId = timeoutSegment ? timeoutSegment.segmentId : 0
     const cleanup = await TimeoutService.cleanupTransferTimeout()
     const latestTransferStateChange = await TimeoutService.getLatestTransferStateChange()
+
+    const fxTimeoutSegment = await TimeoutService.getFxTimeoutSegment()
     const intervalMax = (latestTransferStateChange && parseInt(latestTransferStateChange.transferStateChangeId)) || 0
-    const result = await TimeoutService.timeoutExpireReserved(segmentId, intervalMin, intervalMax)
-    const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_EXPIRED).toApiErrorObject(Config.ERROR_HANDLING)
-    if (!Array.isArray(result)) {
-      result[0] = result
-    }
-    for (let i = 0; i < result.length; i++) {
-      const span = EventSdk.Tracer.createSpan('cl_transfer_timeout')
-      try {
-        const state = Utility.StreamingProtocol.createEventState(Enum.Events.EventStatus.FAILURE.status, fspiopError.errorInformation.errorCode, fspiopError.errorInformation.errorDescription)
-        const metadata = Utility.StreamingProtocol.createMetadataWithCorrelatedEvent(result[i].transferId, Enum.Kafka.Topics.NOTIFICATION, Enum.Events.Event.Action.TIMEOUT_RECEIVED, state)
-        const headers = Utility.Http.SwitchDefaultHeaders(result[i].payerFsp, Enum.Http.HeaderResources.TRANSFERS, Enum.Http.Headers.FSPIOP.SWITCH.value, resourceVersions[Enum.Http.HeaderResources.TRANSFERS].contentVersion)
-        const message = Utility.StreamingProtocol.createMessage(result[i].transferId, result[i].payeeFsp, result[i].payerFsp, metadata, headers, fspiopError, { id: result[i].transferId }, `application/vnd.interoperability.${Enum.Http.HeaderResources.TRANSFERS}+json;version=${resourceVersions[Enum.Http.HeaderResources.TRANSFERS].contentVersion}`)
-        span.setTags(Utility.EventFramework.getTransferSpanTags({ payload: message.content.payload, headers }, Enum.Events.Event.Type.TRANSFER, Enum.Events.Event.Action.TIMEOUT_RECEIVED))
-        await span.audit({
-          state,
-          metadata,
-          headers,
-          message
-        }, EventSdk.AuditEventAction.start)
-        if (result[i].bulkTransferId === null) { // regular transfer
-          if (result[i].transferStateId === Enum.Transfers.TransferInternalState.EXPIRED_PREPARED) {
-            message.to = message.from
-            message.from = Enum.Http.Headers.FSPIOP.SWITCH.value
-            // event & type set above when `const metadata` is initialized to NOTIFICATION / TIMEOUT_RECEIVED
-            await Kafka.produceGeneralMessage(Config.KAFKA_CONFIG, Producer, Enum.Kafka.Topics.NOTIFICATION, Enum.Events.Event.Action.TIMEOUT_RECEIVED, message, state, null, span)
-          } else if (result[i].transferStateId === Enum.Transfers.TransferInternalState.RESERVED_TIMEOUT) {
-            message.metadata.event.type = Enum.Events.Event.Type.POSITION
-            message.metadata.event.action = Enum.Events.Event.Action.TIMEOUT_RESERVED
-            // Key position timeouts with payer account id
-            await Kafka.produceGeneralMessage(Config.KAFKA_CONFIG, Producer, Enum.Kafka.Topics.POSITION, Enum.Events.Event.Action.TIMEOUT_RESERVED, message, state, result[i].payerParticipantCurrencyId?.toString(), span)
-          }
-        } else { // individual transfer from a bulk
-          if (result[i].transferStateId === Enum.Transfers.TransferInternalState.EXPIRED_PREPARED) {
-            message.to = message.from
-            message.from = Enum.Http.Headers.FSPIOP.SWITCH.value
-            message.metadata.event.type = Enum.Events.Event.Type.BULK_PROCESSING
-            message.metadata.event.action = Enum.Events.Event.Action.BULK_TIMEOUT_RECEIVED
-            await Kafka.produceGeneralMessage(Config.KAFKA_CONFIG, Producer, Enum.Kafka.Topics.BULK_PROCESSING, Enum.Events.Event.Action.BULK_TIMEOUT_RECEIVED, message, state, null, span)
-          } else if (result[i].transferStateId === Enum.Transfers.TransferInternalState.RESERVED_TIMEOUT) {
-            message.metadata.event.type = Enum.Events.Event.Type.POSITION
-            message.metadata.event.action = Enum.Events.Event.Action.BULK_TIMEOUT_RESERVED
-            // Key position timeouts with payer account id
-            await Kafka.produceGeneralMessage(Config.KAFKA_CONFIG, Producer, Enum.Kafka.Topics.POSITION, Enum.Events.Event.Action.BULK_TIMEOUT_RESERVED, message, state, result[i].payerParticipantCurrencyId?.toString(), span)
-          }
-        }
-      } catch (err) {
-        Logger.isErrorEnabled && Logger.error(err)
-        const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err)
-        const state = new EventSdk.EventStateMetadata(EventSdk.EventStatusType.failed, fspiopError.apiErrorCode.code, fspiopError.apiErrorCode.message)
-        await span.error(fspiopError, state)
-        await span.finish(fspiopError.message, state)
-        throw fspiopError
-      } finally {
-        if (!span.isFinished) {
-          await span.finish()
-        }
-      }
-    }
+    const fxIntervalMin = fxTimeoutSegment ? fxTimeoutSegment.value : 0
+    const fxSegmentId = fxTimeoutSegment ? fxTimeoutSegment.segmentId : 0
+    const fxCleanup = await TimeoutService.cleanupFxTransferTimeout()
+    const latestFxTransferStateChange = await TimeoutService.getLatestFxTransferStateChange()
+    const fxIntervalMax = (latestFxTransferStateChange && parseInt(latestFxTransferStateChange.fxTransferStateChangeId)) || 0
+
+    const { transferTimeoutList, fxTransferTimeoutList } = await TimeoutService.timeoutExpireReserved(segmentId, intervalMin, intervalMax, fxSegmentId, fxIntervalMin, fxIntervalMax)
+    transferTimeoutList && await _processTimedOutTransfers(transferTimeoutList)
+    fxTransferTimeoutList && await _processFxTimedOutTransfers(fxTransferTimeoutList)
+
     return {
       intervalMin,
       cleanup,
       intervalMax,
-      result
+      fxIntervalMin,
+      fxCleanup,
+      fxIntervalMax,
+      transferTimeoutList,
+      fxTransferTimeoutList
     }
   } catch (err) {
-    Logger.isErrorEnabled && Logger.error(err)
+    logger.error('error in timeout:', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   } finally {
     running = false
@@ -192,7 +336,7 @@ const registerTimeoutHandler = async () => {
     await timeoutJob.start()
     return true
   } catch (err) {
-    Logger.isErrorEnabled && Logger.error(err)
+    logger.error('error in registerTimeoutHandler:', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -212,7 +356,7 @@ const registerAllHandlers = async () => {
     }
     return true
   } catch (err) {
-    Logger.isErrorEnabled && Logger.error(err)
+    logger.error('error in registerAllHandlers:', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }