@sap/async-xsjs 1.0.2

package/lib/xsjs/Session.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var util = require('util');
+
+module.exports = Session;
+
+function Session(req, locale) {
+  this.user = req.user && req.user.id;
+  var language = locale && locale.sessionLanguage || '';
+  Object.defineProperty(this, 'language', {
+    value: language,
+    enumerable: true
+  });
+  this.securityContext = req.authInfo;
+}
+
+Session.prototype.getUsername = function () {
+  return this.user && this.user.toUpperCase();
+};
+
+Session.prototype.assertAppPrivilege = function (privilegeName) {
+  if (!this.hasAppPrivilege(privilegeName)) {
+    var err = new Error(util.format('User %s has no %s privilege.', this.user, privilegeName));
+    err.privilege = privilegeName;
+    throw err;
+  }
+};
+
+Session.prototype.hasAppPrivilege = function (privilegeName) {
+  return !!this.securityContext && this.securityContext.checkLocalScope(privilegeName);
+};

package/lib/xsjs/constants.js

@@ -0,0 +1,71 @@
+'use strict';
+
+exports.httpStatusCodes = {
+  CONTINUE: 100,
+  SWITCH_PROTOCOL: 101,
+
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NON_AUTHORITATIVE: 203,
+  NO_CONTENT: 204,
+  RESET_CONTENT: 205,
+  PARTIAL_CONTENT: 206,
+
+  MULTIPLE_CHOICES: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  USE_PROXY: 305,
+  TEMPORARY_REDIRECT: 307,
+
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTH_REQUIRED: 407,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  LENGTH_REQUIRED: 411,
+  PRECONDITION_FAILED: 412,
+  REQUEST_ENTITY_TOO_LARGE: 413,
+  REQUEST_URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  REQUESTED_RANGE_NOT_SATISFIABLE: 416,
+  EXPECTATION_FAILED: 417,
+
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_YET_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  HTTP_VERSION_NOT_SUPPORTED: 505
+};
+
+exports.webTypes = {
+  INVALID: -1,
+  OPTIONS: 0,
+  GET: 1,
+  HEAD: 2,
+  POST: 3,
+  PUT: 4,
+  DEL: 5,
+  TRACE: 6,
+  CONNECT: 7,
+  PATCH: 8
+};
+
+exports.WEB = {
+  MESSAGES : {
+    LINE_BREAK : '\r\n'
+  },
+  MESSAGE_TYPE : {
+    REQUEST : 'request',
+    RESPONSE : 'response'
+  }
+};

package/lib/xsjs/db/common/DbBase.js

