@mojaloop/sdk-scheme-adapter 11.18.8

package/lib/router.js

@@ -0,0 +1,28 @@
+/**************************************************************************
+ *  (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:                                                      *
+ *       Matt Kingston - matt.kingston@modusbox.com                       *
+ **************************************************************************/
+
+'use strict';
+
+
+module.exports = (handlerMap) => async (ctx, next) => {
+    const handlers = handlerMap[ctx.state.path.pattern];
+    const handler = handlers ? handlers[ctx.method.toLowerCase()] : undefined;
+    if (!handlers || !handler) {
+        ctx.state.logger.log('No handler found');
+        ctx.response.status = 404;
+        // TODO: response content according to API spec. Should probably actually be a 404 here.
+        ctx.response.body = { statusCode: 404, message: 'Not found' };
+    }
+    else {
+        ctx.state.logger.push({ handler }).log('Found handler');
+        await handler(ctx);
+    }
+    await next();
+};

package/lib/validate.js

@@ -0,0 +1,205 @@
+/**************************************************************************
+ *  (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:                                                      *
+ *       Matt Kingston - matt.kingston@modusbox.com                       *
+ **************************************************************************/
+
+'use strict';
+
+
+// TODO: is it worth bringing in an external lib just for converting params to JSON schema?
+// Consider replacing this.
+const paramsToJsonSchema = require('openapi-jsonschema-parameters').convertParametersToJSONSchema;
+const jsrp = require('json-schema-ref-parser');
+const util = require('util');
+
+const { Errors } = require('@mojaloop/sdk-standard-components');
+
+// Don't stop at the first error, we'll let the user know what all their errors are. Also, when we
+// validate, coerce types to those we're interested in where possible.
+const Ajv = require('ajv');
+const ajv = new Ajv({ allErrors: true, coerceTypes: true, strict: false });
+
+const httpMethods = ['get', 'head', 'post', 'put', 'delete', 'connnect', 'options', 'trace', 'patch'];
+
+// Create a json schema in the format we've chosen to use
+const createSchema = (pathValue, methodValue) => {
+    let properties = {
+        ...paramsToJsonSchema([ ...(pathValue.parameters || []), ...(methodValue.parameters || []) ]),
+        body: extractBody(methodValue.requestBody) || {}
+    };
+    // Make all header keys lower-case
+    if ('headers' in properties && 'properties' in properties.headers) {
+        properties.headers.properties = Object.assign(
+            ...Object.entries(properties.headers.properties).map(([headerName, value]) => ({ [headerName.toLowerCase()]: value })));
+        properties.headers.required = properties.headers.required.map(r => r.toLowerCase());
+    }
+    const required = Object.entries(properties)
+        .filter(([, value]) => value.required && value.required.length > 0)
+        .map(([prop,]) => prop);
+    return {
+        type: 'object',
+        properties,
+        required
+    };
+};
+
+// Extract the body schema if it's nested within content.'application/json'
+const extractBody = rqBody => {
+    if (rqBody && 'content' in rqBody) {
+        if ('application/json' in rqBody.content) {
+            return rqBody.content['application/json'].schema;
+        }
+        // TODO: handle more content types
+        throw new Error('Unhandled content type');
+    }
+    return rqBody;
+};
+
+// Here we're transforming the incoming openapi spec to combine path-level parameters and
+// method-level parameters, to get everything in the format we'll validate with.
+//
+// Input:
+// {
+//   /path/to/resource: {
+//     parameters: { required: true, in: "headers", name: "content-type", type: "integer" },
+//     get": {
+//       parameters: { required: true, in: "query", name: "length", type: "integer" },
+//       requestBody: { "$ref": "#/components/requestBodies/someBodyObj" }
+//     }
+//   }
+// }
+//
+// Output:
+// {
+//   /path/to/resource: {
+//     get: {
+//       validator: {
+//         [ Function validate ]
+//         schema: {
+//           query: { properties: { length: { type: "string" } }, required: ["length"] },
+//           body: { "$ref": "#/components/requestBodies/someBodyObj" },
+//           headers: { properties: { "content-type": { type: "integer" } }, required: ["content-type"] }
+//         }
+//       }
+//     }
+//   }
+// }
+const transformApiDoc = apiDoc => ({
+    ...apiDoc,
+    // TODO: as we now discard most of the extra information, it probably makes sense to explicitly
+    // return the object form we're interested in, rather than do all of this awkward object
+    // mapping. I.e.:
+    // return { get: { validator: [Function validator] }, put: { validator: [Function validator] } };
+    paths: Object.assign(...Object.entries(apiDoc.paths).map(([pathName, pathValue]) => ({
+        [pathName]: Object.assign(
+            ...Object.entries(pathValue)
+                .filter(([method,]) => httpMethods.includes(method))
+                .map(([method, methodValue]) => {
+                    const schema = createSchema(pathValue, methodValue);
+                    const validatorF = ajv.compile(schema);
+                    return {
+                        [method]: {
+                            validator: (ctx, path) => {
+                                const result = validatorF({
+                                    body: ctx.request.body,
+                                    headers: ctx.request.headers,
+                                    params: ctx.params,
+                                    query: ctx.request.query,
+                                    path
+                                });
+                                if (result === true) {
+                                    return undefined;
+                                }
+                                return validatorF.errors;
+                            }
+                        }
+                    };
+                })
+        )
+    })))
+});
+
+class Validator {
+    // apiDoc
+    //   POJO representing apiDoc API spec. Example:
+    //   const v = new Validator(require('./apiDoc.json'));
+    async initialise(apiDoc) {
+        // Dereferencing the api doc makes it much easier to work with. Specifically, it allows us
+        // to compile a validator for each path.
+        const pojoApiDoc = await jsrp.dereference(apiDoc);
+
+        this.apiDoc = transformApiDoc(pojoApiDoc);
+        const pathParamMatch = /\{[^{}]+\}/g;
+        this.paths = Object.entries(this.apiDoc.paths).map(([path, pathSpec]) => ({
+            pattern: path,
+            matcher: {
+                // If we were using node 10, instead of having this awkward params object, we could
+                // replace the path parameters with named regex matches corresponding to the path
+                // names.
+                regex: new RegExp(`^${path.replace(pathParamMatch, '([^{}/]+)')}$`),
+                params: (path.match(pathParamMatch) || []).map(s => s.replace(/(^{|}$)/g, ''))
+            },
+            methods: { ...pathSpec }
+        }));
+    }
+
+    // TODO: roll the entire validation functionality into a single function? Or split it out into
+    // path, headers, body, query? Or neither? If we validate the body separately, we can avoid
+    // parsing the body until (and unless) it comes time for body validation. BUT this means we
+    // won't tell the user everything that's wrong with their request in a single response, which
+    // is probably more valuable, given the purpose of the simulator. However; having the lib
+    // support this option would be good.
+    validatePath(path, logger) {
+        let result = this.paths.find(p => path.match(p.matcher.regex) !== null);
+
+        if (result === undefined) {
+            throw new Errors.MojaloopFSPIOPError(null, `Couldn't match path ${path}`, null,
+                Errors.MojaloopApiErrorCodes.UNKNOWN_URI);
+        }
+        result.params = Object.assign({}, ...path.match(result.matcher.regex).slice(1).map((m, i) => ({ [result.matcher.params[i]]: m})));
+
+        logger.push({ path, result }).log('Matched path');
+        return result;
+    }
+
+
+    validateRequest(ctx, logger) {
+        const path = this.validatePath(ctx.path, logger);
+        if (!(ctx.method.toLowerCase() in path.methods)) {
+            const err = new Error(`Method ${ctx.method} not supported for path ${ctx.path}`);
+            err.httpStatusCode = 405;
+            throw err;
+        }
+
+        const validationResult = path.methods[ctx.method.toLowerCase()].validator(ctx, path.params);
+
+        if (validationResult !== undefined && validationResult.length > 0) {
+            logger.push({ validationResult }).log('Validation result');
+
+            let err;
+            const firstError = validationResult[0];
+
+            if(firstError.keyword === 'required') {
+                // this is a missing required property; there is a specific mojaloop api spec error code for this
+                err = new Errors.MojaloopFSPIOPError(firstError, util.format('Request failed validation', 
+                    validationResult), null, Errors.MojaloopApiErrorCodes.MISSING_ELEMENT);
+
+                // overwrite the defaul error message with something more useful
+                err.apiErrorCode.message = `${firstError.dataPath} ${firstError.message}`;
+                throw err;
+            }
+
+            err = new Error(util.format('Request failed validation', validationResult));
+            Object.assign(err, firstError);
+            throw err;
+        }
+        return path;
+    }
+}
+
+module.exports = Validator;

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "@mojaloop/sdk-scheme-adapter",
+  "version": "11.18.8",
+  "description": "An adapter for connecting to Mojaloop API enabled switches.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "engines": {
+    "node": ">=14.15"
+  },
+  "scripts": {
+    "audit:resolve": "SHELL=sh resolve-audit --production",
+    "audit:check": "SHELL=sh check-audit --production",
+    "build": "npm run build:openapi; npm run build:dto:outbound",
+    "build:openapi": "npm run build:openapi:inbound && npm run build:openapi:outbound",
+    "build:openapi:inbound": "openapi bundle --output ./InboundServer/api.yaml --ext yaml ./InboundServer/api_template.yaml",
+    "build:openapi:outbound": "openapi bundle --output ./OutboundServer/api.yaml --ext yaml ./OutboundServer/api_template/openapi.yaml",
+    "build:dto:outbound": "openapi-typescript ./OutboundServer/api.yaml --output ./OutboundServer/api_interfaces/openapi.d.ts",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "jest --ci --reporters=default --reporters=jest-junit --env=node test/unit/",
+    "test:int": "jest --ci --reporters=default --reporters=jest-junit --env=node test/integration",
+    "validate:api": "npm run validate:api:in; npm run validate:api:out",
+    "validate:api:in": "swagger-cli validate ./InboundServer/api.yaml",
+    "validate:api:out": "swagger-cli validate ./OutboundServer/api.yaml",
+    "updates:check": "npm run dep:check",
+    "updates:update": "npm run dep:update && npm install",
+    "dep:check": "npx ncu -e 2",
+    "dep:update": "npx ncu -u",
+    "release": "standard-version --releaseCommitMessageFormat 'chore(release): {{currentTag}} [skip ci]'"
+  },
+  "author": "Matt Kingston, James Bush, ModusBox Inc.",
+  "contributors": [
+    "Kamuela Franco <kamuela.franco@modusbox.com>",
+    "Steven Oderayi <steven.oderayi@modusbox.com>",
+    "Valentin Genev <valentin.genev@modusbox.com>",
+    "Shashikant Hirugade <shashikant.hirugade@modusbox.com>",
+    "Paweł Marzec <pawel.marzec@modusbox.com>",
+    "Kevin Leyow <kevin.leyow@modusbox.com",
+    "Miguel de Barros <miguel.debarros@modusbox.com>"
+  ],
+  "license": "Apache-2.0",
+  "licenses": [
+    {
+      "type": "Apache-2.0",
+      "url": "http://www.apache.org/licenses/LICENSE-2.0"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:mojaloop/sdk-scheme-adapter.git"
+  },
+  "dependencies": {
+    "@koa/cors": "^3.1.0",
+    "@mojaloop/central-services-error-handling": "11.3.0",
+    "@mojaloop/central-services-health": "13.0.0",
+    "@mojaloop/central-services-logger": "10.6.1",
+    "@mojaloop/central-services-metrics": "11.0.0",
+    "@mojaloop/central-services-shared": "14.0.0",
+    "@mojaloop/event-sdk": "10.7.1",
+    "@mojaloop/sdk-standard-components": "15.13.0",
+    "ajv": "8.6.3",
+    "ajv-keywords": "5.0.0",
+    "axios": "^0.21.4",
+    "co-body": "^6.1.0",
+    "dotenv": "^10.0.0",
+    "env-var": "^7.0.1",
+    "javascript-state-machine": "^3.1.0",
+    "js-yaml": "^4.1.0",
+    "json-schema-ref-parser": "^9.0.9",
+    "koa": "^2.13.1",
+    "koa-body": "^4.2.0",
+    "koa2-oauth-server": "^1.0.0",
+    "openapi-jsonschema-parameters": "^9.3.0",
+    "promise-timeout": "^1.3.0",
+    "redis": "^3.1.2",
+    "uuidv4": "^6.2.12",
+    "ws": "^7.5.5"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.15.5",
+    "@babel/preset-env": "^7.15.6",
+    "@mojaloop/api-snippets": "^12.6.6",
+    "@redocly/openapi-cli": "^1.0.0-beta.59",
+    "@types/jest": "^27.0.1",
+    "babel-jest": "^27.2.0",
+    "eslint": "^7.32.0",
+    "eslint-config-airbnb-base": "^14.2.1",
+    "eslint-plugin-import": "^2.24.2",
+    "eslint-plugin-jest": "^24.4.0",
+    "jest": "^27.2.0",
+    "jest-junit": "^12.2.0",
+    "nock": "^13.1.3",
+    "npm-audit-resolver": "^2.3.1",
+    "npm-check-updates": "^11.8.5",
+    "openapi-response-validator": "^9.3.0",
+    "openapi-typescript": "^4.0.2",
+    "redis-mock": "^0.56.3",
+    "standard-version": "^9.3.1",
+    "supertest": "^6.1.6",
+    "swagger-cli": "^4.0.4"
+  }
+}

