@mojaloop/sdk-scheme-adapter 11.18.8

package/audit-resolve.json

@@ -0,0 +1,65 @@
+{
+  "decisions": {
+    "1556|@mojaloop/central-services-shared>widdershins>node-fetch": {
+      "decision": "fix",
+      "madeAt": 1624032509533
+    },
+    "1589|@mojaloop/central-services-shared>rc>ini": {
+      "decision": "fix",
+      "madeAt": 1624032519962
+    },
+    "1654|@mojaloop/central-services-shared>widdershins>swagger2openapi>yargs>y18n": {
+      "decision": "fix",
+      "madeAt": 1624032531602
+    },
+    "1654|@mojaloop/central-services-shared>widdershins>yargs>y18n": {
+      "decision": "fix",
+      "madeAt": 1624032531602
+    },
+    "1673|@mojaloop/central-services-shared>openapi-backend>lodash": {
+      "decision": "fix",
+      "madeAt": 1624032541954
+    },
+    "1673|@mojaloop/central-services-shared>shins>sanitize-html>lodash": {
+      "decision": "fix",
+      "madeAt": 1624032541954
+    },
+    "1673|koa2-oauth-server>00unidentified>lodash": {
+      "decision": "fix",
+      "madeAt": 1624032544849
+    },
+    "1500|@mojaloop/central-services-shared>widdershins>yargs>yargs-parser": {
+      "decision": "ignore",
+      "madeAt": 1631785234887,
+      "expiresAt": 1632390016480
+    },
+    "1675|@mojaloop/central-services-shared>shins>sanitize-html": {
+      "decision": "ignore",
+      "madeAt": 1631785236962,
+      "expiresAt": 1632390016480
+    },
+    "1676|@mojaloop/central-services-shared>shins>sanitize-html": {
+      "decision": "ignore",
+      "madeAt": 1631785236962,
+      "expiresAt": 1632390016480
+    },
+    "1766|@mojaloop/central-services-shared>widdershins>urijs": {
+      "decision": "fix",
+      "madeAt": 1627405029179
+    },
+    "1779|@mojaloop/event-sdk>grpc>@mapbox/node-pre-gyp>tar": {
+      "decision": "fix",
+      "madeAt": 1631785230676
+    },
+    "1780|@mojaloop/event-sdk>grpc>@mapbox/node-pre-gyp>tar": {
+      "decision": "fix",
+      "madeAt": 1631785230676
+    },
+    "1781|@mojaloop/event-sdk>grpc>@mapbox/node-pre-gyp>tar": {
+      "decision": "fix",
+      "madeAt": 1631785230676
+    }
+  },
+  "rules": {},
+  "version": 1
+}

package/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+    presets: [['@babel/preset-env', {targets: {node: 'current'}}]],
+};

package/config.js

