terminusdb 12.0.2

package/lib/viewer/woqlPaging.js

@@ -0,0 +1,148 @@
+/* eslint-disable consistent-return */
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable no-unused-vars */
+const WOQLQuery = require('../query/woqlCore');
+const UTILS = require('../utils');
+
+/**
+ * Functions to manipulate and check the paging related properties of a query
+ */
+
+WOQLQuery.prototype.getLimit = function () {
+  return this.getPagingProperty('limit');
+};
+
+WOQLQuery.prototype.setLimit = function (l) {
+  return this.setPagingProperty('limit', l);
+};
+
+WOQLQuery.prototype.isPaged = function (q) {
+  q = (q || this.query);
+  for (const prop of Object.keys(q)) {
+    if (prop === 'limit') return true;
+    if (this.paging_transitive_properties.indexOf(prop) !== -1) {
+      return this.isPaged(q[prop][q[prop].length - 1]);
+    }
+  }
+  return false;
+};
+
+WOQLQuery.prototype.getPage = function () {
+  if (this.isPaged()) {
+    const psize = this.getLimit();
+    if (this.hasStart()) {
+      const s = this.getStart();
+      // eslint-disable-next-line radix
+      return (parseInt(s / psize) + 1);
+    }
+    return 1;
+  }
+  return false;
+};
+
+WOQLQuery.prototype.setPage = function (pagenum) {
+  const pstart = (this.getLimit() * (pagenum - 1));
+  if (this.hasStart()) {
+    this.setStart(pstart);
+  } else {
+    this.addStart(pstart);
+  }
+  return this;
+};
+
+WOQLQuery.prototype.nextPage = function () {
+  return this.setPage(this.getPage() + 1);
+};
+
+WOQLQuery.prototype.firstPage = function () {
+  return this.setPage(1);
+};
+
+WOQLQuery.prototype.previousPage = function () {
+  const npage = this.getPage() - 1;
+  if (npage > 0) this.setPage(npage);
+  return this;
+};
+
+WOQLQuery.prototype.setPageSize = function (size) {
+  this.setPagingProperty('limit', size);
+  if (this.hasStart()) {
+    this.setStart(0);
+  } else {
+    this.addStart(0);
+  }
+  return this;
+};
+
+WOQLQuery.prototype.hasSelect = function () {
+  return (!!this.getPagingProperty('select'));
+};
+
+WOQLQuery.prototype.getSelectVariables = function (q) {
+  q = (q || this.query);
+  for (const prop of Object.keys(q)) {
+    if (prop === 'select') {
+      const vars = q[prop].slice(0, q[prop].length - 1);
+      return vars;
+    }
+    if (this.paging_transitive_properties.indexOf(prop) !== -1) {
+      const val = this.getSelectVariables(q[prop][q[prop].length - 1]);
+      if (typeof val !== 'undefined') {
+        return val;
+      }
+    }
+  }
+};
+
+WOQLQuery.prototype.hasStart = function () {
+  return (typeof this.getPagingProperty('start') !== 'undefined');
+};
+
+WOQLQuery.prototype.getStart = function () {
+  return this.getPagingProperty('start');
+};
+
+WOQLQuery.prototype.setStart = function (start) {
+  return this.setPagingProperty('start', start);
+};
+
+WOQLQuery.prototype.addStart = function (s) {
+  if (this.hasStart()) this.setStart(s);
+  else {
+    const nq = { start: [s, this.query] };
+    this.query = nq;
+  }
+  return this;
+};
+
+/**
+ * Returns the value of one of the 'paging' related properties (limit, start,...)
+ */
+WOQLQuery.prototype.getPagingProperty = function (pageprop, q) {
+  q = (q || this.query);
+  for (const prop of Object.keys(q)) {
+    if (prop === pageprop) return q[prop][0];
+    if (this.paging_transitive_properties.indexOf(prop) !== -1) {
+      const val = this.getPagingProperty(pageprop, q[prop][q[prop].length - 1]);
+      if (typeof val !== 'undefined') {
+        return val;
+      }
+    }
+  }
+};
+
+/**
+ * Sets the value of one of the paging_transitive_properties properties
+ */
+WOQLQuery.prototype.setPagingProperty = function (pageprop, val, q) {
+  q = (q || this.query);
+  for (const prop of Object.keys(q)) {
+    if (prop === pageprop) {
+      q[prop][0] = val;
+    } else if (this.paging_transitive_properties.indexOf(prop) !== -1) {
+      this.setPagingProperty(pageprop, val, q[prop][q[prop].length - 1]);
+    }
+  }
+  return this;
+};

