@mojaloop/sdk-scheme-adapter 11.18.8

package/lib/model/PartiesModel.js

@@ -0,0 +1,70 @@
+/**************************************************************************
+ *  (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 PartiesModel
+
+/**
+ * @name channelName
+ * @description generates the pub/sub channel name
+ * @param {object} - args
+ *   @param {string} args.type     - the party type
+ *   @param {string} args.id       - the party id
+ *   @param {string} [args.subId]  - the optional party subId
+ * @returns {string} - the pub/sub channel name
+ */
+function channelName({ type, id, subId }) {
+    const tokens = ['parties', type, id, subId];
+    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.type     - the party type
+ *   @param {string} args.id       - the party id
+ *   @param {string} [args.subId]  - the optional party subId
+ */
+function requestAction(requests, { type, id, subId }) {
+    return requests.getParties(type, id, subId);
+}
+
+/**
+ * @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
+ *   @param {string} args.type     - the party type
+ *   @param {string} args.id       - the party id
+ *   @param {string} [args.subId]  - the optional party subId
+ */
+function argsValidation({ type, id, subId }) {
+    const channel = channelName({ type, id, subId });
+    if (channel.indexOf('-undefined-') != -1) {
+        throw new Error('PartiesModel args required at least two string arguments: \'type\' and \'id\'');
+    }
+}
+
+// generate model 
+const PartiesModel = Async2SyncModel.generate({
+    modelName: 'PartiesModel',
+    channelNameMethod: channelName,
+    requestActionMethod: requestAction,
+    argsValidationMethod: argsValidation
+});
+
+module.exports = PartiesModel;
+

package/lib/model/ProxyModel/MatchRules/Expression.js

@@ -0,0 +1,48 @@
+/**************************************************************************
+ *  (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                   *
+ **************************************************************************/
+
+class Expression {
+    /**
+     *
+     * @param data {string}
+     */
+    constructor(data) {
+        if (typeof data !== 'string') {
+            throw new Error('Invalid constructor parameters');
+        }
+        const ruleStr = data.trim();
+        if (ruleStr.startsWith('~')) {
+            let re = ruleStr.substr(1).trim();
+            if (re === '*') {
+                re = '.*';
+            }
+            this._rule = new RegExp(re, 'i');
+        } else {
+            this._rule = ruleStr.toLowerCase();
+        }
+    }
+
+    /**
+     *
+     * @param data {string}
+     */
+    match(data) {
+        if (typeof data !== 'string') {
+            throw new Error('data should be string');
+        }
+        if (typeof this._rule === 'string') {
+            return this._rule === data.toLowerCase();
+        } else {
+            return this._rule.test(data);
+        }
+    }
+}
+
+module.exports = Expression;

package/lib/model/ProxyModel/MatchRules/Headers.js

@@ -0,0 +1,65 @@
+/**************************************************************************
+ *  (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 MatchRule = require('./MatchRule');
+const Expression = require('./Expression');
+
+class Headers extends MatchRule {
+    /**
+     *
+     * @param data {Object}
+     * @param data.name {ExpressionData}
+     * @param data.value {ExpressionData}
+     */
+    constructor(data) {
+        super();
+        this._rules = this._createRule(data);
+    }
+
+    _createRule(data) {
+        return data.map(d => ({
+            name: new Expression(d.name),
+            value: new Expression(d.value),
+        }));
+    }
+
+    _matchRule(rule, data) {
+        for (const [name, value] of Object.entries(data)) {
+            if (rule.name.match(name) && rule.value.match(value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     *
+     * @param {Array.<Object>} data
+     */
+    match(data) {
+        if (typeof data !== 'object') {
+            throw new Error('data should be header object');
+        }
+
+        if (!this._rules || this._rules.length === 0) {
+            return false;
+        }
+
+        for (const rule of this._rules) {
+            if (!this._matchRule(rule, data)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
+
+module.exports = Headers;

package/lib/model/ProxyModel/MatchRules/MatchRule.js

@@ -0,0 +1,27 @@
+/**************************************************************************
+ *  (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                   *
+ **************************************************************************/
+
+class MatchRule {
+    constructor() {
+        if (this.constructor === MatchRule) {
+            throw new TypeError('Can not construct MatchRule abstract class.');
+        }
+        if (this.match === MatchRule.prototype.match) {
+            throw new TypeError('Please implement abstract method match.');
+        }
+    }
+
+    match() {
+        throw new TypeError('Do not call abstract method match from child.');
+    }
+
+}
+
+module.exports = MatchRule;

package/lib/model/ProxyModel/MatchRules/Path.js

@@ -0,0 +1,36 @@
+/**************************************************************************
+ *  (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 MatchRule = require('./MatchRule');
+const Expression = require('./Expression');
+
+class Path extends MatchRule {
+    /**
+     *
+     * @param data {ExpressionData}
+     */
+    constructor(data) {
+        super();
+        this._rule = new Expression(data);
+    }
+
+    /**
+     *
+     * @param data {string}
+     */
+    match(data) {
+        if (typeof data !== 'string') {
+            throw new Error('data should be string');
+        }
+        return this._rule.match(data);
+    }
+}
+
+module.exports = Path;

package/lib/model/ProxyModel/MatchRules/Query.js

@@ -0,0 +1,65 @@
+/**************************************************************************
+ *  (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 MatchRule = require('./MatchRule');
+const Expression = require('./Expression');
+
+class Query extends MatchRule {
+    /**
+     *
+     * @param data {Object}
+     * @param data.key {ExpressionData}
+     * @param data.value {ExpressionData}
+     */
+    constructor(data) {
+        super();
+        this._rules = this._createRule(data);
+    }
+
+    _createRule(data) {
+        return data.map(d => ({
+            key: new Expression(d.key),
+            value: new Expression(d.value),
+        }));
+    }
+
+    _matchRule(rule, data) {
+        for (const [key, value] of Object.entries(data)) {
+            if (rule.key.match(key) && rule.value.match(value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     *
+     * @param {Array.<Object>} data
+     */
+    match(data) {
+        if (typeof data !== 'object') {
+            throw new Error('data should be a query object');
+        }
+
+        if (!this._rules || this._rules.length === 0) {
+            return false;
+        }
+
+        for (const rule of this._rules) {
+            if (!this._matchRule(rule, data)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
+
+module.exports = Query;

package/lib/model/ProxyModel/MatchRules/index.js

@@ -0,0 +1,19 @@
+/**************************************************************************
+ *  (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 Path = require('./Path');
+const Headers = require('./Headers');
+const Query = require('./Query');
+
+module.exports = {
+    Path,
+    Headers,
+    Query,
+};

package/lib/model/ProxyModel/Route.js

@@ -0,0 +1,82 @@
+/**************************************************************************
+ *  (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 { Path, Query, Headers } = require('./MatchRules');
+
+class Route {
+    /**
+     *
+     * @param data {Object}
+     */
+    constructor(data) {
+        this._route = this._createRoute(data);
+    }
+
+    /**
+     *
+     * @param matchData {Object}
+     * @returns {Object}
+     * @private
+     */
+    _createMatchRule(matchData) {
+        return {
+            ...matchData.path && {
+                path: new Path(matchData.path),
+            },
+            ...matchData.query && {
+                query: new Query(matchData.query),
+            },
+            ...matchData.headers && {
+                headers: new Headers(matchData.headers),
+            },
+        };
+    }
+
+    /**
+     *
+     * @param route {Object}
+     * @returns {{matchRules: [], destination: string}}
+     * @private
+     */
+    _createRoute(route) {
+        const matchRules = [];
+        for (const matchData of route.match) {
+            matchRules.push(this._createMatchRule(matchData));
+        }
+        return {
+            matchRules,
+            destination: route.destination.path,
+        };
+    }
+
+    _matchRule(request, matchRule) {
+        for (const [ruleName, ruleValue] of Object.entries(matchRule)) {
+            if (!ruleValue.match(request[ruleName])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    matchRequest(request) {
+        for (const matchRule of this._route.matchRules) {
+            if (this._matchRule(request, matchRule)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    get destination() {
+        return this._route.destination;
+    }
+}
+
+module.exports = Route;

package/lib/model/ProxyModel/configSchema.json

@@ -0,0 +1,118 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$comment": "Proxy Config Schema",
+  "definitions": {
+
+    "URLPath": {
+      "description": "URL Path",
+      "type": "string",
+      "pattern": "^\/.*$"
+    },
+
+    "Expression": {
+      "type": "string",
+      "minLength": 1
+    },
+
+    "MatchRule": {
+      "description": "Matching rule (with AND condition)",
+      "type": "object",
+      "properties": {
+        "path": {
+          "$ref": "#/definitions/Expression"
+        },
+        "query": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "key": {
+                "$ref": "#/definitions/Expression"
+              },
+              "value": {
+                "$ref": "#/definitions/Expression"
+              }
+            },
+            "required": [
+              "key",
+              "value"
+            ]
+          }
+        },
+        "headers": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "name": {
+                "$ref": "#/definitions/Expression"
+              },
+              "value": {
+                "$ref": "#/definitions/Expression"
+              }
+            },
+            "required": [
+              "name",
+              "value"
+            ]
+          }
+        }
+      },
+      "anyOf": [
+        {
+          "required": [
+            "path"
+          ]
+        },
+        {
+          "required": [
+            "query"
+          ]
+        },
+        {
+          "required": [
+            "headers"
+          ]
+        }
+      ]
+    },
+
+    "Route": {
+      "description": "Routing rule",
+      "type": "object",
+      "properties": {
+        "match": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/MatchRule"
+          }
+        },
+        "destination": {
+          "type": "object",
+          "properties": {
+            "path": {
+              "$ref": "#/definitions/URLPath"
+            }
+          },
+          "required": ["path"]
+        }
+      },
+      "required": ["match", "destination"]
+    }
+  },
+
+  "type": "object",
+  "properties": {
+    "version": {
+      "type": "number",
+      "minimum": 1
+    },
+    "routes": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/Route"
+      }
+    }
+  },
+  "required": ["version", "routes"]
+}