@mojaloop/sdk-scheme-adapter 11.18.8

package/lib/model/ProxyModel/index.js

@@ -0,0 +1,138 @@
+/**************************************************************************
+ *  (C) Copyright ModusBox Inc. 2020 - All rights reserved.               *
+ *                                                                        *
+ *  This file is made available under the terms of the license agreement  *
+ *  specified in the corresponding source code repository.                *
+ *                                                                        *
+ *  ORIGINAL AUTHOR:                                                      *
+ *       Yevhen Kyriukha - yevhen.kyriukha@modusbox.com                   *
+ **************************************************************************/
+
+const { BackendError } = require('../common');
+const { MojaloopRequests } = require('@mojaloop/sdk-standard-components');
+const Ajv = require('ajv');
+const configSchema = require('./configSchema');
+const util = require('util');
+const Route = require('./Route');
+
+/**
+ * ProxyModel forwards request to corresponding endpoint based on provided route config
+ */
+class ProxyModel {
+    /**
+     *
+     * @param config
+     * @param config.logger {Object}
+     * @param config.proxyConfig {Object}
+     * @param config.peerEndpoint {string}
+     * @param config.dfspId {string}
+     * @param config.tls {Object}
+     * @param config.wso2Auth {Object}
+     */
+    constructor(config) {
+        this._logger = config.logger;
+
+        this._requests = new MojaloopRequests({
+            logger: this._logger,
+            peerEndpoint: config.peerEndpoint,
+            dfspId: config.dfspId,
+            tls: config.tls,
+            jwsSign: config.jwsSign,
+            jwsSigningKey: config.jwsSigningKey,
+            wso2Auth: config.wso2Auth
+        });
+
+        this._validateConfig(config.proxyConfig);
+        this._routes = this._createRoutes(config.proxyConfig);
+    }
+
+    async _executePostRequest(request) {
+        const res = await this._requests.postCustom(request.url, request.body, request.headers, request.query, true);
+        await this._logger.push({statusCode: res.statusCode, headers: res.headers}).log('POST request sent successfully');
+        return res;
+    }
+
+    async _executePutRequest(request) {
+        const res = await this._requests.putCustom(request.url, request.body, request.headers, request.query, true);
+        await this._logger.push({statusCode: res.statusCode, headers: res.headers}).log('PUT request sent successfully');
+        return res;
+    }
+
+    async _executeGetRequest(request) {
+        const res = await this._requests.getCustom(request.url, request.headers, request.query, true);
+        await this._logger.push({statusCode: res.statusCode, headers: res.headers}).log('GET request sent successfully');
+        return res;
+    }
+
+    _validateConfig(config) {
+        const ajv = new Ajv();
+        const validate = ajv.compile(configSchema);
+        const valid = validate(config);
+        if (!valid) {
+            const errors = util.inspect(validate.errors);
+            this._logger.push({ errors }).error('Proxy config is invalid');
+            throw new Error(`Proxy config is invalid: ${errors}`);
+        }
+    }
+
+    /**
+     *
+     * @param config
+     * @returns {Array.<Object>} myObjects
+     * @private
+     */
+    _createRoutes(config) {
+        try {
+            return config.routes.map(routeConfig => new Route(routeConfig));
+        } catch (e) {
+            this._logger.push({ e }).error('Failed to create route');
+            throw e;
+        }
+    }
+
+    _getMatchingDestination(request) {
+        for (const route of this._routes) {
+            // Destructure request object to show what we are expecting
+            const {path, query, headers} = request;
+            if (route.matchRequest({path, query, headers})) {
+                return route.destination;
+            }
+        }
+    }
+
+    /**
+     * Perform request forwarding
+     * @param request {object}
+     * @param request.method {string}
+     * @param request.url {string}
+     * @param request.body {object}
+     * @param request.headers {object}
+     * @return {Promise<object>}
+     */
+    async proxyRequest(request) {
+        const allowedMethods = ['GET', 'POST', 'PUT'];
+        const method = request.method.toUpperCase();
+        if (!allowedMethods.includes(method)) {
+            throw new BackendError(`Unsupported HTTP method "${request.method}"`, 400);
+        }
+        const url = this._getMatchingDestination(request);
+        if (!url) {
+            this._logger.log(`No proxy rule found for ${request.url}`);
+            return;
+        }
+        const destReq = {
+            url,
+            body: request.body,
+            headers: request.headers,
+            query: request.query,
+        };
+        switch (method) {
+            case 'GET': return this._executeGetRequest(destReq);
+            case 'POST': return this._executePostRequest(destReq);
+            case 'PUT': return this._executePutRequest(destReq);
+        }
+    }
+}
+
+
+module.exports = ProxyModel;

