@sap/async-xsjs 1.0.2

package/lib/xsjs/db/hdbapi/table-string-parser.js

@@ -0,0 +1,52 @@
+'use strict';
+
+module.exports = {
+  parse: parseTableString,
+  adaptForHdbext: adaptForHdbext
+};
+
+function parseTableString(str) {
+  var regex = /^\s*(?:(?:("(?:[^"]|"")*")|([^"][^\s.]*))\s*\.{1})?\s*(?:("(?:[^"]|"")*")|([^"][^\s.]*))\s*$/;
+  var result = regex.exec(str);
+
+  if (result === null) {
+    return null;
+  }
+
+  return {
+    schema: {
+      escaped: result[1],
+      unescaped: result[2]
+    },
+    table: {
+      escaped: result[3],
+      unescaped: result[4]
+    }
+  };
+}
+
+function adaptForHdbext(parsed) {
+  var adapted = {};
+
+  ['schema', 'table'].forEach(function (identifier) {
+    if (parsed[identifier].escaped) {
+      // hdbext escapes the schema and table names.
+      // If we have received them escaped, then we should unescape them
+      // so that these identifiers do not get escaped twice.
+      adapted[identifier] = unescape(parsed[identifier].escaped);
+    } else if (parsed[identifier].unescaped) {
+      // In XSC if we pass an unescaped identifier, it is treated as upper case name.
+      // We need to manually convert it to upper case
+      // before hdbext escapes the identifier.
+      adapted[identifier] = parsed[identifier].unescaped.toUpperCase();
+    }
+  });
+
+  return adapted;
+}
+
+function unescape(identifier) {
+  identifier = identifier.substring(1, identifier.length - 1);
+  identifier = identifier.replace(/""/g, '"');
+  return identifier;
+}

package/lib/xsjs/db/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+exports.DB  = require('./dbapi/DB');
+exports.HDB = require('./hdbapi/HDB');

package/lib/xsjs/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+exports.Jobs        = require('./jobs/Jobs');
+exports.Application = require('./Application');
+exports.Session     = require('./Session');
+exports.db          = require('./db');
+exports.net         = require('./net');
+exports.web         = require('./web');
+exports.security    = require('./security');
+exports.trace       = require('./trace/trace');
+exports.util        = require('./util');
+exports.require     = require('./require');
+exports.text        = require('./text');

package/lib/xsjs/jobs/Job.js

