@sap/async-xsjs 1.0.2

package/lib/xsjs/security/crypto.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var crypto = require('crypto');
+var buffUtils = require('../../utils/buffer-utils');
+
+function hashInput(data, key, algorithmType) {
+  data = buffUtils.getData(data);
+  var algorithm = key ? crypto.createHmac(algorithmType, key) : crypto.createHash(algorithmType);
+  algorithm.update(data, 'utf8');
+  return buffUtils.toArrayBuffer(algorithm.digest());
+}
+
+exports.md5 = function(data, key) {
+  return hashInput(data, key, 'md5');
+};
+
+exports.sha1 = function(data, key) {
+  return hashInput(data, key, 'sha1');
+};
+
+exports.sha256 = function(data, key) {
+  return hashInput(data, key, 'sha256');
+};

package/lib/xsjs/security/index.js

@@ -0,0 +1,5 @@
+'use strict';
+
+exports.crypto = require('./crypto');
+exports.AntiVirus = require('./AntiVirus');
+exports.x509 = require('./x509');

package/lib/xsjs/security/x509.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var x509 = require('@sap/node-jwt');
+var buffUtils = require('../../utils/buffer-utils');
+
+exports.getIssuer = function(data) {
+  return new x509('').getIssuer(buffUtils.getData(data));
+};
+
+exports.getSubject = function(data) {
+  return new x509('').getSubject(buffUtils.getData(data));
+};

package/lib/xsjs/text/analysis/Session.js

@@ -0,0 +1,128 @@
+'use strict';
+
+var ta = require('@sap/textanalysis');
+var bufferUtils = require('../../../utils/buffer-utils');
+
+module.exports = Session;
+
+function Session($db, params) {
+  this.configuration = params.configuration;
+  this.client = (async () => { await $db.getConnection()._client; })();
+  this.schema = $db._dbReqOptions._globalOptions.schema;
+}
+
+Session.prototype.analyze = async function (params) {
+  return await analyze(this, params);
+};
+
+function analyze(session, params) {
+  var values = normalizeInput(params);
+  values.CONFIGURATION_SCHEMA_NAME = session.schema;
+  values.CONFIGURATION = session.configuration;
+  return new Promise ((resolve, reject) => {
+
+    ta.analyze(values, session.client, function (err, parameters, rows) {
+      if (err) {
+        return reject(err);
+      }
+      var tokens = [], entities = [], metadata = [], grammaticalRoles = [];
+      if (rows) {
+        for (var i = 0; i < rows.length; i++) {
+          var row = rows[i];
+          if (row.RULE === 'Entity Extraction') {
+            var entity = {
+              id: row.COUNTER,
+              text: row.TOKEN,
+              normalizedForm: row.NORMALIZED,
+              labelPath: row.TYPE,
+              offset: row.OFFSET,
+              paragraph: row.PARAGRAPH,
+              sentence: row.SENTENCE,
+              parent: row.PARENT
+            };
+            entities.push(entity);
+          }
+          else if (row.RULE === 'LXP') {
+            var token = {
+              token: row.TOKEN,
+              normalizedToken: row.NORMALIZED,
+              partOfSpeech: row.TYPE,
+              offset: row.OFFSET,
+              paragraph: row.PARAGRAPH,
+              sentence: row.SENTENCE
+              // TODO: stems
+            };
+            tokens.push(token);
+          }
+          else if (row.RULE === 'Grammatical Role') {
+            var grammaticalRoleGovernor = {
+              id: row.PARENT,
+              dependencyType: row.TYPE
+            };
+            var grammaticalRole = {
+              id: row.COUNTER,
+              offset: row.OFFSET,
+              paragraph: row.PARAGRAPH,
+              sentence: row.SENTENCE,
+              text: row.TOKEN,
+              governors: [grammaticalRoleGovernor]
+            };
+            grammaticalRoles.push(grammaticalRole);
+          }
+          else if (row.RULE === 'Metadata') {
+            var meta = {
+              id: row.COUNTER,
+              token: row.TOKEN,
+              tokenType: row.TYPE,
+              offset: row.OFFSET,
+              paragraph: row.PARAGRAPH,
+              parent: row.PARENT
+            };
+            metadata.push(meta);
+          }
+        }
+      }
+      return resolve({
+        language: parameters.LANGUAGE_CODE,
+        mimeType: parameters.MIME_TYPE,
+        textSize: 0, // not returned by TA_ANALYZE
+        plaintext: parameters.PLAINTEXT,
+        tokens: tokens,
+        entities: entities,
+        metadata: metadata,
+        grammaticalRoles: grammaticalRoles
+      });
+    });
+  });
+}
+
+function normalizeInput(params) {
+  var mappings = {
+    'inputDocumentText': 'DOCUMENT_TEXT',
+    'language': 'LANGUAGE_CODE',
+    'mimeType': 'MIME_TYPE',
+    'tokenSeparators': 'TOKEN_SEPARATORS',
+    'languageDetection': 'LANGUAGE_DETECTION'
+  };
+
+  var values = {
+    RETURN_PLAINTEXT: params.includePlainText ? 1 : 0
+  };
+
+  Object.keys(mappings).forEach(function (xscProp) {
+    if (params.hasOwnProperty(xscProp) && params[xscProp] !== undefined) {
+      var prop = mappings[xscProp];
+      values[prop] = params[xscProp];
+    }
+  });
+
+  if (params.inputDocumentBinaryContent) {
+    values.DOCUMENT_BINARY = extractBinary(params.inputDocumentBinaryContent);
+  }
+
+  return values;
+}
+
+function extractBinary(binContent) {
+  return bufferUtils.isBinary(binContent) ? bufferUtils.toBuffer(binContent) : Buffer.from(binContent);
+}

