@mojaloop/sdk-scheme-adapter 12.0.1 → 12.0.2

package/docker/ml-testing-toolkit/spec_files/system_config.json

@@ -0,0 +1,62 @@
+{
+  "API_PORT": 5000,
+  "HOSTING_ENABLED": false,
+  "CONFIG_VERSIONS": {
+    "response": 1,
+    "callback": 1,
+    "validation": 1,
+    "forward": 1,
+    "userSettings": 1
+  },
+  "DB": {
+    "URI": "mongodb://mongo:27018/dfsps"
+  },
+  "OAUTH": {
+    "AUTH_ENABLED": false,
+    "APP_OAUTH_CLIENT_KEY": "asdf",
+    "APP_OAUTH_CLIENT_SECRET": "asdf",
+    "MTA_ROLE": "Application/MTA",
+    "PTA_ROLE": "Application/PTA",
+    "EVERYONE_ROLE": "Internal/everyone",
+    "OAUTH2_ISSUER": "http://ml-testing-toolkit:5050/api/oauth2/token",
+    "JWT_COOKIE_NAME": "TTK-API_ACCESS_TOKEN",
+    "EMBEDDED_CERTIFICATE": "password"
+  },
+  "CONNECTION_MANAGER": {
+    "API_URL": "http://connection-manager-api:5061",
+    "AUTH_ENABLED": false,
+    "HUB_USERNAME": "hub",
+    "HUB_PASSWORD": "hub"
+  },
+  "KEYCLOAK": {
+    "ENABLED": false,
+    "API_URL": "http://172.17.0.1:9080",
+    "REALM": "testingtoolkit",
+    "USERNAME": "hub",
+    "PASSWORD": "hub"
+  },
+  "API_DEFINITIONS": [
+    {
+      "type": "fspiop",
+      "version": "1.0",
+      "folderPath": "fspiop_1.0",
+      "asynchronous": true
+    },
+    {
+      "type": "fspiop",
+      "version": "1.1",
+      "folderPath": "fspiop_1.1",
+      "asynchronous": true
+    },
+    {
+      "type": "settlements",
+      "version": "1.0",
+      "folderPath": "settlements_1.0"
+    },
+    {
+      "type": "central_admin",
+      "version": "9.3",
+      "folderPath": "central_admin_9.3"
+    }
+  ]
+}

package/docker/ml-testing-toolkit/spec_files/user_config.json

@@ -0,0 +1,45 @@
+{
+  "VERSION": 1,
+  "CALLBACK_ENDPOINT": "http://scheme-adapter:4000",
+  "ALS_ENDPOINT": "http://account-lookup-service:4002",
+  "CALLBACK_RESOURCE_ENDPOINTS": {
+    "enabled": false,
+    "endpoints": [
+      {
+        "method": "put",
+        "path": "/parties/{Type}/{ID}",
+        "endpoint": "http://localhost:4001"
+      },
+      {
+        "method": "put",
+        "path": "/quotes/{ID}",
+        "endpoint": "http://localhost:3002"
+      },
+      {
+        "method": "put",
+        "path": "/transfers/{ID}",
+        "endpoint": "http://localhost:3000"
+      }
+    ]
+  },
+  "HUB_ONLY_MODE": false,
+  "ENDPOINTS_DFSP_WISE": {
+    "dfsps": {}
+  },
+  "SEND_CALLBACK_ENABLE": true,
+  "FSPID": "switch",
+  "DEFAULT_USER_FSPID": "userdfsp",
+  "TRANSFERS_VALIDATION_WITH_PREVIOUS_QUOTES": false,
+  "TRANSFERS_VALIDATION_ILP_PACKET": false,
+  "TRANSFERS_VALIDATION_CONDITION": false,
+  "ILP_SECRET": "secret",
+  "VERSIONING_SUPPORT_ENABLE": true,
+  "VALIDATE_INBOUND_JWS": false,
+  "VALIDATE_INBOUND_PUT_PARTIES_JWS": false,
+  "JWS_SIGN": false,
+  "JWS_SIGN_PUT_PARTIES": false,
+  "INBOUND_MUTUAL_TLS_ENABLED": false,
+  "OUTBOUND_MUTUAL_TLS_ENABLED": false,
+  "ADVANCED_FEATURES_ENABLED": true,
+  "CALLBACK_TIMEOUT": 20000
+}

