@sap/async-xsjs 1.0.2

package/lib/xsjs/util/Zip.js

@@ -0,0 +1,220 @@
+'use strict';
+
+var _ = require('lodash');
+var zipLib = require('yazl');
+var unzipLib = require('yauzl');
+var VError = require('verror');
+var ctypes = require('../../ctypes');
+var ResultSet = require('../db/dbapi/ResultSet');
+var bufferUtils = require('../../utils/buffer-utils');
+var compressionUtils = require('../../utils/compression-utils');
+
+module.exports = Zip;
+
+function Zip(source, index, settings) {
+  if (!(this instanceof Zip)) { // if the constructor is used without the "new" keyword
+    return new Zip(source, index, settings);
+  }
+
+  if (arguments.length > 3) {
+    throw new VError('Zip.constructor: expects at most 3 arguments, got %d', arguments.length);
+  }
+
+  var argsCount = Array.prototype.slice.call(arguments).reduce(function (prev, current) {
+    return prev + !!current;
+  }, 0);
+
+  if (argsCount && !_.isObject(source)) {
+    throw new Error('Zip.constructor: Expected one of the following as first argument: ArrayBuffer, Body object, ResultSet object or JS object');
+  }
+
+  Object.defineProperty(this, '_metadata_', {
+    enumerable: false,
+    get: async function () {
+      await updateZipContent(this);
+      return await readZip(this, false);
+    }
+  });
+  defineZipProperty(this, '_zipAsBuffer', null);
+  defineZipProperty(this, '_uncompressedSizeRestriction', Infinity);
+
+  switch (argsCount) {
+  case 1: // case: (ArrayBuffer or Body) or Settings object
+    if (compressionUtils.isWebBodyOrArrayBuffer(source)) {
+      this._zipAsBuffer = compressionUtils.extractBuffer(source);
+    } else {
+      this._uncompressedSizeRestriction = extractZipSettingsFromJsObject(source, argsCount);
+    }
+    break;
+  case 2:
+    if (compressionUtils.isWebBodyOrArrayBuffer(source)) { // case: (ArrayBuffer or Body) and Settings object
+      this._zipAsBuffer = compressionUtils.extractBuffer(source);
+      this._uncompressedSizeRestriction = extractZipSettingsFromJsObject(index, argsCount);
+    } else if (source instanceof ResultSet) { // case: ResultSet and index
+      this._zipAsBuffer = extractBufferFromResultSet(source, index);
+    } else {
+      throw new Error('Zip.constructor: Expected ArrayBuffer, Body object, ResultSet object or JS object as first argument');
+    }
+    break;
+  case 3: // case: ResultSet, index and settings
+    if (source instanceof ResultSet) {
+      this._zipAsBuffer = extractBufferFromResultSet(source, index);
+      this._uncompressedSizeRestriction = extractZipSettingsFromJsObject(settings, argsCount);
+    } else {
+      throw new Error('Zip.constructor: Expected ResultSet as first argument and Number as a second argument');
+    }
+    break;
+  }
+
+  var self = this;
+  return new Promise((resolve, reject) => {
+    if (this._zipAsBuffer) {
+      __readZip(this, true, ()=>{resolve(self);}, reject);
+    } else {
+      resolve(self);
+    }
+  });
+}
+
+defineZipProperty(Zip.prototype, 'asArrayBuffer', async function () {
+  await updateZipContent(this);
+  return bufferUtils.toArrayBuffer(this._zipAsBuffer);
+});
+
+function updateZipContent(zipInstance) {
+  var zipFileChunks = [];
+  var zipFileSize = 0;
+
+  return new Promise((resolve, reject) => {
+    var zip = new zipLib.ZipFile();
+    zip.outputStream.on('data', function (data) {
+      zipFileChunks.push(data);
+      zipFileSize += data.length;
+    });
+    zip.outputStream.on('end', function () {
+      zipInstance._zipAsBuffer = bufferUtils.toBuffer(constructFileFromFileChunks(zipFileChunks, zipFileSize));
+      resolve();
+    });
+    zip.outputStream.on('error', reject);
+    for (var entry in zipInstance) {
+      var content = zipInstance[entry];
+      zip.addBuffer(_.isString(content) ? Buffer.from(content, 'utf8') : bufferUtils.toBuffer(content), entry);
+    }
+    zip.end();
+  });
+}
+
+function defineZipProperty(zipInstance, key, value) {
+  Object.defineProperty(zipInstance, key, { value: value, writable: true, enumerable: false });
+}
+
+// loads the entries and the metadata for the zip
+function readZip(zipInstance, checkZipSize) {
+  return new Promise((resolve, reject)=>{
+    __readZip(zipInstance, checkZipSize, resolve, reject);
+  });
+}
+
+// loads the entries and the metadata for the zip
+function __readZip(zipInstance, checkZipSize, resolve, reject) {
+  unzipLib.fromBuffer(zipInstance._zipAsBuffer, { lazyEntries: true }, function (err, zipfile) {
+    if (err) {
+      return reject(err);
+    }
+
+    var currentCompressedSizeInBytes = 0;
+    var currentUncompressedSizeInBytes = 0;
+    zipfile.readEntry();
+
+    zipfile.on('entry', function (entry) {
+      currentCompressedSizeInBytes += entry.compressedSize;
+      currentUncompressedSizeInBytes += entry.uncompressedSize;
+      if (checkZipSize && currentUncompressedSizeInBytes > zipInstance._uncompressedSizeRestriction) { // zip bomb prevention
+        return reject(new VError(
+          'The uncompressed size of the given zip exceeds the maximum allowed size of %d bytes. The zip will not be loaded.',
+          zipInstance._uncompressedSizeRestriction
+        ));
+      }
+
+      var fileChunks = [];
+      var fileSize = 0;
+      zipfile.openReadStream(entry, function (err, readStream) {
+        if (err) {
+          return reject(err);
+        }
+
+        readStream.on('data', function (chunk) {
+          fileChunks.push(chunk);
+          fileSize += chunk.length;
+        });
+
+        readStream.on('end', function () {
+          var fileContent = constructFileFromFileChunks(fileChunks, fileSize);
+          zipInstance[entry.fileName] = fileContent;
+          zipfile.readEntry();
+        });
+      });
+    });
+
+    zipfile.on('error', function (err) {
+      if (err) {
+        return reject(err);
+      }
+    });
+
+    zipfile.once('end', function () {
+      resolve({
+        compressedSizeInBytes: currentCompressedSizeInBytes,
+        uncompressedSizeInBytes: currentUncompressedSizeInBytes
+      });
+    });
+  });
+}
+
+function extractBufferFromResultSet(resultSet, index) {
+  if (!Number.isInteger(index)) {
+    throw new Error('Zip.constructor: second argument expected to be a positive integer');
+  }
+
+  try {
+    var rez = bufferUtils.toBuffer(resultSet.getBlob(index));
+    return rez;
+  } catch (exception) {
+    throw new VError.WError(exception, 'Zip.constructor: Failed to create a zip out of a ResultSet with index %d', index);
+  }
+}
+
+function extractZipSettingsFromJsObject(settings, argumentPosition) {
+  if (!_.isObject(settings)) {
+    throw new VError('Zip.constructor: expected argument %d to be a JS object', argumentPosition);
+  }
+
+  if (settings.hasOwnProperty('password')) {
+    throw new Error('Feature not supported: Creating zip with password encryption');
+  }
+
+  var sizeSetting = getUncompressedSizeRestriction(settings);
+  if (sizeSetting && !_.isNumber(sizeSetting)) {
+    throw new Error('Zip.constructor: value of property maxUncompressedSizeInBytes got to be a safe JS Number or ctypes.Int64.');
+  }
+  return sizeSetting;
+}
+
+function getUncompressedSizeRestriction(settings) {
+  if (settings.maxUncompressedSizeInBytes instanceof ctypes.Int64) {
+    return settings.maxUncompressedSizeInBytes.toJSON();
+  }
+  return settings.maxUncompressedSizeInBytes || Infinity;
+}
+
+function constructFileFromFileChunks(fileChunks, fileSize) {
+  var fileContent = new Uint8Array(fileSize);
+  var offset = 0;
+
+  fileChunks.forEach(function (chunk) {
+    fileContent.set(chunk, offset);
+    offset += chunk.length;
+  });
+
+  return fileContent.buffer;
+}

