@sap/async-xsjs 1.0.2

package/lib/xsjs/net/http/Client.js

@@ -0,0 +1,220 @@
+'use strict';
+
+var util = require('util');
+var qs = require('querystring');
+var requestLib = require('request');
+var _ = require('lodash');
+var SAPPassport = require('@sap/e2e-trace').Passport;
+var WebResponse = require('../../web/WebResponse');
+var MultipartResponseBuilder = require('../../web/utils/MultipartResponseBuilder');
+var contentTypeParser = require('content-type');
+
+var methodMapping = {
+  // -1: 'INVALID',
+  0: 'OPTIONS',
+  1: 'GET',
+  2: 'HEAD',
+  3: 'POST',
+  4: 'PUT',
+  5: 'DELETE',
+  6: 'TRACE',
+  7: 'CONNECT',
+  8: 'PATCH'
+};
+
+function Client(sapPassport) {
+  if (!(this instanceof Client)) {
+    return new Client(sapPassport);
+  }
+  this._response = null;
+  this._sapPassport = sapPassport;
+}
+
+Client.prototype.getResponse = async function () {
+  if (!this._response) {
+    throw new Error('Make an HTTP request before trying to get the response');
+  }
+  if (util.types.isPromise(this._response)) {
+    this._response = new WebResponse(await this._response);
+  }
+  return this._response;
+};
+
+Client.prototype.request = function (arg0, arg1, proxyOpt) {
+  this._response = null;
+  var options = {
+    headers: {},
+    timeout: 10000
+  };
+  if (this._sapPassport) {
+    var passport = new SAPPassport(this._sapPassport);
+    passport.update({
+      connectionID: '00000000000000000000000000000000',
+      connectionCounter: 0
+    });
+    options.headers[SAPPassport.HEADER_NAME] = passport.serialize();
+  }
+  if (_.isNumber(arg0)) {
+    processWebMethodAndUrl(options, arg0, arg1, proxyOpt);
+  } else if (_.isString(arg1)) {
+    processWebRequestAndUrl(options, arg0, arg1, proxyOpt);
+  } else {
+    processWebRequestAndDestination(options, arg0, arg1);
+  }
+
+  if (this._timeoutInMilliseconds) {
+    options.timeout = this._timeoutInMilliseconds;
+  }
+  this._response = new Promise ((resolve, reject) => {
+    requestLib(options, function(err, response) {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve(response);
+    });
+  });
+  return this;
+};
+
+Client.prototype.setTimeout = function (timeout) {
+  this._timeoutInMilliseconds = timeout * 1000;
+};
+
+Client.prototype.close = function () {
+};
+
+Client.prototype.setTrustStore = function () {
+  throw new Error('Feature not supported!');
+};
+
+function processWebMethodAndUrl(options, webMethod, url, proxyOpt) {
+  options.url = url;
+  options.method = methodMapping[webMethod];
+  setProxy(options, proxyOpt);
+}
+
+function processWebRequestAndUrl(options, webRequest, url, proxyOpt) {
+  options.url = url;
+  useDataFromWebRequest(options, webRequest);
+  setProxy(options, proxyOpt);
+}
+
+function processWebRequestAndDestination(options, webRequest, destination) {
+  options.url = (destination.useSSL === true ? 'https://' : 'http://') + destination.host + ':' + destination.port;
+  if (destination.timeout) {
+    options.timeout = destination.timeout;
+  }
+  addPathPrefix(options, destination);
+  useDataFromWebRequest(options, webRequest);
+  setProxyFromDestination(options, destination);
+  setBasicAuthFromDestination(options, destination);
+}
+
+function useDataFromWebRequest(options, webRequest) {
+  options.method = methodMapping[webRequest.method];
+  addPath(options, webRequest);
+  addRequestParameters(options, webRequest);
+  handleEntities(options, webRequest);
+  addHeaders(options, webRequest);
+  addCookies(options, webRequest);
+  addBody(options, webRequest);
+}
+
+function handleEntities(options, webRequest) {
+  let multiPartHeader = webRequest.headers.get('content-type');
+  if (webRequest.entities.length > 0 && multiPartHeader && multiPartHeader.indexOf('multipart') > -1) {
+    let boundary = '';
+    if (multiPartHeader.indexOf('boundary') > -1) {
+      boundary = contentTypeParser.parse(multiPartHeader).parameters.boundary;
+    } else {
+      boundary = MultipartResponseBuilder.generateBoundary();
+      let multiPartHeaderWithBoundary = `${multiPartHeader};boundary=${boundary}`;
+      webRequest.headers.set('content-type', multiPartHeaderWithBoundary);
+    }
+
+    if (multiPartHeader.indexOf('related') > -1) {
+      options.multipart = [];
+      webRequest.entities.forEach(entity => {
+        options.multipart.push({
+          'content-type': entity.contentType,
+          body: entity.body._content
+        });
+      });
+    } else {
+      throw new Error('Multipart/form-data and Multi-part/mixed are not supported!');
+    }
+  }
+}
+
+function addPath(options, webRequest) {
+  if (webRequest.path) {
+    if (options.url.charAt(options.url.length - 1) !== '/' && webRequest.path.charAt(0) !== '/') {
+      options.url += '/';
+    }
+    options.url += webRequest.path;
+  }
+}
+
+function addRequestParameters(options, webRequest) {
+  if (webRequest.parameters.length > 0) {
+    if (options.url.indexOf('?') !== -1) {
+      options.url += '&';
+    } else {
+      options.url += '?';
+    }
+    options.url += qs.encode(webRequest.parameters.reduce(function (p, n) { p[n.name] = n.value; return p; }, {}));
+  }
+}
+
+function addHeaders(options, webRequest) {
+  webRequest.headers.forEach(function (header) {
+    options.headers[header.name] = header.value;
+  });
+}
+
+function addCookies(options, webRequest) {
+  options.headers.Cookie = webRequest.cookies.map(function (cookie) {
+    return cookie.name + '=' + cookie.value;
+  }).join('; ');
+}
+
+function addBody(options, webRequest) {
+  if (options.method === 'POST' || options.method === 'PUT' || options.method === 'PATCH') {
+    options.body = webRequest.body._content;
+    options.json = false;
+  }
+}
+
+function setProxy(options, proxyOpt) {
+  if (proxyOpt) {
+    options.proxy = proxyOpt;
+  }
+}
+
+function addPathPrefix(options, destination) {
+  if (destination.pathPrefix) {
+    if (destination.pathPrefix.charAt(0) !== '/') {
+      options.url += '/';
+    }
+    options.url += destination.pathPrefix;
+  }
+}
+
+function setProxyFromDestination(options, destination) {
+  if (destination.useProxy === true) {
+    return options.proxy = 'http://' + destination.proxyHost + ':' + destination.proxyPort;
+  }
+  // explicitly disable proxy
+  if (destination.useProxy === false) {
+    options.proxy = null;
+  }
+}
+
+function setBasicAuthFromDestination(options, destination) {
+  if (destination.authType === 'basic') {
+    options.auth = { user: destination.username, pass: destination.password };
+  }
+}
+
+module.exports = Client;

