@sap/async-xsjs 1.0.2

package/lib/sandbox.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var _ = require('lodash');
+var vm = require('vm');
+var ctypes = require('./ctypes');
+
+module.exports.create = create;
+
+function create(xsruntime, additionalContext) {
+  var sandbox = vm.createContext(_.extend(
+    {
+      $          : xsruntime,
+      ctypes     : ctypes,
+      console    : console,
+      xsruntime  : xsruntime,
+      Uint8Array : Uint8Array // eslint-disable-line no-undef
+    }, additionalContext));
+  vm.runInContext('\
+      if (!Number.isInteger) { Number.isInteger = function(i) { return typeof i === "number"; } };\
+      String.prototype.contains   = function(str) {return this.indexOf(str) >=  0;};\
+      String.prototype.startsWith = function(str) {return this.indexOf(str) === 0;};\
+      String.prototype.endsWith   = function(str) {\
+                                                    var l = this.lastIndexOf(str);\
+                                                    return l === -1 ?  false : l + str.length === this.length;\
+                                                  };\
+      [\'Array\',\'String\'].forEach(function(fn) {\
+        var obj = eval(fn);\
+        Object.getOwnPropertyNames(obj.prototype).filter(function(p) {\
+                return typeof obj.prototype[p] === \'function\'}).forEach(function(o)\
+                  {\
+                    obj[o] = function()\
+                    {\
+                      var args = Array.prototype.slice.call(arguments);\
+                      var f = args.shift();\
+                      return obj.prototype[o].apply(f, args);\
+                    }\
+                  });\
+      });', sandbox);
+  return sandbox;
+}

package/lib/utils/XsJsFunctionRunner.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var assert = require('assert');
+var util = require('util');
+var runXsFunction = require('./xs-function-runner').runXsFunction;
+
+module.exports = XsJsFunctionRunner;
+
+
+/**
+ * Constructs an objects that can execute functions from given xsjs script.
+ *
+ * @param {Runtime} xsjs runtime, see lib/runtime.js
+ * @param {string} pathToScript path to xsjs script, e.g. /foo/bar.xsjs
+ * @param {object} context execution context defining global variables
+ */
+function XsJsFunctionRunner(runtime, pathToScript, context) {
+  assert(runtime && typeof runtime === 'object', 'Valid runtime should be provided');
+  assert(typeof pathToScript === 'string', 'Valid path to script should be provided');
+  assert(context && typeof context === 'object', 'Valid context should be provided');
+
+  validateScript(runtime, pathToScript);
+
+  this._scriptRunner = createScriptRunner(runtime, pathToScript, context);
+}
+
+/**
+ * Executes function from the script provided in constructor. Uses {xs-function-runner#runXsFunction}, see this
+ * function for more details on how it works.
+ *
+ * @param functionName
+ * @param thisArg
+ * @param argsArray
+ * @param cb
+ */
+XsJsFunctionRunner.prototype.run = async function(functionName, thisArg, argsArray) {
+  return await runXsFunction(this._scriptRunner, functionName, thisArg, argsArray);
+};
+
+function validateScript(runtime, pathToScript) {
+  var script = runtime.getXsjsModule(pathToScript);
+  if (!script) {
+    throw new Error(util.format('Script "%s" not found', pathToScript));
+  }
+}
+
+function createScriptRunner(runtime, pathToScript, context) {
+  return {
+    runtime: runtime,
+    context: context,
+    pathToScript: pathToScript,
+    runScript: async function() {
+      var module = await runtime.runXsjs(pathToScript, context);
+      return module.namespace.default;
+    }
+  };
+}

