@sap/async-xsjs 1.0.2

package/lib/xsjs/web/WebBody.js

@@ -0,0 +1,135 @@
+'use strict';
+
+var WebRequest = require('./WebRequest');
+var WebResponse = require('./WebResponse');
+var WebEntityResponse = require('./WebEntityResponse');
+var CRLF = require('../constants').WEB.MESSAGES.LINE_BREAK;
+var HttpRequestParser = require('./utils/HttpRequestParser');
+var MultipartResponseBuilder = require('./utils/MultipartResponseBuilder');
+var buffUtils = require('../../utils/buffer-utils');
+var Locale = require('../Locale');
+
+module.exports = WebBody;
+
+function WebBody(bodyOwner, bodyContent, indexOpt) {
+  // a WebBody cannot be used on its own. The body owner is an object that has a property named 'body'
+  this._bodyOwner = bodyOwner;
+
+  if (indexOpt) {
+    this._content = extractContentOfBlobColumn(bodyContent, indexOpt);
+  } else if (isWebResponse(bodyContent)) {
+    addSpecificHttpHeadersToBodyOwner(this);
+    setBodyFromWebResponse(this, bodyContent);
+  } else if (isWebEntityResponse(bodyContent)) {
+    addSpecificHttpHeadersToBodyOwner(this);
+    setBodyFromWebEntityResponse(this, bodyContent);
+  } else {
+    this._content = bodyContent;
+  }
+}
+
+function extractContentOfBlobColumn(resultSet, index) {
+  if (index > resultSet._columnInfo.length) {
+    throw new Error('No column found for index ' + index);
+  }
+  return resultSet._row[index - 1];
+}
+
+function addSpecificHttpHeadersToBodyOwner(webBody) {
+  webBody._bodyOwner.headers.set('content-type', 'application/http');
+  webBody._bodyOwner.headers.set('content-transfer-encoding', 'binary');
+}
+
+function isWebResponse(arg) {
+  return arg instanceof WebResponse;
+}
+
+function isWebEntityResponse(arg) {
+  return arg instanceof WebEntityResponse;
+}
+
+function setBodyFromWebResponse(webBody, webResponse) {
+  webBody._content = '';
+  addStatusLine(webBody, webResponse);
+  addHeaders(webBody, webResponse);
+  addCookies(webBody, webResponse);
+  addTheBody(webBody, webResponse);
+}
+
+function addTheBody(webBody, webEntityResponse) {
+  if (webEntityResponse.entities.length === 0) {
+    webBody._content += CRLF;
+    webBody._content += webEntityResponse.body.asString();
+  } else {
+    var boundary = MultipartResponseBuilder.generateBoundary();
+    webBody._content += ('content-type: multipart/mixed; boundary=' + boundary) + CRLF;
+    webBody._content += CRLF;
+    webBody._content += MultipartResponseBuilder.build(webEntityResponse, boundary);
+  }
+}
+
+function addStatusLine(webBody, webResponse) {
+  webBody._content += webResponse._httpVersion + ' ' + webResponse.status + ' ' + webResponse.statusMessage + CRLF;
+}
+
+function isMultipart(name, value) {
+  return (name === 'content-type' && value.indexOf('multipart') > -1);
+}
+
+function addHeaders(webBody, webEntityResponse) {
+  webEntityResponse.headers.forEach(function (singleTupelPair) {
+    if (!isMultipart(singleTupelPair.name, singleTupelPair.value)) {
+      webBody._content += singleTupelPair.name + ': ' + singleTupelPair.value + CRLF;
+    }
+  });
+}
+
+function addCookies(webBody, webResponse) {
+  webResponse.cookies.forEach(function (singleCookie) {
+    webBody._content += 'set-cookie: ' + singleCookie.name + '=' + singleCookie.value + CRLF;
+  });
+}
+
+function setBodyFromWebEntityResponse(webBody, webEntityResponse) {
+  webBody._content = '';
+  addHeaders(webBody, webEntityResponse);
+  addTheBody(webBody, webEntityResponse);
+}
+
+WebBody.prototype.asString = function () {
+  if (this._content === null || this._content === undefined || typeof this._content === 'number') {
+    return '' + this._content;
+  }
+  if (buffUtils.isBinary(this._content)) {
+    return buffUtils.toBuffer(this._content).toString('utf8');
+  }
+  if (typeof this._content === 'boolean') {
+    return this._content ? '1' : '0';
+  }
+  return this._content;
+};
+
+WebBody.prototype._retrieveContent = function () {
+  return buffUtils.isBinary(this._content) ? buffUtils.toBuffer(this._content) : this.asString();
+};
+
+WebBody.prototype.asArrayBuffer = function () {
+  var content = buffUtils.isBinary(this._content) ? this._content : Buffer.from(this._content, 'utf8');
+  return buffUtils.toArrayBuffer(content);
+};
+
+WebBody.prototype.asWebRequest = function () {
+  var bodyOwnerHeaders = this._bodyOwner.headers;
+  if (!bodyOwnerHeaders) {
+    throw new Error('Cannot get Body as WebRequest. The object to which the current body belongs does not have any headers.');
+  }
+  if (bodyOwnerHeaders.get('Content-Type') !== 'application/http') {
+    throw new Error('Cannot get Body as WebRequest. Content-Type header should be equal to "application/http" in order to proceed.');
+  }
+  if (bodyOwnerHeaders.get('Content-Transfer-Encoding') !== 'binary') {
+    throw new Error('Cannot get Body as WebRequest. Content-Transfer-Encoding header should be equal to "binary" in order to proceed.');
+  }
+  var req = HttpRequestParser.parse(this.asString());
+  var locale = new Locale(req);
+  return new WebRequest(req, locale);
+};