package/lib/xsjs/text/index.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var MiningSession = require('./mining/Session');
+var AnalysisSession = require('./analysis/Session');
+
+exports.create = createTextObject;
+
+
+function createTextObject($db) {
+  return {
+    mining: createMiningObject($db),
+    analysis: createAnalysisObject($db)
+  };
+}
+
+function createMiningObject($db) {
+  return {
+    Session: function (params) {
+      return new MiningSession($db, params);
+    }
+  };
+}
+
+function createAnalysisObject($db) {
+  return {
+    Session: function (params) {
+      return new AnalysisSession($db, params);
+    }
+  };
+}

package/lib/xsjs/text/mining/Session.js

@@ -0,0 +1,82 @@
+'use strict';
+
+var textmining = require('@sap/textmining');
+
+module.exports = Session;
+
+function Session($db, params) {
+  this._tm = new textmining({
+    client: async () => { await determineClient($db, params); },
+    referenceTable: params.referenceTable,
+    referenceColumn: params.referenceColumn
+  });
+}
+
+Session.prototype.categorizeKNN = function (params) {
+  return new Promise ((resolve, reject) => {
+    this._tm.categorizeKNN(params, function(err, result) {
+      if (err) { return reject(err);}
+      resolve(result);
+    });
+  });
+};
+
+Session.prototype.getRelatedDocuments = function (params) {
+  return new Promise ((resolve, reject) => {
+    this._tm.getRelatedDocuments(params, function(err, result) {
+      if (err) { return reject(err);}
+      resolve(result);
+    });
+  });
+};
+
+Session.prototype.getRelatedTerms = function (params) {
+  return new Promise ((resolve, reject) => {
+    this._tm.getRelatedTerms(params, function(err, result) {
+      if (err) { return reject(err);}
+      resolve(result);
+    });
+  });
+};
+
+Session.prototype.getRelevantTerms = function (params) {
+  return new Promise ((resolve, reject) => {
+    this._tm.getRelevantTerms(params, function(err, result) {
+      if (err) { return reject(err);}
+      resolve(result);
+    });
+  });
+};
+
+Session.prototype.getRelevantDocuments = function (params) {
+  return new Promise ((resolve, reject) => {
+    this._tm.getRelevantDocuments(params, function(err, result) {
+      if (err) { return reject(err);}
+      resolve(result);
+    });
+  });
+};
+
+Session.prototype.getSuggestedTerms = function (params) {
+  return new Promise ((resolve, reject) => {
+    this._tm.getSuggestedTerms(params, function(err, result) {
+      if (err) { return reject(err);}
+      resolve(result);
+    });
+  });
+};
+
+Session.prototype.initialize = function (params) {
+  return new Promise ((resolve, reject) => {
+    this._tm.initialize(params, function(err, result) {
+      if (err) { return reject(err);}
+      resolve(result);
+    });
+  });
+};
+
+async function determineClient($db, params) {
+  var conn = params.connection || await $db.getConnection();
+  return conn._client;
+}
+