@@ -0,0 +1,85 @@
+'use strict';
+
+var _ = require('lodash');
+var connection = require('./connection');
+var enums = require('./enums');
+
+module.exports = DbBase;
+
+function DbBase(dbReqOptions) {
+  this._dbReqOptions = dbReqOptions;
+  this._openConnections = new Set();
+}
+
+DbBase.prototype.isolation = enums.isolationLevel.XSC;
+DbBase.prototype.types = enums.types.XSC;
+
+DbBase.prototype._getClient = async function (userOptions) {
+  var sqlccName = getSqlccName(userOptions);
+  var hanaOptions = (sqlccName) ?
+    this._dbReqOptions.getSqlccOptions(sqlccName) :
+    await this._dbReqOptions.getInstanceOptionsPromise();
+
+  hanaOptions = mergeUserOptions(hanaOptions, userOptions);
+  this._options = hanaOptions; // used by $.text
+  var client = await connection.connect(hanaOptions);
+
+  var openConnections = this._openConnections;
+  openConnections.add(client);
+
+  var originalClose = client.close;
+
+  Object.defineProperty(client, 'close', {
+    writable: true,
+    value: function () {
+      openConnections.delete(client);
+      client.close = originalClose;
+      originalClose.apply(client, arguments);
+    }
+  });
+
+  return client;
+};
+
+DbBase.prototype._closeAllConnections = function () {
+  for (var client of this._openConnections) {
+    client.close(function() { }); // ignoring an error here
+  }
+  this._openConnections.clear();
+};
+
+function getSqlccName(userOptions) {
+  userOptions = userOptions || {};
+  if (!userOptions.sqlcc) {
+    return;
+  }
+
+  if (!_.isString(userOptions.sqlcc)) {
+    throw new TypeError('The provided SQLCC name is not a string');
+  }
+
+  var sqlccName = userOptions.sqlcc.trim();
+  if (!sqlccName) {
+    throw new TypeError('The provided SQLCC name is empty string or contains only whitespaces');
+  }
+  return sqlccName;
+}
+
+function extractUserOptions(userOptions) {
+  var acceptedProperties = ['sqlcc', 'isolationLevel', 'locale', 'treatDateAsUTC'];
+  var filtered = _.pick(userOptions, acceptedProperties);
+  if (filtered.isolationLevel) {
+    filtered.isolationLevel = enums.convert.toDriverIsolationLevel(filtered.isolationLevel);
+  }
+  if ('locale' in filtered && !filtered.locale) {
+    // falsy values for locale provided in xsjs code are ignored
+    delete filtered.locale;
+  }
+  return filtered;
+}
+
+function mergeUserOptions(options, userOptions) {
+  userOptions = extractUserOptions(userOptions);
+  var opt = _.extend({}, options, userOptions);
+  return opt;
+}

package/lib/xsjs/db/common/DbOptions.js