package/lib/viewer/woqlResult.js

@@ -0,0 +1,258 @@
+/* eslint-disable camelcase */
+/* eslint-disable consistent-return */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable no-plusplus */
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-unused-vars */
+/// /@ts-check
+const UTILS = require('../utils');
+const WOQL = require('../woql');
+const WOQLQ = require('./woqlPaging');
+
+/**
+ * @typedef {Object} WOQLQuery
+ */
+
+/**
+ * @module WOQLResult
+ * @license Apache Version 2
+ * Object representing the result of a WOQL Query
+ * @param {object} results result JSON object as returned by WOQL query
+ * @param {WOQLQuery} query the query object that generated the result
+ * @param {object} [config] optional result configuration options object
+ * [config.no_compress] by default all URLs are compressed where possible (v:X rather than http://.../variable/x) set to true to return non-compressed values
+ * [config.context] specify the JSON-LD context to use for compressing results - by default
+ * the query context will be used
+ */
+function WOQLResult(results, query, config) {
+  this.bindings = results ? results.bindings : [];
+  this.insert_count = results ? results.inserts : 0;
+  this.delete_count = results ? results.deletes : 0;
+  this.transaction_retry_count = results ? results.transaction_retry_count : 0;
+  /**
+     * @type {array | boolean}
+     */
+  this.variable_names = results ? results['api:variable_names'] : false;
+  // console.log(results, this.variable_names)
+  this.query = query || WOQL.query();
+  this.cursor = 0;
+  // if (!(config && config.no_compress)) {
+  //    const context = results && results.prefixes ? results.prefixes : false
+  //    this.compress(context)
+  // }
+}
+
+WOQLResult.prototype.formatter = function (context) {
+  context = context || this.query.getContext();
+  const formatted = [];
+  if (this.bindings && this.bindings.length > 0) {
+    this.bindings.forEach((row) => {
+      const rowObj = {};
+      Object.keys(row).forEach((propName) => {
+        const propValue = row[propName];
+
+        if (typeof propValue === 'string') {
+          if (propValue !== 'system:unknown') {
+            rowObj[propName] = UTILS.shorten(propValue, context);
+          } else {
+            rowObj[propName] = '';
+          }
+        } else {
+          rowObj[propName] = propValue['@value'];
+        }
+      });
+      formatted.push(rowObj);
+    });
+  }
+  return formatted;
+};
+
+/**
+ * @param {object} [context] optional context to use for compression -
+ * if ommitted query context is used
+ * @returns {WOQLResult}
+ */
+WOQLResult.prototype.compress = function (context) {
+  context = context || this.query.getContext();
+  if (context) {
+    for (let i = 0; i < this.bindings.length; i++) {
+      for (const prop of Object.keys(this.bindings[i])) {
+        const nprop = UTILS.shorten(prop, context);
+        let nval = this.bindings[i][prop];
+        if (typeof this.bindings[i][prop] === 'string') {
+          nval = UTILS.shorten(this.bindings[i][prop], context);
+        } else if (Array.isArray(this.bindings[i][prop])) {
+          nval = [];
+          for (let j = 0; j < this.bindings[i][prop].length; j++) {
+            let oval = this.bindings[i][prop][j];
+            if (typeof oval === 'string') oval = UTILS.shorten(oval, context);
+            else if (Array.isArray(oval)) {
+              const noval = [];
+              for (let k = 0; k < oval.length; k++) {
+                let kval = oval[k];
+                if (typeof kval === 'string') kval = UTILS.shorten(kval, context);
+                noval.push(kval);
+              }
+              oval = noval;
+            }
+            nval.push(oval);
+          }
+        }
+        delete this.bindings[i][prop];
+        this.bindings[i][nprop] = nval;
+      }
+    }
+  }
+  // console.log(this.bindings)
+  return this;
+};
+
+/**
+ * Returns true if there are any results
+ * @returns {boolean}
+ */
+WOQLResult.prototype.hasBindings = function () {
+  if (this.bindings && this.count()) return true;
+  return false;
+};
+
+/**
+ * Returns true if there are any results
+ * @returns {boolean}
+ */
+WOQLResult.prototype.hasUpdates = function () {
+  if (this.inserts() > 0 || this.deletes() > 0) return true;
+  return false;
+};
+
+/**
+ * Returns original array of bindings returned by API
+ * @returns {array} the data result
+ */
+WOQLResult.prototype.getBindings = function () {
+  return this.bindings;
+};
+/**
+ * Returns original array of bindings returned by API
+ * @returns {array} the data result
+ */
+WOQLResult.prototype.rows = function () {
+  return this.bindings;
+};
+
+/**
+ * Returns list of variables returned in bindings from API
+ * @returns {array|boolean}
+ */
+WOQLResult.prototype.getVariableList = function () {
+  if (this.variable_names) {
+    return this.variable_names;
+  }
+  if (this.bindings && this.bindings[0]) {
+    return Object.keys(this.bindings[0]);
+  }
+  return [];
+};
+
+/**
+ * Number of rows in bound results
+ * @returns {number}
+ */
+WOQLResult.prototype.count = function () {
+  return this.bindings.length;
+};
+
+/**
+ * Number of reported inserts
+ * @returns {number}
+ */
+WOQLResult.prototype.inserts = function () {
+  return this.insert_count;
+};
+
+/**
+ * Number of reported inserts
+ * @returns {number}
+ */
+WOQLResult.prototype.deletes = function () {
+  return this.delete_count;
+};
+
+/**
+ * Get the first object record from the result set
+ * @returns {object}
+ */
+WOQLResult.prototype.first = function () {
+  this.cursor = 0;
+  return this.bindings[0];
+};
+
+/**
+ * Get the last object record from the result set
+ * @returns {object}
+ */
+
+WOQLResult.prototype.last = function () {
+  this.cursor = this.bindings.length - 1;
+  return this.bindings[this.bindings.length - 1];
+};
+
+/**
+ * @returns {object}
+ */
+
+WOQLResult.prototype.next = function () {
+  if (this.cursor >= this.bindings.length) return false;
+  const res = this.bindings[this.cursor];
+  this.cursor++;
+  return res;
+};
+
+/**
+ * @returns {object}
+ */
+
+// eslint-disable-next-line consistent-return
+WOQLResult.prototype.prev = function () {
+  if (this.cursor > 0) {
+    this.cursor--;
+    return this.bindings[this.cursor];
+  }
+};
+
+/**
+ * Normally sorting of results is the job of the query - this is just in case you
+ * want to resort results according to some key (variable)
+ * @param {string} key
+ * @param {string} asc_or_desc
+ * @returns {WOQLResult}
+ */
+// eslint-disable-next-line camelcase
+WOQLResult.prototype.sort = function (key, asc_or_desc) {
+  this.bindings.sort((a, b) => this.compareValues(a[key], b[key], asc_or_desc));
+  // eslint-disable-next-line no-unused-expressions
+  this;
+};
+
+/**
+ * Compares results a, b according to "asc" or "desc" order
+ * @param {object} a
+ * @param {object} b
+ * @param {string} [asc_or_desc]
+ * @returns {number}
+ */
+WOQLResult.prototype.compareValues = function (a, b, asc_or_desc = 'asc') {
+  if (!a || !b) return 0;
+  if (typeof a['@value'] !== 'undefined' && typeof b['@value'] !== 'undefined') {
+    a = a['@value'];
+    b = b['@value'];
+  }
+  if (a > b) {
+    return asc_or_desc && asc_or_desc === 'asc' ? 1 : -1;
+  }
+  if (b > a) {
+    return asc_or_desc && asc_or_desc === 'asc' ? -1 : 1;
+  }
+};
+
+module.exports = WOQLResult;