package/lib/xsjs/net/http/HTTP.js

@@ -0,0 +1,72 @@
+'use strict';
+
+var VError = require('verror');
+var Client = require('./Client');
+var Destination = require('../Destination');
+var WebRequest = require('../../web/WebRequest');
+var utils = require('../../../utils');
+var constants = require('../../constants');
+var httpStatusCodes = constants.httpStatusCodes;
+var webTypes = constants.webTypes;
+
+module.exports = HTTP;
+
+function HTTP(dtDestinations, getDestinationFunction, sapPassport) {
+  if (!dtDestinations || (typeof dtDestinations !== 'object')) {
+    throw new TypeError('Design time destinations container object should be provided');
+  }
+
+  if (getDestinationFunction && (typeof getDestinationFunction !== 'function')) {
+    throw new TypeError('Destination provider is mandatory and should be a function');
+  }
+
+  this.readDestination = async function (packagename, objectname) {
+    var destinationName = utils.toXSObjectId(packagename, objectname);
+    if (!destinationName) {
+      throw new TypeError('Valid destination packagename or objectname should be provided');
+    }
+
+    var dtDestination = dtDestinations[destinationName];
+    var destination = (isAsync(getDestinationFunction)) ?
+        await getDestinationFunctionPromise(packagename, objectname, dtDestination, getDestinationFunction) :
+        getDestinationFunction(packagename, objectname, dtDestination);
+
+    if (!destination) {
+      throw new VError('Destination not found (package: "%s", objectname: "%s")', packagename, objectname);
+    }
+    return new Destination(destination);
+  };
+  this.Client = Client.bind(null, sapPassport);
+}
+
+HTTP.prototype.Request = WebRequest;
+HTTP.prototype.Destination = Destination;
+
+Object.keys(httpStatusCodes).forEach(function (key) {
+  Object.defineProperty(HTTP.prototype, key, {
+    value: httpStatusCodes[key],
+    enumerable: true
+  });
+});
+
+Object.keys(webTypes).forEach(function (key) {
+  Object.defineProperty(HTTP.prototype, key, {
+    value: webTypes[key],
+    enumerable: true
+  });
+});
+
+function isAsync(getDestinationFunction) {
+  return (getDestinationFunction.length > 3);
+}
+
+function getDestinationFunctionPromise (packagename, objectname, dtDestination, getDestinationFunction) {
+  return new Promise ((resolve, reject) => {
+    getDestinationFunction(packagename, objectname, dtDestination, function (err, result) {
+      if (err) {
+        return reject (err);
+      }
+      resolve(result);
+    });
+  });
+}

