@mojaloop/sdk-scheme-adapter 12.2.3 → 13.0.1

package/src/lib/metrics.js

@@ -0,0 +1,148 @@
+/**************************************************************************
+ *  (C) Copyright ModusBox Inc. 2019 - All rights reserved.               *
+ *                                                                        *
+ *  This file is made available under the terms of the license agreement  *
+ *  specified in the corresponding source code repository.                *
+ *                                                                        *
+ *  ORIGINAL AUTHOR:                                                      *
+ *       James Bush - james.bush@modusbox.com                             *
+ **************************************************************************/
+
+'use strict';
+
+const http = require('http');
+const Koa = require('koa');
+const koaBody = require('koa-body');
+const PrometheusClient = require('prom-client');
+
+
+/**
+  * A utility class that abstracts the underlying metrics implementation (Prometheus)
+  * from the consumer. This may be premature if Prometheus is never swapped out...but
+  * who can tell what the Universe will bring us.
+  *
+  * This object exposes methods for getting different types of measurement construct
+  * in order for consuming code to record metrics. The constructs are quite tightly
+  * coupled to Prometheus view of metrics, although that is fairly abstract so the
+  * risk appears low that this will cause conflicts in future.
+  *
+  * The metrics client is intended to be used as a singleton in a process and keeps a
+  * 'per name' cache of metrics to avoid duplicates. Not sure if this is strictly
+  * necessary but I dont have time to dig into the prom-client code to see what
+  * happens if you create the same metric twice.
+  */
+class MetricsClient {
+    constructor() {
+        this._prometheusRegister = PrometheusClient.register;
+        this._metrics = {};
+
+        this._counterPrefix = 'cntr_';
+        this._histogramPrefix = 'hist_';
+        this._gaugePrefix = 'gage_';
+    }
+
+
+    getHistogram(name, description, buckets) {
+        const metricName = `${this._histogramPrefix}${name}`;
+
+        let conf = {
+            name: name,
+            help: description,
+        };
+
+        if(buckets) {
+            conf.buckets = buckets;
+        }
+
+        if(!this._metrics[metricName]) {
+            this._metrics[metricName] = new PrometheusClient.Histogram(conf);
+        }
+
+        return this._metrics[metricName];
+    }
+
+
+    getCounter(name, description) {
+        const metricName = `${this._counterPrefix}${name}`;
+
+        if(!this._metrics[metricName]) {
+            this._metrics[metricName] = new PrometheusClient.Counter({
+                name: name,
+                help: description
+            });
+        }
+
+        return this._metrics[metricName];
+    }
+
+
+    getGauge(name, description) {
+        const metricName = `${this._counterPrefix}${name}`;
+
+        if(!this._metrics[metricName]) {
+            this._metrics[metricName] = new PrometheusClient.Gauge({
+                name: name,
+                help: description
+            });
+        }
+
+        return this._metrics[metricName];
+    }
+}
+
+
+/**
+  * Exposes an HTTP endpoint for metrics to be scraped by some external daemon
+  */
+class MetricsServer {
+    /**
+      * @param {number} port metrics server listen port
+      * @param {Logger} logger Logger
+      * @param {Object} prometheusClient Prometheus client instance
+      */
+    constructor({ port, logger }) {
+        this._port = port;
+        this._logger = logger;
+        this._prometheusClient = PrometheusClient;
+        this._prometheusRegister = PrometheusClient.register;
+        this._api = this.setupApi();
+        this._server = http.createServer(this._api.callback());
+    }
+
+    async start() {
+        if (this._server.listening) {
+            return;
+        }
+        this._prometheusClient.collectDefaultMetrics({
+            prefix: 'mojaloop_connector_default_'
+        });
+
+        await new Promise((resolve) => this._server.listen(this._port, resolve));
+        this._logger.push({ port: this._port }).log('Serving Metrics');
+    }
+
+    async stop() {
+        await new Promise(resolve => this._server.close(resolve));
+        this._logger.log('Metrics Server shut down complete');
+    }
+
+    setupApi() {
+        const result = new Koa();
+
+        result.use(koaBody());
+        result.use(async ctx => {
+            this._logger.log('Metrics request received');
+
+            ctx.response.set('Content-Type', this._prometheusRegister.contentType);
+            ctx.response.body = this._prometheusRegister.metrics();
+        });
+
+        return result;
+    }
+}
+
+
+module.exports = {
+    MetricsServer,
+    MetricsClient
+};