package/lib/xsjs/util/codec.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var _ = require('lodash');
+var buffUtils = require('../../utils/buffer-utils');
+
+module.exports.decodeBase64 = function decodeBase64(base64Data) {
+  checkIsString(base64Data);
+  return buffUtils.toArrayBuffer(Buffer.from(base64Data, 'base64'));
+};
+
+module.exports.decodeHex = function decodeHex(hexData) {
+  checkIsString(hexData);
+  return buffUtils.toArrayBuffer(Buffer.from(hexData, 'hex'));
+};
+
+module.exports.encodeBase64 = function encodeBase64(data) {
+  return toBuffer(data).toString('base64');
+};
+
+module.exports.encodeHex = function encodeBase64(data) {
+  return toBuffer(data).toString('hex');
+};
+
+function checkIsString(data) {
+  if (!_.isString(data)) {
+    throw new Error('Input parameter must be String');
+  }
+}
+
+function toBuffer(data) {
+  data = buffUtils.getData(data);
+  return _.isString(data) ? Buffer.from(data) : data;
+}

package/lib/xsjs/util/compression.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var _ = require('lodash');
+var zlib = require('zlib');
+var buffUtils = require('../../utils/buffer-utils');
+var compressionUtils = require('../../utils/compression-utils');
+
+module.exports = {
+  gunzip: function (source) {
+    if (!compressionUtils.isWebBodyOrArrayBuffer(source)) {
+      throw new Error('gunzip: expected either ArrayBuffer or Request/Response Body argument.');
+    }
+    var buffer = compressionUtils.extractBuffer(source);
+    return buffUtils.toArrayBuffer(zlib.gunzipSync(buffer));
+  },
+
+  gzip: function (source) {
+    if (!_.isString(source) && !compressionUtils.isWebBodyOrArrayBuffer(source)) {
+      throw new Error('gzip: expected either string, ArrayBuffer or Request/Response Body argument.');
+    }
+    var content = _.isString(source) ? source : compressionUtils.extractBuffer(source);
+    return buffUtils.toArrayBuffer(zlib.gzipSync(content));
+  }
+};