package/lib/utils/XsJsLibFunctionRunner.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var assert = require('assert');
+var util = require('util');
+var runXsFunction = require('./xs-function-runner').runXsFunction;
+
+module.exports = XsJsLibFunctionRunner;
+
+/**
+ * Constructs an object that can execute functions from given xsjslib script.
+ *
+ * @param {Runtime} xsjs runtime, see lib/runtime.js
+ * @param {string} libId library ID according to XS1 rules, example:
+ *    'foo.bar.mylib' corresponding to /foo/bar/mylib.xsjslib
+ * @param {object} context execution context defining global variables, if not provided, a default one is created
+ */
+function XsJsLibFunctionRunner(runtime, libId, context) {
+  assert(runtime && typeof runtime === 'object', 'Valid runtime should be provided');
+  assert(typeof libId === 'string', 'Valid path to script should be provided');
+  assert(context && typeof context === 'object', 'Valid context should be provided');
+
+  validateLibrary(runtime, libId);
+
+  this._scriptRunner = createScriptRunner(runtime, libId, context);
+}
+
+/**
+ * Executes function from the script provided in constructor. Uses {xs-function-runner#runXsFunction}, see this
+ * function for more details on how it works.
+ *
+ * @param functionName
+ * @param thisArg
+ * @param argsArray
+ * @param cb
+ */
+XsJsLibFunctionRunner.prototype.run = async function(functionName, thisArg, argsArray) {
+  return await runXsFunction(this._scriptRunner, functionName, thisArg, argsArray);
+};
+
+function validateLibrary(runtime, libId) {
+  var module = runtime.getLibraryModule(libId);
+  if (!module) {
+    throw new Error(util.format('Xsjs library with id "%s" not found', libId));
+  }
+}
+
+function createScriptRunner(runtime, libId, context) {
+  return {
+    runtime: runtime,
+    context: context,
+    pathToScript: libId,
+    runScript: async function() {
+      var module = await runtime.runXsjslib(libId, context);
+      return module.namespace.default;
+    }
+  };
+}

package/lib/utils/buffer-utils.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var _ = require('lodash');
+var hexRegex = /^(?:[0-9a-fA-F]{2})*$/;
+
+module.exports = {
+
+  isArrayBuffer: function (arg) {
+    return Object.prototype.toString.call(arg) === '[object ArrayBuffer]';
+  },
+
+  isBuffer: function (arg) {
+    return Buffer.isBuffer(arg);
+  },
+
+  isBinary: function (arg) {
+    return module.exports.isBuffer(arg) || module.exports.isArrayBuffer(arg);
+  },
+
+  toArrayBuffer: function (data) {
+    if (module.exports.isArrayBuffer(data)) {
+      return data;
+    }
+
+    var ab = new ArrayBuffer(data.length); // eslint-disable-line no-undef
+    var view = new Uint8Array(ab); // eslint-disable-line no-undef
+    for (var i = 0; i < data.length; ++i) {
+      view[i] = data[i];
+    }
+    return ab;
+  },
+
+  hexStringToBuffer: function (data) {
+    if (!hexRegex.test(data)) {
+      throw new TypeError('Invalid hex string: ' + data);
+    }
+
+    return Buffer.from(data, 'hex');
+  },
+
+  toBuffer: function (data) {
+    if (module.exports.isBuffer(data)) {
+      return data;
+    }
+
+    if (_.isString(data)) {
+      return Buffer.from(data);
+    }
+
+    var array = new Uint8Array(data); // eslint-disable-line no-undef
+    return Buffer.from(array);
+  },
+
+  bodyToBuffer: function (webBody) {
+    var rawContent = webBody._retrieveContent();
+    return _.isString(rawContent) ? Buffer.from(rawContent, 'utf8') : rawContent;
+  },
+
+  toBufferEncoding: function (encoding) {
+    encoding = encoding.toLowerCase();
+    switch (encoding) {
+    case 'utf-8': return 'utf8';
+    case 'utf-16': return 'utf16le';
+    case 'us-ascii': return 'ascii';
+    default: return Buffer.isEncoding(encoding) ? encoding : null;
+    }
+  },
+
+  getData: function (data) {
+    if (!_.isString(data) && !module.exports.isArrayBuffer(data)) {
+      throw new Error('First argument must be string or ArrayBuffer.');
+    }
+
+    return module.exports.isArrayBuffer(data) ? module.exports.toBuffer(data) : data;
+  }
+
+};

package/lib/utils/compression-utils.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var WebBody = require('../xsjs/web/WebBody');
+var buffUtils = require('./buffer-utils');
+
+module.exports = {
+  isWebBodyOrArrayBuffer: function(parameter) {
+    return parameter instanceof WebBody || buffUtils.isArrayBuffer(parameter);
+  },
+
+  extractBuffer: function (source) {
+    return (source instanceof WebBody) ? buffUtils.bodyToBuffer(source) : buffUtils.toBuffer(source);
+  }
+};