package/docker/wait4/setup_hosts_file.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env sh
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+set -u
+set -e
+
+HOSTS_FILE=/etc/hosts
+touch ${HOSTS_FILE}
+
+if [ `cat ${HOSTS_FILE} | grep 'scheme-adapter' | wc -l`  -gt 0 ]; then
+  echo "[WARN] Already found scheme-adapter hosts in ${HOSTS_FILE}"
+  echo "[WARN] exiting with status: 0"
+  exit 0
+fi
+
+echo "
+# Added by mojaloop
+# to allow local access to mojaloop docker-compose environment
+127.0.0.1       host.docker.internal
+127.0.0.1       scheme-adapter, scheme-adapter-int, ml-testing-toolkit, mongo, redis
+# end of section
+" >> ${HOSTS_FILE}
+
+cat ${HOSTS_FILE}

package/docker/wait4/wait4.config.js

@@ -0,0 +1,71 @@
+module.exports = {
+  // format version sem-ver
+  // `v{major}.${minor}.${patch}`
+  wait4: 'v0.1.0',
+
+  // How many times should we retry waiting for a service?
+  retries: 60,
+
+  // How many ms to wait before retrying a service connection?
+  waitMs: 2500,
+
+  // services definitions
+  services: [
+    {
+      name: 'sdk-scheme-adapter',
+
+      // list of services to wait for
+      wait4: [
+        {
+          description: 'Redis Cache',
+          uri: 'redis:6379',
+          method: 'ncat'
+        },
+        {
+          description: 'ml-testing-toolkit',
+          uri: 'ml-testing-toolkit:5000',
+          method: 'ncat'
+        }
+      ]
+    },
+    {
+      name: 'cicd-integration-tests',
+      wait4: [
+        {
+          description: 'Inbound service',
+          uri: 'localhost:4000',
+          method: 'ncat'
+        },
+        {
+          description: 'Outbound service',
+          uri: 'localhost:4001',
+          method: 'ncat'
+        },
+        {
+          uri: 'localhost:5000',
+          method: 'ncat'
+        },
+        {
+          description: 'Redis Cache',
+          uri: 'localhost:6379',
+          method: 'ncat'
+        }
+      ]
+    },
+    {
+      name: 'ml-testing-toolkit',
+      wait4: [
+        {
+          description: 'Inbound service',
+          uri: 'scheme-adapter:4000',
+          method: 'ncat'
+        },
+        {
+          description: 'MongoDB object store',
+          uri: 'mongodb://mongo:27018/dfsps',
+          method: 'mongo'
+        }
+      ]
+    }
+  ]
+}