package/lib/xsjs/web/WebEntityRequest.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var util = require('util');
+var ParametersTupelList = require('./TupelLists/ParametersTupelList');
+var BasicWebEntity = require('./BasicWebEntity');
+
+module.exports = WebEntityRequest;
+
+function WebEntityRequest(arg) {
+  BasicWebEntity.call(this, arg);
+
+  if (!arg) {
+    this.parameters = new ParametersTupelList();
+  } else {
+    var req = arg;
+    this.parameters = new ParametersTupelList();
+    this.parameters._addData(req.query);
+    addParametersFromBody(this, req);
+  }
+
+  this.entities.create = function() {
+    var newEntity = new WebEntityRequest();
+    this.push(newEntity);
+    return newEntity;
+  };
+}
+
+util.inherits(WebEntityRequest, BasicWebEntity);
+
+function addParametersFromBody(webEntityRequest, expressReq) {
+  webEntityRequest.parameters._addData(expressReq['form-urlencoded']);
+}
+
+WebEntityRequest.create = function(headers, parameters, body) {
+  var entityRequest = new WebEntityRequest();
+  entityRequest.headers._addData(headers);
+  entityRequest.parameters._addData(parameters);
+  entityRequest.setBody(body);
+  return entityRequest;
+};

package/lib/xsjs/web/WebEntityResponse.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var util = require('util');
+var BasicWebEntity = require('./BasicWebEntity');
+
+module.exports = WebEntityResponse;
+
+function WebEntityResponse(arg) {
+  BasicWebEntity.call(this, arg);
+
+  this.entities.create = function() {
+    var newEntity = new WebEntityResponse();
+    this.push(newEntity);
+    return newEntity;
+  };
+
+}
+
+util.inherits(WebEntityResponse, BasicWebEntity);
+
+WebEntityResponse.create = function(headers, body) {
+  var entityResponse = new WebEntityResponse();
+  entityResponse.headers._addData(headers);
+  entityResponse.setBody(body);
+  return entityResponse;
+};

package/lib/xsjs/web/WebRequest.js