package/lib/xsjs/net/index.js

@@ -0,0 +1,5 @@
+'use strict';
+
+exports.HTTP = require('./http/HTTP');
+exports.createMail = require('./smtp').createMail;
+exports.createSMTPConnection = require('./smtp').createSMTPConnection;

package/lib/xsjs/net/smtp/Mail.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var nodemailer = require('nodemailer');
+var toNodemailerMail = require('./nodemailer-util').toNodemailerMail;
+var assert = require('assert');
+
+module.exports = Mail;
+
+function Mail(settings, mailObjectOpt) {
+  assert(settings && settings.host && settings.port, 'Invalid smtp settings. Host and port are mandatory.');
+  this._settings = settings;
+  this.bcc = mailObjectOpt && mailObjectOpt.bcc || [];
+  this.cc = mailObjectOpt && mailObjectOpt.cc || [];
+  this.parts = mailObjectOpt && mailObjectOpt.parts || [];
+  this.sender = mailObjectOpt && mailObjectOpt.sender || {};
+  this.subject = mailObjectOpt && mailObjectOpt.subject || '';
+  this.to = mailObjectOpt && mailObjectOpt.to || [];
+}
+
+Mail.prototype.send = async function () {
+  var nodeMail = toNodemailerMail(this);
+  var transporter = nodemailer.createTransport({
+    host: this._settings.host,
+    port: parseInt(this._settings.port, 10),
+    ignoreTLS: this._settings.ignoreTLS,
+    secure: this._settings.secure,
+    connectionTimeout: this._settings.connectionTimeout || 60000,
+    authMethod: this._settings.authMethod,
+    auth: this._settings.auth
+  });
+  var info;
+  try {
+    info = await transporter.sendMail(nodeMail);
+  } finally {
+    transporter.close();
+  }
+  return { finalReply: info.response, messageId: info.messageId };
+};

package/lib/xsjs/net/smtp/Part.js