@@ -0,0 +1,158 @@
+/**************************************************************************
+ *  (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 fs = require('fs');
+require('dotenv').config();
+const { from } = require('env-var');
+const yaml = require('js-yaml');
+
+function getFileContent (path) {
+    if (!fs.existsSync(path)) {
+        throw new Error('File doesn\'t exist');
+    }
+    return fs.readFileSync(path);
+}
+
+/**
+     * Gets Resources versions from enviromental variable RESOURCES_VERSIONS
+     * should be string in format: "resouceOneName=1.0,resourceTwoName=1.1"
+     */
+function getVersionFromConfig (resourceString) {
+    const resourceVersionMap = {};
+    resourceString
+        .split(',')
+        .forEach(e => e.split('=')
+            .reduce((p, c) => {
+                resourceVersionMap[p] = {
+                    contentVersion: c,
+                    acceptVersion: c.split('.')[0],
+                };
+            }));
+    return resourceVersionMap;
+}
+
+function parseResourceVersions (resourceString) {
+    if (!resourceString) return {};
+    const resourceFormatRegex = /(([A-Za-z])\w*)=([0-9]+).([0-9]+)([^;:|],*)/g;
+    const noSpResources = resourceString.replace(/\s/g,'');
+    if (!resourceFormatRegex.test(noSpResources)) {
+        throw new Error('Resource versions format should be in format: "resouceOneName=1.0,resourceTwoName=1.1"');
+    }
+    return getVersionFromConfig(noSpResources);
+}
+
+const env = from(process.env, {
+    asFileContent: (path) => getFileContent(path),
+    asFileListContent: (pathList) => pathList.split(',').map((path) => getFileContent(path)),
+    asYamlConfig: (path) => yaml.load(getFileContent(path)),
+    asResourceVersions: (resourceString) => parseResourceVersions(resourceString),
+});
+
+module.exports = {
+    __parseResourceVersion: parseResourceVersions,
+    mutualTLS: {
+        inboundRequests: {
+            enabled: env.get('INBOUND_MUTUAL_TLS_ENABLED').default('false').asBool(),
+            creds: {
+                ca: env.get('IN_CA_CERT_PATH').asFileListContent(),
+                cert: env.get('IN_SERVER_CERT_PATH').asFileContent(),
+                key: env.get('IN_SERVER_KEY_PATH').asFileContent(),
+            },
+        },
+        outboundRequests: {
+            enabled: env.get('OUTBOUND_MUTUAL_TLS_ENABLED').default('false').asBool(),
+            creds: {
+                ca: env.get('OUT_CA_CERT_PATH').asFileListContent(),
+                cert: env.get('OUT_CLIENT_CERT_PATH').asFileContent(),
+                key: env.get('OUT_CLIENT_KEY_PATH').asFileContent(),
+            },
+        },
+    },
+    inboundServerPort: env.get('INBOUND_LISTEN_PORT').default('4000').asPortNumber(),
+    outboundServerPort: env.get('OUTBOUND_LISTEN_PORT').default('4001').asPortNumber(),
+    testServerPort: env.get('TEST_LISTEN_PORT').default('4002').asPortNumber(),
+    peerEndpoint: env.get('PEER_ENDPOINT').required().asString(),
+    alsEndpoint: env.get('ALS_ENDPOINT').asString(),
+    quotesEndpoint: env.get('QUOTES_ENDPOINT').asString(),
+    bulkQuotesEndpoint: env.get('BULK_QUOTES_ENDPOINT').asString(),
+    transactionRequestsEndpoint: env.get('TRANSACTION_REQUESTS_ENDPOINT').asString(),
+    transfersEndpoint: env.get('TRANSFERS_ENDPOINT').asString(),
+    bulkTransfersEndpoint: env.get('BULK_TRANSFERS_ENDPOINT').asString(),
+    backendEndpoint: env.get('BACKEND_ENDPOINT').required().asString(),
+
+    dfspId: env.get('DFSP_ID').default('mojaloop').asString(),
+    ilpSecret: env.get('ILP_SECRET').default('mojaloop-sdk').asString(),
+    checkIlp: env.get('CHECK_ILP').default('true').asBool(),
+    expirySeconds: env.get('EXPIRY_SECONDS').default('60').asIntPositive(),
+
+    autoAcceptQuotes: env.get('AUTO_ACCEPT_QUOTES').default('true').asBool(),
+    autoAcceptParty: env.get('AUTO_ACCEPT_PARTY').default('true').asBool(),
+    autoAcceptR2PBusinessQuotes: env.get('AUTO_ACCEPT_R2P_BUSINESS_QUOTES').default('false').asBool(),
+    autoAcceptR2PDeviceQuotes: env.get('AUTO_ACCEPT_R2P_DEVICE_QUOTES').default('true').asBool(),
+    autoAcceptR2PDeviceOTP: env.get('AUTO_ACCEPT_R2P_DEVICE_OTP').default('false').asBool(),
+    autoAcceptParticipantsPut: env.get('AUTO_ACCEPT_PARTICIPANTS_PUT').default('false').asBool(),
+
+    /* TODO:  high-risk transactions can require additional clearing check */
+    // enableClearingCheck: env.get('ENABLE_CLEARING_CHECK').default('false').asBool(),
+
+    useQuoteSourceFSPAsTransferPayeeFSP: env.get('USE_QUOTE_SOURCE_FSP_AS_TRANSFER_PAYEE_FSP').default('false').asBool(),
+
+    // Getting secrets from files instead of environment variables reduces the likelihood of
+    // accidental leakage.
+
+    validateInboundJws: env.get('VALIDATE_INBOUND_JWS').default('true').asBool(),
+    validateInboundPutPartiesJws: env.get('VALIDATE_INBOUND_PUT_PARTIES_JWS').default('false').asBool(),
+    jwsSign: env.get('JWS_SIGN').default('true').asBool(),
+    jwsSignPutParties: env.get('JWS_SIGN_PUT_PARTIES').default('false').asBool(),
+    jwsSigningKey: env.get('JWS_SIGNING_KEY_PATH').asFileContent(),
+    jwsVerificationKeysDirectory: env.get('JWS_VERIFICATION_KEYS_DIRECTORY').asString(),
+    cacheConfig: {
+        host: env.get('CACHE_HOST').required().asString(),
+        port: env.get('CACHE_PORT').required().asPortNumber(),
+    },
+    enableTestFeatures: env.get('ENABLE_TEST_FEATURES').default('false').asBool(),
+    oauthTestServer: {
+        enabled: env.get('ENABLE_OAUTH_TOKEN_ENDPOINT').default('false').asBool(),
+        clientKey: env.get('OAUTH_TOKEN_ENDPOINT_CLIENT_KEY').asString(),
+        clientSecret: env.get('OAUTH_TOKEN_ENDPOINT_CLIENT_SECRET').asString(),
+        listenPort: env.get('OAUTH_TOKEN_ENDPOINT_LISTEN_PORT').asPortNumber(),
+    },
+    wso2: {
+        auth: {
+            staticToken: env.get('WSO2_BEARER_TOKEN').asString(),
+            tokenEndpoint: env.get('OAUTH_TOKEN_ENDPOINT').asString(),
+            clientKey: env.get('OAUTH_CLIENT_KEY').asString(),
+            clientSecret: env.get('OAUTH_CLIENT_SECRET').asString(),
+            refreshSeconds: env.get('OAUTH_REFRESH_SECONDS').default('60').asIntPositive(),
+        },
+        requestAuthFailureRetryTimes: env.get('WSO2_AUTH_FAILURE_REQUEST_RETRIES').default('0').asIntPositive(),
+    },
+    rejectExpiredQuoteResponses: env.get('REJECT_EXPIRED_QUOTE_RESPONSES').default('false').asBool(),
+    rejectTransfersOnExpiredQuotes: env.get('REJECT_TRANSFERS_ON_EXPIRED_QUOTES').default('false').asBool(),
+    rejectExpiredTransferFulfils: env.get('REJECT_EXPIRED_TRANSFER_FULFILS').default('false').asBool(),
+
+    requestProcessingTimeoutSeconds: env.get('REQUEST_PROCESSING_TIMEOUT_SECONDS').default('30').asIntPositive(),
+
+    logIndent: env.get('LOG_INDENT').default('2').asIntPositive(),
+
+    allowTransferWithoutQuote: env.get('ALLOW_TRANSFER_WITHOUT_QUOTE').default('false').asBool(),
+
+    // for outbound transfers, allows an extensionList item in an error respone to be used instead
+    // of the primary error code when setting the statusCode property on the synchronous response
+    // to the DFSP backend. This is useful if an intermediary such as FXP returns underlying error
+    // codes in error extensionLists.
+    outboundErrorStatusCodeExtensionKey: env.get('OUTBOUND_ERROR_STATUSCODE_EXTENSION_KEY').asString(),
+
+    proxyConfig: env.get('PROXY_CONFIG_PATH').asYamlConfig(),
+    reserveNotification: env.get('RESERVE_NOTIFICATION').default('false').asBool(),
+    // resourceVersions config should be string in format: "resouceOneName=1.0,resourceTwoName=1.1"
+    resourceVersions: env.get('RESOURCE_VERSIONS').default('').asResourceVersions()
+};