@@ -0,0 +1,209 @@
+'use strict';
+
+var fs = require('fs');
+var util = require('util');
+var parseUrl = require('url').parse;
+var CookiesTupelList = require('./TupelLists/CookiesTupelList');
+var http = require('../constants').webTypes;
+var contentTypeParser = require('content-type');
+var WebEntityRequest = require('./WebEntityRequest');
+var MultipartParser = require('./utils/MultipartParser');
+var MESSAGE_TYPE = require('../constants').WEB.MESSAGE_TYPE;
+var HttpError = require('../../utils/errors/HttpError');
+
+module.exports = WebRequest;
+
+function WebRequest(arg0, arg1) {
+  if (this instanceof WebRequest) {
+    WebEntityRequest.call(this, arg0);
+
+    if (typeof arg0 === 'number') {
+      var method = arg0;
+      var path = arg1;
+      if (typeof path !== 'string') {
+        throw new Error('Expected string as a path (second argument)');
+      }
+      this.method = method;
+      this.cookies = new CookiesTupelList();
+      this.language = '';
+      this.path = path || '';
+      this.queryPath = '';
+    } else {
+      var req = arg0;
+      var locale = arg1;
+      normalizeRequestHeaders(this);
+      setBodyOrEntities(this, req);
+      addFormData(this, req);
+      this.method = resolveMethod(req.method);
+      this.cookies = new CookiesTupelList();
+      this.cookies._addData(req.cookies);
+      setRequestLanguage(this, locale);
+      setPath(this, req.path);
+      addTildeHeaders(this, req);
+      setQueryPath(this);
+    }
+  } else {
+    return new WebRequest(arg0, arg1);
+  }
+}
+
+util.inherits(WebRequest, WebEntityRequest);
+
+function addTildeHeaders(webRequest, req) {
+  var originalUrl = parseUrl(req.originalUrl);
+  var headers = webRequest.headers;
+  headers.set('~request_line', util.format('%s %s HTTP/%s', req.method, originalUrl.path, req.httpVersion));
+  headers.set('~request_method', req.method);
+  headers.set('~request_uri', originalUrl.path);
+
+  headers.set('~path', originalUrl.pathname);
+  headers.set('~path_translated', webRequest.path);
+  if (originalUrl.query) {
+    headers.set('~query_string', originalUrl.query);
+  }
+}
+
+function normalizeRequestHeaders(webRequest) {
+  // erase the value of the cookie header if present
+  if (webRequest.headers.get('cookie')) {
+    webRequest.headers.set('cookie', '');
+  }
+}
+
+function setBodyOrEntities(webRequest, req) {
+  var boundary = extractBoundaryOfMultipartRequest(webRequest);
+  if (boundary) {
+    try {
+      MultipartParser.parseFromBuffer(req.body, boundary, webRequest, MESSAGE_TYPE.REQUEST);
+      webRequest.body = undefined;
+    } catch (err) {
+      throw new HttpError(400, err.message);
+    }
+  } else {
+    webRequest.setBody(req.body);
+  }
+}
+
+function extractBoundaryOfMultipartRequest(webRequest) {
+  var contentType = webRequest.headers.get('content-type');
+  if (!contentType) {
+    return '';
+  }
+  var isMultipart = contentType.indexOf('multipart') > -1;
+  var isNotFormData = contentType.indexOf('form-data') < 0; // multiparty has alredy handled that
+  if (isMultipart && isNotFormData) {
+    var boundary = contentTypeParser.parse(contentType).parameters.boundary;
+    if (!boundary) {
+      throw new HttpError(400, 'Multipart request error. No boundary parameter found on header Content-Type ("' + contentType + '")');
+    }
+    return boundary;
+  }
+  return '';
+}
+
+function addFormData(webRequest, expressRequest) {
+  var formData = expressRequest['form-data'];
+  if (!formData) {
+    return;
+  }
+  webRequest.body = undefined;
+
+  reuseInputFieldsData(webRequest, formData);
+  reuseFileUploadData(webRequest, formData);
+}
+
+function reuseInputFieldsData(webRequest, formData) {
+  var inputFieldNames = Object.keys(formData.fields);
+
+  inputFieldNames.forEach(function (singleInputFieldName) {
+    var valuesForInputField = formData.fields[singleInputFieldName];
+    valuesForInputField.forEach(function (singleValue) {
+      var headers = { 'content-disposition': 'form-data; name="' + singleInputFieldName + '"' };
+      var parameters = {};
+      parameters[singleInputFieldName] = singleValue;
+      var body = singleValue;
+      webRequest.entities.push(WebEntityRequest.create(headers, parameters, body));
+    });
+  });
+}
+
+function reuseFileUploadData(webRequest, formData) {
+  var uploaderNames = Object.keys(formData.files);
+
+  uploaderNames.forEach(function (singleUploaderName) {
+    var uploadedFiles = formData.files[singleUploaderName];
+    uploadedFiles.forEach(function (singleUploadedFile) {
+      var headers = singleUploadedFile.headers;
+      headers['~content_disposition'] = 'form-data';
+      headers['~content_name'] = singleUploaderName;
+      headers['~content_filename'] = singleUploadedFile.originalFilename;
+      // the last one is extra comparing to the XSEngine headers
+      headers['~content_file_size'] = singleUploadedFile.size;
+
+      var body = readUploadedFile(singleUploadedFile.path);
+      removeFileOnFileSystem(singleUploadedFile.path);
+
+      webRequest.entities.push(WebEntityRequest.create(headers, {}, body));
+    });
+  });
+}
+
+function readUploadedFile(filePath) {
+  return fs.readFileSync(filePath);
+}
+
+function removeFileOnFileSystem(filePath) {
+  fs.unlinkSync(filePath);
+}
+
+function resolveMethod(method) {
+  switch (method) {
+  case 'OPTIONS':
+    return http.OPTIONS;
+  case 'GET':
+    return http.GET;
+  case 'HEAD':
+    return http.HEAD;
+  case 'POST':
+    return http.POST;
+  case 'PUT':
+    return http.PUT;
+  case 'DELETE':
+    return http.DEL;
+  case 'TRACE':
+    return http.TRACE;
+  case 'CONNECT':
+    return http.CONNECT;
+  case 'PATCH':
+    return http.PATCH;
+  default:
+    return http.INVALID;
+  }
+}
+
+function setRequestLanguage(webRequest, locale) {
+  Object.defineProperty(webRequest, 'language', {
+    value: locale.requestLanguage,
+    enumerable: true
+  });
+}
+
+function setPath(webRequest, reqPath) {
+  var pathPattern = /(.+\.xsjs[^\?]*)(\?.+)?/;
+  var result = pathPattern.exec(reqPath);
+  if (result && result.length > 1) {
+    webRequest.path = result[1];
+  } else {
+    webRequest.path = reqPath;
+  }
+}
+
+function setQueryPath(webRequest) {
+  var beginOfQueryPath = webRequest.path.indexOf('.xsjs/');
+  if (beginOfQueryPath > 0) {
+    beginOfQueryPath += '.xsjs/'.length;
+    webRequest.queryPath = webRequest.path.substring(beginOfQueryPath);
+  } else {
+    webRequest.queryPath = '';
+  }
+}