@@ -0,0 +1,228 @@
+'use strict';
+
+var path = require('path');
+var util = require('util');
+var utils = require('../../utils');
+var jobsClient = require('@sap/jobs-client');
+
+var Schedules = require('./Schedules');
+var Schedule = require('./Schedule');
+
+module.exports = Job;
+
+function Job(runtime, constructJob) {
+  var self = this;
+  this._scheduler = createScheduler(runtime);
+
+  this.schedules = {};
+  if (!constructJob.uri) {
+    throw new Error('Job: uri string parameter required');
+  }
+  var jobPath = resolveJobURI(runtime, constructJob.uri);
+  var jobName = runtime.getJobName(jobPath);
+  return new Promise ((resolve, reject) => {
+    self._scheduler.fetchJob({ name: jobName, displaySchedules: true }, function(err, job) {
+      if (err) { return reject(err);}
+      if (!job._id) {
+        reject('Scheduler response missing _id property');
+      }
+      if (!job.schedules) {
+        reject('Scheduler response missing schedules property');
+      }
+      self._jobId = job._id;
+      self.active = job.active;
+      var jobSchedules = job.schedules;
+      var id = [];
+      var schedulesObject = new Schedules(self._scheduler, self._jobId);
+      var schedulePromises = jobSchedules.map((jobSchedule) => {
+        if (!jobSchedule.scheduleId) {
+          reject('Scheduler response missing scheduleId property');
+        }
+        var description = jobSchedule.description;
+        var data = jobSchedule.data;
+        var cron = jobSchedule.cron;
+        var active = jobSchedule.active;
+        var scheduleId = jobSchedule.scheduleId;
+        id.push(jobSchedule.scheduleId);
+        return new Schedule(self._scheduler,
+            description, data, cron, active, self._jobId, scheduleId);
+      });
+      Promise.all(schedulePromises).then((resolvedSchedules) => {
+        var currentScheduleId;
+        for (var k = 0; k < resolvedSchedules.length; k++) {
+          var resolvedSchedule = resolvedSchedules[k];
+          currentScheduleId = id[k];
+          schedulesObject[currentScheduleId] = resolvedSchedule;
+        }
+        self.schedules = schedulesObject;
+        resolve(self);
+      });
+    });
+  });
+}
+
+Object.defineProperty(Job.prototype, 'deactivate', {
+  enumerable : false,
+  value : deactivate
+});
+Object.defineProperty(Job.prototype, 'activate', {
+  enumerable : false,
+  value : activate
+});
+Object.defineProperty(Job.prototype, 'configure', {
+  enumerable : false,
+  value : configure
+});
+
+
+function resolveJobURI(runtime, uri) {
+  if (!/\.xsjob$/.test(uri)) {
+    throw new Error('URI ' + uri + ' should reference a xsjob');
+  }
+  var jobPath;
+  if (uri[0] === '/') {
+    jobPath = uri;
+  } else {
+    // uri is relative to calling xsjs
+    var callingXsjs = utils.getCallingXsjsRelativePath(runtime.get('rootDirs'));
+    var dir = path.dirname(callingXsjs);
+    jobPath = path.normalize('/' + dir + '/' + uri).replace(/\\/g, '/');
+  }
+  if (!(jobPath in runtime.xsjobs)) {
+    throw new Error('Could not find job ' + jobPath);
+  }
+  return jobPath;
+}
+
+function createScheduler(runtime) {
+  var jobs = runtime.get('jobs');
+  return new jobsClient.Scheduler({
+    baseURL: jobs.url,
+    timeout: jobs.timeout,
+    user: jobs.user,
+    password: jobs.password
+  });
+}
+
+async function configure(config) {
+  if (typeof config !== 'object') {
+    throw new Error('Job.configure: takes exactly one parameter object');
+  }
+  var user = config.user;
+  var password = config.password;
+  var status = config.status;
+  var startTime = config.start_time;
+  var endTime = config.end_time;
+  if (!config.hasOwnProperty('user')) {
+    throw new Error('Job.configure: user string parameter required');
+  }
+  if (!config.hasOwnProperty('password')) {
+    throw new Error('Job.configure: password string parameter required');
+  }
+  if (!config.hasOwnProperty('locale')) {
+    throw new Error('Job.configure: locale string parameter required');
+  }
+  if (!config.hasOwnProperty('status')) {
+    throw new Error('Job.configure: status boolean parameter required');
+  }
+  if (!config.hasOwnProperty('start_time')) {
+    throw new Error('Job.configure: startTime object parameter required');
+  }
+  if (!config.hasOwnProperty('end_time')) {
+    throw new Error('Job.configure: endTime object parameter required');
+  }
+
+  // for now we accept only Date objects until we implement date parsing compatible to XS1
+  if (!util.isDate(startTime)) {
+    throw new Error('Job.configure: startTime object parameter required');
+  }
+  if (!util.isDate(endTime)) {
+    throw new Error('Job.configure: endTime object parameter required');
+  }
+
+  var st = convertTime(startTime, 'startTime');
+  var et = convertTime(endTime, 'endTime');
+
+  await updateJobPromise(this._scheduler, {
+    jobId: this._jobId,
+    job: {
+      user: user,
+      password: password,
+      active: status
+    }
+  });
+
+  for (var scheduleKey in this.schedules) {
+    if (scheduleKey === '_jobId') {
+      continue;
+    }
+    await updateJobSchedulePromise(this._scheduler, {
+      jobId: this._jobId,
+      scheduleId: scheduleKey,
+      schedule: {
+        startTime: st,
+        endTime: et
+      }
+    });
+  }
+}
+
+function convertTime(time, propName) {
+  if (time === null) {
+    return null;
+  }
+  if (util.isDate(time)) {
+    return {
+      date: time.toISOString()
+    };
+  }
+  throw new Error('Job.configure: Invalid ' + propName + ' date');
+}
+
+async function _activate(job, credentials, active) {
+  if (typeof credentials !== 'object') {
+    throw new Error('Only one parameter object is required');
+  }
+  if (!credentials.user) {
+    throw new Error('User string parameter required');
+  }
+
+  if (!credentials.password) {
+    throw new Error('Password string parameter required');
+  }
+
+  await updateJobPromise (job._scheduler, {
+    jobId: job._jobId,
+    job: {
+      user: credentials.user,
+      password: credentials.password,
+      active: active
+    }
+  });
+}
+
+async function activate(credentials) {
+  await _activate(this, credentials, true);
+}
+
+async function deactivate(credentials) {
+  await _activate(this, credentials, false);
+}
+
+function updateJobPromise(scheduler, req) {
+  return new Promise ((resolve, reject) => {
+    scheduler.updateJob(req, function(err, result) {
+      if (err) { return reject(err);}
+      resolve(result);
+    });
+  });
+}
+
+function updateJobSchedulePromise(scheduler, req) {
+  return new Promise ((resolve, reject) => {
+    scheduler.updateJobSchedule(req, function(err, result) {
+      if (err) { return reject(err);}
+      resolve(result);
+    });
+  });
+}

