@mojaloop/sdk-scheme-adapter 13.0.4 → 15.0.1

package/src/lib/cache.js

@@ -10,7 +10,6 @@
 
 'use strict';
 
-const util = require('util');
 const redis = require('redis');
 
 const CONN_ST = {
@@ -27,11 +26,12 @@ class Cache {
     constructor(config) {
         this._config = config;
 
-        if(!config.host || !config.port || !config.logger) {
-            throw new Error('Cache config requires host, port and logger properties');
+        if(!config.cacheUrl || !config.logger) {
+            throw new Error('Cache config requires cacheUrl and logger properties');
         }
 
         this._logger = config.logger;
+        this._url = config.cacheUrl;
 
         // a redis connection to handle get, set and publish operations
         this._client = null;
@@ -78,9 +78,6 @@ class Cache {
         this._inProgressConnection = Promise.all([this._getClient(), this._getClient()]);
         [this._client, this._subscriptionClient] = await this._inProgressConnection;
 
-        // hook up our sub message handler
-        this._subscriptionClient.on('message', this._onMessage.bind(this));
-
         if (this._config.enableTestFeatures) {
             this.setTestMode(true);
         }
@@ -104,7 +101,7 @@ class Cache {
         this._logger
             .push({ 'notify-keyspace-events': mode })
             .log('Configuring Redis to emit keyevent events');
-        this._client.config('SET', 'notify-keyspace-events', mode);
+        await this._client.configSet('notify-keyspace-events', mode);
     }
 
     async disconnect() {
@@ -124,8 +121,8 @@ class Cache {
         }
         this._connectionState = CONN_ST.DISCONNECTING;
         this._inProgressDisconnection = Promise.all([
-            new Promise(resolve => this._client.quit(resolve)),
-            new Promise(resolve => this._subscriptionClient.quit(resolve))
+            this._client.quit(),
+            this._subscriptionClient.quit()
         ]);
         this._client = null;
         this._subscriptionClient = null;
@@ -143,30 +140,36 @@ class Cache {
       * @returns {Promise} - Promise that resolves with an integer callback Id to submit in unsubscribe request
       */
     async subscribe(channel, callback) {
-        return new Promise((resolve, reject) => {
-            this._subscriptionClient.subscribe(channel, (err) => {
-                if(err) {
-                    this._logger.log(`Error subscribing to channel ${channel}: ${err.stack || util.inspect(err)}`);
-                    return reject(err);
-                }
-
-                this._logger.log(`Subscribed to cache pub/sub channel ${channel}`);
-
-                if(!this._callbacks[channel]) {
-                    // if this is the first subscriber for this channel we init the hashmap
-                    this._callbacks[channel] = {};
+        // get an id for this callback
+        const id = this._callbackId++;
+
+        if(!this._callbacks[channel]) {
+        // if this is the first subscriber for this channel we init the hashmap
+            this._callbacks[channel] = { [id]: callback };
+            await this._subscriptionClient.subscribe(channel, (msg) => {
+                // we have some callbacks to make
+                for (const [id, cb] of Object.entries(this._callbacks[channel])) {
+                    this._logger.log(`Cache message received on channel ${channel}. Making callback with id ${id}`);
+
+                    // call the callback with the channel name, message and callbackId...
+                    // ...(which is useful for unsubscribe)
+                    try {
+                        cb(channel, msg, id);
+                    } catch (err) {
+                        this._logger
+                            .push({ callbackId: id, err })
+                            .log('Unhandled error in cache subscription handler');
+                    }
                 }
+            });
+        } else {
+            this._callbacks[channel][id] = callback;
+        }
 
-                // get an id for this callback
-                const id = this._callbackId++;
-
-                // store the callback against the channel/id
-                this._callbacks[channel][id] = callback;
+        // store the callback against the channel/id
+        this._logger.log(`Subscribed to cache pub/sub channel ${channel}`);
 
-                // return the id we gave the callback
-                return resolve(id);
-            });
-        });
+        return id;
     }
 
 
@@ -177,88 +180,59 @@ class Cache {
       * @param callbackId {integer} - id of the callback to remove
       */
     async unsubscribe(channel, callbackId) {
-        return new Promise((resolve, reject) => {
-            if(this._callbacks[channel] && this._callbacks[channel][callbackId]) {
-                delete this._callbacks[channel][callbackId];
-                this._logger.log(`Cache unsubscribed callbackId ${callbackId} from channel ${channel}`);
-
-                if(Object.keys(this._callbacks[channel]).length < 1) {
-                    //no more callbacks for this channel
-                    delete this._callbacks[channel];
-                }
-
-                return resolve();
+        if(this._callbacks[channel] && this._callbacks[channel][callbackId]) {
+            delete this._callbacks[channel][callbackId];
+            this._logger.log(`Cache unsubscribed callbackId ${callbackId} from channel ${channel}`);
+
+            if(Object.keys(this._callbacks[channel]).length < 1) {
+                //no more callbacks for this channel
+                delete this._callbacks[channel];
+                await this._subscriptionClient.unsubscribe(channel);
             }
-
+        } else {
             // we should not be asked to unsubscribe from a subscription we do not have. Raise this as a promise
             // rejection so it can be spotted. It may indiate a logic bug somewhere else
             this._logger.log(`Cache not subscribed to channel ${channel} for callbackId ${callbackId}`);
-            return reject(new Error(`Channel ${channel} does not have a callback with id ${callbackId} subscribed`));
-        });
-    }
-
-
-    /**
-      * Handler for published messages
-      */
-    async _onMessage(channel, msg) {
-        if(this._callbacks[channel]) {
-            // we have some callbacks to make
-            Object.keys(this._callbacks[channel]).forEach(k => {
-                this._logger.log(`Cache message received on channel ${channel}. Making callback with id ${k}`);
-
-                // call the callback with the channel name, message and callbackId...
-                // ...(which is useful for unsubscribe)
-                try {
-                    this._callbacks[channel][k](channel, msg, k);
-                } catch (err) {
-                    this._logger
-                        .push({ callbackId: k, err })
-                        .log('Unhandled error in cache subscription handler');
-                }
-            });
+            throw new Error(`Channel ${channel} does not have a callback with id ${callbackId} subscribed`);
         }
     }
 
-
     /**
       * Returns a new redis client
       *
       * @returns {object} - a connected REDIS client
       * */
     async _getClient() {
-        return new Promise((resolve, reject) => {
-            const client = redis.createClient(this._config);
+        const client = redis.createClient({ url: this._url });
 
-            client.on('error', (err) => {
-                this._logger.push({ err }).log('Error from REDIS client getting subscriber');
-                return reject(err);
-            });
+        client.on('error', (err) => {
+            this._logger.push({ err }).log('Error from REDIS client getting subscriber');
+        });
 
-            client.on('reconnecting', (err) => {
-                this._logger.push({ err }).log('REDIS client Reconnecting');
-                return reject(err);
-            });
+        client.on('reconnecting', (err) => {
+            this._logger.push({ err }).log('REDIS client Reconnecting');
+        });
 
-            client.on('subscribe', (channel, count) => {
-                this._logger.push({ channel, count }).log('REDIS client subscribe');
-                // On a subscribe event, ensure that testFeatures are enabled.
-                // This is required here in the advent of a disconnect/reconnect event. Redis client will re-subscribe all subscriptions, but previously enabledTestFeatures will be lost.
-                // Handling this on the on subscribe event will ensure its always configured.
-                if (this._config.enableTestFeatures) {
-                    this.setTestMode(true);
-                }
-            });
+        client.on('subscribe', (channel, count) => {
+            this._logger.push({ channel, count }).log('REDIS client subscribe');
+            // On a subscribe event, ensure that testFeatures are enabled.
+            // This is required here in the advent of a disconnect/reconnect event. Redis client will re-subscribe all subscriptions, but previously enabledTestFeatures will be lost.
+            // Handling this on the on subscribe event will ensure its always configured.
+            if (this._config.enableTestFeatures) {
+                this.setTestMode(true);
+            }
+        });
 
-            client.on('connect', () => {
-                this._logger.log(`REDIS client connected at: ${this._config.host}:${this._config.port}`);
-            });
+        client.on('connect', () => {
+            this._logger.log(`REDIS client connected at: ${this._url}`);
+        });
 
-            client.on('ready', () => {
-                this._logger.log(`Connected to REDIS at: ${this._config.host}:${this._config.port}`);
-                return resolve(client);
-            });
+        client.on('ready', () => {
+            this._logger.log(`Connected to REDIS at: ${this._url}`);
         });
+        await client.connect();
+
+        return client;
     }
 
 
@@ -270,23 +244,11 @@ class Cache {
       * @returns {Promise} - Promise that will resolve with redis replies or reject with an error
       */
     async publish(channelName, value) {
-        return new Promise((resolve, reject) => {
-            if(typeof(value) !== 'string') {
-                // ALWAYS publish string values
-                value = JSON.stringify(value);
-            }
-
-            // note that we publish on the non-SUBSCRIBE connection
-            this._client.publish(channelName, value, (err, replies) => {
-                if(err) {
-                    this._logger.push({ channelName, err }).log(`Error publishing to channel ${channelName}`);
-                    return reject(err);
-                }
-
-                this._logger.push({ channelName, value }).log(`Published to channel ${channelName}`);
-                return resolve(replies);
-            });
-        });
+        if(typeof(value) !== 'string') {
+            // ALWAYS publish string values
+            value = JSON.stringify(value);
+        }
+        await this._client.publish(channelName, value);
     }
 
 
@@ -297,22 +259,11 @@ class Cache {
       * @param value {stirng} - cache value
       */
     async set(key, value) {
-        return new Promise((resolve, reject) => {
-            //if we are given an object, turn it into a string
-            if(typeof(value) !== 'string') {
-                value = JSON.stringify(value);
-            }
-
-            this._client.set(key, value, (err, replies) => {
-                if(err) {
-                    this._logger.push({ key, value, err }).log(`Error setting cache key: ${key}`);
-                    return reject(err);
-                }
-
-                this._logger.push({ key, value, replies }).log(`Set cache key: ${key}`);
-                return resolve(replies);
-            });
-        });
+        //if we are given an object, turn it into a string
+        if(typeof(value) !== 'string') {
+            value = JSON.stringify(value);
+        }
+        await this._client.set(key, value);
     }
 
     /**
@@ -322,22 +273,11 @@ class Cache {
       * @param value {string} - cache value
       */
     async add(key, value) {
-        return new Promise((resolve, reject) => {
-            //if we are given an object, turn it into a string
-            if(typeof(value) !== 'string') {
-                value = JSON.stringify(value);
-            }
-
-            this._client.sadd(key, value, (err, replies) => {
-                if(err) {
-                    this._logger.push({ key, value, err }).log(`Error setting cache key: ${key}`);
-                    return reject(err);
-                }
-
-                this._logger.push({ key, value, replies }).log(`Add cache key: ${key}`);
-                return resolve(replies);
-            });
-        });
+        //if we are given an object, turn it into a string
+        if(typeof(value) !== 'string') {
+            value = JSON.stringify(value);
+        }
+        await this._client.sAdd(key, value);
     }
 
     /**
@@ -346,28 +286,7 @@ class Cache {
       * @param key {string} - cache key
       */
     async members(key) {
-        return new Promise((resolve, reject) => {
-            this._client.smembers(key, (err, value) => {
-                if(err) {
-                    this._logger.push({ key, err }).log(`Error getting cache key: ${key}`);
-                    return reject(err);
-                }
-
-                this._logger.push({ key, value }).log(`Got cache key: ${key}`);
-
-                if(typeof(value) === 'string') {
-                    try {
-                        value = JSON.parse(value);
-                    }
-                    catch(err) {
-                        this._logger.push({ err }).log('Error parsing JSON cache value');
-                        return reject(err);
-                    }
-                }
-
-                return resolve(value);
-            });
-        });
+        return this._client.sMembers(key);
     }
 
     /**
@@ -376,28 +295,16 @@ class Cache {
       * @param key {string} - cache key
       */
     async get(key) {
-        return new Promise((resolve, reject) => {
-            this._client.get(key, (err, value) => {
-                if(err) {
-                    this._logger.push({ key, err }).log(`Error getting cache key: ${key}`);
-                    return reject(err);
-                }
-
-                this._logger.push({ key, value }).log(`Got cache key: ${key}`);
-
-                if(typeof(value) === 'string') {
-                    try {
-                        value = JSON.parse(value);
-                    }
-                    catch(err) {
-                        this._logger.push({ err }).log('Error parsing JSON cache value');
-                        return reject(err);
-                    }
-                }
-
-                return resolve(value);
-            });
-        });
+        let value = await this._client.get(key);
+        if(typeof(value) === 'string') {
+            try {
+                value = JSON.parse(value);
+            }
+            catch(err) {
+                this._logger.push({ err }).log('Error parsing JSON cache value');
+            }
+        }
+        return value;
     }
 }
 

package/src/lib/metrics.js

@@ -134,7 +134,7 @@ class MetricsServer {
             this._logger.log('Metrics request received');
 
             ctx.response.set('Content-Type', this._prometheusRegister.contentType);
-            ctx.response.body = this._prometheusRegister.metrics();
+            ctx.response.body = await this._prometheusRegister.metrics();
         });
 
         return result;

package/src/lib/model/InboundTransfersModel.js

@@ -389,9 +389,9 @@ class InboundTransfersModel {
 
             // create a  mojaloop transfer fulfil response
             const mojaloopResponse = {
-                completedTimestamp: new Date(),
-                transferState: this._reserveNotification ? 'RESERVED' : 'COMMITTED',
-                fulfilment: fulfilment,
+                completedTimestamp: response.completedTimestamp || new Date(),
+                transferState: response.transferState || (this._reserveNotification ? TransferStateEnum.RESERVED : TransferStateEnum.COMPLETED),
+                fulfilment: response.fulfilment || fulfilment,
                 ...response.extensionList && {
                     extensionList: {
                         extension: response.extensionList,
@@ -406,7 +406,7 @@ class InboundTransfersModel {
                 headers: res.originalRequest.headers,
                 body: res.originalRequest.body,
             };
-            this.data.currentState = this._reserveNotification ? TransferStateEnum.RESERVED : TransferStateEnum.COMPLETED;
+            this.data.currentState = response.transferState || (this._reserveNotification ? TransferStateEnum.RESERVED : TransferStateEnum.COMPLETED);
             await this._save();
             return res;
         } catch(err) {
@@ -788,10 +788,14 @@ class InboundTransfersModel {
                 // if the transfer was successful in the switch, set the overall transfer state to COMPLETED
                 this.data.currentState = TransferStateEnum.COMPLETED;
             }
+            else if(body.transferState === 'ABORTED') {
+                // if the transfer was ABORTED in the switch, set the overall transfer state to ABORTED
+                this.data.currentState = TransferStateEnum.ABORTED;
+            }            
             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.currentState = TransferStateEnum.ERROR_OCCURED;
                 this.data.lastError = 'Final notification state not COMMITTED';
             }
 
@@ -800,7 +804,7 @@ class InboundTransfersModel {
             const res = await this._backendRequests.putTransfersNotification(this.data, transferId);
             return res;
         } catch (err) {
-            this._logger.push({ err }).log('Error notifying backend of final transfer state');
+            this._logger.push({ err }).log(`Error notifying backend of final transfer state equal to: ${body.transferState}`);
         }
     }
 

package/src/lib/model/OutboundTransfersModel.js

@@ -163,7 +163,7 @@ class OutboundTransfersModel {
         if(!this.data.hasOwnProperty('direction')) {
             this.data.direction = 'OUTBOUND';
         }
-        if(this.data.skipPartyLookup && typeof(this.data.to.fspId) === undefined) {
+        if(this.data.skipPartyLookup && !this.data.to.fspId) {
             throw new Error('fspId of to party must be specific id when skipPartyLookup is truthy');
         }
 

package/test/__mocks__/redis.js

@@ -1,53 +1,78 @@
 /**************************************************************************
- *  (C) Copyright ModusBox Inc. 2019 - All rights reserved.               *
+ *  (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:                                                      *
- *       James Bush - james.bush@modusbox.com                             *
+ *       Yevhen Kyriukha - yevhen.kyriukha@modusbox.com                   *
  **************************************************************************/
 
-'use strict';
-
 const redisMock = require('redis-mock');
+const { promisify } = require('util');
+
+const { EventEmitter } = require('events');
+
+const events = {};
 
-// redis-mock currently ignores callback argument, the following class fix this
+// redis-mock currently ignores callback arguments, the following class fixes that
 class RedisClient extends redisMock.RedisClient {
-    constructor(options, stream, redisMock) {
-        super(options, stream, redisMock);
+    constructor(opts) {
+        super(opts);
+        events[opts.cacheUrl] = events[opts.cacheUrl] || new EventEmitter();
+        this.events = events[opts.cacheUrl];
     }
 
-    _executeCallback(...args) {
-        if (typeof args[args.length - 1] === 'function') {
-            const callback = args[args.length - 1];
-            const argList = Array.prototype.slice.call(args, 0, args.length - 1);
-            callback(null, argList);
-        }
+    async subscribe(...args) {
+        this.events.on(...args);
+        // return promisify(super.subscribe.bind(this))(...args);
     }
 
-    config(...args) {
-        this._executeCallback(...args);
+    async unsubscribe(channel) {
+        this.events.removeAllListeners(channel);
     }
 
-    subscribe(...args) {
-        super.subscribe(...args);
-        this._executeCallback(...args);
+    async publish(...args) {
+        process.nextTick(() => this.events.emit(...args));
     }
 
-    publish(...args) {
-        super.publish(...args);
-        this._executeCallback(...args);
+    set(...args) {
+        return promisify(super.set.bind(this))(...args);
     }
 
-    set(...args) {
-        super.set(...args);
-        this._executeCallback(...args);
+    get(...args) {
+        return promisify(super.get.bind(this))(...args);
+    }
+
+    keys(...args) {
+        return promisify(super.keys.bind(this))(...args);
+    }
+
+    end() {
+        this.events.removeAllListeners();
     }
-}
 
+    connect() {}
 
+    async disconnect() {
+        return this.end();
+    }
+
+    async quit() {
+        return this.end();
+    }
+
+    sAdd(...args) {
+        return promisify(super.sadd.bind(this))(...args);
+    }
+
+    sMembers(...args) {
+        return promisify(super.smembers.bind(this))(...args);
+    }
+
+    configSet() {}
+}
 
 module.exports = {
-    createClient: (options = {host: 'localhost', port: 6380}, stream, redisMock) => new RedisClient(options, stream, redisMock),
+    createClient: (opts) => new RedisClient(opts),
 };

package/test/config/integration.env

@@ -43,8 +43,7 @@ JWS_VERIFICATION_KEYS_DIRECTORY=/jwsVerificationKeys
 LOG_INDENT=0
 
 # REDIS CACHE CONNECTION
-CACHE_HOST=redis
-CACHE_PORT=6379
+CACHE_URL=redis://redis:6379
 CACHE_SHOULD_EXPIRE=false
 CACHE_EXPIRY_SECONDS=3600
 

package/test/integration/lib/cache.test.js

@@ -37,8 +37,7 @@ const { Logger } = require('@mojaloop/sdk-standard-components');
 const env = require('../testEnv');
 
 const defaultCacheConfig = {
-    host: env.redis.host,
-    port: env.redis.port,
+    cacheUrl: env.redisUrl,
     logger: null
 };
 

package/test/integration/testEnv.js

@@ -1,7 +1,4 @@
 module.exports = {
     OutboundHostURI: 'http://localhost:4001',
-    redis: {
-        host: 'localhost',
-        port: 6379
-    }
+    redisUrl: 'redis://localhost:6379',
 };

package/test/unit/ControlClient.test.js

@@ -1,14 +1,9 @@
 
 const ControlAgent = require('~/ControlAgent');
 const TestControlServer = require('./ControlServer');
-const InboundServer = require('~/InboundServer');
-const OutboundServer = require('~/OutboundServer');
-const TestServer = require('~/TestServer');
-const defaultConfig = require('./data/defaultConfig.json');
 const { Logger } = require('@mojaloop/sdk-standard-components');
 
 jest.mock('~/lib/cache');
-const Cache = require('~/lib/cache');
 
 // TODO:
 // - diff against master to determine what else needs testing
@@ -66,48 +61,9 @@ describe('ControlAgent', () => {
             const newConfigEvent = new Promise(
                 (resolve) => client.on(ControlAgent.EVENT.RECONFIGURE, resolve)
             );
-            await server.broadcastConfigChange(changedConfig);
+            server.broadcastConfigChange(changedConfig);
             const newConfEventData = await newConfigEvent;
             expect(newConfEventData).toEqual(changedConfig);
         });
     });
 });
-
-describe('Server reconfigure methods', () => {
-    let conf, logger, cache;
-
-    const isPromise = (o) => Promise.resolve(o) === o;
-
-    beforeEach(() => {
-        conf = JSON.parse(JSON.stringify(defaultConfig));
-        logger = new Logger.Logger({ stringify: () => '' });
-        cache = new Cache({ ...conf.cacheConfig, logger: logger.push({ component: 'cache' }) });
-    });
-
-    test('InboundServer reconfigure method returns sync function', async () => {
-        const server = new InboundServer(conf, logger, cache);
-        const res = await server.reconfigure(conf, logger, cache);
-        expect(isPromise(res)).toEqual(false);
-    });
-
-    test('OutboundServer reconfigure method returns sync function', async () => {
-        const server = new OutboundServer(conf, logger, cache);
-        const res = await server.reconfigure(conf, logger, cache);
-        expect(isPromise(res)).toEqual(false);
-    });
-
-    test('TestServer reconfigure method returns sync function', async () => {
-        const server = new TestServer({ logger, cache });
-        const res = await server.reconfigure({ logger, cache });
-        expect(isPromise(res)).toEqual(false);
-    });
-
-    test('ControlClient reconfigure method returns sync function', async () => {
-        const server = new TestControlServer.Server({ logger, appConfig: { ...conf, control: { port: 4005 }}});
-        const client = await ControlAgent.Client.Create({ port: 4005, logger, appConfig: {} });
-        const res = await client.reconfigure({ logger, port: 4005, appConfig: {} });
-        expect(isPromise(res)).toEqual(false);
-        await client.close();
-        await server.close();
-    });
-});