package/lib/xsjs/web/WebResponse.js

@@ -0,0 +1,183 @@
+'use strict';
+
+var _ = require('lodash');
+var util = require('util');
+var status = require('statuses');
+var utils = require('../../utils');
+var CookiesTupelList = require('./TupelLists/CookiesTupelList');
+var bufferUtils = require('../../utils/buffer-utils');
+var contentTypeParser = require('content-type');
+var WebEntityResponse = require('./WebEntityResponse');
+var SetCookieParser = require('./utils/SetCookieParser');
+var MultipartParser = require('./utils/MultipartParser');
+var MultipartResponseBuilder = require('./utils/MultipartResponseBuilder');
+var MESSAGE_TYPE = require('../constants').WEB.MESSAGE_TYPE;
+var logging = require('../../logging');
+var wrapAppError = require('../../utils/errors/wrap-app-error');
+
+module.exports = WebResponse;
+
+function WebResponse(res, followUpContext) {
+  WebEntityResponse.call(this, res);
+
+  if (!res) {
+    this.cookies = new CookiesTupelList();
+    this.status = 200;
+  } else {
+    normalizeResponseHeaders(this);
+    setBodyOrEntities(this, res);
+    this.cookies = new CookiesTupelList();
+    this.cookies._addData(extractCookies(res));
+    this.status = res.statusCode;
+    this.statusMessage = status[res.statusCode];
+    this._httpVersion = 'HTTP/' + res.httpVersion;
+  }
+
+  if (followUpContext) {
+    var loggingContext = followUpContext.loggingContext;
+    this.followUp = async function (followUpObject) {
+      if (typeof followUpObject !== 'object') {
+        throw new Error('[$.web.WebResponse].followUp: expected an object as an argument');
+      }
+
+      var pathToScript = extractPathToScript(followUpObject.uri);
+      var functionName = extractFunctionName(followUpObject.functionName);
+
+      var context = followUpCreateContext(followUpContext);
+      var thisArg = utils.createXsFunctionThisArg(context);
+      var runner = new utils.XsJsFunctionRunner(followUpContext.runtime, pathToScript, context);
+      try {
+        await runner.run(functionName, thisArg, [followUpObject.parameter]);
+      } catch (err){
+        var logger = loggingContext.getLogger(logging.CATEGORY);
+        logger.error(wrapAppError(err), util.format('$.response.followUp - Execution of function "%s" in script "%s" failed', functionName, pathToScript));
+        return;
+      }
+      var tracer = loggingContext.getTracer(__filename);
+      tracer.info('$.response.followUp - Execution of function "%s" in script "%s" finished successfully', functionName, pathToScript);
+    };
+  } else {
+    this.followUp = function () {
+      throw new Error('[$.web.WebResponse].followUp: cannot invoke function on current object');
+    };
+  }
+}
+
+util.inherits(WebResponse, WebEntityResponse);
+
+function normalizeResponseHeaders(webResponse) {
+  // remove the set-cookie header if exists
+  if (webResponse.headers.get('set-cookie')) {
+    webResponse.headers.remove('set-cookie');
+  }
+}
+
+function setBodyOrEntities(webResponse, internalResponse) {
+  var boundary = extractBoundaryOfMultipartResponse(webResponse);
+  if (boundary) {
+    MultipartParser.parseFromBuffer(internalResponse.body, boundary, webResponse, MESSAGE_TYPE.RESPONSE);
+    webResponse.body = undefined;
+  } else {
+    internalResponse.body && webResponse.setBody(internalResponse.body);
+  }
+}
+
+function extractBoundaryOfMultipartResponse(webResponse) {
+  var contentType = webResponse.headers.get('content-type');
+  if (!contentType) {
+    return '';
+  }
+
+  var isMultipart = contentType.indexOf('multipart') > -1;
+  if (isMultipart) {
+    var boundary = contentTypeParser.parse(contentType).parameters.boundary;
+    if (!boundary) {
+      throw new Error('Multipart response error. No boundary parameter found on header Content-Type ("' + contentType + '")');
+    }
+    return boundary;
+  }
+  return '';
+}
+
+function extractCookies(internalResponse) {
+  if (!internalResponse.headers) {
+    return {};
+  }
+  var setCookieHeader = internalResponse.headers['set-cookie'];
+  if (!setCookieHeader) {
+    return {};
+  }
+  return SetCookieParser.parse(setCookieHeader);
+}
+
+function extractPathToScript(uri) {
+  if (typeof uri !== 'string') {
+    throw new Error('[$.web.WebResponse].followUp argument: uri property missing or not a string');
+  }
+  uri = uri.trim();
+  var result = /([^:]+):([^:]+\.xsjs)/.exec(uri);
+  if (!result || result.length !== 3) {
+    throw new Error('[$.web.WebResponse].followUp argument uri property got to be in the format: package:script.xsjs');
+  }
+  var packageName = result[1];
+  var fileName = result[2];
+  return utils.toPath(packageName, fileName);
+}
+
+function extractFunctionName(functionName) {
+  if (functionName === null || functionName === undefined || typeof functionName !== 'string') {
+    throw new Error('[$.web.WebResponse].followUp argument: functionName missing or not a string');
+  }
+  functionName = functionName.trim();
+  if (!functionName) {
+    throw new Error('[$.web.WebResponse].followUp argument: functionName cannot be empty');
+  }
+  return functionName;
+}
+
+function adjustContentType(webResponse) {
+  if (webResponse.headers.get('content-type')) {
+    return;
+  }
+  var body = webResponse.body._content;
+  var bodyIsJson = _.isObject(body) && !bufferUtils.isBinary(body);
+  webResponse.headers.set('content-type', bodyIsJson ? 'application/json' : 'text/html');
+}
+
+WebResponse.prototype._pipe = function(res) {
+  adjustContentType(this);
+  res.status(this.status);
+  this.headers.forEach(function (header) {
+    res.set(header.name, header.value);
+  });
+  this.cookies.forEach(function (cookie) {
+    res.cookie(cookie.name, cookie.value);
+  });
+  if (this.entities.length > 0) {
+    var boundary = MultipartResponseBuilder.generateBoundary();
+    res.set('content-type', 'multipart/mixed; boundary=' + boundary);
+    var body = MultipartResponseBuilder.build(this, boundary);
+    res.send(body);
+  } else {
+    res.send(this.body._retrieveContent());
+  }
+};
+
+Object.defineProperties(WebResponse.prototype, {
+  cacheControl: {
+    set: function (value) {
+      this.headers.set('cache-control', value);
+    },
+    get: function () {
+      return this.headers.get('cache-control');
+    },
+    enumerable: true
+  }
+});
+
+function followUpCreateContext(followUpContext) {
+  // We are using Object.assgin to keep $.trace object
+  // And properties like $.trace, $.response and $.application which are currently (probably incorrectly) available in followUp jobs, for backwards compatibility.
+  var baseContext = followUpContext.runtime.createBaseContext(followUpContext.req, followUpContext.locale, followUpContext.traceOptions);
+  return Object.assign({}, followUpContext.context, baseContext);
+}