package/index.d.ts

@@ -0,0 +1 @@
+export * as OutboundAPI from './OutboundServer/api_interfaces';

package/index.js

@@ -0,0 +1,149 @@
+/**************************************************************************
+ *  (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 { hostname } = require('os');
+const config = require('./config');
+const EventEmitter = require('events');
+
+const InboundServer = require('./InboundServer');
+const OutboundServer = require('./OutboundServer');
+const OAuthTestServer = require('./OAuthTestServer');
+const TestServer = require('./TestServer');
+
+// import things we want to expose e.g. for unit tests and users who dont want to use the entire
+// scheme adapter as a service
+const InboundServerMiddleware = require('./InboundServer/middlewares.js');
+const OutboundServerMiddleware = require('./OutboundServer/middlewares.js');
+const Router = require('./lib/router');
+const Validate = require('./lib/validate');
+const RandomPhrase = require('./lib/randomphrase');
+const Cache = require('./lib/cache');
+const { Logger } = require('@mojaloop/sdk-standard-components');
+
+/**
+ * Class that creates and manages http servers that expose the scheme adapter APIs.
+ */
+class Server extends EventEmitter {
+    constructor(conf, logger) {
+        super({ captureExceptions: true });
+        this.conf = conf;
+        this.logger = logger;
+        this.cache = new Cache({
+            ...conf.cacheConfig,
+            logger: this.logger.push({ component: 'cache' }),
+            enableTestFeatures: conf.enableTestFeatures,
+        });
+
+        this.inboundServer = new InboundServer(
+            this.conf,
+            this.logger.push({ app: 'mojaloop-sdk-inbound-api' }),
+            this.cache
+        );
+        this.inboundServer.on('error', (...args) => {
+            this.logger.push({ args }).log('Unhandled error in Inbound Server');
+            this.emit('error', 'Unhandled error in Inbound Server');
+        });
+
+        this.outboundServer = new OutboundServer(
+            this.conf,
+            this.logger.push({ app: 'mojaloop-sdk-outbound-api' }),
+            this.cache
+        );
+        this.outboundServer.on('error', (...args) => {
+            this.logger.push({ args }).log('Unhandled error in Outbound Server');
+            this.emit('error', 'Unhandled error in Outbound Server');
+        });
+
+        this.oauthTestServer = new OAuthTestServer({
+            clientKey: this.conf.oauthTestServer.clientKey,
+            clientSecret: this.conf.oauthTestServer.clientSecret,
+            port: this.conf.oauthTestServer.listenPort,
+            logger: this.logger.push({ app: 'mojaloop-sdk-oauth-test-server' }),
+        });
+
+        this.testServer = new TestServer({
+            port: this.conf.testServerPort,
+            logger: this.logger.push({ app: 'mojaloop-sdk-test-api' }),
+            cache: this.cache,
+        });
+    }
+
+    async start() {
+        await this.cache.connect();
+
+        const startTestServer = this.conf.enableTestFeatures ? this.testServer.start() : null;
+        const startOauthTestServer = this.conf.oauthTestServer.enabled
+            ?  this.oauthTestServer.start()
+            : null;
+        await Promise.all([
+            this.inboundServer.start(),
+            this.outboundServer.start(),
+            startTestServer,
+            startOauthTestServer,
+        ]);
+    }
+
+    stop() {
+        return Promise.all([
+            this.inboundServer.stop(),
+            this.outboundServer.stop(),
+            this.oauthTestServer.stop(),
+            this.testServer.stop(),
+        ]);
+    }
+}
+
+
+if(require.main === module) {
+    (async () => {
+        // this module is main i.e. we were started as a server;
+        // not used in unit test or "require" scenarios
+        const logger = new Logger.Logger({
+            context: {
+                // If we're running from a Mojaloop helm chart deployment, we'll have a SIM_NAME
+                simulator: process.env['SIM_NAME'],
+                hostname: hostname(),
+            },
+            stringify: Logger.buildStringify({ space: config.logIndent }),
+        });
+        const svr = new Server(config, logger);
+        svr.on('error', (err) => {
+            logger.push({ err }).log('Unhandled server error');
+            process.exit(1);
+        });
+
+        // handle SIGTERM to exit gracefully
+        process.on('SIGTERM', async () => {
+            logger.log('SIGTERM received. Shutting down APIs...');
+            await svr.stop();
+            process.exit(0);
+        });
+
+        svr.start().catch(err => {
+            logger.push({ err }).log('Error starting server');
+            process.exit(1);
+        });
+    })();
+}
+
+
+// export things we want to expose e.g. for unit tests and users who dont want to use the entire
+// scheme adapter as a service
+module.exports = {
+    Cache,
+    InboundServerMiddleware,
+    OutboundServerMiddleware,
+    RandomPhrase,
+    Router,
+    Server,
+    Validate,
+};