@@ -0,0 +1,30 @@
+'use strict';
+module.exports = Part;
+
+function Part(partObjectOpt) {
+  this.alternative = partObjectOpt && partObjectOpt.alternative || '';
+  this.alternativeContentType = partObjectOpt && partObjectOpt.alternativeContentType || '';
+  this.contentId = partObjectOpt && partObjectOpt.contentId || '';
+  this.contentType = partObjectOpt && partObjectOpt.contentType || '';
+  this.data = partObjectOpt && partObjectOpt.data || '';
+  this.encoding = partObjectOpt && partObjectOpt.encoding || '';
+  this.fileName = partObjectOpt && partObjectOpt.fileName || '';
+  this.fileNameEncoding = partObjectOpt && partObjectOpt.fileNameEncoding || 'UTF-8';
+  this.text = partObjectOpt && partObjectOpt.text || '';
+  this.type = partObjectOpt && partObjectOpt.type || Part.prototype.TYPE_TEXT;
+}
+
+Object.defineProperties(Part, {
+  TYPE_TEXT: {
+    value: 'text',
+    enumerable: true
+  },
+  TYPE_ATTACHMENT: {
+    value: 'attachment',
+    enumerable: true
+  },
+  TYPE_INLINE: {
+    value: 'inline',
+    enumerable: true
+  }
+});

package/lib/xsjs/net/smtp/SMTPConnection.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var assert = require('assert');
+var nodemailer = require('nodemailer');
+var toNodemailerMail = require('./nodemailer-util').toNodemailerMail;
+
+module.exports = SMTPConnection;
+
+function SMTPConnection(settings) {
+  assert(settings && settings.host && settings.port, 'Invalid smtp settings. Host and port are mandatory.');
+  this._transporter = nodemailer.createTransport({
+    pool: true,
+    host: settings.host,
+    port: parseInt(settings.port, 10),
+    ignoreTLS: settings.ignoreTLS,
+    secure: settings.secure,
+    connectionTimeout: settings.connectionTimeout || 60000,
+    authMethod: settings.authMethod,
+    auth: settings.auth,
+    maxConnections: 1
+  });
+  this._isClosed = true;
+}
+
+SMTPConnection.prototype.send = async function (mail) {
+  var nodeMail = toNodemailerMail(mail);
+  var info = await this._transporter.sendMail(nodeMail);
+  this._isClosed = false;
+  return { finalReply: info.response, messageId: info.messageId };
+};
+
+SMTPConnection.prototype.close = function () {
+  this._transporter.close();
+  this._isClosed = true;
+};
+
+SMTPConnection.prototype.isClosed = function () {
+  return this._isClosed;
+};

package/lib/xsjs/net/smtp/index.js

@@ -0,0 +1,18 @@
+'use strict';
+var Mail = require('./Mail');
+var Part = require('./Part');
+var SMTPConnection = require('./SMTPConnection');
+
+exports.createMail = function (settings) {
+  var mail = function(mailObjectOpt) {
+    return new Mail(settings, mailObjectOpt);
+  };
+  Object.defineProperty(mail, 'Part', {value: Part});
+  return mail;
+};
+
+exports.createSMTPConnection = function (settings) {
+  return function() {
+    return new SMTPConnection(settings);
+  };
+};