package/docker/wait4/wait4.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+
+'use-strict'
+const util = require('util')
+/**
+ * @file wait4.js
+ * @description Waits for a given service's prerequisite services to be up and running.
+ *
+ *  Observe the following Environment Variables:
+ *  `WAIT4_SERVICE`  - REQUIRED  The name of the service. Must refer to any entry of `services.[*].name` in config.json
+ *  `WAIT4_CONFIG`   - OPTIONAL path to config.json file, by default `./wait4.config.json`
+ *  `WAIT4_RETRIES`  - OPTIONAL  How many times should we retry waiting for a service? _optional_ Defaults to 10
+ *  `WAIT4_WAIT_MS`  - OPTIONAL  How many ms to wait before retrying a service connection? _optional_ Defaults to 1000 (1 second)
+ *
+ *  To keep the script code simple, we drop any validation, so the format of config file must be perfect!
+ *
+ *
+ */
+async function main () {
+  console.log('args are', process.argv)
+
+  try {
+    const config = require(process.env.WAIT4_CONFIG || './wait4.config.js')
+    const service = getService(config)
+    console.info(`wait4 Service: ${service.name}`)
+
+    // merge config with environment or defaults
+    config.retries = parseInt(process.env.WAIT4_RETRIES || config.retries || 10)
+    config.waitMs = parseInt(process.env.WAIT4_WAIT_MS || config.waitMs || 1000)
+
+    // wait for services connections or paradox to be ready
+    const waitresses = getWaiters(service.wait4, config)
+    const report = await Promise.all(waitresses)
+
+    console.info(`wait4 Report:\n${util.inspect(report, false, 5, true)}`)
+    process.exit(0)
+  } catch (error) {
+    console.error(`wait4 Error: ${error}`)
+    process.exit(1)
+  }
+}
+
+main()
+
+function getService (config) {
+  const serviceName = process.argv.slice(-1).pop() || process.env.WAIT4_SERVICE
+  if (!serviceName) {
+    console.error('wait4 Environment variable WAIT4_SERVICE or service name parameter are required')
+    process.exit(1)
+  }
+  return config.services.find(s => s.name === serviceName)
+}
+/**
+ * @function getWaiters
+ * @description - generates the list of promises of doing the wait job
+ * @param {array} wait4 - list of wait job descriptions
+ * @param {object} config - configuration
+ */
+function getWaiters (wait4, config) {
+  const methods = {
+    mongo: methodMongoDB,
+    mysql: methodMySQL,
+    // creating a alternative wait method since consent oracle uses a different separated config
+    mysqlAlt: methodMySQLAlt,
+    ncat: methodNCat
+  }
+  console.log(`wait4 Dependencies to wait for:\n${util.inspect(wait4, false, 5, true)}`)
+  return wait4.map(waitJob => wrapWithRetries(
+    methods[waitJob.method],
+    waitJob,
+    waitJob.retries || config.retries,
+    waitJob.waitMs || config.waitMs
+  ))
+}
+
+/**
+ * @function wrapWithRetries
+ * @description - Call the given function with a number of retries.
+ * @param {fn} method - Async function to be called with retries
+ * @param {object} waitJob - waitJob's definition
+ * @param {number} retries - Number of times to retry before returning an error if the func fails
+ * @param {number} waitTimeMs - Ms time to wait before trying again
+ */
+async function wrapWithRetries (method, waitJob, retries, waitTimeMs) {
+  try {
+    // generate method's RC config
+    const RC = getRC(waitJob)
+    // method do it's wait job
+    waitJob = await method(waitJob, RC)
+    waitJob.status = 'connected'
+    return Promise.resolve(waitJob)
+  } catch (err) {
+    console.info(`wait4 Retry(${waitJob.uri})`)
+    if (retries > 0) {
+      // let retry wait job again
+      return new Promise((resolve) => {
+        waitJob.retries = (waitJob.retries || 0) + 1
+        setTimeout(() => resolve(wrapWithRetries(method, waitJob, retries - 1, waitTimeMs)), waitTimeMs)
+      })
+    }
+    // no more retries left
+    console.error(`wait4 Out of retries for uri:${waitJob.uri}\n\t\tand method: ${waitJob.method}`)
+    waitJob.status = 'stalled'
+    return Promise.reject(err)
+  }
+}
+
+/**
+ * @function getRC
+ * @description - create RC config instance
+ * @param {object} waitJob
+ */
+function getRC (waitJob) {
+  // acquire rc parameters
+  const namespace = (waitJob.rc && waitJob.rc.namespace) || 'CLEDG'
+  const configPath = (waitJob.rc && waitJob.rc.configPath) || '../config/default.json'
+
+  // require rc to deliver config
+  try {
+    return require('rc')(namespace, require(configPath))
+  } catch (err) {
+    return waitJob.rc || {}
+  }
+}
+
+/**
+ * @function methodMongoDB
+ * @description Waits for the MongoDB service to be up and running
+ * @param {object} waitJob
+ * @param {object} RC
+ */
+async function methodMongoDB (waitJob, RC) {
+  const isDisabled = RC.MONGODB.DISABLED && RC.MONGODB.DISABLED.toString().trim().toLowerCase() === 'true'
+  if (isDisabled) {
+    return `MongoDB(${waitJob.uri}) Disabled`
+  }
+
+  // make connection to MongoDB using `Mongoose`
+  const mongoose = require('mongoose')
+  const model = mongoose.model('test', mongoose.Schema({ name: 'string' }))
+  await mongoose.connect(waitJob.uri, { useUnifiedTopology: true, promiseLibrary: global.Promise })
+  await model.findOne({ name: 'x' }).exec()
+  return waitJob
+}
+
+/**
+ * @function methodMySQL
+ * @description Waits for the MySQL service to be up and running
+ * @param {*} waitJob
+ * @param {*} RC
+ */
+async function methodMySQL (waitJob, RC) {
+  // make connection to MySQL using `knex`
+  const knex = require('knex')({
+    client: RC.DATABASE.DIALECT,
+    connection: {
+      host: RC.DATABASE.HOST.replace(/\/$/, ''),
+      port: RC.DATABASE.PORT,
+      user: RC.DATABASE.USER,
+      password: RC.DATABASE.PASSWORD,
+      database: RC.DATABASE.SCHEMA
+    }
+  })
+  await knex.select(1)
+
+  return waitJob
+}
+
+/**
+ * @function methodMySQLAlt
+ * @description Waits for the MySQL service to be up and running
+ * @param {*} waitJob
+ * @param {*} RC
+ */
+async function methodMySQLAlt (waitJob, RC) {
+  // make connection to MySQL using `knex`
+  const knex = require('knex')({
+    client: 'mysql',
+    connection: {
+      host: RC.connection.host.replace(/\/$/, ''),
+      port: RC.connection.port,
+      user: RC.connection.user,
+      password: RC.connection.password,
+      database: RC.connection.schema
+    }
+  })
+  await knex.select(1)
+
+  return waitJob
+}
+
+/**
+ * @function methodNCat
+ * @description checks is any TCP network stream up on given host:port
+ * @param {*} waitJob
+ * @param {*} RC
+ */
+async function methodNCat (waitJob) {
+  const [host, port] = waitJob.uri.toString().split(':').map(x => x.trim())
+  const { execSync } = require('child_process')
+  const command = `nc -z ${host} ${port}`
+  execSync(command)
+  return waitJob
+}