package/lib/utils/date-utils.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const FRACTIONAL_SECONDS_DIGITS = {
+  JS_DATE: 3,
+  STRING: 7
+};
+
+module.exports = {
+  dateToJsDate: dateToJsDate,
+  timeToJsDate: timeToJsDate,
+  dateTimeToJsDate: dateTimeToJsDate,
+  normalizeDateTimeString: normalizeDateTimeString
+};
+
+function dateToJsDate(date, treatAsUTC) {
+  return createDateObject({
+    year: date.substring(0, 4),
+    month: parseInt(date.substring(5, 7)) - 1,
+    day: date.substring(8),
+    hour: 0,
+    minute: 0,
+    second: 0,
+    millis: 0
+  }, treatAsUTC);
+}
+
+function timeToJsDate(time, treatAsUTC) {
+  return createDateObject({
+    year: 0,
+    month: 0,
+    day: 0,
+    hour: time.substring(0, 2),
+    minute: time.substring(3, 5),
+    second: time.substring(6),
+    millis: 0
+  }, treatAsUTC);
+}
+
+function dateTimeToJsDate(dateTime, treatAsUTC) {
+  var targetLength = FRACTIONAL_SECONDS_DIGITS.JS_DATE;
+  var millis = dateTime.substring(20);
+  if (millis.length < targetLength) {
+    millis += '0'.repeat(targetLength - millis.length);
+  } else if (millis.length > targetLength) {
+    millis = millis.substring(0, targetLength);
+  }
+
+  return createDateObject({
+    year: dateTime.substring(0, 4),
+    month: parseInt(dateTime.substring(5, 7)) - 1,
+    day: dateTime.substring(8, 10),
+    hour: dateTime.substring(11, 13),
+    minute: dateTime.substring(14, 16),
+    second: dateTime.substring(17, 19),
+    millis: millis
+  }, treatAsUTC);
+}
+
+function createDateObject(values, treatAsUTC) {
+  var date;
+  if (treatAsUTC) {
+    date = new Date(Date.UTC(values.year,
+      values.month,
+      values.day,
+      values.hour,
+      values.minute,
+      values.second,
+      values.millis));
+  } else {
+    date = new Date(values.year,
+      values.month,
+      values.day,
+      values.hour,
+      values.minute,
+      values.second,
+      values.millis);
+  }
+
+  // Workaround: two-digit years map to 1900-1999 which is not desired
+  if (values.year >= 0 && values.year < 100) {
+    if (treatAsUTC) {
+      date.setUTCFullYear(values.year);
+    } else {
+      date.setFullYear(values.year);
+    }
+  }
+
+  return date;
+}
+
+function normalizeDateTimeString(dateTime) {
+  var parts = dateTime.split('.');
+  if (parts.length === 1) {
+    return dateTime;
+  }
+
+  var fractionalSeconds = parts[1];
+  var targetLength = FRACTIONAL_SECONDS_DIGITS.STRING;
+  if (fractionalSeconds.length <= targetLength) {
+    return dateTime;
+  }
+
+  return parts[0] + '.' + parts[1].substring(0, targetLength);
+}

package/lib/utils/errors/HttpError.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var util = require('util');
+var http = require('http');
+
+module.exports = HttpError;
+
+function HttpError(status, msg) {
+  if (typeof status === 'string' && !msg) {
+    msg = status;
+    status = undefined;
+  }
+  this.status = status || 500;
+  this.message = msg || http.STATUS_CODES[this.status] || (this.status + '');
+  Error.captureStackTrace(this, HttpError);
+}
+
+util.inherits(HttpError, Error);
+
+HttpError.prototype.name = 'HttpError';

package/lib/utils/errors/wrap-app-error.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var _ = require('lodash');
+
+module.exports = function wrapAppError(err) {
+  if (_.isError(err)) {
+    return err;
+  }
+  if (err && err.message && err.code) {
+    // error objects coming from @sap/hana-client
+    // are not instances of Error
+    var e = new Error(err.message);
+    e.code = err.code;
+    e.sqlState = err.sqlState;
+    return e;
+  }
+  return new Error(err);
+};