package/jest.config.js

@@ -0,0 +1,15 @@
+module.exports = {
+    verbose: true,
+    collectCoverageFrom: [
+        '**/src/**/**/*.js'
+    ],
+    coverageThreshold: {
+        global: {
+            statements: 90,
+            functions: 90,
+            branches: 90,
+            lines: 90
+        }
+    },
+    clearMocks: true
+};

package/lib/api/index.js

@@ -0,0 +1,12 @@
+class ApiServer {
+    constructor(conf) {
+        this.conf = conf;
+        this.api = null;
+        this.server = null;
+        this.logger = null;
+    }
+
+
+}
+
+module.exports = ApiServer;

package/lib/cache.js

@@ -0,0 +1,352 @@
+/**************************************************************************
+ *  (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 util = require('util');
+const redis = require('redis');
+
+const CONN_ST = {
+    CONNECTED: 'CONNECTED',
+    CONNECTING: 'CONNECTING',
+    DISCONNECTED: 'DISCONNECTED',
+    DISCONNECTING: 'DISCONNECTING',
+};
+
+/**
+ * A shared cache abstraction over a REDIS distributed key/value store
+ */
+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');
+        }
+
+        this._logger = config.logger;
+
+        // a redis connection to handle get, set and publish operations
+        this._client = null;
+
+        // connection/disconnection logic
+        this._connectionState = CONN_ST.DISCONNECTED;
+
+        // a redis connection to handle subscribe operations and published message routing
+        // Note that REDIS docs suggest a client that is in SUBSCRIBE mode
+        // should not have any other commands executed against it.
+        // see: https://redis.io/topics/pubsub
+        this._subscriptionClient = null;
+
+        // a 'hashmap like' callback map
+        this._callbacks = {};
+
+        // tag each callback with an Id so we can gracefully unsubscribe and not leak resources
+        this._callbackId = 0;
+    }
+
+    /**
+     * Connects to a redis server and waits for ready events
+     * Note: We create two connections. One for get, set and publish commands
+     * and another for subscribe commands. We do this as we are not supposed
+     * to issue any non-pub/sub related commands on a connection used for sub
+     * See: https://redis.io/topics/pubsub
+     */
+    async connect() {
+        switch(this._connectionState) {
+            case CONN_ST.CONNECTED:
+                return;
+            case CONN_ST.CONNECTING:
+                await this._inProgressConnection;
+                return;
+            case CONN_ST.DISCONNECTED:
+                break;
+            case CONN_ST.DISCONNECTING:
+                // TODO: should this be an error?
+                // If we're disconnecting, we'll let that finish first
+                await this._inProgressDisconnection;
+                break;
+        }
+
+        this._connectionState = CONN_ST.CONNECTING;
+        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));
+
+        this._inProgressConnection = null;
+        this._connectionState = CONN_ST.CONNECTED;
+    }
+
+    /**
+     * Configure Redis to emit keyevent events. This corresponds to the application test mode, and
+     * enables us to listen for changes on callback_* and request_* keys.
+     * Docs: https://redis.io/topics/notifications
+     */
+    async setTestMode(enable) {
+        // See for modes: https://redis.io/topics/notifications#configuration
+        // This mode, 'Es$' is:
+        //   E     Keyevent events, published with __keyevent@<db>__ prefix.
+        //   s     Set commands
+        //   $     String commands
+        const mode = enable ? 'Es$' : '';
+        this._logger
+            .push({ 'notify-keyspace-events': mode })
+            .log('REDIS client Configured to emit keyspace-events');
+        this._client.config('SET', 'notify-keyspace-events', mode);
+    }
+
+    async disconnect() {
+        switch(this._connectionState) {
+            case CONN_ST.CONNECTED:
+                break;
+            case CONN_ST.CONNECTING:
+                // TODO: should this be an error?
+                // If we're connecting, we'll let that finish first
+                await this._inProgressConnection;
+                break;
+            case CONN_ST.DISCONNECTED:
+                return;
+            case CONN_ST.DISCONNECTING:
+                await this._inProgressDisconnection;
+                return;
+        }
+        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 = null;
+        this._subscriptionClient = null;
+        await this._inProgressDisconnection;
+        this._inProgressDisconnection = null;
+        this._connectionState = CONN_ST.DISCONNECTED;
+    }
+
+
+    /**
+     * Subscribes to a channel
+     *
+     * @param channel {string} - The channel name to subscribe to
+     * @param callback {function} - Callback function to be executed when messages arrive on the specified channel
+     * @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++;
+
+                // store the callback against the channel/id
+                this._callbacks[channel][id] = callback;
+
+                // return the id we gave the callback
+                return resolve(id);
+            });
+        });
+    }
+
+
+    /**
+     * Unsubscribes a callback from a channel
+     *
+     * @param channel {string} - name of the channel to unsubscribe from
+     * @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();
+            }
+
+            // 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');
+                }
+            });
+        }
+    }
+
+
+    /**
+     * Returns a new redis client
+     *
+     * @returns {object} - a connected REDIS client
+     * */
+    async _getClient() {
+        return new Promise((resolve, reject) => {
+            const client = redis.createClient(this._config);
+
+            client.on('error', (err) => {
+                this._logger.push({ err }).log('REDIS client Error');
+                return reject(err);
+            });
+
+            client.on('reconnecting', (err) => {
+                this._logger.push({ err }).log('REDIS client Reconnecting');
+                return reject(err);
+            });
+
+            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('ready', () => {
+                this._logger.log(`REDIS client ready at: ${this._config.host}:${this._config.port}`);
+                return resolve(client);
+            });
+
+            client.on('connect', () => {
+                this._logger.log(`REDIS client connected at: ${this._config.host}:${this._config.port}`);
+            });
+        });
+    }
+
+
+    /**
+     * Publishes the specified message to the specified channel
+     *
+     * @param channelName {string} - channel name to publish to
+     * @param value - any type that will be converted to a JSON string (unless it is already a string) and published as the message
+     * @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);
+            });
+        });
+    }
+
+
+    /**
+     * Sets a value in the cache
+     *
+     * @param key {string} - cache key
+     * @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);
+            });
+        });
+    }
+
+    /**
+     * Gets a value from the 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);
+            });
+        });
+    }
+}
+
+// Define constants on the prototype, but prevent a user of the cache from overwriting them for all
+// instances
+Object.defineProperty(Cache.prototype, 'CALLBACK_PREFIX', { value: 'callback_', writable: false });
+Object.defineProperty(Cache.prototype, 'REQUEST_PREFIX', { value: 'request_', writable: false });
+Object.defineProperty(Cache.prototype, 'EVENT_SET', { value: '__keyevent@0__:set', writable: false });
+
+module.exports = Cache;