package/lib/xsjs/util/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var crypto = require('crypto');
+var isArrayBuffer = require('../../utils/buffer-utils').isArrayBuffer;
+var SAXParser = require('./SAXParser');
+
+module.exports.Zip = require('./Zip');
+module.exports.codec = require('./codec');
+module.exports.compression = require('./compression');
+
+module.exports.stringify = function stringify(buf) {
+  if (!isArrayBuffer(buf)) {
+    throw new Error('Input parameter must be ArrayBuffer');
+  }
+  return String.fromCharCode.apply(null, new Uint8Array(buf)); // eslint-disable-line no-undef
+};
+
+module.exports.createUuid = function createUuid() {
+  return crypto.randomBytes(16).toString('hex').toUpperCase();
+};
+
+module.exports.SAXParser = SAXParser;

package/lib/xsjs/web/BasicWebEntity.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var assert = require('assert');
+var EntityList = require('./EntityList');
+var HeadersTupelList = require('./TupelLists/HeadersTupelList');
+var ResultSet = require('../db/dbapi/ResultSet');
+
+module.exports = BasicWebEntity;
+
+function BasicWebEntity(arg) {
+  this.headers = new HeadersTupelList();
+  this.entities = new EntityList();
+  this.setBody('');
+
+  if (arg) {
+    this.headers._addData(arg.headers);
+  }
+}
+
+BasicWebEntity.prototype.setBody = async function(bodyContent, indexOpt) {
+  if (indexOpt !== null && indexOpt !== undefined) {
+    assert(bodyContent.constructor === ResultSet, 'First argument should be a $.db.ResultSet');
+    assert(indexOpt > 0, 'Second argument should be greater than 0');
+  }
+  var WebBody = require('./WebBody');
+  var isZip = require('../../utils/xs-types').isZip;
+  bodyContent = isZip(bodyContent) ? await bodyContent.asArrayBuffer() : bodyContent;
+  this.body = new WebBody(this, bodyContent, indexOpt);
+};
+
+Object.defineProperties(BasicWebEntity.prototype, {
+  contentType: {
+    set: function(type) {
+      this.headers.set('content-type', type);
+    },
+    get: function() {
+      return this.headers.get('content-type');
+    },
+    enumerable: true
+  }
+});