package/docker-compose.yml

@@ -0,0 +1,67 @@
+version: '3.7'
+networks:
+  mojaloop-net:
+    name: mojaloop-net
+
+services:
+  redis:
+    networks:
+        - mojaloop-net
+    image: "redis:5.0.4-alpine"
+    ports:
+      - "6379:6379"
+  scheme-adapter:
+    networks:
+        - mojaloop-net
+    build:
+      context: .
+    env_file: ./test/config/integration.env
+    ports:
+      - "4000:4000"
+      - "4001:4001"
+      - "4002:4002"
+    depends_on:
+      - redis
+    command: sh -c "/wait4/wait4.js sdk-scheme-adapter; node src/index.js"
+    volumes:
+      - ./docker/wait4:/wait4
+
+  ml-testing-toolkit:
+    networks:
+        - mojaloop-net
+    image: mojaloop/ml-testing-toolkit:v11.7.11
+    container_name: ml-testing-toolkit
+    volumes:
+      - "./docker/ml-testing-toolkit/spec_files:/opt/mojaloop-testing-toolkit/spec_files"
+      - "./docker/ml-testing-toolkit/secrets:/opt/mojaloop-testing-toolkit/secrets"
+
+    ports:
+      - "5000:5000"
+      - "5050:5050"
+    environment:
+      - AUTH_ENABLED=FALSE
+    command: npm start
+    depends_on:
+      - mongo
+
+  mongo:
+    networks:
+        - mojaloop-net
+    image: mongo
+    ports:
+      - "27018:27017"
+  #
+  # for local development we want to have ttk-ui
+  #
+  # mojaloop-testing-toolkit-ui:
+  #   image: mojaloop/ml-testing-toolkit-ui:v11.8.4
+  #   ports:
+  #     - "6060:6060"
+  #   networks:
+  #     - mojaloop-net
+  #   environment:
+  #     - API_BASE_URL=http://localhost:5050
+  #     - AUTH_ENABLED=FALSE
+  #   command:
+  #     - sh
+  #     - /usr/share/nginx/start.sh