@mojaloop/sdk-scheme-adapter 11.18.8

package/lib/check.js

@@ -0,0 +1,25 @@
+/**************************************************************************
+ *  (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:                                                      *
+ *       Matt Kingston - matt.kingston@modusbox.com                       *
+ **************************************************************************/
+
+// This module maps all methods on Node assert to non-throwing "check" functions which return true
+// if the assertion succeeded and false otherwise
+
+const assert = require('assert').strict;
+
+module.exports = Object.fromEntries(
+    Object.entries(assert).map(([k, f]) => [k, (...args) => {
+        try {
+            f.bind(assert)(...args);
+            return true;
+        } catch (err) {
+            return false;
+        }
+    }])
+);

package/lib/model/AccountsModel.js

@@ -0,0 +1,396 @@
+/**************************************************************************
+ *  (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';
+
+const util = require('util');
+const { uuid } = require('uuidv4');
+const StateMachine = require('javascript-state-machine');
+const { MojaloopRequests, Errors } = require('@mojaloop/sdk-standard-components');
+const { BackendError } = require('./common');
+
+const stateEnum = {
+    'ERROR_OCCURRED': 'ERROR_OCCURRED',
+    'COMPLETED': 'COMPLETED',
+};
+
+
+/**
+ *  Models the state machine and operations required for performing an outbound transfer
+ */
+class AccountsModel {
+    constructor(config) {
+        this._cache = config.cache;
+        this._logger = config.logger;
+        this._requestProcessingTimeoutSeconds = config.requestProcessingTimeoutSeconds;
+        this._dfspId = config.dfspId;
+
+        this._requests = new MojaloopRequests({
+            logger: this._logger,
+            peerEndpoint: config.alsEndpoint,
+            dfspId: config.dfspId,
+            tls: config.tls,
+            jwsSign: config.jwsSign,
+            jwsSigningKey: config.jwsSigningKey,
+            wso2: config.wso2,
+        });
+    }
+
+
+    /**
+     * Initializes the internal state machine object
+     */
+    _initStateMachine (initState) {
+        this._stateMachine = new StateMachine({
+            init: initState,
+            transitions: [
+                { name: 'createAccounts', from: 'start', to: 'succeeded' },
+                { name: 'error', from: '*', to: 'errored' },
+            ],
+            methods: {
+                onTransition: this._handleTransition.bind(this),
+                onAfterTransition: this._afterTransition.bind(this),
+                onPendingTransition: (transition, from, to) => {
+                    // allow transitions to 'error' state while other transitions are in progress
+                    if(transition !== 'error') {
+                        throw new BackendError(`Transition requested while another transition is in progress: ${transition} from: ${from} to: ${to}`, 500);
+                    }
+                }
+            }
+        });
+
+        return this._stateMachine[initState];
+    }
+
+
+    /**
+     * Updates the internal state representation to reflect that of the state machine itself
+     */
+    _afterTransition() {
+        this._logger.log(`State machine transitioned: ${this._data.currentState} -> ${this._stateMachine.state}`);
+        this._data.currentState = this._stateMachine.state;
+    }
+
+
+    /**
+     * Initializes the accounts model
+     *
+     * @param data {object} - The outbound API POST /accounts request body
+     */
+    async initialize(data) {
+        this._data = data;
+
+        // add a modelId if one is not present e.g. on first submission
+        if(!this._data.hasOwnProperty('modelId')) {
+            this._data.modelId = uuid();
+        }
+
+        // initialize the transfer state machine to its starting state
+        if(!this._data.hasOwnProperty('currentState')) {
+            this._data.currentState = 'start';
+        }
+
+        if(!this._data.hasOwnProperty('response')) {
+            this._data.response = [];
+        }
+
+        this._initStateMachine(this._data.currentState);
+    }
+
+
+    /**
+     * Handles state machine transitions
+     */
+    async _handleTransition(lifecycle, ...args) {
+        this._logger.log(`Request ${this._data.requestId} is transitioning from ${lifecycle.from} to ${lifecycle.to} in response to ${lifecycle.transition}`);
+
+        switch(lifecycle.transition) {
+            case 'init':
+                return;
+
+            case 'createAccounts':
+                return this._createAccounts();
+
+            case 'error':
+                this._logger.log(`State machine is erroring with error: ${util.inspect(args)}`);
+                this._data.lastError = args[0] || new BackendError('unspecified error', 500);
+                break;
+
+            default:
+                this._logger.log(`Unhandled state transition for request ${this._data.requestId}`);
+        }
+    }
+
+
+    async _executeCreateAccountsRequest(request) {
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise(async (resolve, reject) => {
+            const requestKey = `ac_${request.requestId}`;
+
+            const subId = await this._cache.subscribe(requestKey, async (cn, msg, subId) => {
+                try {
+                    let error;
+                    let message = JSON.parse(msg);
+
+                    if (message.type === 'accountsCreationErrorResponse') {
+                        error = new BackendError(`Got an error response creating accounts: ${util.inspect(message.data)}`, 500);
+                        error.mojaloopError = message.data;
+                    } else if (message.type !== 'accountsCreationSuccessfulResponse') {
+                        this._logger.push({ message }).log(
+                            `Ignoring cache notification for request ${requestKey}. ` +
+                            `Unknown message type ${message.type}.`
+                        );
+                        return;
+                    }
+
+                    // cancel the timeout handler
+                    clearTimeout(timeout);
+
+                    // stop listening for account creation response messages.
+                    // no need to await for the unsubscribe to complete.
+                    // we dont really care if the unsubscribe fails but we should log it regardless
+                    this._cache.unsubscribe(requestKey, subId).catch(e => {
+                        this._logger.log(`Error unsubscribing (in callback) ${requestKey} ${subId}: ${e.stack || util.inspect(e)}`);
+                    });
+
+                    if (error) {
+                        return reject(error);
+                    }
+
+                    const response = message.data;
+                    this._logger.push({ response }).log('Account creation response received');
+                    return resolve(response);
+                }
+                catch(err) {
+                    return reject(err);
+                }
+            });
+
+            // 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);
+
+                // we dont really care if the unsubscribe fails but we should log it regardless
+                this._cache.unsubscribe(requestKey, subId).catch(e => {
+                    this._logger.log(`Error unsubscribing (in timeout handler) ${requestKey} ${subId}: ${e.stack || util.inspect(e)}`);
+                });
+
+                return reject(err);
+            }, this._requestProcessingTimeoutSeconds * 1000);
+
+            // 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);
+                this._logger.push({ res }).log('Account creation request sent to peer');
+            }
+            catch(err) {
+                // cancel the timout and unsubscribe before rejecting the promise
+                clearTimeout(timeout);
+
+                // we dont really care if the unsubscribe fails but we should log it regardless
+                this._cache.unsubscribe(requestKey, subId).catch(e => {
+                    this._logger.log(`Error unsubscribing (in error handler) ${requestKey} ${subId}: ${e.stack || util.inspect(e)}`);
+                });
+
+                return reject(err);
+            }
+        });
+    }
+
+
+    async _createAccounts() {
+        const requests = this._buildRequests();
+        for await (let request of requests) {
+            const response = await this._executeCreateAccountsRequest(request);
+            this._data.response.push(...this._buildClientResponse(response));
+        }
+    }
+
+    _buildClientResponse(response) {
+        return response.partyList.map(party => ({
+            idType: party.partyId.partyIdType,
+            idValue: party.partyId.partyIdentifier,
+            idSubValue: party.partyId.partySubIdOrType,
+            ...!response.currency && {
+                error: {
+                    statusCode: Errors.MojaloopApiErrorCodes.CLIENT_ERROR.code,
+                    message: 'Provided currency not supported',
+                }
+            },
+            ...party.errorInformation && {
+                error: {
+                    statusCode: party.errorInformation.errorCode,
+                    message: party.errorInformation.errorDescription,
+                },
+            },
+        }));
+    }
+
+
+    /**
+     * Builds accounts creation requests payload from current state
+     *
+     * @returns {Array} - the account creation requests
+     */
+    _buildRequests() {
+        const MAX_ITEMS_PER_REQUEST = 10000; // As per API Spec 6.2.2.2 (partyList field)
+
+        const requests = [];
+        for (let account of this._data.accounts) {
+            let request = requests.find(req =>
+                req.currency === account.currency && (req.partyList.length < MAX_ITEMS_PER_REQUEST));
+            if (!request) {
+                request = {
+                    requestId: uuid(),
+                    partyList: [],
+                    currency: account.currency,
+                };
+                requests.push(request);
+            }
+            request.partyList.push({
+                partyIdType: account.idType,
+                partyIdentifier: account.idValue,
+                partySubIdOrType: account.idSubValue,
+                fspId: this._dfspId,
+            });
+        }
+        return requests;
+    }
+
+    /**
+     * Returns an object representing the final state of the transfer suitable for the outbound API
+     *
+     * @returns {object} - Response representing the result of the transfer process
+     */
+    getResponse() {
+        // we want to project some of our internal state into a more useful
+        // representation to return to the SDK API consumer
+        const resp = { ...this._data };
+
+        switch(this._data.currentState) {
+            case 'succeeded':
+                resp.currentState = stateEnum.COMPLETED;
+                break;
+
+            case 'errored':
+                resp.currentState = stateEnum.ERROR_OCCURRED;
+                break;
+
+            default:
+                this._logger.log(
+                    `Account model response being returned from an unexpected state: ${this._data.currentState}. ` +
+                    'Returning ERROR_OCCURRED state'
+                );
+                resp.currentState = stateEnum.ERROR_OCCURRED;
+                break;
+        }
+
+        return resp;
+    }
+
+
+    /**
+     * Persists the model state to cache for reinitialisation at a later point
+     */
+    async _save() {
+        try {
+            this._data.currentState = this._stateMachine.state;
+            const res = await this._cache.set(`accountModel_${this._data.modelId}`, this._data);
+            this._logger.push({ res }).log('Persisted account model in cache');
+        }
+        catch(err) {
+            this._logger.push({ err }).log('Error saving account model');
+            throw err;
+        }
+    }
+
+
+    /**
+     * Loads an accounts model from cache for resumption of the accounts management process
+     *
+     * @param modelId {string} - UUID of the model to load from cache
+     */
+    async load(modelId) {
+        try {
+            const data = await this._cache.get(`accountModel_${modelId}`);
+            if(!data) {
+                throw new BackendError(`No cached data found for account model with id: ${modelId}`, 500);
+            }
+            await this.initialize(data);
+            this._logger.push({ cache: this._data }).log('Account model loaded from cached state');
+        }
+        catch(err) {
+            this._logger.push({ err }).log('Error loading account model');
+            throw err;
+        }
+    }
+
+
+    /**
+     * Returns a promise that resolves when the state machine has reached a terminal state
+     */
+    async run() {
+        try {
+            // run transitions based on incoming state
+            switch(this._data.currentState) {
+                case 'start': {
+                    await this._stateMachine.createAccounts();
+                    const accounts = this._data.response;
+                    const failCount = accounts.filter((account) => account.error).length;
+                    const successCount = this._data.response.length - failCount;
+                    this._logger.log(`Accounts created: ${successCount} succeeded, ${failCount} failed`);
+                    // if (failCount > 0) {
+                    //     throw new BackendError(`Failed to create ${failCount} account(s)`, 500);
+                    // }
+                    break;
+                }
+
+                case 'succeeded':
+                    // all steps complete so return
+                    this._logger.log('Accounts creation completed');
+                    await this._save();
+                    return this.getResponse();
+
+                case 'errored':
+                    // stopped in errored state
+                    this._logger.log('State machine in errored state');
+                    return;
+            }
+
+            // now call ourslves recursively to deal with the next transition
+            this._logger.log(
+                `Account model state machine transition completed in state: ${this._stateMachine.state}. ` +
+                'Handling next transition.'
+            );
+            return this.run();
+        }
+        catch(err) {
+            this._logger.log(`Error running account model: ${util.inspect(err)}`);
+
+            // as this function is recursive, we dont want to error the state machine multiple times
+            if(this._data.currentState !== 'errored') {
+                // err should not have a executionState property here!
+                if(err.executionState) {
+                    this._logger.log(`State machine is broken: ${util.inspect(err)}`);
+                }
+                // transition to errored state
+                await this._stateMachine.error(err);
+
+                // avoid circular ref between executionState.lastError and err
+                err.executionState = JSON.parse(JSON.stringify(this.getResponse()));
+            }
+            throw err;
+        }
+    }
+}
+
+
+module.exports = AccountsModel;