package/lib/xsjs/jobs/Jobs.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var Job = require('./Job');
+module.exports = Jobs;
+
+// $.jobs
+function Jobs(runtime) {
+  this.Job = function (constructJob) {
+    return new Job(runtime, constructJob);
+  };
+}

package/lib/xsjs/jobs/Logs.js

@@ -0,0 +1,127 @@
+'use strict';
+
+var assert = require('assert');
+var moment = require('moment');
+
+module.exports = Logs;
+
+function Logs(scheduler, scheduleId, jobId) {
+  assert(scheduler, 'Missing scheduler');
+  assert(scheduleId, ' Missing scheduleId');
+  assert(jobId, 'Missing jobId');
+
+  Object.defineProperty(this, 'scheduleId', {
+    enumerable: false,
+    value: scheduleId
+  });
+  Object.defineProperty(this, 'jobId', {
+    enumerable: false,
+    value: jobId
+  });
+  var self = this;
+  return new Promise ((resolve) => {
+    fetchJobSchedulePromise(scheduler, {
+      jobId: self.jobId,
+      scheduleId: self.scheduleId,
+      displayLogs: true
+    })
+    .then((body) => {
+      var resolvedLogs = body.logs.map(function (jlog) {
+        var host = null;
+        var port = null;
+        var status = normalizeRunStatus(jlog.runStatus, jlog.runState);
+        return new JobLogObject(
+          jlog.scheduleTimestamp,
+          status,
+          status === 'ERROR' ? jlog.runText : null,
+          jlog.executionTimestamp,
+          jlog.completionTimestamp,
+          host,
+          port,
+          jlog.action,
+          jlog.user,
+          jlog.locale);
+      });
+      self.jobLog = resolvedLogs;
+      // self.jobLogs = resolvedLogs;
+      resolve(self);
+    });
+  });
+}
+
+function getTimeValue(value) {
+  if (value !== null && typeof value !== 'undefined') {
+    return moment(value, moment.ISO_8601).toDate();
+  }
+  return null;
+}
+
+function JobLogObject(plannedTime, status, errorMessage, startedAt, finishedAt, host, port, action, user, locale) {
+  Object.defineProperty(this, 'planned_time', {
+    enumerable: true,
+    value: getTimeValue(plannedTime),
+    writable: false
+  });
+  Object.defineProperty(this, 'status', {
+    enumerable: true,
+    value: status,
+    writable: false
+  });
+  Object.defineProperty(this, 'error_message', {
+    enumerable: true,
+    value: errorMessage,
+    writable: false
+  });
+  Object.defineProperty(this, 'started_at', {
+    enumerable: true,
+    value: getTimeValue(startedAt),
+    writable: false
+  });
+  Object.defineProperty(this, 'finished_at', {
+    enumerable: true,
+    value: getTimeValue(finishedAt),
+    writable: false
+  });
+  Object.defineProperty(this, 'host', {
+    enumerable: true,
+    value: host,
+    writable: false
+  });
+  Object.defineProperty(this, 'port', {
+    enumerable: true,
+    value: port,
+    writable: false
+  });
+  Object.defineProperty(this, 'action', {
+    enumerable: true,
+    value: action,
+    writable: false
+  });
+  Object.defineProperty(this, 'user', {
+    enumerable: true,
+    value: user,
+    writable: false
+  });
+  Object.defineProperty(this, 'locale', {
+    enumerable: true,
+    value: locale,
+    writable: false
+  });
+}
+
+function normalizeRunStatus(status, state) {
+  switch (status) {
+  case 'RUNNING': return 'RUNNING';
+  case 'COMPLETED': return state === 'REQUEST_ERROR' ? 'ERROR' : state;
+  default: return state;
+  }
+}
+
+function fetchJobSchedulePromise(scheduler, req) {
+  return new Promise ((resolve, reject) => {
+    scheduler.fetchJobSchedule(req, function (err, result) {
+      if (err) { return reject(err);}
+      resolve(result);
+    });
+  });
+}