@@ -0,0 +1,163 @@
+'use strict';
+
+var _ = require('lodash');
+var VError = require('verror');
+var HttpError = require('../../../utils/errors/HttpError');
+var connOptions = require('@sap/hdbext').connectionOptions;
+var instanceManager = require('@sap/instance-manager');
+
+var INSTANCE_MANAGER_OPTS = [
+  'user', 'password',
+  'post_managed_instance_url', 'delete_managed_instance_url',
+  'get_managed_instance_url', 'get_all_managed_instances_url',
+  'polling_interval_millis', 'polling_timeout_seconds',
+  'cache_max_items', 'cache_item_expire_seconds'
+];
+
+var SERVICE_MANAGER_OPTS = [
+  'clientid', 'clientsecret',
+  'sm_url', 'url','polling_interval_millis', 'polling_timeout_seconds',
+  'cache_max_items', 'cache_item_expire_seconds'
+];
+
+var DEFAULT_OPTIONS = {
+  pooling: true,
+  maxPoolSize: 10,
+  connectionLifetime: 30
+};
+
+module.exports = DbOptions;
+
+function DbOptions(globalOptions, xsApplicationUser) {
+  this._globalOptions = _.extend({}, DEFAULT_OPTIONS, globalOptions);
+  this._xsApplicationUser = xsApplicationUser;
+  this._instManager = null;
+}
+
+DbOptions.prototype._getInstanceManager = function (cb) {
+  if (this._instManager) {
+    return cb(null, this._instManager);
+  }
+  var self = this;
+  instanceManager.create(this._globalOptions, function (err, instManager) {
+    if (err) {
+      return cb(err);
+    }
+    self._instManager = instManager;
+    cb(null, instManager);
+  });
+};
+
+DbOptions.prototype.forRequest = function (req, locale) {
+  return new DbRequestOptions(this, req, locale);
+};
+
+function DbRequestOptions(dbOptions, req, locale) {
+  this._dbOptions = dbOptions;
+  this._globalOptions = _.cloneDeep(dbOptions._globalOptions);
+  this._xsApplicationUser = dbOptions._xsApplicationUser;
+  this._req = req;
+  this._locale = locale;
+}
+
+DbRequestOptions.prototype.getSqlccOptions = function (sqlccName) {
+  let options;
+  if (isInstanceManagerOptions(this._globalOptions)) {
+    options = _.omit(this._globalOptions, INSTANCE_MANAGER_OPTS);
+  } else if (isServiceManagerOptions(this._globalOptions)) {
+    options = _.omit(this._globalOptions, SERVICE_MANAGER_OPTS);
+  } else {
+    options = this._globalOptions;
+  }
+  if (!options.sqlcc || !options.sqlcc[sqlccName]) {
+    throw new TypeError('SQLCC connection with name "' + sqlccName +
+      '" not found in the provided hana configurations');
+  }
+
+  options = _.merge({}, options, options.sqlcc[sqlccName]);
+  return addRequestOptions(this._req, this._locale, options, this._xsApplicationUser);
+};
+
+DbRequestOptions.prototype.getInstanceOptions = function (callback) {
+  if (!isInstanceManagerOptions(this._globalOptions) && !isServiceManagerOptions(this._globalOptions)) {
+    var options = addRequestOptions(this._req, this._locale, this._globalOptions, this._xsApplicationUser);
+    return callback(null, options);
+  }
+  var self = this;
+  this._dbOptions._getInstanceManager(function (err, instManager) {
+    if (err) {
+      return callback(err);
+    }
+    var tenant = getTenant(self._req.authInfo);
+    if (!tenant) {
+      return callback(new Error('Could not get HANA service instance as no tenant is available in current context.'));
+    }
+    instManager.get(tenant, function (err, instance) {
+      if (err) {
+        return callback(err);
+      }
+      if (!instance) {
+        return callback(new VError("No service instance for tenant '%s'", tenant));
+      }
+      if (instance.status !== 'CREATION_SUCCEEDED') {
+        return callback(new VError("Status of service instance for tenant '%s' is %s", tenant, instance.status));
+      }
+      var hanaOptions;
+      if (isInstanceManagerOptions(self._globalOptions)){
+        hanaOptions = _.merge(_.omit(self._globalOptions, INSTANCE_MANAGER_OPTS), instance.credentials);
+      } else {
+        hanaOptions = _.merge(_.omit(self._globalOptions, SERVICE_MANAGER_OPTS), instance.credentials);
+      }
+      callback(null, addRequestOptions(self._req, self._locale, hanaOptions, self._xsApplicationUser));
+    });
+  });
+};
+
+DbRequestOptions.prototype.getInstanceOptionsPromise = function () {
+  var self = this;
+  return new Promise ((resolve, reject) => {
+    self.getInstanceOptions((err, result) => {
+      if (err) { return reject(err); }
+      resolve(result);
+    });
+  });
+};
+
+function getTenant(authInfo) {
+  return authInfo && authInfo.getZoneId();
+}
+
+function getUserToken(authInfo) {
+  return authInfo && authInfo.getHdbToken();
+}
+
+function isInstanceManagerOptions(options) {
+  return !!options.get_managed_instance_url;
+}
+
+function isServiceManagerOptions(options) {
+  return !!options.sm_url;
+}
+
+function addRequestOptions(req, locale, hanaSettings, xsApplicationUser) {
+  var hana = _.merge({}, hanaSettings, connOptions.getRequestOptions(req));
+
+  if (locale && locale.dbLocale) {
+    hana.locale = locale.dbLocale;
+  }
+
+  if (xsApplicationUser === false) {
+    delete hana['sessionVariable:XS_APPLICATIONUSER'];
+  }
+
+  if (hana.connectWithLoggedUser) {
+    var userToken = getUserToken(req.authInfo);
+    if (!userToken) {
+      throw new HttpError(400, 'No user token in request');
+    }
+    hana.user = '';
+    hana.password = userToken;
+  }
+  delete hana.sqlcc;
+  return hana;
+}

package/lib/xsjs/db/common/arguments-validation.js