package/lib/viewer/woqlRule.js

@@ -0,0 +1,312 @@
+/* eslint-disable guard-for-in */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable valid-typeof */
+/* eslint-disable no-continue */
+/* eslint-disable no-plusplus */
+/* eslint-disable no-use-before-define */
+const TerminusRule = require('./terminusRule');
+const UTILS = require('../utils');
+
+/**
+ * @file WOQL Rules
+ * @license Apache Version 2
+ * WOQL Rules support pattern matching on results of WOQL Queries
+ */
+
+function WOQLRule() {
+  TerminusRule.TerminusRule.call(this);
+  this.pattern = new WOQLPattern();
+}
+Object.setPrototypeOf(WOQLRule.prototype, TerminusRule.TerminusRule.prototype);
+
+/**
+ * Specifies that the rule only applies to specific variables returned by the WOQL query
+ * @param {Array<string>} vars - array of strings, each a variable name, variable prefixes
+ * ("v:") are added automatically if absent
+ */
+WOQLRule.prototype.setVariables = function (vars) {
+  if (vars && vars.length) {
+    this.pattern.variables = UTILS.removeNamespacesFromVariables(vars);
+    this.current_variable = this.pattern.variables[this.pattern.variables.length - 1];
+  }
+  return this;
+};
+
+/**
+ * Shorthand to the above using spread operator
+ */
+WOQLRule.prototype.vars = function (...varlist) {
+  return this.setVariables(varlist);
+};
+
+/**
+ * Specifies that the rule applies to a specific variable, variable prefix ("v:")
+ * is added automatically if absent
+ */
+WOQLRule.prototype.v = function (v) {
+  if (v) {
+    this.current_variable = UTILS.removeNamespaceFromVariable(v);
+    return this;
+  }
+  return this.current_variable;
+};
+
+/**
+ * Specifies that the rule applies to a specific edge, a source -> target pair of variables
+ */
+WOQLRule.prototype.edge = function (source, target) {
+  this.scope('edge');
+  if (source) {
+    const vs = UTILS.removeNamespaceFromVariable(source);
+    this.setVariables([vs]);
+    this.pattern.source = vs;
+  }
+  if (target) {
+    const vs = UTILS.removeNamespaceFromVariable(target);
+    if (!source) this.setVariables([vs]);
+    this.pattern.target = vs;
+  }
+  return this;
+};
+
+/**
+ * Specifies that the rule applies to a specific edge, a source -> target pair of variables
+ */
+WOQLRule.prototype.rownum = function (rownum) {
+  if (typeof rownum === 'undefined') return this.pattern.rownum;
+  this.pattern.rownum = rownum;
+  return this;
+};
+
+/**
+ * Specifies that the value of a variable must be one of the values contained in the list
+ * @param {...(string|number)} list - parameters are any atomic value (string | number) -
+ * the rule will match only cells that have one of these values
+ */
+WOQLRule.prototype.in = function (...list) {
+  if (this.current_variable) {
+    if (!this.pattern.constraints) this.pattern.constraints = {};
+    if (!this.pattern.constraints[this.current_variable]) {
+      this.pattern.constraints[this.current_variable] = [];
+    }
+    this.pattern.constraints[this.current_variable].push(list);
+  }
+  return this;
+};
+
+/**
+ * Specifies a filter function to apply to each element - only those values that
+ * return true when this filter is invoked will be matched
+ * @param {function} tester - test function that will be used to filter values
+ */
+WOQLRule.prototype.filter = function (tester) {
+  if (this.current_variable) {
+    if (!this.pattern.constraints) this.pattern.constraints = {};
+    if (!this.pattern.constraints[this.current_variable]) {
+      this.pattern.constraints[this.current_variable] = [];
+    }
+    this.pattern.constraints[this.current_variable].push(tester);
+  }
+  return this;
+};
+
+WOQLRule.prototype.matchRow = function (rules, row, rownum, action) {
+  const matches = [];
+  for (let i = 0; i < rules.length; i++) {
+    if (action && this.rule && typeof this.rule[action] === 'undefined') continue;
+    if (rules[i].pattern.matchRow(row, rownum)) {
+      matches.push(rules[i]);
+    }
+  }
+  return matches;
+};
+
+WOQLRule.prototype.matchCell = function (rules, row, key, rownum, action) {
+  const matches = [];
+  for (let i = 0; i < rules.length; i++) {
+    if (action && this.rule && typeof this.rule[action] === 'undefined') continue;
+    if (rules[i].pattern.matchCell(row, key, rownum)) {
+      matches.push(rules[i]);
+    }
+  }
+  return matches;
+};
+
+/**
+ *
+ * @param {array} rules
+ * @param {string} key - column name
+ * @param {string} ruleName - the rule name like header, width etc...
+ * @returns {array}
+ */
+WOQLRule.prototype.matchColumn = function (rules, key, ruleName) {
+  const matches = [];
+  for (let i = 0; i < rules.length; i++) {
+    if (ruleName && this.rule && typeof this.rule[ruleName] === undefined) continue;
+    const ruleRow = rules[i];
+    /*
+        * if it is not the rule that I'm looking for
+        */
+    if (ruleName && ruleRow.rule[ruleName] === undefined) {
+      continue;
+    }
+    if (ruleRow.pattern.matchColumn(key)) {
+      matches.push(ruleRow);
+    }
+  }
+  return matches;
+};
+
+WOQLRule.prototype.matchNode = function (rules, row, key, nid, action) {
+  const matches = [];
+  for (let i = 0; i < rules.length; i++) {
+    if (action && this.rule && typeof this.rule[action] === 'undefined') continue;
+    if (rules[i].pattern.matchNode(row, key, nid)) {
+      matches.push(rules[i]);
+    }
+  }
+  return matches;
+};
+
+WOQLRule.prototype.matchPair = function (rules, row, keya, keyb, action) {
+  const matches = [];
+  for (let i = 0; i < rules.length; i++) {
+    if (action && this.rule && typeof this.rule[action] === 'undefined') continue;
+    if (rules[i].pattern.matchPair(row, keya, keyb)) {
+      matches.push(rules[i]);
+    }
+  }
+  return matches;
+};
+
+// alias
+WOQLRule.prototype.matchEdge = WOQLRule.prototype.matchPair;
+
+/**
+ * Object to encapsulate the matching of woql result patterns - inherits from TerminusRule
+ * @param {Object} pattern
+ */
+function WOQLPattern(pattern) {
+  TerminusRule.TerminusPattern.call(this, pattern);
+}
+Object.setPrototypeOf(WOQLPattern.prototype, TerminusRule.TerminusPattern.prototype);
+
+WOQLPattern.prototype.prettyPrint = function () {
+  // starts with obj. ...
+  let str = `${this.scope}('`;
+  if (this.variables) {
+    str += this.variables.join("', '");
+  }
+  str += "')";
+  if (typeof this.literal !== 'undefined') {
+    str += `.literal(${this.literal})`;
+  }
+  if (typeof this.type !== 'undefined') {
+    str += `.type(${this.unpack(this.type)})`;
+  }
+  if (typeof this.value !== 'undefined') {
+    str += `.value(${this.unpack(this.value, true)})`;
+  }
+  for (const v in this.constraints) {
+    str += `.v('${v}')`;
+    for (let i = 0; i < this.constraints[v].length; i++) {
+      if (typeof this.constraints[v][i] === 'function') {
+        str += `.filter(${this.constraints[v][i]})`;
+      } else {
+        // eslint-disable-next-line no-undef
+        str += `.in(${json.unpack(this.constraints[v][i])})`;
+      }
+    }
+  }
+  return str;
+};
+
+/**
+ * @param {String|Object} data
+ * @param {string|Array<string>} [key] - a variable or an array of two variables
+ * (in the case of edge scope) which constitutes the key being tested
+ * @param {String} [scope] - the scope in which the test is being carried out (row, column, cell)
+ */
+
+WOQLPattern.prototype.matchRow = function (row, rownum) {
+  if (typeof this.rownum !== 'undefined' && typeof rownum !== 'undefined') {
+    if (!this.numberMatch(this.rownum, rownum)) return false;
+  }
+  if (this.scope && this.scope !== 'row') return false;
+  if (!this.testVariableConstraints(row)) return false;
+  return true;
+};
+
+WOQLPattern.prototype.matchCell = function (row, key, rownum) {
+  if (typeof this.rownum !== 'undefined' && typeof rownum !== 'undefined') {
+    if (!this.numberMatch(this.rownum, rownum)) return false;
+  }
+  if (!this.testBasics('column', row[key])) return false;
+  if (this.variables && this.variables.length && this.variables.indexOf(key) === -1) return false;
+  if (!this.testVariableConstraints(row)) return false;
+  return true;
+};
+
+WOQLPattern.prototype.matchNode = function (row, key) {
+  if (!this.testBasics('node', row[key])) return false;
+  if (this.variables && this.variables.length && this.variables.indexOf(key) === -1) return false;
+  if (!this.testVariableConstraints(row)) return false;
+  return true;
+};
+
+WOQLPattern.prototype.matchColumn = function (key) {
+  if (this.scope && this.scope !== 'column') return false;
+  if (this.variables && this.variables.length && this.variables.indexOf(key) === -1) return false;
+  return true;
+};
+
+WOQLPattern.prototype.matchPair = function (row, keya, keyb) {
+  if (this.scope && this.scope !== 'edge') return false;
+  if (this.source && this.source !== keya) return false;
+  if (this.target && this.target !== keyb) return false;
+  if (!this.testVariableConstraints(row)) return false;
+  return true;
+};
+
+WOQLPattern.prototype.testVariableConstraints = function (row) {
+  for (const k in this.constraints) {
+    if (!this.testVariableConstraint(k, row[k])) return false;
+  }
+  return true;
+};
+
+WOQLPattern.prototype.testVariableConstraint = function (name, val) {
+  if (!this.constraints[name]) return true;
+  for (let i = 0; i < this.constraints[name].length; i++) {
+    if (!this.testValue(val, this.constraints[name][i])) {
+      return false;
+    }
+  }
+  return true;
+};
+
+WOQLPattern.prototype.setPattern = function (pattern) {
+  for (const key in pattern) {
+    this[key] = pattern[key];
+  }
+};
+
+WOQLPattern.prototype.json = function () {
+  const json = {};
+  if (this.scope) {
+    json.scope = this.scope;
+  }
+  if (this.value) {
+    json.value = this.value;
+  }
+  if (this.rownum) json.rownum = this.rownum;
+  if (this.variables) json.variables = this.variables;
+  if (this.literal) json.literal = this.literal;
+  if (this.type) json.type = this.type;
+  if (this.constraints) json.constraints = this.constraints;
+  if (this.source) json.source = this.source;
+  if (this.target) json.target = this.target;
+  return json;
+};
+
+module.exports = { WOQLRule, WOQLPattern };