package/lib/model/QuotesModel.js

@@ -0,0 +1,94 @@
+/**************************************************************************
+ *  (C) Copyright ModusBox Inc. 2020 - All rights reserved.               *
+ *                                                                        *
+ *  This file is made available under the terms of the license agreement  *
+ *  specified in the corresponding source code repository.                *
+ *                                                                        *
+ *  ORIGINAL AUTHOR:                                                      *
+ *       Paweł Marzec - pawel.marzec@modusbox.com                         *
+ **************************************************************************/
+
+'use strict';
+
+const Async2SyncModel = require('./Async2SyncModel');
+
+
+// delegated methods for QuotesModel
+
+/**
+ * @name channelName
+ * @description generates the pub/sub channel name
+ * @param {object} - args
+ *   @param {string} args.quoteId - the quote payload
+ *   @param {string} [args.fspId] - ignored if passed - the destination fsp id
+ *   @param {string} [args.quote] - ignored if passed - the quote payload
+ * @returns {string} - the pub/sub channel name
+ */
+function channelName({ quoteId /* ,fspId, quote - are not used here */ }) {
+    const tokens = ['quotes', quoteId ];
+    return tokens.map(x => `${x}`).join('-');
+}
+
+/**
+ * @name requestAction
+ * @description invokes the call to switch
+ * @param {object} requests - MojaloopRequests instance
+ * @param {array} args - the arguments passed as object to `run` method
+ *   @param {string} [args.quoteId] - ignored if passed - the quote I=id
+ *   @param {string} args.fspId - the destination fsp id
+ *   @param {string} args.quote - the quote payload
+ */
+function requestAction(requests, { /* quoteId - is not used here */ fspId, quote }) {
+    if ( !fspId ) {
+        throw new Error('QuotesModel args requires \'fspId\' to be nonempty string');
+    }
+
+    if ( !(quote  && typeof(quote) === 'object') ) {
+        throw new Error('QuotesModel.requestAction args requires \'quote\' to be specified');
+    }
+    return requests.postQuotes(quote, fspId);
+}
+
+/**
+ * @name argsValidationMethod
+ * @description makes validation of args object, invoked in `run, triggerDeferredJob, generateKey` methods to ensure everything is going well
+ * @param {array} args - the arguments passed as object to `run` method
+ *   @param {string} args.quoteId - the party type
+ *   @param {string} [args.fspId] - the destination fsp id
+ *   @param {string} [args.quote] - the quote payload
+ */
+function argsValidation({ quoteId, fspId, quote }) {
+    if (!(quoteId && typeof(quoteId) === 'string' && quoteId.length > 0)) {
+        throw new Error('QuotesModel args requires \'quoteId\' is nonempty string and mandatory property');
+    }
+    if (fspId && !(typeof (fspId) === 'string' && fspId.length > 0)) {
+        throw new Error('QuotesModel args requires \'fspId\' to be nonempty string');
+    }
+    if (quote && quote.quoteId !== quoteId) {
+        throw new Error('QuotesModel args requires properties \'quote.quoteId\' and \'quoteId\' to be the equal in value');
+    }
+}
+
+/**
+ * @name reformatMessage
+ * @description reformats message received from PUB/SUB channel, it is optional method, if not specified identify function is used by default
+ * @param {object} message - message received
+ * @returns {object} - reformatted message
+ */
+function reformatMessage(message) {
+    return {
+        quotes: { ...message }
+    };
+}
+    
+// generate model 
+const QuotesModel = Async2SyncModel.generate({
+    modelName: 'QuotesModel',
+    channelNameMethod: channelName,
+    requestActionMethod: requestAction,
+    argsValidationMethod: argsValidation,
+    reformatMessageMethod: reformatMessage
+});
+
+module.exports = QuotesModel;
+