package/lib/xsjs/web/EntityList.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var util = require('util');
+
+module.exports = EntityList;
+
+function EntityList() {
+  Array.call(this);
+}
+
+util.inherits(EntityList, Array);

package/lib/xsjs/web/TupelLists/CookiesTupelList.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var util = require('util');
+var assert = require('assert');
+var TupelListBase = require('./TupelListBase');
+
+module.exports = CookiesTupelList;
+
+function CookiesTupelList() {
+  TupelListBase.call(this, { lowerCaseNames: false });
+}
+
+util.inherits(CookiesTupelList, TupelListBase);
+
+CookiesTupelList.prototype.set = function (name, value) {
+  assert(typeof name === 'string', 'Expected string as first argument');
+  assert(typeof value === 'string', 'Expected string as second argument');
+
+  this.push({ name: name, value: value });
+  return true;
+};
+
+CookiesTupelList.prototype.get = function (name) {
+  assert(typeof name === 'string', 'Expected string as argument');
+  var nameLowerCase = name.toLowerCase();
+
+  for (var i = 0; i < this.length; i++) {
+    if (this[i].name.toLowerCase() === nameLowerCase) {
+      return this[i].value;
+    }
+  }
+  return undefined;
+};
+
+CookiesTupelList.prototype.remove = function (name) {
+  assert(typeof name === 'string', 'Expected string as argument');
+
+  var idxCurrentTupel = 0;
+  while (idxCurrentTupel < this.length) {
+    if (this[idxCurrentTupel].name === name) {
+      this.splice(idxCurrentTupel, 1);
+      return;
+    } else {
+      ++idxCurrentTupel;
+    }
+  }
+};

package/lib/xsjs/web/TupelLists/HeadersTupelList.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var util = require('util');
+var assert = require('assert');
+var TupelListBase = require('./TupelListBase');
+
+
+module.exports = HeadersTupelList;
+
+function HeadersTupelList() {
+  TupelListBase.call(this, { lowerCaseNames: true });
+}
+
+util.inherits(HeadersTupelList, TupelListBase);
+
+HeadersTupelList.prototype.set = function (name, value) {
+  assert(typeof name === 'string', 'Expected string as first argument');
+  assert(typeof value === 'string', 'Expected string as second argument');
+
+  this.remove(name);
+  this.push({ name: name.toLowerCase(), value: value });
+  return true;
+};
+
+HeadersTupelList.prototype.get = function (name) {
+  assert(typeof name === 'string', 'Expected string as argument');
+  name = name.toLowerCase();
+
+  var filtered = this.filter(function (tupel) {
+    return tupel.name === name;
+  }).map(function (tupel) {
+    return tupel.value;
+  });
+  if (filtered.length > 1) {
+    return filtered;
+  }
+  if (filtered.length === 1) {
+    return filtered[0];
+  }
+  return undefined;
+};
+
+HeadersTupelList.prototype.remove = function (name) {
+  assert(typeof name === 'string', 'Expected string as argument');
+  name = name.toLowerCase();
+
+  var currentPairIndex = 0;
+  while (currentPairIndex < this.length) {
+    if (this[currentPairIndex].name === name) {
+      this.splice(currentPairIndex, 1);
+    } else {
+      ++currentPairIndex;
+    }
+  }
+};