package/lib/xsjs/jobs/Schedule.js

@@ -0,0 +1,110 @@
+'use strict';
+
+var assert = require('assert');
+
+var Logs = require('./Logs');
+
+module.exports = Schedule;
+
+function Schedule(scheduler, description, parameter, xscron, active, jobId, scheduleId) {
+  assert(scheduler, 'Missing scheduler');
+  assert(scheduleId, ' Missing scheduleId');
+  assert(jobId, 'Missing jobId');
+  var self = this;
+
+  Object.defineProperty(this, 'description', {
+    enumerable: true,
+    get: function () {
+      return description;
+    },
+    set: async function (value) {
+      if (typeof value !== 'string') {
+        throw new Error('Incorrect type for "description"');
+      }
+      await updateJobSchedulePromise(scheduler, {
+        jobId: jobId,
+        scheduleId: scheduleId,
+        schedule: {
+          description: value
+        }
+      });
+      description = value;
+    }
+  });
+  Object.defineProperty(this, 'active', {
+    enumerable: true,
+    get: function () {
+      return active;
+    },
+    set: async (value) => {
+      if (typeof value !== 'boolean') {
+        throw new Error('Incorrect type for "Active"');
+      }
+      await updateJobSchedulePromise(scheduler, {
+        jobId: jobId,
+        scheduleId: scheduleId,
+        schedule: {
+          active: value
+        }
+      });
+      active = value;
+    }
+  });
+
+  Object.defineProperty(this, 'parameter', {
+    enumerable: true,
+    get: function () {
+      return parameter;
+    },
+    set: async (value) => {
+      if (typeof value !== 'string' && typeof value !== 'object') {
+        throw new Error('Incorrect type for "parameter"');
+      }
+      await updateJobSchedulePromise(scheduler, {
+        jobId: jobId,
+        scheduleId: scheduleId,
+        schedule: {
+          data: (typeof value === 'string') ? JSON.parse(value) : value
+        }
+      });
+      parameter = value;
+    }
+  });
+  Object.defineProperty(this, 'xscron', {
+    enumerable: true,
+    get: function () {
+      return xscron;
+    },
+    set: async function (value) {
+      if (typeof value !== 'string') {
+        throw new Error('Incorrect type for "xscron"');
+      }
+      await updateJobSchedulePromise(scheduler, {
+        jobId: jobId,
+        scheduleId: scheduleId,
+        schedule: {
+          cron: value
+        }
+      });
+      xscron = value;
+    }
+  });
+
+  return new Promise((resolve, reject) => {
+    var logsPromise = new Logs(scheduler, scheduleId, jobId);
+    logsPromise.then((logs) => {
+      self.logs = logs;
+      resolve(self);
+    }).catch((err) => {
+      reject(err); });
+  });
+}
+
+function updateJobSchedulePromise(scheduler, req) {
+  return new Promise ((resolve, reject) => {
+    scheduler.updateJobSchedule(req, function(err, result) {
+      if (err) { return reject(err);}
+      resolve(result);
+    });
+  });
+}

package/lib/xsjs/jobs/Schedules.js