package/lib/model/TransfersModel.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const Async2SyncModel = require('./Async2SyncModel');
+
+
+// delegated methods for TransfersModel
+
+/**
+ * @name channelName
+ * @description generates the pub/sub channel name
+ * @param {object} - args
+ * @param {string} args.transferId - the transfer id
+ * @returns {string} - the pub/sub channel name
+ */
+function channelName({ transferId }) {
+    const tokens = ['transfers', transferId ];
+    return tokens.map(x => `${x}`).join('-');
+}
+
+/**
+ * @name requestAction
+ * @description invokes the call to switch
+ * @param {object} requests - MojaloopRequests instance
+ * @param {array} args - the arguments passed as object to `run` method
+ *   @param {string} [args.transferId] - ignored if passed - the transfer I=id
+ *   @param {string} args.fspId - the destination fsp id
+ *   @param {string} args.transfer - the transfer payload
+ */
+function requestAction(requests, { /* transferId - is not used here */ fspId, transfer }) {
+    if ( !fspId ) {
+        throw new Error('TransfersModel args requires \'fspId\' to be nonempty string');
+    }
+
+    if ( !(transfer  && typeof(transfer) === 'object') ) {
+        throw new Error('TransfersModel.requestAction args requires \'transfer\' to be specified');
+    }
+    return requests.postTransfers(transfer, fspId);
+}
+
+/**
+ * @name argsValidationMethod
+ * @description makes validation of args object, invoked in `run, triggerDeferredJob, generateKey` methods to ensure everything is going well
+ * @param {array} args - the arguments passed as object to `run` method
+ *   @param {string} args.transferId - the party type
+ *   @param {string} [args.fspId] - the destination fsp id
+ *   @param {string} [args.transfer] - the transfer payload
+ */
+function argsValidation({ transferId, fspId, transfer }) {
+    if (!(transferId && typeof(transferId) === 'string' && transferId.length > 0)) {
+        throw new Error('TransfersModel args requires \'transferId\' is nonempty string and mandatory property');
+    }
+    if (fspId && !(typeof (fspId) === 'string' && fspId.length > 0)) {
+        throw new Error('TransfersModel args requires \'fspId\' to be nonempty string');
+    }
+    if (transfer && transfer.transferId !== transferId) {
+        throw new Error('TransfersModel args requires properties \'transfer.transferId\' and \'transferId\' to be the equal in value');
+    }
+}
+
+/**
+ * @name reformatMessage
+ * @description reformats message received from PUB/SUB channel, it is optional method, if not specified identify function is used by default
+ * @param {object} message - message received
+ * @returns {object} - reformatted message
+ */
+function reformatMessage(message) {
+    return {
+        transfer: { ...message }
+    };
+}
+
+// generate model
+const TransfersModel = Async2SyncModel.generate({
+    modelName: 'TransfersModel',
+    channelNameMethod: channelName,
+    requestActionMethod: requestAction,
+    argsValidationMethod: argsValidation,
+    reformatMessageMethod: reformatMessage
+});
+
+module.exports = TransfersModel;

package/lib/model/common/BackendError.js