package/lib/xsjs/net/smtp/nodemailer-util.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var assert = require('assert');
+var Part = require('./Part');
+var util = require('util');
+var buffUtils = require('../../../utils/buffer-utils');
+
+function getDataAsStringAndEncoding(data) {
+  var partDataAsString = '';
+  var encoding = null;
+  if (data) {
+    if (typeof data === 'string') {
+      partDataAsString = data;
+    } else {
+      partDataAsString = buffUtils.toBuffer(data).toString('base64');
+      encoding = 'base64';
+    }
+  }
+  return { data: partDataAsString, encoding: encoding };
+}
+
+function getAttachment(part, isInline) {
+  var partDataAsStringAndEncoding = getDataAsStringAndEncoding(part.data);
+  var attachment = {
+    filename: part.fileName || '',
+    content: partDataAsStringAndEncoding.data || '',
+    contentType: part.contentType || '',
+    encoding: partDataAsStringAndEncoding.encoding
+  };
+  if (isInline) {
+    attachment.cid = part.contentId || '';
+    attachment.contentDisposition = 'inline';
+  }
+  return attachment;
+}
+
+exports.toNodemailerMail = function (mail) {
+  assert(mail.constructor.name === 'Mail', 'Not a mail object: ' + mail);
+  assert(mail.sender, 'Mail.send(): missing sender');
+  assert(mail.to || mail.cc || mail.bcc, 'Mail.send(): missing recipients');
+  var mailOptions = {
+    from: mail.sender,
+    to: mail.to,
+    cc: mail.cc,
+    bcc: mail.bcc,
+    subject: mail.subject || '',
+    attachments: [],
+    alternatives: [],
+    html: ''
+  };
+
+  if (mail.parts && util.isArray(mail.parts)) {
+    mail.parts.forEach(function (part) {
+      if (part.type === Part.TYPE_TEXT) {
+        var alternatives = [];
+        if (part.contentType === 'text/html') {
+          mailOptions.html = part.text;
+        } else {
+          mailOptions.text = part.text;
+        }
+        if (part.alternative) {
+          alternatives.push({ content: part.alternative, contentType: part.alternativeContentType || 'text/plain' });
+        }
+        if (alternatives) {
+          mailOptions.alternatives = alternatives;
+        }
+      } else if (part.type === Part.TYPE_ATTACHMENT) {
+        mailOptions.attachments.push(getAttachment(part, false));
+      } else if (part.type === Part.TYPE_INLINE) {
+        mailOptions.attachments.push(getAttachment(part, true));
+      } else {
+        throw new Error('Part.type cannot be: ' + part.type);
+      }
+    });
+  }
+  return mailOptions;
+};

package/lib/xsjs/require.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var _ = require('lodash');
+var path = require('path');
+var assert = require('assert');
+var utils = require('../utils');
+
+module.exports = function xsjsRequire(packagename, rootDirs) {
+  assert(_.isString(packagename), 'packagename must be a string');
+
+  var xsjsDir = path.parse(utils.getCallingXsjs(rootDirs)).dir;
+  var isLocalFile = ['./', '/', '../'].some(function(prefix) {
+    return _.startsWith(packagename, prefix);
+  });
+  if (isLocalFile) { // We are requiring a file on the system
+    return require(path.resolve(xsjsDir, packagename));
+  }
+
+  var nodeCache = require.cache[__filename];
+  var oldLookupPaths = nodeCache.paths;
+  var newLookupPaths = [];
+  var systemRoot = path.parse(xsjsDir).root;
+  for (;;) {
+    if (path.basename(xsjsDir) !== 'node_modules') {
+      newLookupPaths.push(path.join(xsjsDir, 'node_modules'));
+      if (xsjsDir === systemRoot) {
+        break;
+      }
+    }
+    xsjsDir = path.resolve(xsjsDir, '..');
+  }
+
+  nodeCache.paths = newLookupPaths;
+  try {
+    return require(packagename);
+  } finally {
+    nodeCache.paths = oldLookupPaths;
+  }
+};

package/lib/xsjs/security/AntiVirus.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var vsi = require('@sap/node-vsi');
+var buffUtils = require('../../utils/buffer-utils');
+
+module.exports = AntiVirus;
+
+function AntiVirus(profile) {
+  var vsiProfile = vsi.vsiProfile;
+  profile = typeof profile !== 'undefined' ? profile : '';
+  this.av = new vsiProfile(profile);
+  if (this.av.getLastError() !== '') {
+    this.isAvAvailable = false;
+    return;
+  }
+  this.isAvAvailable = true;
+}
+
+AntiVirus.prototype.isAvailable = function() {
+  return this.isAvAvailable;
+};
+
+AntiVirus.prototype.scan = function(data, name) {
+  data = buffUtils.getData(data).toString('binary');
+  name = name || 'binary';
+  var rc = this.av.scanBytes(name, data, data.length);
+  if (rc !== 0) {
+    throw new Error(this.av.getLastError());
+  }
+  return true;
+};

package/lib/xsjs/security/Store.js