package/lib/xsjs/web/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+exports.WebRequest                 = require('./WebRequest');
+exports.WebResponse                = require('./WebResponse');

package/lib/xsjs/web/utils/HeadersParser.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var CRLF = require('../../constants').WEB.MESSAGES.LINE_BREAK;
+
+
+exports.parse = function(headersSection) {
+  var parsedHeaders = {};
+
+  var arrLines = headersSection.split(CRLF);
+  handleHeaderLines(arrLines, parsedHeaders);
+
+  return parsedHeaders;
+};
+
+function handleHeaderLines(arrLines, parsedHeaders) {
+  var singleLine;
+  var isPartOfMultilineHeader;
+
+  for (var i = arrLines.length - 1; i >= 0; i--) {
+    singleLine = arrLines[i];
+    isPartOfMultilineHeader = (singleLine.indexOf(' ') === 0) && (i > 0);
+
+    if (isPartOfMultilineHeader) {
+      singleLine = collapseSpacesAtTheFrontToJustOne(singleLine);
+      var indexOfLineForAddingTheCurrentLineTo = i - 1;
+      arrLines[indexOfLineForAddingTheCurrentLineTo] += singleLine;
+      continue;
+    }
+    parseHeaderString(singleLine, parsedHeaders);
+  }
+}
+
+function collapseSpacesAtTheFrontToJustOne(str) {
+  return str.replace(/[ ]+/, ' ');
+}
+
+function parseHeaderString(str, parsedHeaders) {
+  var result = /([^:]+):(.*)/.exec(str);
+  if (result && result.length === 3) {
+    var name = result[1].trim().toLowerCase();
+    var value = result[2].trim();
+    var existingValue = parsedHeaders[name];
+    if (!existingValue) {
+      parsedHeaders[name] = value;
+    } else if (typeof existingValue === 'string') {
+      parsedHeaders[name] = [existingValue];
+      parsedHeaders[name].unshift(value);
+    } else {
+      // it is an array
+      parsedHeaders[name].unshift(value);
+    }
+  }
+}