@@ -0,0 +1,26 @@
+/**************************************************************************
+ *  (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:                                                      *
+ *       Yevhen Kyriukha - yevhen.kyriukha@modusbox.com                   *
+ **************************************************************************/
+
+'use strict';
+
+class BackendError extends Error {
+    constructor(msg, httpStatusCode) {
+        super(msg);
+        this.httpStatusCode = httpStatusCode;
+    }
+
+    toJSON() {
+        // return shallow clone of `this`, from `this` are only taken enumerable owned properties
+        return Object.assign({}, this);
+        
+    }
+}
+
+module.exports = BackendError;

package/lib/model/common/PersistentStateMachine.js

@@ -0,0 +1,93 @@
+/**************************************************************************
+ *  (C) Copyright ModusBox Inc. 2020 - All rights reserved.               *
+ *                                                                        *
+ *  This file is made available under the terms of the license agreement  *
+ *  specified in the corresponding source code repository.                *
+ *                                                                        *
+ *  ORIGINAL AUTHOR:                                                      *
+ *       Paweł Marzec - pawel.marzec@modusbox.com                         *
+ **************************************************************************/
+
+'use strict';
+const StateMachine = require('javascript-state-machine');
+
+async function saveToCache() {
+    const { data, cache, key, logger } = this.context;
+    try {
+        const res = await cache.set(key, data);
+        logger.push({ res }).log(`Persisted model in cache: ${key}`);
+    }
+    catch(err) {
+        logger.push({ err }).log(`Error saving model: ${key}`);
+        throw err;
+    }
+}
+
+async function onAfterTransition(transition) {
+    const { logger } = this.context;
+    logger.log(`State machine transitioned '${transition.transition}': ${transition.from} -> ${transition.to}`);
+    this.context.data.currentState = transition.to;
+}
+
+function onPendingTransition(transition) {
+    // allow transitions to 'error' state while other transitions are in progress
+    if(transition !== 'error') {
+        throw new Error(`Transition '${transition}' requested while another transition is in progress.`);
+    }
+}
+
+async function create(data, cache, key, logger, stateMachineSpec ) {
+    let initState = stateMachineSpec.init || 'init';
+
+    if(!data.hasOwnProperty('currentState')) {
+        data.currentState = initState;
+    } else {
+        initState = stateMachineSpec.init = data.currentState;
+    }
+
+    stateMachineSpec.data = Object.assign(
+        stateMachineSpec.data || {}, 
+        {
+            context: {
+                data, cache, key, logger
+            }
+        }
+    );
+
+    stateMachineSpec.methods = Object.assign(
+        stateMachineSpec.methods || {}, 
+        {
+            onAfterTransition, 
+            onPendingTransition,
+            saveToCache
+        }
+    );
+
+    const stateMachine = new StateMachine(stateMachineSpec);
+    await stateMachine[initState];
+    return stateMachine;
+}
+
+
+async function loadFromCache(cache, key, logger, stateMachineSpec, optCreate) {
+    try {
+        const data = await cache.get(key);
+        if(!data) {
+            throw new Error(`No cached data found for: ${key}`);
+        }
+        logger.push({ cache: data }).log('data loaded from cache');
+
+        // use delegation to allow customization of 'create'
+        const createPSM = optCreate || create;
+        return createPSM(data, cache, key, logger, stateMachineSpec);
+    }
+    catch(err) {
+        logger.push({ err }).log(`Error loading data: ${key}`);
+        throw err;
+    }
+}
+
+module.exports = {
+    loadFromCache,
+    create
+};

package/lib/model/common/index.js

@@ -0,0 +1,18 @@
+/**************************************************************************
+ *  (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:                                                      *
+ *       Paweł Marzec - pawel.marzec@modusbox.com                         *
+ **************************************************************************/
+
+'use strict';
+const BackendError = require('./BackendError');
+const PersistentStateMachine = require('./PersistentStateMachine');
+
+module.exports = {
+    BackendError,
+    PersistentStateMachine
+};