@@ -0,0 +1,102 @@
+'use strict';
+
+var _ = require('lodash');
+var VError = require('verror');
+
+module.exports = {
+  validateSetterArgs: validateArgs,
+  validateGetterArgs: validateGetterArgs,
+  validateParsedInteger: validateParsedInteger,
+  validateNumber: validateNumber,
+  validateInteger: validateInteger,
+  numberToInteger: numberToInteger,
+  validateIntegerBoundaries: validateIntegerBoundaries,
+  validateDateValue: validateDateValue,
+  validateString: validateString,
+  validateDateTime: validateDateTime,
+  INTEGER_TYPE: {
+    TINY_INT: { min: 0, max: 255 },
+    SMALL_INT: { min: -32768, max: 32767 },
+    INTEGER: { min: -2147483648, max: 2147483647 },
+    BIG_INT: { min: Number.MIN_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER } // or using ctypes.INT64 for larger values
+  }
+};
+
+function validateArgs(args, minNumArgs) {
+  if (args.length < minNumArgs) {
+    throw new VError('Expected %d arguments', minNumArgs);
+  }
+  var columnIndex = args[0];
+  if (!_.isInteger(columnIndex) || columnIndex > module.exports.INTEGER_TYPE.INTEGER.max) {
+    throw new VError('Expected integer for first argument');
+  }
+  if (columnIndex < 1) {
+    throw new VError('Column index should be bigger than zero');
+  }
+  if (minNumArgs === 2 && Number.isNaN(args[1])) {
+    throw new VError('Second argument is NaN (not a number)');
+  }
+}
+
+function validateGetterArgs(args, minNumArgs, resultSetRow) {
+  validateArgs(args, minNumArgs);
+
+  if (_.isNull(resultSetRow)) {
+    throw new Error('next() is not called for this result set');
+  }
+  if (_.isUndefined(resultSetRow)) {
+    throw new Error('next() returned false - no results');
+  }
+}
+
+function validateParsedInteger(parsedValue, rawValue) {
+  if (_.isNaN(parsedValue) || (_.isString(rawValue) && rawValue.indexOf('.') > -1)) {
+    throw new VError('Unsupported type conversion from %s to number. Not a valid number value: "%s"', typeof rawValue, rawValue);
+  }
+}
+
+function validateNumber(value) {
+  if (!_.isNumber(value)) {
+    throw new VError('Expected a number as second argument');
+  }
+}
+
+function validateInteger(value) {
+  if (!_.isInteger(value)) {
+    throw new VError('Expected an integer as second argument');
+  }
+}
+
+function numberToInteger(num) {
+  if (_.isInteger(num)) {
+    return num;
+  }
+  return (num < 0) ? Math.ceil(num) : Math.floor(num);
+}
+
+function validateIntegerBoundaries(type, value) {
+  if (value < type.min || value > type.max) {
+    if (type === module.exports.INTEGER_TYPE.BIG_INT) {
+      throw new Error('Number values are only accurate between -2^53+1 and 2^53-1. Please use ctypes.int64 objects for larger numbers');
+    }
+    throw new VError('Expected integer between %d and %d as second argument', type.min, type.max);
+  }
+}
+
+function validateDateValue(value) {
+  if (!_.isString(value)) {
+    throw new VError('Unsupported type conversion from %s to a valid date object', typeof value);
+  }
+}
+
+function validateString(value) {
+  if (!_.isString(value)) {
+    throw new VError('Expected a string as second argument');
+  }
+}
+
+function validateDateTime(value) {
+  if (!_.isDate(value) && !_.isString(value)) {
+    throw new Error('Expected either a Date object or a string as second argument');
+  }
+}

package/lib/xsjs/db/common/connection.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var hdbext = require('@sap/hdbext');
+
+exports = module.exports;
+exports.connect = connect;
+
+async function connect (hanaOptions) {
+  var conn = await hdbext.createConnectionPromise(hanaOptions);
+  conn.setAutoCommit(false);
+  return conn;
+}

package/lib/xsjs/db/common/enums.js