package/lib/utils/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var xspath = require('./xspath');
+exports.toResourceId = xspath.toResourceId;
+exports.toPath = xspath.toPath;
+exports.toXSObjectId = xspath.toXSObjectId;
+
+var callstack = require('./xsstack');
+exports.getCallingXsjs = callstack.getCallingXsjs;
+exports.getCallingXsjsRelativePath = callstack.getCallingXsjsRelativePath;
+
+var xsjsrunner = require('./xs-function-runner');
+exports.runXsFunction = xsjsrunner.runXsFunction;
+exports.createXsFunctionThisArg = xsjsrunner.createXsFunctionThisArg;
+
+exports.XsJsFunctionRunner = require('./XsJsFunctionRunner');
+exports.XsJsLibFunctionRunner = require('./XsJsLibFunctionRunner');

package/lib/utils/xs-function-runner.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var assert = require('assert');
+var util = require('util');
+
+exports.runXsFunction = runXsFunction;
+exports.createXsFunctionThisArg = createXsFunctionThisArg;
+
+/**
+ * Executes the given function from the xsjs script provided in the constructor.
+ *
+ * Note that although xsjs code is executed in a fiber, this function will run it asynchronously,
+ * i.e. it will return when xsjs code executes the first async/blocking operation.
+ *
+ * @param {scriptRunner} object of type <code>{ runtime: {}, context: {}, pathToScript: '', runScript: function() {} }</code>.
+ * Will be used to get the executed script where function with name 'functionName'
+ * should exist and will be executed.
+ * @param {string} functionName name of the function to execute
+ * @param {object} thisArg the value of `this` provided to the function, can be null or undefined
+ * @param {array} argsArray function arguments, can be null or undefined
+ */
+async function runXsFunction(scriptRunner, functionName, thisArg, argsArray) {
+  assert(typeof scriptRunner === 'object', 'Valid script runner should to be provided');
+  assert(functionName && typeof functionName === 'string', 'Invalid function name');
+  assert(!argsArray || Array.isArray(argsArray), 'Pass function arguments as an array');
+  var rt = scriptRunner.runtime;
+  var context = scriptRunner.context;
+
+  var module = null;
+  try {
+    module = await scriptRunner.runScript();
+    var jsFunction = module[functionName];
+    if (!jsFunction) {
+      throw new Error(util.format('Function "%s" not found in script "%s"', functionName, scriptRunner.pathToScript));
+    }
+    if (typeof jsFunction !== 'function') {
+      throw new Error(util.format('"%s" is not a function', functionName));
+    }
+    return jsFunction.apply(thisArg, argsArray);
+  } finally {
+    rt.cleanupContext(context);
+    rt.triggerGc();
+  }
+}
+
+function createXsFunctionThisArg(context) {
+  return {
+    $: context,
+    xsengine: context
+  };
+}

package/lib/utils/xs-types.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var Zip = require('../xsjs/util/Zip');
+var WebBody = require('../xsjs/web/WebBody');
+var BasicWebEntity = require('../xsjs/web/BasicWebEntity');
+
+module.exports.isWebBody = isWebBody;
+module.exports.isZip = isZip;
+module.exports.isBasicWebEntity = isBasicWebEntity;
+
+function isWebBody(obj) {
+  return obj instanceof WebBody;
+}
+
+function isZip(obj) {
+  return obj instanceof Zip;
+}
+
+function isBasicWebEntity(obj) {
+  return obj instanceof BasicWebEntity;
+}

package/lib/utils/xspath.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var util = require('util');
+
+exports.toResourceId = function (pathname) {
+  var pos = pathname.lastIndexOf('.');
+  if (pos < 0) {
+    throw new Error('File without extension: ' + pathname);
+  }
+  return pathname.substring(1, pos).replace(/\/|\\/g, '.');
+};
+
+
+exports.toPath = function (packagename, filename) {
+  var normalizedPackage = packagename ? ('/' + packagename.replace(/\./g, '/')) : '';
+  return util.format('%s/%s', normalizedPackage,  filename || '');
+};
+
+exports.toXSObjectId = function (packagename, objectname) {
+  if (typeof packagename !== 'string') {
+    throw new TypeError('Packagename should be a string and is required to build XS object ID');
+  }
+
+  if (objectname && (typeof objectname !== 'string')) {
+    throw new TypeError('Object name provided to build XS object ID is not a string');
+  }
+
+  var packName = packagename.trim();
+  var objName = (objectname) ? objectname.trim() : '';
+
+  if (packName && objName) {
+    return packName + '.' + objName;
+  }
+
+  return packName;
+};