package/lib/xsjs/trace/trace.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var logging = require('../../logging');
+
+
+exports.createTrace = function (options) {
+  var id = options.id;
+  var location = options.location;
+  var req = options.req;
+
+  var tracer;
+  if (id) {
+    tracer = logging.appContext.createLogContext({ id: id }).getTracer(location);
+  } else if (req && req.loggingContext) {
+    tracer = req.loggingContext.getTracer(location);
+  } else if (location) {
+    tracer = logging.appContext.createLogContext({ id: '' }).getTracer(location);
+  } else {
+    tracer = logging.tracer;
+  }
+  return buildTraceObject(tracer);
+};
+
+function buildTraceObject(tracer) {
+  return {
+    debug: tracer.debug.bind(tracer),
+    info: tracer.info.bind(tracer),
+    warning: tracer.warning.bind(tracer),
+    warn: tracer.warning.bind(tracer),
+    error: tracer.error.bind(tracer),
+    fatal: tracer.fatal.bind(tracer),
+
+    isDebugEnabled: tracer.isEnabled.bind(tracer, 'debug'),
+    isInfoEnabled: tracer.isEnabled.bind(tracer, 'info'),
+    isWarningEnabled: tracer.isEnabled.bind(tracer, 'warning'),
+    isErrorEnabled: tracer.isEnabled.bind(tracer, 'error'),
+    isFatalEnabled: tracer.isEnabled.bind(tracer, 'fatal'),
+
+    _tracer: tracer
+  };
+}

package/lib/xsjs/util/SAXParser.js

