@blazedpath/commons 0.0.4

package/blz-base/index.js

@@ -0,0 +1,1466 @@
+const _ = require("underscore");
+const Got = require('got');
+const Soap = require('soap');
+const Fs = require('fs-extra');
+const Path = require('path');
+const Util = require('util');
+const { LRUCache } = require('lru-cache');
+const securityService = require('../blz-security/index');
+const configService = require('../blz-config/index');
+const jsyaml = require('js-yaml');
+const { getHealthStatus } = require('./health/index')
+
+let _metadata = null;
+let _connections = null;
+let _configParameters = null;
+let _transformations = null;
+let _externalRestCallId = null;
+let _externalSoapCallId = null;
+
+class MandatoryTransactionViolation extends Error {
+	constructor() {
+		super("Any transaction exists over transaction stack");
+		this.code = this.constructor.name;
+	}
+}
+
+class NeverTransactionViolation extends Error {
+	constructor() {
+		super("A transaction exists over transaction stack");
+		this.code = this.constructor.name;
+	}
+}
+
+class StackEmptyViolation extends Error {
+	constructor() {
+		super("Stack transaction is empty");
+		this.code = this.constructor.name;
+	}
+}
+
+class InvalidStackViolation extends Error {
+	constructor() {
+		super("Invalid stack. You dont have any (valid) connection");
+		this.code = this.constructor.name;
+	}
+}
+function transactionsContext(context) {
+	if (!context.rdsTransactionContext) {
+		context.rdsTransactionContext = [];
+	}
+	return context.rdsTransactionContext;
+}
+function checkValidTransaction(stack) {
+	let brick = _.last(stack);
+	if (brick.propagationType == "not-supported" || brick.propagationType == "never") {
+		throw new InvalidStackViolation();
+	}
+	if (!brick.connection) {
+		throw new InvalidStackViolation();
+	}
+}
+function beginRequiredNew(stack) {
+	if (_.isEmpty(stack)) {
+		stack.push({
+			propagationType: "requires-new",
+			connection: Object.create(null)
+		});
+	} else {
+		checkValidTransaction(stack);
+		stack.push({
+			propagationType: "requires-new",
+			connection: Object.create(null)
+		});
+	}
+}
+const beginRequired = function (stack) {
+	if (_.isEmpty(stack)) {
+		stack.push({
+			propagationType: "requires-new",
+			connection: Object.create(null)
+		});
+	} else {
+		checkValidTransaction(stack);
+		let brick = _.last(stack);
+		stack.push({
+			propagationType: "required",
+			connection: brick.connection
+		});
+	}
+}
+
+const beginNested = function (stack) {
+	if (_.isEmpty(stack)) {
+		stack.push({
+			propagationType: "requires-new",
+			connection: Object.create(null)
+		});
+	} else {
+		checkValidTransaction(stack);
+		let brick = _.last(stack);
+		stack.push({
+			propagationType: "nested",
+			connection: brick.connection
+		});
+	}
+}
+
+const beginNotSupported = function(stack) {
+	stack.push({
+		propagationType: "not-supported",
+		connection: null
+	});
+}
+
+const beginSupports = function(stack) {
+	if (_.isEmpty(stack)) {
+		stack.push({
+			propagationType: "supports",
+			connection: null
+		});
+		return;
+	}
+	let brick = _.last(stack);
+	if (!brick.connection) {
+		stack.push({
+			propagationType: "supports",
+			connection: null
+		});
+		return;
+	}
+	stack.push({
+		propagationType: "supports",
+		connection: brick.connection
+	});
+}
+
+const beginMandatory = function(stack) {
+	if (_.isEmpty(stack)) {
+		throw new MandatoryTransactionViolation();
+	}
+	let brick = _.last(stack);
+	if (!brick.connection) {
+		throw new MandatoryTransactionViolation();
+	}
+	stack.push({
+		propagationType: "mandatory",
+		connection: brick.connection
+	});
+}
+
+const beginNever = function (stack) {
+	if (!_.isEmpty(stack)) {
+		let brick = _.last(stack);
+		if (brick.connection) {
+			throw new NeverTransactionViolation();
+		}
+	}
+	stack.push({
+		propagationType: "never",
+		connection: null
+	});
+}
+
+
+const beginTransaction = function (context, type) {
+	let stack = transactionsContext(context);
+	switch (type) {
+		case "nested":
+			beginNested(stack);
+			break;
+		case "never":
+			beginNever(stack);
+			break;
+		case "not-supported":
+			beginNotSupported(stack);
+			break;
+		case "mandatory":
+			beginMandatory(stack);
+			break;
+		case "required":
+			beginRequired(stack);
+			break;
+		case "requires-new":
+			beginRequiredNew(stack);
+			break;
+		case "supports":
+			beginSupports(stack);
+			break;
+		default:
+			throw new Error(`${type} is not supported yet`);
+	}
+}
+
+const commitTransaction = async function (context, type) {
+	let transactionsStack = transactionsContext(context);
+	if (_.isEmpty(transactionsStack)) {
+		return;
+	}
+	let transactionBrick = transactionsStack[transactionsStack.length - 1];
+	switch (transactionBrick.propagationType) {
+		case "nested":
+			for (let connectionName in transactionBrick.connection) {
+				await transactionBrick.connection[connectionName].commitTransaction();
+			}
+			break;
+		case "never":
+			break;
+		case "not-supported":
+			break;
+		case "mandatory":
+			break;
+		case "required":
+			break;
+		case "requires-new":
+			for (let connectionName in transactionBrick.connection) {
+				await transactionBrick.connection[connectionName].commitTransaction();
+			}
+			break;
+		case "supports":
+			break;
+		default:
+			break;
+	}
+}
+
+const rollbackTransaction = async function (context, type) {
+	let transactionsStack = transactionsContext(context);
+	if (_.isEmpty(transactionsStack)) {
+		return;
+	}
+	let transactionBrick = transactionsStack[transactionsStack.length - 1];
+	switch (transactionBrick.propagationType) {
+		case "nested":
+			for (let connectionName in transactionBrick.connection) {
+				await transactionBrick.connection[connectionName].rollbackTransaction();
+			}
+			break;
+		case "never":
+			break;
+		case "not-supported":
+			break;
+		case "mandatory":
+			break;
+		case "required":
+			break;
+		case "requires-new":
+			for (let connectionName in transactionBrick.connection) {
+				await transactionBrick.connection[connectionName].rollbackTransaction();
+			}
+			break;
+		case "supports":
+			break;
+		default:
+			break;
+	}
+}
+
+const closeTransaction = async function (context, type) {
+	let transactionsStack = transactionsContext(context);
+	if (_.isEmpty(transactionsStack)) {
+		return;
+	}
+	let transactionBrick = transactionsStack.pop();
+	switch (transactionBrick.propagationType) {
+		case "nested":
+			break;
+		case "never":
+			break;
+		case "not-supported":
+			break;
+		case "mandatory":
+			break;
+		case "required":
+			break;
+		case "requires-new":
+			for (let connectionName in transactionBrick.connection) {
+				await transactionBrick.connection[connectionName].close()
+			}
+			break;
+		case "supports":
+			break;
+		default:
+			break;
+	}
+}
+
+const tryParse = function (value, _default = null) {
+	try {
+		return value && typeof value === 'string'
+			? JSON.parse(value)
+			: _default
+	} catch (ex) {
+		return _default
+	}
+}
+
+const compare = function (value1, value2) {
+	if (value1 === null && value2 === null)
+		return 0;
+	if (value1 === null && value2 !== null)
+		return -1;
+	if (value1 !== null && value2 === null)
+		return 1;
+	let value1Type = toString.call(value1);
+	let value2Type = toString.call(value2);
+	let value1ToCompare = null;
+	let value2ToCompare = null;
+	if ((value1Type === '[object String]' && value2Type === '[object String]') ||
+		(value1Type === '[object Number]' && value2Type === '[object Number]')) {
+		value1ToCompare = value1;
+		value2ToCompare = value2;
+	}
+	else if (value1Type === '[object Boolean]' && value2Type === '[object Boolean]') {
+		value1ToCompare = value1 ? 1 : 0;
+		value2ToCompare = value2 ? 1 : 0;
+	}
+	else if (value1Type === '[object Date]' && value2Type === '[object Date]') {
+		value1ToCompare = value1.getTime();
+		value2ToCompare = value2.getTime();
+	}
+	else if (value1Type === '[object Object]' && value2Type === '[object Object]') {
+		value1ToCompare = JSON.stringify(value1);
+		value2ToCompare = JSON.stringify(value2);
+	}
+	else if (value1Type === '[object Array]' && value2Type === '[object Array]') {
+		let result = compare(value1.length, value2.length);
+		if (result !== 0)
+			return result;
+		for (let i = 0; i < value1.length; i++) {
+			let item1 = value1[i];
+			let item2 = value2[i];
+			result = compare(item1, item2);
+			if (result !== 0)
+				return result;
+		}
+		return 0;
+	}
+	else {
+		if (value1Type === '[object String]')
+			value1ToCompare = value1;
+		else if (value1Type === '[object Number]')
+			value1ToCompare = value1.toString();
+		else if (value1Type === '[object Boolean]')
+			value1ToCompare = value1 ? '1' : '0';
+		else if (value1Type === '[object Date]')
+			value1ToCompare = value1.toJSON();
+		else
+			value1ToCompare = value1.toString();
+		if (value2Type === '[object String]')
+			value2ToCompare = value2;
+		else if (value2Type === '[object Number]')
+			value2ToCompare = value2.toString();
+		else if (value2Type === '[object Boolean]')
+			value2ToCompare = value2 ? '1' : '0';
+		else if (value2Type === '[object Date]')
+			value2ToCompare = value2.toJSON();
+		else
+			value2ToCompare = value2.toString();
+	}
+	if (value1ToCompare === value2ToCompare)
+		return 0;
+	else if (value1ToCompare < value2ToCompare)
+		return -1;
+	else if (value1ToCompare > value2ToCompare)
+		return 1;
+	else
+		return null;
+};
+
+const convertToListOf = function (value, fnConvert) {
+	if (Array.isArray(value)) {
+		let list = [];
+		for (let i = 0; i < value.length; i++) {
+			list.push(fnConvert(value[i]));
+		}
+		return list;
+	}
+	else {
+		return [fnConvert(value)];
+	}
+};
+
+const convertMilliseconds = function (strMilliseconds) {
+	if (strMilliseconds) {
+		if (strMilliseconds.length < 3)
+			strMilliseconds = strMilliseconds.padEnd(3, '0');
+		if (strMilliseconds.length > 3)
+			strMilliseconds = strMilliseconds.substr(0, 3);
+		return Number(strMilliseconds);
+	}
+	else
+		return 0;
+};
+
+const simplifyName = function (value) {
+	return value.toUpperCase().replace('-', '').replace('_', '');
+};
+
+const fixSoapValue = function (value) {
+	if (value !== null && typeof value === 'object') {
+		for (let key in value) {
+			let childValue = value[key];
+			if (isSoapNull(childValue))
+				value[key] = null;
+			else
+				fixSoapValue(childValue);
+		}
+	}
+};
+const isSoapNull = function (value) {
+	return value && value.attributes && value.attributes['xsi:nil'] && value.attributes['xsi:nil'] === 'true';
+};
+
+// See more options in: https://nodejs.org/docs/latest-v16.x/api/util.html#utilinspectobject-options
+const STRINGIFY_OBJECT_DEFAULT_OPTIONS = {
+	showHidden: true,
+	depth: 5,
+}
+const stringifyObject = function (obj, options = {}) {
+	const inspectOptions = {
+		...STRINGIFY_OBJECT_DEFAULT_OPTIONS,
+		...options
+	}
+	return Util.inspect(obj, inspectOptions)
+}
+
+const checkDuplicateKeysInEnv = function (environmentPath) {
+	const env = Fs.readFileSync(environmentPath, 'utf8')
+	const lines = env.split('\n')
+	const keys = []
+	const duplicateKeys = []
+	lines.forEach((line) => {
+		line = line.trim()
+		if (line === '' || line.startsWith('#')) return
+		const [key] = line.split('=')
+		if (keys.includes(key)) {
+			duplicateKeys.push(key)
+		}
+		keys.push(key)
+	})
+	if (duplicateKeys.length > 0) {
+		throw new Error(`Error. Duplicate keys in .env file: ${JSON.stringify([...new Set(duplicateKeys)])}`)
+	}
+}
+
+const normalizeConfig = function (config = {}) {
+	for (const p in config.connections) {
+		const connection = config.connections[p]
+
+		if (connection.type !== "Mongodb") continue
+		const hasOldFormat = Boolean(connection.database && connection.database.trim())
+		const hasNewFormat = Boolean(connection.databaseName && connection.databaseName.trim())
+		const hasToWarnAboutConfusion = hasOldFormat && hasNewFormat
+		const hasToUpdate = hasOldFormat && !hasNewFormat
+
+		if (hasToWarnAboutConfusion) {
+			console.warn(`Warning: Your are using the old format ("blz_${p}_database") and the new format ("blz_${p}_databaseName"). We will use the new one ("blz_${p}_databaseName"). Please, consider to remove the old format to avoid confusion.`)
+			delete connection.database
+		}
+		if (hasToUpdate) {
+			console.warn(`Warning: Your are using the "blz_${p}_database" variable, but you need to use "blz_${p}_databaseName" instead. Environment variables for MongoDb databases with "blz_xxx_database" format may will disappear in the future. Please, update it.`)
+			connection.databaseName = connection.database
+			delete connection.database
+		}
+	}
+}
+const deepClone = (obj) => {
+    if (typeof obj !== 'object' || obj === null) {
+        return obj;
+    }
+    let clone = Array.isArray(obj) ? [] : {};
+    for (let key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            clone[key] = deepClone(obj[key]);
+        }
+    }
+    return clone;
+}
+let cache = new LRUCache({ max: 500, maxSize: 5000, ttl: 1000 * 60 * 60 * 3, sizeCalculation: (value, key) => { return 1 } })
+
+const safeRequire = function(path) {
+	try {
+		require.resolve(path);
+		return require(path);
+	} catch (err) {
+		if (err.code === 'MODULE_NOT_FOUND') {
+			let newPath = path.replace(/^\.\.\//, '');
+			if (path !== newPath) {
+				return safeRequire(newPath);
+			}
+			return undefined;
+		}
+		throw err;
+	}
+}
+
+module.exports = {
+	deepClone,
+	beginTransaction,
+	commitTransaction,
+	rollbackTransaction,
+	closeTransaction,
+	compare,
+	stringifyObject,
+	checkDuplicateKeysInEnv,
+	normalizeConfig,
+	setMetadata: function (metadata) {
+		_metadata = metadata;
+	},
+	getMetadataItem: function (metadataItemName) {
+		if (_metadata[metadataItemName] === undefined)
+			return null;
+		return _metadata[metadataItemName];
+	},
+	getConnection: function (connectionName) {
+		if (!_connections[connectionName]) {
+			console.log(`The connectionName: "${connectionName}" does not seem to be defined. Please review the .env or yaml build configuration.`);
+		} return _connections[connectionName]; 
+	},
+	setConnections: function (connections) {
+		_connections = connections;
+	},
+	getConfigParameterValue: function (configParameterName) {
+		if (_configParameters[configParameterName] === undefined) {
+			console.log(`The configParameter: "${configParameterName}" does not seem to be defined. Please review the .env or yaml build configuration.`);
+			return null;
+		}
+		return _configParameters[configParameterName];
+	},
+	setConfigParameters: function (configParameters) {
+		_configParameters = configParameters;
+	},
+	setTransformations: function (transformations) {
+		_transformations = transformations;
+	},
+	transform: async function (callContext, transformationName, source, writer) {
+		let transformation = _metadata[transformationName];
+		let transformationExecutor = require('../sources/' + transformation.sourceFileName);
+		if (source) {
+			if (source._blz_reader) { // reader
+				let reader = source;
+				if (writer) {
+					return await reader.read(callContext, transformation.sourceCodePaths, async function (sourceItem) { return await writer.write(callContext, await transformationExecutor(callContext, sourceItem)); });
+				}
+				else {
+					return await reader.read(callContext, transformation.sourceCodePaths, async function (sourceItem) { return await transformationExecutor(callContext, sourceItem); });
+				}
+			}
+			else if (Array.isArray(source)) { // list
+				if (writer) {
+					let target = [];
+					for (let i = 0; i < source.length; i++) {
+						let sourceItem = source[i];
+						target.push(await writer.write(callContext, await transformationExecutor(callContext, sourceItem)));
+					}
+					return target;
+				}
+				else {
+					let target = [];
+					for (let i = 0; i < source.length; i++) {
+						let sourceItem = source[i];
+						target.push(await transformationExecutor(callContext, sourceItem));
+					}
+					return target;
+				}
+			}
+			else { // obj
+				if (writer) {
+					return await writer.write(callContext, transformationExecutor(callContext, source));
+				}
+				else {
+					return await transformationExecutor(callContext, source);
+				}
+			}
+		}
+		return null;
+	},
+	writer: function (callContext, functionName, extraArgs) {
+		let fn
+		try {
+			fn = require('../sources/' + module.exports.ensureDashedFormat(functionName) + '.js')
+		}
+		catch (err) {
+			throw this.error('InvalidFunction', { functionName: functionName });
+		}
+		return {
+			isWriter: true,
+			fn: fn,
+			extraArgs: extraArgs,
+			write: async function (callContext, obj) {
+				if (this.extraArgs) {
+					return await this.fn(callContext, obj, ...this.extraArgs);
+				}
+				else {
+					return await this.fn(callContext, obj);
+				}
+			}
+		};
+	},
+	getValue: function (root, bind) {
+		if (root === null)
+			return null;
+		if (bind || bind === 0) {
+			let rootType = toString.call(root);
+			if (rootType === '[object Object]' || rootType === '[object Error]') {
+				let bindParts = bind.split('.');
+				let current = root;
+				for (let i = 0; i < bindParts.length; i++) {
+					let bindPart = bindParts[i];
+					if (current[bindPart] === null || current[bindPart] === undefined)
+						return null;
+					current = current[bindPart];
+				}
+				return current;
+			}
+			else if (rootType === '[object Array]') {
+				return root[bind];
+			}
+			else {
+				return null;
+			}
+		}
+		else {
+			return root;
+		}
+	},
+	setValue: function (root, bind, value) {
+		let bindParts = bind.split('.');
+		let current = root;
+		for (let i = 0; i < (bindParts.length - 1); i++) {
+			let bindPart = bindParts[i];
+			if (current[bindPart] === null || current[bindPart] === undefined)
+				current[bindPart] = {};
+			current = current[bindPart];
+		}
+		current[bindParts[bindParts.length - 1]] = value;
+	},
+	divide: function (dividend, divisor) {
+		if (divisor === null || divisor === 0) {
+			let err = new Error();
+			err.code = 'DivisionByZero';
+			err.data = { dividend: dividend, divisor: divisor };
+			throw err;
+		}
+		else {
+			return dividend / divisor;
+		}
+	},
+	remainder: function (dividend, divisor) {
+		if (divisor === null || divisor === 0) {
+			let err = new Error();
+			err.code = 'RemainderByZero';
+			err.data = { dividend: dividend, divisor: divisor };
+			throw err;
+		}
+		else {
+			return dividend % divisor;
+		}
+	},
+	httpErrors: {
+		400: 'BadRequest',
+		401: 'Unauthorized',
+		402: 'PaymentRequired',
+		403: 'Forbidden',
+		404: 'NotFound',
+		405: 'MethodNotAllowed',
+		406: 'NotAcceptable',
+		407: 'ProxyAuthenticationRequired',
+		408: 'RequestTimeout',
+		409: 'Conflict',
+		410: 'Gone',
+		411: 'LengthRequired',
+		412: 'PreconditionFailed',
+		500: 'InternalServerError',
+		501: 'NotImplemented',
+		502: 'BadGateway',
+		503: 'ServiceUnavailable',
+		504: 'GatewayTimeout',
+		524: 'Timeout'
+	},
+	httpStatuses: {
+		'BadRequest': 400,
+		'Unauthorized': 401,
+		'PaymentRequired': 402,
+		'Forbidden': 403,
+		'NotFound': 404,
+		'MethodNotAllowed': 405,
+		'NotAcceptable': 406,
+		'ProxyAuthenticationRequired': 407,
+		'RequestTimeout': 408,
+		'Conflict': 409,
+		'Gone': 410,
+		'LengthRequired': 411,
+		'PreconditionFailed': 412,
+		'InternalServerError': 500,
+		'NotImplemented': 501,
+		'BadGateway': 502,
+		'ServiceUnavailable': 503,
+		'GatewayTimeout': 504,
+		'Timeout': 524
+	},
+	getHttpStatus: function (err) {
+		return this.httpStatuses[err.code];
+	},
+	httpCall: async function (httpRequest) {
+		let requestUrl = httpRequest.url;
+		let requestOptions = {
+			method: httpRequest.method,
+			headers: {},
+			throwHttpErrors: false
+		};
+		if (httpRequest.method !== 'GET')
+			requestOptions.body = httpRequest.body;
+		if (httpRequest.headers)
+			for (let i = 0; i < httpRequest.headers.length; i++) {
+				let httpHeader = httpRequest.headers[i];
+				requestOptions.headers[httpHeader.name] = httpHeader.value;
+			}
+		if (requestUrl.match(/https.*/)) {
+			requestOptions = {
+				...requestOptions,
+				https: {
+					requestCert: true, // Request a certificate from clients that connect and attempt to verify that certificate.
+					rejectUnauthorized: false, // The server will reject any connection which is not authorized with the list of supplied CAs.
+					agent: false // Is responsible for managing connection persistence and reuse for https clients.
+				}
+			};
+		}
+		let response = await Got(requestUrl, requestOptions);
+		let httpErrorCode = this.httpErrors[response.statusCode];
+		if (httpErrorCode) {
+			let err = new Error();
+			err.code = httpErrorCode;
+			try { err.data = JSON.parse(response.body); } catch (err2) { }
+			throw err;
+		}
+		else {
+			return { status: response.statusCode, body: response.body };
+		}
+	},
+	internalCall: async function (callContext, functionName, args) {
+		let fn = null;
+		try {
+			fn = require('../sources/' + module.exports.ensureDashedFormat(functionName) + '.js')
+		}
+		catch (err) {
+			throw this.error('InvalidFunction', { functionName: functionName });
+		}
+		if (args)
+			return await fn(callContext, ...args);
+		else
+			return await fn(callContext);
+	},
+	externalCall: async function (callContext, connection, functionName, values) {
+		if (connection.type === 'Microservice' || connection.type === 'RestApi' || connection.type === 'ProcessEngine') {
+			let restMappings = _metadata['_rest_mappings'];
+			return await module.exports.callRest(connection, restMappings[connection.name], functionName, values, null, _configParameters, callContext);
+		}
+		else if (connection.type === 'SoapApi') {
+			let soapMappings = _metadata['_soap_mappings'];
+			return await module.exports.callSoap(connection, soapMappings[connection.name], functionName, values, null, _configParameters, callContext);
+		}
+	},
+	error: function (code, data, innerError) {
+		let err = new Error();
+		err.code = code;
+		if (data)
+			err.data = data;
+		if (innerError)
+			err.innerError = innerError;
+		return err;
+	},
+	convertToString: function (value) {
+		if (value === null || value === undefined)
+			return null;
+		let valueType = toString.call(value);
+		if (valueType === '[object String]')
+			return value;
+		if (valueType === '[object Number]')
+			return value.toString();
+		if (valueType === '[object Boolean]')
+			return value ? 'true' : 'false';
+		if (valueType === '[object Date]')
+			return value.toJSON();
+		if (valueType === '[object Object]' && value.type === 'Buffer' && value.data)
+			return Buffer.from(value.data).toString();
+		if (Buffer.isBuffer(value))
+			return value.toString();
+		throw this.error('InvalidConversion', { value: value, targetType: 'string' });
+	},
+	convertToInteger: function (value) {
+		if (value === null)
+			return null;
+		let valueType = toString.call(value);
+		if (valueType === '[object String]' && !isNaN(value))
+			return Math.round(Number(value));
+		if (valueType === '[object Number]')
+			return Math.round(value);
+		if (valueType === '[object Boolean]')
+			return value ? 1 : 0;
+		throw this.error('InvalidConversion', { value: value, targetType: 'integer' });
+	},
+	convertToDecimal: function (value) {
+		if (value === null)
+			return null;
+		let valueType = toString.call(value);
+		if (valueType === '[object String]' && !isNaN(value))
+			return Number(value);
+		if (valueType === '[object Number]')
+			return value;
+		if (valueType === '[object Boolean]')
+			return value ? 1 : 0;
+		throw this.error('InvalidConversion', { value: value, targetType: 'decimal' });
+	},
+	convertToBoolean: function (value) {
+		if (value === null)
+			return null;
+		let valueType = toString.call(value);
+		if (valueType === '[object String]') {
+			if (value === '1' || value.toUpperCase() === 'T' || value.toUpperCase() === 'TRUE' || value.toUpperCase() === 'Y' || value.toUpperCase() === 'YES')
+				return true;
+			if (value === '0' || value.toUpperCase() === 'F' || value.toUpperCase() === 'FALSE' || value.toUpperCase() === 'N' || value.toUpperCase() === 'NO')
+				return false;
+		}
+		if (valueType === '[object Number]') {
+			if (value === 1)
+				return true;
+			if (value === 0)
+				return false;
+		}
+		if (valueType === '[object Boolean]')
+			return value;
+		throw this.error('InvalidConversion', { value: value, targetType: 'boolean' });
+	},
+	convertToDatetime: function (value) {
+		if (value === null)
+			return null;
+		let valueType = toString.call(value);
+		if (valueType === '[object String]') {
+			let matchDatetime = /^(\d{4})-(\d{1,2})-(\d{1,2})[T,\s](\d{1,2})\:(\d{1,2})\:(\d{1,2})\.?(\d+)?Z?$/.exec(value);
+			if (matchDatetime)
+				return new Date(Date.UTC(Number(matchDatetime[1]), Number(matchDatetime[2]) - 1, Number(matchDatetime[3]), Number(matchDatetime[4]), Number(matchDatetime[5]), Number(matchDatetime[6] || 0), convertMilliseconds(matchDatetime[7])));
+		}
+		if (valueType === '[object Date]') {
+			return value;
+		}
+		throw this.error('InvalidConversion', { value: value, targetType: 'datetime' });
+	},
+	convertToDate: function (value) {
+		if (value === null)
+			return null;
+		let valueType = toString.call(value);
+		if (valueType === '[object String]') {
+			let matchDate = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(value);
+			if (matchDate)
+				return new Date(Date.UTC(Number(matchDate[1]), Number(matchDate[2]) - 1, Number(matchDate[3]), 0, 0, 0, 0));
+			let matchDatetime = /^(\d{4})-(\d{1,2})-(\d{1,2})[T,\s](\d{1,2})\:(\d{1,2})\:(\d{1,2})\.?(\d+)?Z?$/.exec(value);
+			if (matchDatetime)
+				return new Date(Date.UTC(Number(matchDatetime[1]), Number(matchDatetime[2]) - 1, Number(matchDatetime[3]), 0, 0, 0, 0));
+		}
+		if (valueType === '[object Date]') {
+			return new Date(Date.UTC(value.getUTCFullYear(), value.getUTCMonth(), value.getUTCDate(), 0, 0, 0, 0));
+		}
+		throw this.error('InvalidConversion', { value: value, targetType: 'date' });
+	},
+	convertToTime: function (value) {
+		if (value === null)
+			return null;
+		let valueType = toString.call(value);
+		if (valueType === '[object String]') {
+			let matchTime = /^(\d{1,2})\:(\d{1,2})\:(\d{1,2})\.?(\d+)?$/.exec(value);
+			if (matchTime)
+				return new Date(Date.UTC(1970, 0, 1, Number(matchTime[1]), Number(matchTime[2]), Number(matchTime[3]), convertMilliseconds(matchTime[4])));
+			let matchDatetime = /^(\d{4})-(\d{1,2})-(\d{1,2})[T,\s](\d{1,2})\:(\d{1,2})\:(\d{1,2})\.?(\d+)?Z?$/.exec(value);
+			if (matchDatetime)
+				return new Date(Date.UTC(1970, 0, 1, Number(matchDatetime[4]), Number(matchDatetime[5]), Number(matchDatetime[6] || 0), convertMilliseconds(matchDatetime[7])));
+		}
+		if (valueType === '[object Date]') {
+			return new Date(Date.UTC(1970, 0, 1, value.getUTCHours(), value.getUTCMinutes(), value.getUTCSeconds(), value.getUTCMilliseconds()));
+		}
+		throw this.error('InvalidConversion', { value: value, targetType: 'time' });
+	},
+	ensureDashedFormat: function (str) {
+		if (str === null)
+			return null;
+		let result = '';
+		let lastChar = '';
+		for (let i = 0; i < str.length; i++) {
+			let char = str[i];
+			if (char.match(/[0-9]/)) {
+				result += char;
+			}
+			else if (lastChar.match(/[A-Z]/) && char.match(/[A-Z]/)) {
+				result += char.toLowerCase();
+			}
+			else if (lastChar.match(/[A-Z]/) && char.match(/[a-z]/)) {
+				result += char;
+			}
+			else if (lastChar.match(/[a-z]/) && char.match(/[A-Z]/)) {
+				result += '-' + char.toLowerCase();
+			}
+			else if (lastChar.match(/[a-z]/) && char.match(/[a-z]/)) {
+				result += char;
+			}
+			else if (char.match(/[A-Z]/)) {
+				result += char.toLowerCase();
+			}
+			else if (char.match(/[a-z]/)) {
+				result += char;
+			}
+			lastChar = char;
+		}
+		return result;
+	},
+	mapRoutingParameters: function (request, routingParameters) {
+		let result = {};
+		if (routingParameters) {
+			const lowerCaseHeadersKeysEntries = Object.keys(request.headers || {}).map(headerKey => [headerKey.toLowerCase(), headerKey])
+			const lowerCaseHeadersKeysMap = Object.fromEntries(lowerCaseHeadersKeysEntries)
+			for (let i = 0; i < routingParameters.length; i++) {
+				let routingParameter = routingParameters[i];
+				if (routingParameter.name && routingParameter.type) {
+					if (routingParameter.in === 'Path' || routingParameter.in === 'Query' || routingParameter.in === 'Header') {
+						let value = null;
+						if (routingParameter.in === 'Path') {
+							if (request.params && request.params[routingParameter.name])
+								value = request.params[routingParameter.name];
+						}
+						else if (routingParameter.in === 'Query') {
+							if (request.query && request.query[routingParameter.name])
+								value = request.query[routingParameter.name];
+						}
+						else if (routingParameter.in === 'Header') {
+							const headerKey = lowerCaseHeadersKeysMap[routingParameter.name.toLowerCase()]
+							const headerValue = headerKey && request.headers && request.headers[headerKey]
+							if (headerValue) {
+								value = headerValue
+							}
+						}
+						if (value) {
+							if (routingParameter.type === 'string')
+								this.setValue(result, routingParameter.bind, this.convertToString(value));
+							else if (routingParameter.type === 'integer')
+								this.setValue(result, routingParameter.bind, this.convertToInteger(value));
+							else if (routingParameter.type === 'decimal')
+								this.setValue(result, routingParameter.bind, this.convertToDecimal(value));
+							else if (routingParameter.type === 'boolean')
+								this.setValue(result, routingParameter.bind, this.convertToBoolean(value));
+							else if (routingParameter.type === 'datetime')
+								this.setValue(result, routingParameter.bind, this.convertToDatetime(value));
+							else if (routingParameter.type === 'date')
+								this.setValue(result, routingParameter.bind, this.convertToDate(value));
+							else if (routingParameter.type === 'time')
+								this.setValue(result, routingParameter.bind, this.convertToTime(value));
+							else if (routingParameter.type === 'list(string)')
+								this.setValue(result, routingParameter.bind, convertToListOf(value, this.convertToString));
+							else if (routingParameter.type === 'list(integer)')
+								this.setValue(result, routingParameter.bind, convertToListOf(value, this.convertToInteger));
+							else if (routingParameter.type === 'list(decimal)')
+								this.setValue(result, routingParameter.bind, convertToListOf(value, this.convertToDecimal));
+							else if (routingParameter.type === 'list(boolean)')
+								this.setValue(result, routingParameter.bind, convertToListOf(value, this.convertToBoolean));
+							else if (routingParameter.type === 'list(datetime)')
+								this.setValue(result, routingParameter.bind, convertToListOf(value, this.convertToDatetime));
+							else if (routingParameter.type === 'list(date)')
+								this.setValue(result, routingParameter.bind, convertToListOf(value, this.convertToDate));
+							else if (routingParameter.type === 'list(time)')
+								this.setValue(result, routingParameter.bind, convertToListOf(value, this.convertToTime));
+						}
+					}
+					else if (routingParameter.in === 'Body') {
+						this.setValue(result, routingParameter.bind, request.payload);
+					}
+				}
+			}
+		}
+		return result;
+	},
+	decodeApiKey: function (request, apiKeyIn, apiKeyName) {
+		switch (apiKeyIn) {
+			case 'Header': {
+				if (request.headers) {
+					let headerValue = request.headers[apiKeyName];
+					if (headerValue) {
+						return { key: headerValue };
+					}
+				}
+				break;
+			}
+			case 'Query': {
+				if (request.query) {
+					let queryValue = request.query[apiKeyName];
+					if (queryValue) {
+						return { key: queryValue };
+					}
+				}
+				break;
+			}
+		}
+		return null;
+	},
+	decodeBasicAuth: function (request) {
+		if (request.headers) {
+			let headerValue = request.headers['authorization'];
+			if (headerValue && headerValue.startsWith('Basic')) {
+				try {
+					let buffer = Buffer.from(headerValue.split(' ')[1], 'base64');
+					let plain = buffer.toString();
+					let credentials = plain.split(':');
+					return { user: credentials[0], password: credentials[1] };
+				}
+				catch (err2) { }
+			}
+		}
+		return null;
+	},
+	decodeBearerToken: function (request) {
+		if (request.headers) {
+			let headerValue = request.headers['authorization'];
+			if (headerValue && headerValue.startsWith('Bearer')) {
+				return { token: headerValue.split(' ')[1] };
+			}
+		}
+		return null;
+	},
+	loadResource: async function (path) {
+		try {
+			let resourceContent = await Fs.readFile(Path.join(__dirname, '../resources', path), 'utf8');
+			if (path.endsWith('.json') ) return JSON.parse(resourceContent)
+			else if (path.endsWith('.yaml') || path.endsWith('.yml'))return jsyaml.load(resourceContent)
+			else return resourceContent;
+		}
+		catch (fserr) {
+			if (fserr.code !== 'ENOENT')
+				throw fserr
+		}
+		let err = new Error();
+		err.code = 'ResourceNotFound';
+		err.data = { path: path };
+		throw err;
+	},	
+	callRest: async function (connection, restMapping, functionName, values, request, configParameters, callContext) {
+		let restMappingFunction = restMapping[functionName];
+		let requestUrl = connection.url.trim();
+		let requestUrlIndex = requestUrl.length - 1;
+		while (requestUrlIndex >= 0 && requestUrl[requestUrlIndex] === '/') {
+			requestUrlIndex--;
+		}
+		requestUrl = requestUrl.substring(0, requestUrlIndex + 1) + restMappingFunction.path;
+		let requestOptions = {
+			method: restMappingFunction.method,
+			headers: { 'Content-Type': 'application/json' },
+			throwHttpErrors: false
+		};
+		if (restMappingFunction.timeout && restMappingFunction.timeout > 0) {
+			requestOptions.timeout = restMappingFunction.timeout;
+		}		
+		var isFirstQueryParameter = true;
+		if (restMappingFunction.parameters) {
+			for (let i = 0; i < restMappingFunction.parameters.length; i++) {
+				let routingParameter = restMappingFunction.parameters[i];
+				let bindParts = routingParameter.bind.split('.');
+				let value = values;
+				for (let j = 0; j < bindParts.length; j++) {
+					let bindPart = bindParts[j];
+					if (value)
+						value = value[bindPart];
+				}
+				if (value === null && routingParameter.in === 'Path')
+					throw new Error('Error trying to call [' + connection.url + restMappingFunction.path + ']. The parameter [' + routingParameter.name + '] is mandatory.');
+				if (value !== null && value !== undefined) {
+					if (routingParameter.in === 'Path') {
+						requestUrl = requestUrl.split('{' + routingParameter.name + '}').join(encodeURIComponent(this.convertToString(value)));
+					}
+					else if (routingParameter.in === 'Query') {
+						if (Array.isArray(value)) {
+							for (let k = 0; k < value.length; k++) {
+								requestUrl += (isFirstQueryParameter ? '?' : '&') + encodeURIComponent(routingParameter.name) + '=' + encodeURIComponent(this.convertToString(value[k]));
+								isFirstQueryParameter = false;
+							}
+						}
+						else {
+							requestUrl += (isFirstQueryParameter ? '?' : '&') + encodeURIComponent(routingParameter.name) + '=' + encodeURIComponent(this.convertToString(value));
+							isFirstQueryParameter = false;
+						}
+					}
+					else if (routingParameter.in === 'Header') {
+						requestOptions.headers[routingParameter.name] = this.convertToString(value);
+					}
+					else if (routingParameter.in === 'Body') {
+						requestOptions.body = JSON.stringify(value);
+					}
+				}
+			}
+		}		
+		if (restMappingFunction.security) {
+			let securityApplied = false;
+			for (let i = 0; i < restMappingFunction.security.length; i++) {
+				if (!securityApplied) {
+					let securityItem = restMappingFunction.security[i];
+					let securityItemOk = true;
+					let securityItemValues = [];
+					for (let j = 0; j < securityItem.length; j++) {
+						let securityConditionItem = securityItem[j];
+						let value = null;
+						switch (securityConditionItem.source) {
+							case 'ConfigParameter': {
+								value = configParameters[securityConditionItem.configParameterName];
+								break;
+							}
+							case 'AccessToken': {								
+								const SESSION_STATE = securityService.getCookieName('session_state')								
+								let sessionState = request.state[SESSION_STATE];
+								// For backward compatibility with previous versions, the session_state is searched if the name of the configured cookie was not found.
+								if (!sessionState) {
+									sessionState = request.state['session_state'];
+								}
+								// If sessionState still does not exists, then token is on the header as it should
+								// Removed since sessionState is now also required in Azure
+								// if(!sessionState) {
+								// 	value = await securityService.extractTokenhNoDecode(request);
+								// 	break;
+								// }
+								// added request on getUseToken in case we use hapi modules full stack
+								const token = await securityService.getUseToken(sessionState, request);
+								if (token) {
+									value = token;
+								} else {
+									const ACCESS_TOKEN = securityService.getCookieName('access_token')
+									value = request.state[ACCESS_TOKEN];
+								}
+								break;
+							}
+							case 'Cookie': {
+								value = request.state[securityConditionItem.cookieName];
+								break;
+							}
+							case 'CallVariable': {
+								value = callContext.callVariables[securityConditionItem.callVariableName];
+								break;
+							}
+						}
+						if (value)
+							securityItemValues.push(value);
+						else
+							securityItemOk = false;
+					}
+					if (securityItemOk) {
+						for (let j = 0; j < securityItem.length; j++) {
+							let securityConditionItem = securityItem[j];
+							let value = securityItemValues[j];
+							switch (securityConditionItem.securityType) {
+								case 'ApiKey': {
+									switch (securityConditionItem.apiKeyIn) {
+										case 'Query': {
+											requestUrl += (isFirstQueryParameter ? '?' : '&') + encodeURIComponent(securityConditionItem.apiKeyName) + '=' + encodeURIComponent(value);
+											isFirstQueryParameter = false;
+											break;
+										}
+										case 'Header': {
+											requestOptions.headers[securityConditionItem.apiKeyName] = value;
+											break;
+										}
+									}
+									break;
+								}
+								case 'BasicAuth': {
+									requestOptions.headers['Authorization'] = 'Basic ' + Buffer.from(value.user + ':' + value.password, 'ascii').toString('base64');
+									break;
+								}
+								case 'BearerToken': {
+									requestOptions.headers['Authorization'] = 'Bearer ' + value;
+									break;
+								}
+							}
+						}
+						securityApplied = true;
+					}
+				}
+			}
+		}
+		securityService.validateSecureRequest(request)
+		// The following IF code block should not exists. Only for propagating without properly configuring it the suite.
+		let propagateAuthToken = process.env.blz_propagateAuthToken;
+		if(propagateAuthToken) {
+			// check if the system is to be ignored for the redirection of the Security token
+			let propagateAuthTokenIgnoreSystems = process.env.blz_propagateAuthTokenIgnoreSystems;
+			const ignoredSystems = propagateAuthTokenIgnoreSystems ? propagateAuthTokenIgnoreSystems.split(",") : [];
+			const ignorePropagation = ignoredSystems.includes(connection.name);
+			// If system is included in the list, ignore propagation. If not, propagate
+			if(!ignorePropagation) {
+				let value = null;
+				const SESSION_STATE = securityService.getCookieName('session_state')
+				// request object comes null when called in a microservice. if it exists it is inside the frontend.
+				if (request){
+					let sessionState = request.state[SESSION_STATE];
+					// For backward compatibility with previous versions, the session_state is searched if the name of the configured cookie was not found.
+					if (!sessionState) {
+						sessionState = request.state['session_state'];
+					}
+					// If sessionState still does not exists, then it is on the header
+					if(!sessionState) {
+						value = await securityService.extractTokenhNoDecode(request);
+					} else {
+						// added request on getUseToken in case we use hapi modules full stack
+						const token = await securityService.getUseToken(sessionState, request);
+						if (token) {
+							value = token;
+						} else {
+							const ACCESS_TOKEN = securityService.getCookieName('access_token')
+							value = request.state[ACCESS_TOKEN];
+						}
+					}
+				} else if (callContext && callContext.callVariables && callContext.callVariables['CallVariable-BearerToken']) {
+					// if i am working from inside a microservice. where should i get the token from?
+					// artificial call variable used to store token
+					value = callContext.callVariables['CallVariable-BearerToken'];
+				} else {
+					value = null;
+				}
+				switch (propagateAuthToken){
+					case 'BearerToken': {
+						if (/^Bearer /.test(value)) {
+							requestOptions.headers['Authorization'] = value;
+						} else {
+							requestOptions.headers['Authorization'] = 'Bearer ' + value;
+						}
+						break;
+					}
+					default:
+						break;
+				}
+			}
+		}
+		if (requestUrl.match(/https.*/)) {
+			requestOptions = {
+				...requestOptions,
+				https: {
+					requestCert: true, // Request a certificate from clients that connect and attempt to verify that certificate.
+					rejectUnauthorized: false, // The server will reject any connection which is not authorized with the list of supplied CAs.
+					agent: false // Is responsible for managing connection persistence and reuse for https clients.
+				}
+			};
+		}
+		let traceStartTime = Date.now();
+		const dateISOString = new Date().toISOString();
+		if (typeof _externalRestCallId === 'undefined')
+			_externalRestCallId = 1;
+		else
+			_externalRestCallId++;
+		const traceId = _externalRestCallId;
+		if (process.env.blz_traceAll === 'true' || process.env.blz_traceExternalRestCalls === 'true') {
+			console.log((callContext.devTime ? '' : dateISOString + ' | ') + 'EXTERNAL REST CALL (' + traceId + ') | ' + connection.name + ' | ' + requestOptions.method + ' ' + requestUrl + ' | HEADERS: ' + JSON.stringify(requestOptions.headers) + (requestOptions.body ? ' | BODY: ' + requestOptions.body : ''));
+		}
+		try {
+
+			const response = await Got(requestUrl, requestOptions);
+			const responseTime = Date.now() - traceStartTime;
+			if (process.env.blz_traceAll === 'true' || process.env.blz_traceExternalRestCalls === 'true') {
+				console.log((callContext.devTime ? '' : dateISOString + ' | ') + 'EXTERNAL REST CALL (' + traceId + ') | ' + connection.name + ' | STATUS: ' + response.statusCode + ' | BODY: ' + response.body + ' | TIME: ' + responseTime + ' milliseconds');
+			}
+			// These 2 are added for the PostProcessRequest event
+			if (request) {
+				request.httpRequestLog = {url: request.path, method: requestOptions.method, headers: Object.entries(requestOptions.headers), body: requestOptions.body, clientInfo: request.clientInfo }
+				request.httpResponseLog = { status: response.statusCode, headers: Object.entries(response.headers), body: response.body}
+			}
+			let httpErrorCode = this.httpErrors[response.statusCode];			
+			// If the request has the header x-navigation-info, it means that the request is a navigation request and the response should be saved in the security service.
+			if (request && request.headers['x-navigation-info']) {
+				try{
+					const clientNavigation = request.headers['x-navigation-info'];
+					const userInfo = await securityService.getUserInfo(request)
+					const config = configService.getConfig()
+					securityService.pushNavigation({
+						app: config.buildSystem.name,
+						username: userInfo.user_name,
+						date: dateISOString,						
+						client: {
+							nav: JSON.parse(Buffer.from(clientNavigation, 'base64').toString('utf-8')),
+							ip: request.headers['x-forwarded-for'] || request.info.remoteAddress,
+							userAgent: request.headers['user-agent'],
+							lang: request.headers['accept-language'],
+							host: request.info.host,
+							protocol: request.headers['x-forwarded-proto'] || request.server.info.protocol,
+							id: request.info.id
+						},
+						request: {
+							traceId: traceId,
+							traceStartTime: traceStartTime,							
+							connection: connection.name,	
+							method: request.method,
+							path: request.path,
+							url: requestUrl,
+							body: requestOptions.body						
+						},
+						response: {
+							status: response.statusCode,
+							body: response.body,
+							time: responseTime
+						}	
+					});
+				} catch(error) {
+					console.error('Error saving navigation in security service', error);
+				}
+			}
+	
+			if (httpErrorCode) {
+				let err = new Error();
+				err.code = httpErrorCode;
+				try {
+					if (process.env.NODE_ENV === 'production') {
+						const data = {
+							requestUrl: requestUrl,
+							responseStatus: response.statusCode,
+							responseBody: tryParse(response.body, response.body)
+						}
+						console.log(`Handle error ${err.code}: ${data}`)
+					} else {
+						err.data = {
+							requestUrl: requestUrl,
+							responseStatus: response.statusCode,
+							responseBody: tryParse(response.body, response.body)
+						};
+					}
+				} catch (ex) {
+					console.log(`Handle error ${err.code}: ${ex}`)
+				}
+				throw err;
+			}
+			else {
+				return tryParse(response.body, response.body)
+			}			
+        } catch (error) {
+			if (error.code == 'ETIMEDOUT') {
+				// Here we check for the timeout originated from the request options timeout added for the Got request.
+				// All other errors should be handled in finally.
+				// response is destroyed if it timed out	
+				let err = new Error();
+				err.code = 'GatewayTimeout';
+				err.data = {
+					requestUrl: requestUrl,
+					responseStatus: this.httpStatuses.GatewayTimeout,
+					responseBody: ""
+				};
+				console.error(err);
+				throw err;
+			} else {
+				console.error(error);
+				throw error;
+			}
+		}
+	},
+	callSoap: async function (connection, soapMapping, functionName, values, request, configParameters, callContext) {
+		let soapClient = await Soap.createClientAsync(soapMapping.wsdlFileName, { endpoint: connection.url });
+		if (process.env.blz_traceAll === 'true' || process.env.blz_traceExternalSoapCalls === 'true') {
+			let traceId = null;
+			let traceStartTime = null;
+			soapClient.on('request', function (xml) {
+				if (typeof _externalSoapCallId === 'undefined')
+					_externalSoapCallId = 1;
+				else
+					_externalSoapCallId++;
+				traceId = _externalSoapCallId;
+				traceStartTime = Date.now();
+				console.log((callContext.devTime ? '' : new Date().toISOString() + ' | ') + 'EXTERNAL SOAP CALL (' + traceId + ') | ' + connection.name + ' | POST ' + connection.url + ' | HEADERS: {} | BODY: ' + xml);
+			}.bind(this));
+			soapClient.on('response', function (body, response) {
+				console.log((callContext.devTime ? '' : new Date().toISOString() + ' | ') + 'EXTERNAL SOAP CALL (' + traceId + ') | ' + connection.name + ' | STATUS: ' + response.statusCode + ' | BODY: ' + response.body + ' | TIME: ' + (Date.now() - traceStartTime) + ' milliseconds');
+			}.bind(this));
+		}
+		if (soapMapping.security) {
+			let value = null;
+			switch (soapMapping.security.source) {
+				case 'ConfigParameter': {
+					value = configParameters[soapMapping.security.configParameterName];
+					break;
+				}
+				case 'AccessToken': {
+					value = request.state['access_token'];
+					break;
+				}
+				case 'Cookie': {
+					value = request.state[soapMapping.security.cookieName];
+					break;
+				}
+				case 'CallVariable': {
+					value = callContext.callVariables[soapMapping.security.callVariableName];
+					break;
+				}
+			}
+			switch (soapMapping.security.securityType) {
+				case 'BasicAuth': {
+					soapClient.setSecurity(new Soap.BasicAuthSecurity(value.user, value.password));
+					break;
+				}
+				case 'BearerToken': {
+					soapClient.setSecurity(new Soap.BearerSecurity(value));
+					break;
+				}
+			}
+		}
+		let soapFunctionName = functionName + 'Async';
+		if (soapClient[soapFunctionName]) {
+			let result = (await soapClient[soapFunctionName](values.request))[0];
+			if (isSoapNull(result))
+				return null;
+			fixSoapValue(result);
+			return result;
+		}
+		let soapFunctionNameSimplified = simplifyName(soapFunctionName);
+		for (let key in soapClient) {
+			if (soapFunctionNameSimplified === simplifyName(key)) {
+				let result = (await soapClient[key](values.request))[0];
+				if (isSoapNull(result))
+					return null;
+				fixSoapValue(result);
+				return result;
+			}
+		}
+		throw new Error('Soap Function "' + soapFunctionName + '" not recognized.');
+	},
+	getFullUrl(request) {
+		let { protocol, host, pathname } = request.url;
+		protocol = ((request.headers['x-forwarded-proto'] || protocol).match(/[a-z]+/gim) || ['https'])[0];
+		return `${protocol}://${request.headers['x-forwarded-host'] || host}${pathname}`;
+	},
+	setCache(key, value, maxAge) {
+		cache.set(key, value, maxAge);
+	},
+	getCache(key) {
+		return cache.get(key);
+	},
+	existsPath: async function (sourcePath) {
+		const fullPath = this.resolvePath(sourcePath)
+		return new Promise((resolve) => {
+			Fs.access(fullPath, (err) => {
+				if (err) {
+					resolve(false)
+				} else {
+					resolve(true)
+				}
+			})
+		})
+	},
+	resolvePath: function (source) {
+		const _source = source.trim()
+		if (_source.startsWith('.')) {
+			return Path.join(process.cwd(), source)
+		}
+		if (_source.startsWith('~')) {
+			return _source.replace('~', process.env.HOME)
+		}
+		return source
+	},
+	readFile: async function(filePath) {
+		const fullPath = this.resolvePath(filePath)
+		if (!await this.existsPath(fullPath)) {
+			return null
+		}
+		return new Promise((resolve, reject) => {
+			Fs.readFile(fullPath, (err, data) => err ? reject(err) : resolve(data.toString('utf8')))
+		})
+	},
+	safeRequire,
+	getHealthStatus
+};