package/lib/xsjs/web/TupelLists/ParametersTupelList.js

@@ -0,0 +1,83 @@
+'use strict';
+
+var util = require('util');
+var assert = require('assert');
+var TupelListBase = require('./TupelListBase');
+
+module.exports = ParametersTupelList;
+
+function ParametersTupelList() {
+  TupelListBase.call(this, { lowerCaseNames: false });
+}
+
+util.inherits(ParametersTupelList, TupelListBase);
+
+ParametersTupelList.prototype.set = function (name, value) {
+  assert(typeof name === 'string', 'Expected string as first argument');
+  assert(typeof value === 'string', 'Expected string as second argument');
+
+  caseSensitiveRemove(this, name);
+  this.push({ name: name, value: value });
+  return true;
+};
+
+ParametersTupelList.prototype.get = function (name) {
+  assert(typeof name === 'string', 'Expected string as argument');
+  var nameLowerCase = name.toLowerCase();
+  var searchFor;
+
+  var filtered = [];
+  for (var i = 0; i < this.length; i++) {
+    var tupel = this[i];
+    if (!searchFor && (tupel.name.toLowerCase() === nameLowerCase)) {
+      searchFor = tupel.name;
+    }
+    if (searchFor && tupel.name === searchFor) {
+      filtered.push(tupel.value);
+    }
+  }
+
+  if (filtered.length > 1) {
+    return filtered;
+  }
+  if (filtered.length === 1) {
+    return filtered[0];
+  }
+  return undefined;
+};
+
+ParametersTupelList.prototype.remove = function (name) {
+  assert(typeof name === 'string', 'Expected string as argument');
+  caseInsensitiveRemove(this, name);
+};
+
+function caseSensitiveRemove(tupelList, name) {
+  var idxCurrentTupel = 0;
+  while (idxCurrentTupel < tupelList.length) {
+    if (tupelList[idxCurrentTupel].name === name) {
+      tupelList.splice(idxCurrentTupel, 1);
+      return;
+    } else {
+      ++idxCurrentTupel;
+    }
+  }
+}
+
+function caseInsensitiveRemove(tupelList, name) {
+  var nameLowerCase = name.toLowerCase();
+  var searchFor;
+
+  var idxCurrentTupel = 0;
+  while (idxCurrentTupel < tupelList.length) {
+    var tupel = tupelList[idxCurrentTupel];
+    if (!searchFor && (tupel.name.toLowerCase() === nameLowerCase)) {
+      searchFor = tupel.name;
+    }
+    if (searchFor && tupel.name === searchFor) {
+      tupelList.splice(idxCurrentTupel, 1);
+      return;
+    } else {
+      ++idxCurrentTupel;
+    }
+  }
+}

package/lib/xsjs/web/TupelLists/TupelListBase.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var util = require('util');
+
+module.exports = TupelListBase;
+
+function TupelListBase(options) {
+  Array.call(this);
+  Object.defineProperties(this, {
+    lowerCaseNames: {
+      value: options.lowerCaseNames
+    }
+  });
+}
+
+util.inherits(TupelListBase, Array);
+
+
+TupelListBase.prototype._addData = function (data) {
+  if (typeof data !== 'object') {
+    return;
+  }
+  Object.keys(data).forEach(function (property) {
+    var value = data[property];
+    var name = (this.lowerCaseNames) ? property.toLowerCase() : property;
+
+    if (!Array.isArray(value)) {
+      addTupelPair(this, name, value);
+    } else {
+      value.forEach(function (arrayElement) {
+        addTupelPair(this, name, arrayElement);
+      }, this);
+    }
+  }, this);
+};
+
+function addTupelPair(tupelList, name, value) {
+  if (typeof value === 'string') {
+    tupelList.push({ name: name, value: value });
+  } else if (typeof value === 'number') {
+    tupelList.push({ name: name, value: '' + value });
+  } else {
+    throw new Error('Could not handle TupelList value: ' + JSON.stringify(value));
+  }
+}