package/src/lib/model/AccountsModel.js

@@ -133,20 +133,23 @@ class AccountsModel {
 
 
     async _executeCreateAccountsRequest(request) {
+        const accountRequest = request;
+
         // eslint-disable-next-line no-async-promise-executor
         return new Promise(async (resolve, reject) => {
-            const requestKey = `ac_${request.requestId}`;
+            const requestKey = `ac_${accountRequest.requestId}`;
 
             const subId = await this._cache.subscribe(requestKey, async (cn, msg, subId) => {
                 try {
                     let error;
-                    let message = JSON.parse(msg);
+                    const message = JSON.parse(msg);
+                    this._data.postAccountsResponse = message.data;
 
                     if (message.type === 'accountsCreationErrorResponse') {
-                        error = new BackendError(`Got an error response creating accounts: ${util.inspect(message.data)}`, 500);
-                        error.mojaloopError = message.data;
+                        error = new BackendError(`Got an error response creating accounts: ${util.inspect(this._data.postAccountsResponse.body)}`, 500);
+                        error.mojaloopError = this._data.postAccountsResponse.body;
                     } else if (message.type !== 'accountsCreationSuccessfulResponse') {
-                        this._logger.push({ message }).log(
+                        this._logger.push(util.inspect(this._data.postAccountsResponse)).log(
                             `Ignoring cache notification for request ${requestKey}. ` +
                             `Unknown message type ${message.type}.`
                         );
@@ -167,7 +170,7 @@ class AccountsModel {
                         return reject(error);
                     }
 
-                    const response = message.data;
+                    const response = this._data.postAccountsResponse;
                     this._logger.push({ response }).log('Account creation response received');
                     return resolve(response);
                 }
@@ -178,7 +181,7 @@ class AccountsModel {
 
             // set up a timeout for the request
             const timeout = setTimeout(() => {
-                const err = new BackendError(`Timeout waiting for response to account creation request ${request.requestId}`, 504);
+                const err = new BackendError(`Timeout waiting for response to account creation request ${accountRequest.requestId}`, 504);
 
                 // we dont really care if the unsubscribe fails but we should log it regardless
                 this._cache.unsubscribe(requestKey, subId).catch(e => {
@@ -191,7 +194,7 @@ class AccountsModel {
             // now we have a timeout handler and a cache subscriber hooked up we can fire off
             // a POST /participants request to the switch
             try {
-                const res = await this._requests.postParticipants(request);
+                const res = await this._requests.postParticipants(accountRequest);
                 this._logger.push({ res }).log('Account creation request sent to peer');
             }
             catch(err) {
@@ -218,11 +221,11 @@ class AccountsModel {
     }
 
     _buildClientResponse(response) {
-        return response.partyList.map(party => ({
+        return response.body.partyList.map(party => ({
             idType: party.partyId.partyIdType,
             idValue: party.partyId.partyIdentifier,
             idSubValue: party.partyId.partySubIdOrType,
-            ...!response.currency && {
+            ...!response.body.currency && {
                 error: {
                     statusCode: Errors.MojaloopApiErrorCodes.CLIENT_ERROR.code,
                     message: 'Provided currency not supported',
@@ -295,7 +298,6 @@ class AccountsModel {
                 resp.currentState = stateEnum.ERROR_OCCURRED;
                 break;
         }
-
         return resp;
     }
 

package/src/lib/model/InboundTransfersModel.js

@@ -10,6 +10,7 @@
 
 'use strict';
 
+const util = require('util');
 
 const {
     BackendRequests,
@@ -21,6 +22,7 @@ const {
     Errors,
 } = require('@mojaloop/sdk-standard-components');
 const shared = require('./lib/shared');
+const { TransferStateEnum } = require('./common');
 
 /**
  *  Models the operations required for performing inbound transfers
@@ -70,6 +72,12 @@ class InboundTransfersModel {
         });
     }
 
+    updateStateWithError(err) {
+        this.data.lastError = err;
+        this.data.currentState = TransferStateEnum.ERROR_OCCURRED;
+        return this._save();
+    }
+
     /**
      * Queries the backend API for the specified party and makes a callback to the originator with the result
      */
@@ -162,7 +170,32 @@ class InboundTransfersModel {
      * Asks the backend for a response to an incoming quote request and makes a callback to the originator with
      * the result
      */
-    async quoteRequest(quoteRequest, sourceFspId) {
+    async quoteRequest(request, sourceFspId) {
+        const quoteRequest = request.body;
+
+        // keep track of our state.
+        // note that instances of this model typically only live as long as it takes to
+        // handle an incoming request and send a response asynchronously, but we hold onto
+        // some state across async ops
+
+        this.data = {
+            // transferId: this follows the slightly dodgy assumption that transferId will be same as this transactionId.
+            // so far this has held in moja implementations but may not always be the case. regardless, future FSPIOP API
+            // versions MUST deal with this cleanly so we can expect to eliminate this assumption at some point.
+            transferId: quoteRequest.transactionId,
+            direction: 'INBOUND',
+            quoteRequest: {
+                headers: request.headers,
+                body: request.body
+            },
+            currentState: TransferStateEnum.QUOTE_REQUEST_RECEIVED,
+            initiatedTimestamp: new Date().toISOString(),
+        };
+
+        // persist the transfer record in the cache. if we crash after this at least we will
+        // have a record of the request in the cache.
+        await this._save();
+
         try {
             const internalForm = shared.mojaloopQuoteRequestToInternal(quoteRequest);
 
@@ -189,19 +222,24 @@ class InboundTransfersModel {
             mojaloopResponse.condition = condition;
 
             // now store the fulfilment and the quote data against the quoteId in our cache
-            await this._cache.set(`quote_${quoteRequest.transactionId}`, {
+            this.data.quote = {
                 request: quoteRequest,
                 internalRequest: internalForm,
                 response: response,
                 mojaloopResponse: mojaloopResponse,
                 fulfilment: fulfilment
-            });
-
-            // now store the quoteResponse data against the quoteId in our cache to be sent as a response to GET /quotes/{ID}
-            await this._cache.set(`quoteResponse_${quoteRequest.quoteId}`, mojaloopResponse);
+            };
+            await this._save();
 
             // make a callback to the source fsp with the quote response
-            return this._mojaloopRequests.putQuotes(quoteRequest.quoteId, mojaloopResponse, sourceFspId);
+            const res = await this._mojaloopRequests.putQuotes(quoteRequest.quoteId, mojaloopResponse, sourceFspId);
+            this.data.quoteResponse = {
+                headers: res.originalRequest.headers,
+                body: res.originalRequest.body,
+            };
+            this.data.currentState = TransferStateEnum.WAITING_FOR_QUOTE_ACCEPTANCE;
+            await this._save();
+            return res;
         }
         catch(err) {
             this._logger.push({ err }).log('Error in quoteRequest');
@@ -257,7 +295,7 @@ class InboundTransfersModel {
                 return 'No response from backend';
             }
 
-            // project our internal quote reponse into mojaloop quote response form
+            // project our internal quote response into mojaloop quote response form
             const mojaloopResponse = shared.internalTransactionRequestResponseToMojaloop(response);
 
             // make a callback to the source fsp with the quote response
@@ -277,25 +315,36 @@ class InboundTransfersModel {
      * Validates an incoming transfer prepare request and makes a callback to the originator with
      * the result
      */
-    async prepareTransfer(prepareRequest, sourceFspId) {
+    async prepareTransfer(request, sourceFspId) {
+        const prepareRequest = request.body;
         try {
             // retrieve our quote data
-            let quote;
-
             if (this._allowDifferentTransferTransactionId) {
                 const transactionId = this._ilp.getTransactionObject(prepareRequest.ilpPacket).transactionId;
-                quote = await this._cache.get(`quote_${transactionId}`);
+                this.data = await this._load(transactionId);
             } else {
-                quote = await this._cache.get(`quote_${prepareRequest.transferId}`);
+                this.data = await this._load(prepareRequest.transferId);
             }
 
-            if(!quote) {
+            const quote = this.data.quote;
+
+            if(!this.data || !quote) {
+                // If using the sdk-scheme-adapter in place of the deprecated `mojaloop-connector`
+                // make sure this is false. Scenarios that use `mojaloop-connector`
+                // absolutely requires a previous quote before allowing a transfer to proceed.
+                // This is a different to the a typical mojaloop sdk-scheme-adapter setup which allows this as an option.
+
                 // Check whether to allow transfers without a previous quote.
                 if(!this._allowTransferWithoutQuote) {
                     throw new Error(`Corresponding quote not found for transfer ${prepareRequest.transferId}`);
                 }
             }
 
+            // persist our state so we have a record if we crash during processing the prepare
+            this.data.prepare = request;
+            this.data.currentState = TransferStateEnum.PREPARE_RECEIVED;
+            await this._save();
+
             // Calculate or retrieve fulfilment and condition
             let fulfilment = null;
             let condition = null;
@@ -313,13 +362,13 @@ class InboundTransfersModel {
                 throw new Error(`ILP condition in transfer prepare for ${prepareRequest.transferId} does not match quote`);
             }
 
-
-            if (quote && this._rejectTransfersOnExpiredQuotes) {
+            if (this._rejectTransfersOnExpiredQuotes) {
                 const now = new Date().toISOString();
                 const expiration = quote.mojaloopResponse.expiration;
                 if (now > expiration) {
                     const error = Errors.MojaloopApiErrorObjectFromCode(Errors.MojaloopApiErrorCodes.QUOTE_EXPIRED);
                     this._logger.error(`Error in prepareTransfer: quote expired for transfer ${prepareRequest.transferId}, system time=${now} > quote time=${expiration}`);
+                    await this.updateStateWithError(error);
                     return this._mojaloopRequests.putTransfersError(prepareRequest.transferId, error, sourceFspId);
                 }
             }
@@ -336,6 +385,7 @@ class InboundTransfersModel {
             }
 
             this._logger.log(`Transfer accepted by backend returning homeTransactionId: ${response.homeTransactionId} for mojaloop transferId: ${prepareRequest.transferId}`);
+            this.data.homeTransactionId = response.homeTransactionId;
 
             // create a  mojaloop transfer fulfil response
             const mojaloopResponse = {
@@ -350,10 +400,16 @@ class InboundTransfersModel {
             };
 
             // make a callback to the source fsp with the transfer fulfilment
-            return this._mojaloopRequests.putTransfers(prepareRequest.transferId, mojaloopResponse,
+            const res = await this._mojaloopRequests.putTransfers(prepareRequest.transferId, mojaloopResponse,
                 sourceFspId);
-        }
-        catch(err) {
+            this.data.fulfil = {
+                headers: res.originalRequest.headers,
+                body: res.originalRequest.body,
+            };
+            this.data.currentState = this._reserveNotification ? TransferStateEnum.RESERVED : TransferStateEnum.COMPLETED;
+            await this._save();
+            return res;
+        } catch(err) {
             this._logger.push({ err }).log('Error in prepareTransfer');
             const mojaloopError = await this._handleError(err);
             this._logger.push({ mojaloopError }).log(`Sending error response to ${sourceFspId}`);
@@ -717,22 +773,108 @@ class InboundTransfersModel {
     */
     async sendNotificationToPayee(body, transferId) {
         try {
-            const res = await this._backendRequests.putTransfersNotification(body, transferId);
+            // load any cached state for this transfer e.g. quote request/response etc...
+            this.data = await this._load(transferId);
+
+            // if we didnt have anything cached, start from scratch
+            if(!this.data) {
+                this.data = {};
+            }
+
+            // tag the final notification body on to the state
+            this.data.finalNotification = body;
+
+            if(body.transferState === 'COMMITTED') {
+                // if the transfer was successful in the switch, set the overall transfer state to COMPLETED
+                this.data.currentState = TransferStateEnum.COMPLETED;
+            }
+            else {
+                // if the final notification has anything other than COMMITTED as the final state, set an error
+                // in the transfer state.
+                this.data.currentState == TransferStateEnum.ERROR_OCCURED;
+                this.data.lastError = 'Final notification state not COMMITTED';
+            }
+
+            await this._save();
+
+            const res = await this._backendRequests.putTransfersNotification(this.data, transferId);
             return res;
         } catch (err) {
-            this._logger.push({ err }).log('Error in sendNotificationToPayee');
+            this._logger.push({ err }).log('Error notifying backend of final transfer state');
         }
     }
 
-    async _handleError(err, mojaloopErrorCode = Errors.MojaloopApiErrorCodes.INTERNAL_SERVER_ERROR) {
+    async _handleError(err) {
+        // by default use a generic server error
+        let mojaloopError = (new Errors.MojaloopFSPIOPError(err, null, null, Errors.MojaloopApiErrorCodes.INTERNAL_SERVER_ERROR)).toApiErrorObject();
         if(err instanceof HTTPResponseError) {
+            // this is an http response error e.g. from calling DFSP backend
             const e = err.getData();
             if(e.res && e.res.data) {
-                mojaloopErrorCode = Errors.MojaloopApiErrorCodeFromCode(`${e.res.data.statusCode}`);
+                // look for a standard mojaloop error that matches the statusCode
+                let mojaloopErrorCode = Errors.MojaloopApiErrorCodeFromCode(`${e.res.data.statusCode}`);
+                let errorDescription = e.res.data.message;
+                if(mojaloopErrorCode) {
+                    // use the standard mojaloop error object
+                    mojaloopError = (new Errors.MojaloopFSPIOPError(err, null, null, mojaloopErrorCode)).toApiErrorObject();
+                    if(errorDescription) {
+                        // if the error has a description, use that instead of the default mojaloop description
+                        // note that the mojaloop API spec allows any string up to 128 utf8 characters to be sent
+                        // in the errorDescription field.
+                        mojaloopError.errorInformation.errorDescription = errorDescription;
+                    }
+                }
+                else {
+                    // this is a custom error, so construct a mojaloop spec body
+                    mojaloopError = {
+                        errorInformation: {
+                            errorCode: e.res.data.statusCode,
+                            errorDescription: e.res.data.message,
+                        }
+                    };
+                }
             }
         }
+        if(this.data) {
+            //we have persisted state so update that with this error
+            this.data.lastError = {
+                originalError: err.stack || util.inspect(err),
+                mojaloopError: mojaloopError,
+            };
+            this.data.currentState = TransferStateEnum.ERROR_OCCURRED;
+            await this._save();
+        }
+        return mojaloopError;
+    }
 
-        return new Errors.MojaloopFSPIOPError(err, null, null, mojaloopErrorCode).toApiErrorObject();
+    /**
+     * Persists the model state to cache for reinstantiation at a later point
+     */
+    async _save() {
+        try {
+            const res = await this._cache.set(`transferModel_in_${this.data.transferId}`, this.data);
+            this._logger.push({ res }).log('Persisted transfer model in cache');
+        }
+        catch(err) {
+            this._logger.push({ err }).log('Error saving transfer model');
+            throw err;
+        }
+    }
+
+    /**
+     * Loads a transfer model from cache for resumption of the transfer process
+     *
+     * @param transferId {string} - UUID transferId of the model to load from cache
+     */
+    async _load(transferId) {
+        try {
+            const data = await this._cache.get(`transferModel_in_${transferId}`);
+            return data;
+        }
+        catch(err) {
+            this._logger.push({ err }).log('Error loading transfer model');
+            throw err;
+        }
     }
 }
 

package/src/lib/model/OutboundRequestToPayModel.js

@@ -155,17 +155,16 @@ class OutboundRequestToPayModel {
             // hook up a subscriber to handle response messages
             const subId = await this._cache.subscribe(payeeKey, (cn, msg, subId) => {
                 try {
-                    let payee = JSON.parse(msg);
-
-                    if(payee.errorInformation) {
+                    this.data.getPartiesResponse = JSON.parse(msg);
+                    if(this.data.getPartiesResponse.body.errorInformation) {
                         // this is an error response to our GET /parties request
-                        const err = new BackendError(`Got an error response resolving party: ${util.inspect(payee)}`, 500);
-                        err.mojaloopError = payee;
-
+                        const err = new BackendError(`Got an error response resolving party: ${util.inspect(this.data.getPartiesResponse.body, { depth: Infinity })}`, 500);
+                        err.mojaloopError = this.data.getPartiesResponse.body;
                         // cancel the timeout handler
                         clearTimeout(timeout);
                         return reject(err);
                     }
+                    let payee = this.data.getPartiesResponse.body;
 
                     if(!payee.party) {
                         // we should never get a non-error response without a party, but just in case...

package/src/lib/model/OutboundRequestToPayTransferModel.js

@@ -427,8 +427,8 @@ class OutboundRequestToPayTransferModel {
                         return reject(error);
                     }
 
-                    const quoteResponseBody = message.data;
-                    const quoteResponseHeaders = message.headers;
+                    const quoteResponseBody = message.data.body;
+                    const quoteResponseHeaders = message.data.headers;
                     this._logger.push({ quoteResponseBody }).log('Quote response received');
 
                     this.data.quoteResponse = quoteResponseBody;