@@ -0,0 +1,93 @@
+'use strict';
+
+var _ = require('lodash');
+var VError = require('verror');
+var driverEnum = require('@sap/hana-client/extension/Enums');
+var types = require('@sap/hana-client/extension/TypeCode');
+
+var XSC_ISOLATION = {
+  READ_COMMITTED: 2,
+  REPEATABLE_READ: 4,
+  SERIALIZABLE: 8
+};
+
+var XSC_TO_DRIVER_ISOLATION = {};
+XSC_TO_DRIVER_ISOLATION[XSC_ISOLATION.READ_COMMITTED] = driverEnum.READ_COMMITTED;
+XSC_TO_DRIVER_ISOLATION[XSC_ISOLATION.REPEATABLE_READ] = driverEnum.REPEATABLE_READ;
+XSC_TO_DRIVER_ISOLATION[XSC_ISOLATION.SERIALIZABLE] = driverEnum.SERIALIZABLE;
+
+var XSC_PARAM_MODE = {
+  IN: 1,
+  INOUT: 2,
+  OUT: 4
+};
+
+var DRIVER_TO_XSC_PARAM_MODE = {};
+DRIVER_TO_XSC_PARAM_MODE[driverEnum.DD_INPUT] = XSC_PARAM_MODE.IN;
+DRIVER_TO_XSC_PARAM_MODE[driverEnum.DD_INPUT_OUTPUT] = XSC_PARAM_MODE.INOUT;
+DRIVER_TO_XSC_PARAM_MODE[driverEnum.DD_OUTPUT] = XSC_PARAM_MODE.OUT;
+
+
+function findCorresponding(map, key) {
+  var value = map[key];
+  if (_.isNil(value)) {
+    throw new VError('Cannot find property %s in %j', key, map);
+  }
+  return value;
+}
+
+function createXscTypesConst() {
+  var xscTypes = _.clone(types);
+  xscTypes.INTEGER = xscTypes.INT;
+  xscTypes.VARCHAR = xscTypes.VARCHAR1;
+  xscTypes.SMALLDECIMAL = 47;
+  return xscTypes;
+}
+
+function toXscType(type) {
+  if (type === types.DAYDATE) {
+    return types.DATE;
+  }
+  if (type === types.SECONDTIME) {
+    return types.TIME;
+  }
+  if (type === types.LONGDATE) {
+    return types.TIMESTAMP;
+  }
+  return type;
+}
+
+function toXscTypeName(typeName) {
+  if (typeName === 'INT') {
+    return 'INTEGER';
+  }
+  if (typeName === 'VARCHAR1') {
+    return 'VARCHAR';
+  }
+  if (typeName === 'DAYDATE') {
+    return 'DATE';
+  }
+  if (typeName === 'SECONDTIME') {
+    return 'TIME';
+  }
+  if (typeName === 'LONGDATE') {
+    return 'TIMESTAMP';
+  }
+  return typeName;
+}
+
+module.exports = {
+  isolationLevel: {
+    XSC: XSC_ISOLATION
+  },
+  types: {
+    XSC: createXscTypesConst()
+  },
+
+  convert: {
+    toDriverIsolationLevel: findCorresponding.bind(null, XSC_TO_DRIVER_ISOLATION),
+    toXscParameterMode: findCorresponding.bind(null, DRIVER_TO_XSC_PARAM_MODE),
+    toXscType,
+    toXscTypeName
+  }
+};

package/lib/xsjs/db/common/execute-batch.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var _ = require('lodash');
+
+module.exports.executeBatchPromise = executeBatchPromise;
+
+async function executeBatchPromise (stmt, args) {
+  var err = null;
+  try {
+    await stmt.executeBatch(args);
+  } catch (error) {
+    err = error;
+  }
+  var statuses = stmt.getRowStatus();
+
+  if (!err) {
+    return statuses;
+  }
+
+  var allFailed = statuses.every(function (value) {
+    return value < 0;
+  });
+
+  if (allFailed) {
+    throw err;
+  }
+
+  if (!_.isNumber(err.code)) {
+    throw err;
+  }
+
+  var code = -Math.abs(err.code);
+  statuses = statuses.map(function (value) {
+    return (value < 0) ? code : value;
+  });
+
+  return statuses;
+}