package/test/__mocks__/@mojaloop/sdk-standard-components.js

@@ -0,0 +1,152 @@
+/**************************************************************************
+ *  (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 assert = require('assert').strict;
+const util = require('util');
+const { MojaloopRequests, Errors, WSO2Auth, Jws, Logger } = jest.requireActual('@mojaloop/sdk-standard-components');
+
+
+class MockMojaloopRequests extends MojaloopRequests {
+    constructor(...args) {
+        super(...args);
+        MockMojaloopRequests.__instance = this;
+        this.postParticipants = MockMojaloopRequests.__postParticipants;
+        this.getParties = MockMojaloopRequests.__getParties;
+        this.postTransactionRequests = MockMojaloopRequests.__postTransactionRequests;
+        this.postQuotes = MockMojaloopRequests.__postQuotes;
+        this.putQuotes = MockMojaloopRequests.__putQuotes;
+        this.putQuotesError = MockMojaloopRequests.__putQuotesError;
+        this.getAuthorizations = MockMojaloopRequests.__getAuthorizations;
+        this.postAuthorizations = MockMojaloopRequests.__postAuthorizations;        
+        this.putAuthorizations = MockMojaloopRequests.__putAuthorizations;
+        this.getTransfers = MockMojaloopRequests.__getTransfers;
+        this.putTransactionRequests = MockMojaloopRequests.__putTransactionRequests;
+        this.postTransfers = MockMojaloopRequests.__postTransfers;
+        this.putTransfers = MockMojaloopRequests.__putTransfers;
+        this.putTransfersError = MockMojaloopRequests.__putTransfersError;
+        this.getBulkQuotes = MockMojaloopRequests.__getBulkQuotes;
+        this.postBulkQuotes = MockMojaloopRequests.__postBulkQuotes;
+        this.putBulkQuotes = MockMojaloopRequests.__putBulkQuotes;
+        this.putBulkQuotesError = MockMojaloopRequests.__putBulkQuotesError;
+        this.getBulkTransfers = MockMojaloopRequests.__getBulkTransfers;
+        this.postBulkTransfers = MockMojaloopRequests.__postBulkTransfers;
+        this.putBulkTransfers = MockMojaloopRequests.__putBulkTransfers;
+        this.putBulkTransfersError = MockMojaloopRequests.__putBulkTransfersError;
+    }
+}
+MockMojaloopRequests.__postParticipants = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__getParties = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__postTransactionRequests = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__postQuotes = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__putQuotes = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__putQuotesError = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__getAuthorizations = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__postAuthorizations = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__putAuthorizations = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__getTransfers = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__putTransactionRequests = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__postTransfers = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__putTransfers = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__putTransfersError = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__getBulkQuotes = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__postBulkQuotes = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__putBulkQuotes = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__putBulkQuotesError = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__getBulkTransfers = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__postBulkTransfers = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__putBulkTransfers = jest.fn(() => Promise.resolve());
+MockMojaloopRequests.__putBulkTransfersError = jest.fn(() => Promise.resolve());
+
+
+class MockIlp {
+    constructor(config) {
+        assert(config.logger, 'Must supply a logger to Ilp constructor');
+        this.logger = config.logger;
+        this.logger.log('MockIlp constructed');
+        this.config = config;
+    }
+
+    calculateFulfil(ilpPacket) {
+        this.logger.log(`Mock ILP not calculating fulfil from ilp packet ${ilpPacket}`);
+        return 'mockGeneratedFulfilment';
+    }
+
+    calculateConditionFromFulfil(fulfil) {
+        this.logger.log(`Mock ILP not calculating condition from fulfil ${fulfil}`);
+        return 'mockGeneratedCondition';
+    }
+
+    validateFulfil(fulfil, condition) {
+        this.logger.log(`Mock ILP not checking fulfil ${fulfil} against condition ${condition}`);
+        return true;
+    }
+
+    getResponseIlp(...args) {
+        this.logger.log(`MockIlp.getResponseIlp called with args: ${util.inspect(args)}`);
+
+        return MockIlp.__response;
+    }
+
+    getQuoteResponseIlp(...args) {
+        this.logger.log(`MockIlp.getQuoteResponseIlp called with args: ${util.inspect(args)}`);
+
+        return this.getResponseIlp(...args);
+    }
+
+
+    getTransactionObject(...args) {
+        this.logger.log(`MockIlp.getTrasnactionObject called with args: ${util.inspect(args)}`);
+
+        return MockIlp.__transactionObject;
+    }
+}
+MockIlp.__response = {
+    fulfilment: 'mockGeneratedFulfilment',
+    ilpPacket: 'mockBase64encodedIlpPacket',
+    condition: 'mockGeneratedCondition'
+};
+
+MockIlp.__transactionObject = {
+    transactionId: 'mockTransactionId'
+};
+
+
+class MockJwsValidator extends Jws.validator {
+    constructor(config) {
+        super(config);
+        MockJwsValidator.__validationKeys = config.validationKeys;
+        this.validate = MockJwsValidator.__validate;
+    }
+}
+MockJwsValidator.__validate = jest.fn(() => true);
+
+
+class MockJwsSigner {
+    constructor(config) {
+        assert(config.logger, 'Must supply a logger to JWS signer constructor');
+        this.config = config;
+        config.logger.log(`MockJwsSigner constructed with config: ${util.inspect(config)}`);
+    }
+}
+
+
+module.exports = {
+    MojaloopRequests: MockMojaloopRequests,
+    Ilp: MockIlp,
+    Jws: {
+        validator: MockJwsValidator,
+        signer: MockJwsSigner
+    },
+    Errors,
+    WSO2Auth,
+    Logger
+};