@@ -0,0 +1,119 @@
+'use strict';
+
+var assert = require('assert');
+var connection = require('../db/common/connection');
+var dbStream = require('@sap/hana-client/extension/Stream');
+
+exports.createStore = createStore;
+
+function createStore(dbReqOptions) {
+  var openConnections = new Set();
+
+  var storeConstructor = function (secureStoreFile) {
+    return dbReqOptions.getInstanceOptionsPromise()
+      .then((hanaOptions) => {
+        return connection.connect(hanaOptions);
+      })
+      .then((client) => {
+        openConnections.add(client);
+        return new Store(client, secureStoreFile);
+      });
+  };
+
+  storeConstructor._closeAllConnections = function () {
+    for (var client of openConnections) {
+      client.close(function () { }); // ignoring an error here;
+    }
+    openConnections.clear();
+  };
+
+  return storeConstructor;
+}
+
+function Store(client, secureStoreFile) {
+  this._client = client;
+  this._secureStoreFile = secureStoreFile;
+}
+
+Store.prototype.read = async function (parameter) {
+  checkParameterHasName(parameter, 'read');
+  return await read.call(this, parameter, false);
+};
+
+Store.prototype.readForUser = async function (parameter) {
+  checkParameterHasName(parameter, 'readForUser');
+  return await read.call(this, parameter, true);
+};
+
+async function read(parameter, isForUser) {
+  var result = await callProc(this._client, 'CALL "SYS"."USER_SECURESTORE_RETRIEVE"(?, ?, ?, ?)', {
+    STORE_NAME: this._secureStoreFile,
+    FOR_XS_APPLICATIONUSER: isForUser,
+    KEY: parameter.name
+  });
+  return result && result.VALUE ? result.VALUE.toString('utf8') : null;
+}
+
+Store.prototype.remove = async function (parameter) {
+  checkParameterHasName(parameter, 'remove');
+  await remove.call(this, parameter, false);
+};
+
+Store.prototype.removeForUser = async function (parameter) {
+  checkParameterHasName(parameter, 'removeForUser');
+  await remove.call(this, parameter, true);
+};
+
+async function remove(parameter, isForUser) {
+  await callProc(this._client, 'CALL "SYS"."USER_SECURESTORE_DELETE"(?, ?, ?)', {
+    STORE_NAME: this._secureStoreFile,
+    FOR_XS_APPLICATIONUSER: isForUser,
+    KEY: parameter.name
+  });
+}
+
+Store.prototype.store = async function (parameter) {
+  checkWriteParameter(parameter, 'store');
+  await store.call(this, parameter, false);
+};
+
+Store.prototype.storeForUser = async function (parameter) {
+  checkWriteParameter(parameter, 'storeForUser');
+  await store.call(this, parameter, true);
+};
+
+async function store(parameter, isForUser) {
+  await callProc(this._client, 'CALL "SYS"."USER_SECURESTORE_INSERT"(?, ?, ?, ?)', {
+    STORE_NAME: this._secureStoreFile,
+    FOR_XS_APPLICATIONUSER: isForUser,
+    KEY: parameter.name,
+    VALUE: Buffer.from(parameter.value, 'utf8')
+  });
+}
+
+function checkWriteParameter(parameter, functionName) {
+  checkParameterHasName(parameter, functionName);
+  assert(typeof parameter.value === 'string', 'Store.' + functionName + ' should be called with object containing property value - string!');
+}
+
+function checkParameterHasName(parameter, functionName) {
+  assert(parameter && typeof parameter === 'object', 'Store.' + functionName + ' called with invalid parameter');
+  assert(parameter.name && typeof parameter.name === 'string', 'Store.' + functionName + ' should be called with object containing property name - non empty string!');
+}
+
+function callProc(client, sql, params) {
+  var stmt = dbStream.createProcStatement(client, sql);
+  return new Promise((resolve, reject) => {
+    stmt.exec(params, function(){
+      var err = arguments[0];
+      if (err) {
+        stmt.drop();
+        reject(err);
+      }
+      else {
+        stmt.drop();
+        resolve(arguments[1]);
+      }
+    });
+  });
+}