package/lib/utils/xsstack.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var callsite = require('callsite');
+var path = require('path');
+
+exports.getCallingXsjs = function () {
+  var stack = callsite();
+  var frame;
+  while ((frame = stack.shift())) {
+    var file = frame.getFileName();
+    var ext = path.extname(file);
+    if (ext === '.xsjs' || ext === '.xsjslib') {
+      return file;
+    }
+  }
+};
+
+exports.getCallingXsjsRelativePath = function (rootDirs) {
+  var file = this.getCallingXsjs();
+  var callingXsjs;
+  rootDirs.forEach(function (dir) {
+    var isCurrentWorkingDir = path.relative(dir, file).indexOf('..') === -1;
+    if (isCurrentWorkingDir) {
+      callingXsjs = path.relative(dir, file);
+    }
+  });
+  return callingXsjs;
+};

package/lib/views/error.html

@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title><%= title %></title>
+    <style type="text/css">
+      body {
+        padding: 20px 50px;
+        font: 14px "Lucida Grande", Helvetica, Arial, sans-serif;
+        color: #333;
+      }
+      pre {
+        padding: 10px;
+        background-color: #f9f9f9;
+        -webkit-border-radius: 5px;
+        -moz-border-radius: 5px;
+        border-radius: 5px;
+        border: 1px solid #eee;
+      }
+    </style>
+  </head>
+  <body>
+    <h1><%= title %></h1>
+    <%= stacktrace %>
+  </body>
+</html>

package/lib/xsjs/Application.js

@@ -0,0 +1,28 @@
+'use strict';
+
+module.exports = Application;
+
+function Application(locale, webResponse) {
+  Object.defineProperties(this, {
+    _langValue: {
+      value: locale.applicationLanguage,
+      writable: true
+    },
+    _webResponse: {
+      value: webResponse
+    }
+  });
+}
+
+Object.defineProperties(Application.prototype, {
+  language: {
+    set: function (value) {
+      this._langValue = value;
+      this._webResponse.cookies.set('xsAppLanguage', value);
+    },
+    get: function () {
+      return this._langValue;
+    },
+    enumerable: true
+  }
+});

package/lib/xsjs/Locale.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var acceptLanguage = require('accept-language');
+
+module.exports = Locale;
+
+function Locale(req) {
+  this.applicationLanguage = resolveApplicationLanguage(req);
+  this.sessionLanguage = resolveSessionLanguage(req);
+  this.requestLanguage = resolveRequestLanguage(req, this);
+  if (!this.sessionLanguage) {
+    this.sessionLanguage = this.requestLanguage;
+  }
+  this.dbLocale = this.requestLanguage.replace(/-/g, '_');
+}
+
+function resolveApplicationLanguage(req) {
+  var appLanguage = req.cookies['xsAppLanguage'];
+  return appLanguage ? appLanguage : '';
+}
+
+function resolveSessionLanguage(req) {
+  // Note: In the XS Classic the $.session.language is taken from the "xsSessionLanguage" cookie.
+  // If not present, it fallbacks to the locale of the HANA user
+  // (which is not applicable in XS Advanced since we work with a single technical user for HANA db connections).
+
+  return req.cookies['xsSessionLanguage'] || '';
+}
+
+function resolveRequestLanguage(req, locale) {
+  var sapLang = req.headers['x-sap-request-language'];
+  if (sapLang) {
+    return sapLang;
+  }
+
+  // Note: Changing the value of $.application.language does not affect the value of $.request.language.
+  // Thus, the value that takes part in the fallback logic is not the value of $.request.language (in the JS layer),
+  // but the value of the corresponding incoming cookie ("xsAppLanguage").
+  if (locale.applicationLanguage) {
+    return locale.applicationLanguage;
+  }
+
+  if (locale.sessionLanguage) {
+    return locale.sessionLanguage;
+  }
+
+  var languagesByPreference = acceptLanguage.parse(req.headers['accept-language']);
+  if (Array.isArray(languagesByPreference) && languagesByPreference.length) {
+    return languagesByPreference[0].value;
+  }
+
+  return '';
+}