package/lib/model/Async2SyncModel.js

@@ -0,0 +1,283 @@
+/**************************************************************************
+ *  (C) Copyright ModusBox Inc. 2021 - 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 util = require('util');
+
+const PSM = require('./common').PersistentStateMachine;
+const MojaloopRequests = require('@mojaloop/sdk-standard-components').MojaloopRequests;
+const deferredJob = require('./lib').deferredJob;
+
+function generate({
+    /**
+     * @name channelNameMethod
+     * @description generates the pub/sub channel name
+     * @param {object} args - the arguments passed as object, same as passed to `run, triggerDeferredJob, generateKey` method
+     * @returns {string} - the pub/sub channel name
+     */
+    channelNameMethod,
+
+    /**
+     * @name requestActionMethod
+     * @description invokes the call to switch
+     * @param {object} requests - MojaloopRequests instance
+     * @param {array} args - the arguments passed as object to `run` method
+     */
+    requestActionMethod,
+
+    /**
+     * @name argsValidationMethod
+     * @description makes validation of args object, invoked in `run, triggerDeferredJob, generateKey` methods to ensure everything is going well
+     * @param {object} requests - MojaloopRequests instance
+     * @param {array} args - the arguments passed as object to `run` method
+     */
+    argsValidationMethod,
+
+    /**
+     * @name reformatMessageMethod
+     * @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
+     */
+    reformatMessageMethod,
+
+    // the name of the model, used for logging
+    modelName
+}) {
+
+    // don't reformat message if method not specified
+    const reformatMessage = reformatMessageMethod || ((m) => m);
+
+    const specStateMachine = {
+        init: 'start',
+        transitions: [
+            { name: 'init', from: 'none', to: 'start' },
+            { name: 'requestAction', from: 'start', to: 'succeeded' },
+            { name: 'error', from: '*', to: 'errored' },
+        ],
+        methods: {
+            // workflow methods
+            run,
+            getResponse,
+
+            // specific transitions handlers methods
+            onRequestAction
+        }
+    };
+
+    /**
+     * @name run
+     * @description run the workflow logic
+     * @param {arguments} args - arguments
+     * @returns {Object} - the http response payload
+     */
+    async function run(args) {
+        // input validation, it should throws if any of args is invalid
+        argsValidationMethod(args);
+
+        const { data, logger } = this.context;
+        try {
+            // run transitions based on incoming state
+            switch (data.currentState) {
+                case 'start':
+                    // the first transition is requestAction
+                    await this.requestAction(args);
+                    // don't await to finish the save
+                    this.saveToCache();
+
+                // eslint-disable-next-line no-fallthrough
+                case 'succeeded':
+                    // all steps complete so return
+                    logger.log('Action called successfully');
+                    return this.getResponse();
+
+                case 'errored':
+                    // stopped in errored state
+                    logger.log('State machine in errored state');
+                    return;
+            }
+        } catch (err) {
+            logger.log(`Error running ${modelName} model: ${util.inspect(err)}`);
+
+            // as this function is recursive, we don't want to error the state machine multiple times
+            if (data.currentState !== 'errored') {
+                // err should not have a requestActionState property here!
+                if (err.requestActionState) {
+                    logger.log('State machine is broken');
+                }
+                // transition to errored state
+                await this.error(err);
+
+                // avoid circular ref between requestActionState.lastError and err
+                err.requestActionState = JSON.parse(JSON.stringify(this.getResponse()));
+            }
+            throw err;
+        }
+    }
+
+    const mapCurrentState = {
+        start: 'WAITING_FOR_ACTION',
+        succeeded: 'COMPLETED',
+        errored: 'ERROR_OCCURRED'
+    };
+
+    /**
+     * @name getResponse
+     * @description returns the http response payload depending on which state machine is
+     * @returns {Object} - the http response payload
+     */
+    function getResponse() {
+        const { data, logger } = this.context;
+        let resp = { ...data };
+
+        // project some of our internal state into a more useful
+        // representation to return to the SDK API consumer
+        resp.currentState = mapCurrentState[data.currentState];
+
+        // handle unexpected state
+        if (!resp.currentState) {
+            logger.error(`${modelName} model response being returned from an unexpected state: ${data.currentState}. Returning ERROR_OCCURRED state`);
+            resp.currentState = mapCurrentState.errored;
+        }
+
+        return resp;
+    }
+    /**
+     * @name onRequestAction
+     * @description generates the pub/sub channel name
+     * @param {object} args - the arguments passed as object
+     * @returns {string} - the pub/sub channel name
+     */
+    async function onRequestAction(fsm, args) {
+        const { cache, logger } = this.context;
+        const { requests, config } = this.handlersContext;
+        logger.push({ args }).log('onRequestAction - arguments');
+
+        return deferredJob(cache, channelNameMethod(args))
+            .init(async (channel) => {
+                const res = await requestActionMethod(requests, args);
+                logger.push({ res, channel, args }).log('RequestAction call sent to peer, listening on response');
+                return res;
+            })
+            .job((message) => {
+                this.context.data = {
+                    ...reformatMessage(message),
+                    currentState: this.state
+                };
+                logger.push({ message }).log('requestActionMethod message received');
+            })
+            .wait(config.requestProcessingTimeoutSeconds * 1000);
+    }
+
+
+    /**
+     *
+     * @param {object} cache - the cache instance used to publish message
+     * @param {object} message  - the message used to trigger deferred job
+     * @param {object} args - args passed to channelNameMethod
+     * @returns {Promise} - the promise which resolves when deferred job is invoked
+     */
+    async function triggerDeferredJob({ cache, message, args }) {
+        // input validation, it should throws if any of args is invalid
+        argsValidationMethod(args);
+
+        const cn = channelNameMethod(args);
+        return deferredJob(cache, cn).trigger(message);
+    }
+
+    /**
+     * @name generateKey
+     * @description generates the cache key used to store state machine
+     * @param {object} args - args passed to channelNameMethod
+
+     * @returns {string} - the cache key
+     */
+    function generateKey(args) {
+        // input validation, it should throws if any of args is invalid
+        argsValidationMethod(args);
+
+        return `key-${channelNameMethod(args)}`;
+    }
+
+
+    /**
+     * @name injectHandlersContext
+     * @description injects the config into state machine data, so it will be accessible to on transition notification handlers via `this.handlersContext`
+     * @param {Object} config   - config to be injected into state machine data
+     * @returns {Object}        - the altered specStateMachine
+     */
+    function injectHandlersContext(config) {
+        return {
+            ...specStateMachine,
+            data: {
+                handlersContext: {
+                    modelName,
+                    config: { ...config }, // injects config property
+                    requests: new MojaloopRequests({
+                        logger: config.logger,
+                        peerEndpoint: config.peerEndpoint,
+                        alsEndpoint: config.alsEndpoint,
+                        quotesEndpoint: config.quotesEndpoint,
+                        transfersEndpoint: config.transfersEndpoint,
+                        transactionRequestsEndpoint: config.transactionRequestsEndpoint,
+                        dfspId: config.dfspId,
+                        tls: config.tls,
+                        jwsSign: config.jwsSign,
+                        jwsSignPutParties: config.jwsSignPutParties,
+                        jwsSigningKey: config.jwsSigningKey,
+                        wso2Auth: config.wso2Auth
+                    })
+                }
+            }
+        };
+    }
+
+
+    /**
+     * @name create
+     * @description creates a new instance of state machine specified in specStateMachine ^
+     * @param {Object} data     - payload data
+     * @param {String} key      - the cache key where state machine will store the payload data after each transition
+     * @param {Object} config   - the additional configuration for transition handlers
+     */
+    async function create(data, key, config) {
+        const spec = injectHandlersContext(config, specStateMachine);
+        return PSM.create(data, config.cache, key, config.logger, spec);
+    }
+
+
+    /**
+     * @name loadFromCache
+     * @description loads state machine from cache by given key and specify the additional config for transition handlers
+     * @param {String} key      - the cache key used to retrieve the state machine from cache
+     * @param {Object} config   - the additional configuration for transition handlers
+     */
+    async function loadFromCache(key, config) {
+        const customCreate = async (data, _cache, key) => create(data, key, config);
+        return PSM.loadFromCache(config.cache, key, config.logger, specStateMachine, customCreate);
+    }
+
+
+    return {
+        channelName: channelNameMethod,
+        triggerDeferredJob,
+        create,
+        generateKey,
+        loadFromCache,
+
+        // exports for testing purposes
+        mapCurrentState
+    };
+}
+
+module.exports = {
+    generate
+};
+