@@ -0,0 +1,174 @@
+'use strict';
+
+var _ = require('lodash');
+var sax = require('sax');
+var VError = require('verror');
+
+var buffUtils = require('../../utils/buffer-utils');
+var compressionUtils = require('../../utils/compression-utils');
+var isWebBody = require('../../utils/xs-types').isWebBody;
+
+module.exports = SAXParser;
+
+var UNSUPPORTED_HANDLERS = ['attlistDeclHandler', 'endDoctypeDeclHandler',
+  'endNameSpaceDeclHandler', 'entityDeclHandler', 'externalEntityRefHandler',
+  'notationDeclHandler', 'processingInstructionHandler', 'startDoctypeDeclHandler',
+  'startNameSpaceDeclHandler', 'xmlDeclHandler'];
+
+var UNSUPPORTED_PROPERTIES = ['currentByteIndex', 'currentColumnNumber', 'currentLineNumber'];
+
+function SAXParser() {
+  if (!(this instanceof SAXParser)) {
+    return new SAXParser();
+  }
+  this._parser = getNewParser();
+  this._parseStarted = false;
+
+  setStartCDataSectionHandler.call(this);
+  setEndCDataSectionHandler.call(this);
+  setStartElementHandler.call(this);
+  setEndElementHandler.call(this);
+  setCharacterDataHandler.call(this);
+  setCommentHandler.call(this);
+  setUnsupported.call(this);
+}
+
+SAXParser.prototype.parse = function (xml, encoding) {
+  if (this._parseStarted) {
+    throw new Error('SAXParser.parse already started');
+  }
+  this._parseStarted = true;
+  var parser = this._parser;
+  return new Promise((resolve, reject) => {
+    parser.onend = resolve;
+    parser.onerror = reject;
+    parser.write(getXML(xml, encoding)).close();
+  });
+};
+
+
+SAXParser.prototype.reset = function () {
+  this._parseStarted = false;
+  this._parser = getNewParser();
+};
+
+SAXParser.prototype.resume = function () {
+  throwNotSupported('resume');
+};
+
+SAXParser.prototype.stop = function (isResumable) { // eslint-disable-line no-unused-vars
+  throwNotSupported('stop');
+};
+
+function setUnsupported() {
+  UNSUPPORTED_HANDLERS.forEach(function (property) {
+    Object.defineProperty(this, property, {
+      set: throwNotSupported.bind(null, property)
+    });
+  }, this);
+
+  UNSUPPORTED_PROPERTIES.forEach(function (property) {
+    var notSupported = throwNotSupported.bind(null, property);
+    Object.defineProperty(this, property, {
+      set: notSupported,
+      get: notSupported
+    });
+  }, this);
+}
+
+function resolveEncoding(encoding) {
+  if (!encoding) {
+    return 'utf8';
+  }
+  var bufferEncoding = buffUtils.toBufferEncoding(encoding);
+  if (bufferEncoding) {
+    return bufferEncoding;
+  }
+  throw new VError('Encoding %s not supported', encoding);
+}
+
+function extractXmlContent(arg) {
+  if (!_.isString(arg) && !compressionUtils.isWebBodyOrArrayBuffer(arg)) {
+    throw new Error('xml must be String, ArrayBuffer or WebBody');
+  }
+  return isWebBody(arg) ? arg._retrieveContent() : buffUtils.getData(arg);
+}
+
+function getXML(xml, encoding) {
+  var data = extractXmlContent(xml);
+  if (_.isString(data)) {
+    return data;
+  }
+  var bufferEncoding = resolveEncoding(encoding);
+  return data.toString(bufferEncoding);
+}
+
+function getNewParser() {
+  return sax.parser(true, {
+    xmlns: true,
+    position: true,
+    strictEntities: false
+  });
+}
+
+function setHandler(eventName, handlerName, numberOfArguments) {
+  Object.defineProperty(this, handlerName, {
+    set: function (handler) {
+      checkHandler(handler, handlerName, numberOfArguments);
+      this._parser[eventName] = handler;
+    }
+  });
+}
+
+function setStartCDataSectionHandler() {
+  setHandler.call(this, 'onopencdata', 'startCDataSectionHandler', 0);
+}
+
+function setEndCDataSectionHandler() {
+  setHandler.call(this, 'onclosecdata', 'endCDataSectionHandler', 0);
+}
+
+function setStartElementHandler() {
+  Object.defineProperty(this, 'startElementHandler', {
+    set: function (startElementHandler) {
+      checkHandler(startElementHandler, 'startElementHandler', 2);
+      this._parser.onopentag = function startElementHandlerWrapper(node) {
+        var attributes = node.attributes;
+        attributes = _.omitBy(attributes, function (att) {
+          return att.prefix === 'xmlns';
+        });
+        attributes = _.mapValues(attributes, function (attribute) {
+          return attribute.value;
+        });
+        startElementHandler(node.name, attributes);
+      };
+    }
+  });
+}
+
+function setEndElementHandler() {
+  setHandler.call(this, 'onclosetag', 'endElementHandler', 1);
+}
+
+function setCharacterDataHandler() {
+  setHandler.call(this, 'ontext', 'characterDataHandler', 1);
+}
+
+function setCommentHandler() {
+  setHandler.call(this, 'oncomment', 'commentHandler', 1);
+}
+
+// function parseXml(parser, xml, cb) {
+//   parser.onend = cb;
+//   parser.write(xml).close();
+// }
+
+function throwNotSupported(item) {
+  throw new Error(item + ' not supported');
+}
+
+function checkHandler(handler, handlerName, numberOfArguments) {
+  if (typeof handler !== 'function' || handler.length !== numberOfArguments) {
+    throw new VError('Expected "%s" to be a function with %d arguments', handlerName, numberOfArguments);
+  }
+}