@@ -0,0 +1,108 @@
+'use strict';
+
+var assert = require('assert');
+var Schedule = require('./Schedule');
+
+module.exports = Schedules;
+
+// internal properties are non-enumerable so they are not mixed with schedule ids
+
+function Schedules(scheduler, jobId) {
+  assert(scheduler, 'Missing scheduler');
+  assert(jobId, 'Missing jobId');
+
+  Object.defineProperty(this, '_scheduler', {
+    enumerable: false,
+    writable: false,
+    value: scheduler
+  });
+  Object.defineProperty(this, '_jobId', {
+    enumerable: false,
+    writable: false,
+    value: jobId
+  });
+}
+
+Object.defineProperty(Schedules.prototype, 'delete', {
+  enumerable: false,
+  value: deleteSchedule
+});
+Object.defineProperty(Schedules.prototype, 'add', {
+  enumerable: false,
+  value: addSchedule
+});
+
+async function deleteSchedule(params) {
+  if (params.id) {
+    var scheduleId = params.id;
+    if (!this.hasOwnProperty(scheduleId)) {
+      throw new Error('Schedule ID not found');
+    }
+    await deleteJobSchedulePromise(this._scheduler, {
+      jobId: this._jobId,
+      scheduleId: scheduleId
+    });
+    delete this[scheduleId];
+    return true;
+  } else {
+    throw new Error('"id" is mandatory');
+  }
+}
+
+async function addSchedule(parameters) {
+  var description = parameters.description;
+  var xscron = parameters.xscron;
+  var parameter = parameters.parameter;
+
+  var body = {};
+  if (parameter) {
+    if (typeof parameter === 'string') {
+      parameter = JSON.parse(parameter);
+    } else if (typeof parameter !== 'object') {
+      throw new Error('Wrong input type for "parameter"');
+    }
+    body.data = parameter;
+  }
+  if (!xscron) {
+    throw new Error('"xscron" is mandatory');
+  } else if (typeof xscron !== 'string') {
+    throw new Error('Wrong input type for "xscron"');
+  } else {
+    body.cron = xscron;
+  }
+  if (description) {
+    if (typeof description !== 'string') {
+      throw new Error('Wrong input type for "description"');
+    } else {
+      body.description = description;
+    }
+  }
+
+  var reply = await createJobSchedulePromise(this._scheduler, {
+    jobId: this._jobId,
+    schedule: body
+  });
+
+  var nscheduleId = reply.scheduleId ;
+  this[nscheduleId] = await new Schedule(this._scheduler, reply.description, reply.data,
+    reply.cron, reply.active, this._jobId, nscheduleId);
+  return nscheduleId;
+}
+
+function deleteJobSchedulePromise(scheduler, req) {
+  return new Promise ((resolve, reject) => {
+    scheduler.deleteJobSchedule(req, function(err){
+      if (err) { return reject(err);}
+      resolve();
+    });
+  });
+}
+
+function createJobSchedulePromise(scheduler, req) {
+  return new Promise((resolve, reject) => {
+    scheduler.createJobSchedule(req, function(err, result){
+      if (err) { return reject(err);}
+      resolve(result);
+    });
+  });
+}

package/lib/xsjs/net/Destination.js

@@ -0,0 +1,43 @@
+'use strict';
+
+// http://help.sap.com/saphelp_hanaplatform/helpdata/en/6e/fe500d91ee462c85cce7609646e17a/content.htm?frameset=/en/34/29fc63a1de4cd6876ea211dc86ee54/frameset.htm&current_toc=/en/34/29fc63a1de4cd6876ea211dc86ee54/plain.htm&node_id=82&fullscreen=true
+var _ = require('lodash');
+
+module.exports = Destination;
+
+/**
+ * According to SPS10 documentation here is a list of properties destinations can have:
+ *
+ * host = "download.finance.yahoo.com";
+ * port = 80;
+ * //All of the following keywords are optional
+ * description = "";
+ * useSSL = false;
+ * sslAuth = client;
+ * sslHostCheck = true;
+ * pathPrefix = "/d/quotes.csv?f=a";
+ * authType = none;
+ * samlProvider = "";
+ * samlACS = "header";
+ * samlAttributes = "";
+ * samlNameId = ["email"];
+ * proxyType = none;
+ * proxyHost = ""; //in-line comments are allowed
+ * proxyPort = 0;
+ * timeout = 0;
+ * remoteSID = "Q7E";
+ * remoteClient = "007";
+ * oAuthAppConfigPackage = "sap.hana.test";
+ * oAuthAppConfig = "abapTest";
+ *
+ * @param options
+ */
+
+function Destination(options) {
+  this.host = '';
+  this.port = 80;
+  this.description = '';
+  this.timeout = 10000;
+
+  _.extend(this, options);
+}