terminusdb 12.0.2

package/lib/viewer/streamConfig.js

@@ -0,0 +1,82 @@
+const Config = require('./viewConfig');
+const WOQLStream = require('./woqlStream');
+
+function WOQLStreamConfig() {
+  Config.ViewConfig.call(this);
+  this.type = 'stream';
+}
+
+Object.setPrototypeOf(WOQLStreamConfig.prototype, Config.ViewConfig.prototype);
+
+WOQLStreamConfig.prototype.create = function (client) {
+  const wqt = new WOQLStream(client, this);
+  return wqt;
+};
+
+WOQLStreamConfig.prototype.row = function () {
+  // eslint-disable-next-line no-use-before-define
+  const wqt = new WOQLStreamRule().scope('row');
+  this.rules.push(wqt);
+  return wqt;
+};
+
+WOQLStreamConfig.prototype.template = function (template) {
+  if (!template) return this.mtemplate;
+  this.mtemplate = template;
+  return this;
+};
+
+WOQLStreamConfig.prototype.prettyPrint = function () {
+  let str = 'view = View.stream();\n';
+  if (typeof this.template() !== 'undefined') {
+    str += `view.template(${JSON.stringify(this.template())})\n`;
+  }
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < this.rules.length; i++) {
+    str += `view.${this.rules[i].prettyPrint()}\n`;
+  }
+  return str;
+};
+
+WOQLStreamConfig.prototype.loadJSON = function (config, rules) {
+  const jr = [];
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < rules.length; i++) {
+    // eslint-disable-next-line no-use-before-define
+    const nr = new WOQLStreamRule();
+    nr.json(rules[i]);
+    jr.push(nr);
+  }
+  this.rules = jr;
+  if (config.template) {
+    this.mtemplate = config.template;
+  }
+};
+
+WOQLStreamConfig.prototype.json = function () {
+  const jr = [];
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < this.rules.length; i++) {
+    jr.push(this.rules[i].json());
+  }
+  const conf = {};
+  if (this.mtemplate) {
+    conf.template = this.mtemplate;
+  }
+  const mj = { stream: conf, rules: jr };
+  return mj;
+};
+
+function WOQLStreamRule() {
+  Config.WOQLViewRule.call(this);
+}
+
+Object.setPrototypeOf(WOQLStreamRule.prototype, Config.WOQLViewRule.prototype);
+
+WOQLStreamRule.prototype.template = function (template) {
+  if (!template) return this.rule.template;
+  this.rule.template = template;
+  return this;
+};
+
+module.exports = WOQLStreamConfig;

package/lib/viewer/tableConfig.js

@@ -0,0 +1,310 @@
+/* eslint-disable no-use-before-define */
+/* eslint-disable no-plusplus */
+const Config = require('./viewConfig');
+const WOQLTable = require('./woqlTable');
+const UTILS = require('../utils');
+
+function WOQLTableConfig() {
+  Config.ViewConfig.call(this);
+  this.type = 'table';
+}
+
+Object.setPrototypeOf(WOQLTableConfig.prototype, Config.ViewConfig.prototype);
+
+WOQLTableConfig.prototype.create = function (client) {
+  const wqt = new WOQLTable(client, this);
+  return wqt;
+};
+
+WOQLTableConfig.prototype.json = function () {
+  const jr = [];
+  for (let i = 0; i < this.rules.length; i++) {
+    jr.push(this.rules[i].json());
+  }
+  const conf = {};
+  if (typeof this.column_order() !== 'undefined') {
+    conf.column_order = this.column_order();
+  }
+  if (typeof this.pagesize() !== 'undefined') {
+    conf.pagesize = this.pagesize();
+  }
+  if (typeof this.renderer() !== 'undefined') {
+    conf.renderer = this.renderer();
+  }
+  if (typeof this.filter() !== 'undefined') {
+    conf.filter = this.filter();
+  }
+  if (typeof this.filterable() !== 'undefined') {
+    conf.filterable = this.filterable();
+  }
+  if (typeof this.pager() !== 'undefined') {
+    conf.pager = this.pager();
+  }
+  if (typeof this.bindings() !== 'undefined') {
+    conf.bindings = this.bindings();
+  }
+  if (typeof this.page() !== 'undefined') {
+    conf.page = this.page();
+  }
+  if (typeof this.changesize() !== 'undefined') {
+    conf.changesize = this.changesize();
+  }
+  const mj = { table: conf, rules: jr };
+  return mj;
+};
+
+WOQLTableConfig.prototype.loadJSON = function (config, rules) {
+  const jr = [];
+  if (Array.isArray(rules)) {
+    for (let i = 0; i < rules.length; i++) {
+      // eslint-disable-next-line no-use-before-define
+      const nr = new WOQLTableRule();
+      nr.json(rules[i]);
+      jr.push(nr);
+    }
+  }
+  this.rules = jr;
+  if (!config) return this;
+  if (typeof config.column_order !== 'undefined') {
+    this.column_order(...config.column_order);
+  }
+  if (typeof config.pagesize !== 'undefined') {
+    this.pagesize(config.pagesize);
+  }
+  if (typeof config.renderer !== 'undefined') {
+    this.renderer(config.renderer);
+  }
+  if (typeof config.filter !== 'undefined') {
+    this.filter(config.filter);
+  }
+  if (typeof config.filterable !== 'undefined') {
+    this.filterable(config.filterable);
+  }
+  if (typeof config.bindings !== 'undefined') {
+    this.bindings(config.bindings);
+  }
+  if (typeof config.pager !== 'undefined') {
+    this.pager(config.pager);
+  }
+  if (typeof config.page !== 'undefined') {
+    this.page(config.page);
+  }
+  if (typeof config.changesize !== 'undefined') {
+    this.changesize(config.changesize);
+  }
+  return this;
+};
+
+WOQLTableConfig.prototype.prettyPrint = function () {
+  let str = 'view = View.table();\n';
+  if (typeof this.column_order() !== 'undefined') {
+    str += `view.column_order('${this.column_order()}')\n`;
+  }
+  if (typeof this.pagesize() !== 'undefined') {
+    str += `view.pagesize(${this.pagesize()})\n`;
+  }
+  if (typeof this.renderer() !== 'undefined') {
+    str += `view.renderer('${this.renderer()}')\n`;
+  }
+  if (typeof this.pager() !== 'undefined') {
+    str += `view.pager(${this.pager()})\n`;
+  }
+  if (typeof this.page() !== 'undefined') {
+    str += `view.page(${this.page()})\n`;
+  }
+  if (typeof this.changesize() !== 'undefined') {
+    str += `view.changesize(${this.changesize()})\n`;
+  }
+
+  for (let i = 0; i < this.rules.length; i++) {
+    const x = this.rules[i].prettyPrint();
+    if (x) str += `view.${x}\n`;
+  }
+  return str;
+};
+
+/**
+ * Gets or sets whether the table is filterable
+ * @param {boolean} [canfilter] - If provided, sets the filterable state
+ * @returns {boolean|WOQLTableConfig} - Returns the filterable state (boolean) when called
+ * without arguments, or returns this instance (WOQLTableConfig) for chaining when setting
+ */
+
+WOQLTableConfig.prototype.filterable = function (canfilter) {
+  if (!canfilter && canfilter !== false) return this.tfilterable;
+  this.tfilterable = canfilter;
+  return this;
+};
+
+/*
+* default is string
+* filter type number | list | date
+*/
+WOQLTableConfig.prototype.filter = function (filter) {
+  if (!filter) return this.tfilter;
+  this.tfilter = filter;
+  return this;
+};
+
+WOQLTableConfig.prototype.renderer = function (rend) {
+  if (!rend) return this.trenderer;
+  this.trenderer = rend;
+  return this;
+};
+
+WOQLTableConfig.prototype.header = function (theader) {
+  if (typeof theader === 'undefined') return this.theader;
+  this.theader = theader;
+  return this;
+};
+
+/**
+ * @param  {...any} val
+ * @returns {object}
+ */
+WOQLTableConfig.prototype.column_order = function (...val) {
+  if (typeof val === 'undefined' || val.length === 0) {
+    return this.order;
+  }
+  this.order = UTILS.removeNamespacesFromVariables(val);
+  return this;
+};
+
+WOQLTableConfig.prototype.pager = function (val) {
+  if (typeof val === 'undefined') {
+    return this.show_pager;
+  }
+  this.show_pager = val;
+  return this;
+};
+
+WOQLTableConfig.prototype.changesize = function (val) {
+  if (typeof val === 'undefined') return this.change_pagesize;
+  this.change_pagesize = val;
+  return this;
+};
+
+WOQLTableConfig.prototype.pagesize = function (val) {
+  if (typeof val === 'undefined') {
+    return this.show_pagesize;
+  }
+  this.show_pagesize = val;
+  return this;
+};
+
+WOQLTableConfig.prototype.page = function (val) {
+  if (typeof val === 'undefined') {
+    return this.show_pagenumber;
+  }
+  this.show_pagenumber = val;
+  return this;
+};
+
+WOQLTableConfig.prototype.column = function (...cols) {
+  const nr = new WOQLTableRule().scope('column');
+  nr.setVariables(cols);
+  this.rules.push(nr);
+  return nr;
+};
+
+WOQLTableConfig.prototype.row = function () {
+  const nr = new WOQLTableRule().scope('row');
+  this.rules.push(nr);
+  return nr;
+};
+
+/*
+ * Table
+ */
+
+function WOQLTableRule() {
+  Config.WOQLViewRule.call(this);
+}
+
+Object.setPrototypeOf(WOQLTableRule.prototype, Config.WOQLViewRule.prototype);
+
+WOQLTableRule.prototype.header = function (hdr) {
+  if (typeof hdr === 'undefined') {
+    return this.rule.header;
+  }
+  this.rule.header = hdr;
+  return this;
+};
+
+WOQLTableRule.prototype.filter = function (hdr) {
+  if (typeof hdr === 'undefined') {
+    return this.rule.filter;
+  }
+  this.rule.filter = hdr;
+  return this;
+};
+
+WOQLTableRule.prototype.filterable = function (hdr) {
+  if (typeof hdr === 'undefined') {
+    return this.rule.filterable;
+  }
+  this.rule.filterable = hdr;
+  return this;
+};
+
+WOQLTableRule.prototype.width = function (wid) {
+  if (typeof wid === 'undefined') {
+    return this.rule.width;
+  }
+  this.rule.width = wid;
+  return this;
+};
+
+WOQLTableRule.prototype.maxWidth = function (wid) {
+  if (typeof wid === 'undefined') {
+    return this.rule.maxWidth;
+  }
+  this.rule.maxWidth = wid;
+  return this;
+};
+
+WOQLTableRule.prototype.minWidth = function (wid) {
+  if (typeof wid === 'undefined') {
+    return this.rule.minWidth;
+  }
+  this.rule.minWidth = wid;
+  return this;
+};
+
+WOQLTableRule.prototype.unsortable = function (unsortable) {
+  if (typeof unsortable === 'undefined') {
+    return this.rule.unsortable;
+  }
+  this.rule.unsortable = unsortable;
+  return this;
+};
+
+WOQLTableRule.prototype.uncompressed = function (uncompressed) {
+  if (typeof uncompressed === 'undefined') {
+    return this.rule.uncompressed;
+  }
+  this.rule.uncompressed = uncompressed;
+  return this;
+};
+
+WOQLTableRule.prototype.prettyPrint = function () {
+  let str = Config.WOQLViewRule.prototype.prettyPrint.apply(this);
+  if (typeof this.header() !== 'undefined') {
+    str += `.header(${this.header()})`;
+  }
+  if (this.sortable()) {
+    str += '.sortable(true)';
+  }
+  if (typeof this.width() !== 'undefined') {
+    str += `.width(${this.width()})`;
+  }
+  if (typeof this.maxWidth() !== 'undefined') {
+    str += `.maxWidth(${this.maxWidth()})`;
+  }
+  if (typeof this.minWidth() !== 'undefined') {
+    str += `.minWidth(${this.minWidth()})`;
+  }
+  return str;
+};
+
+module.exports = WOQLTableConfig;

package/lib/viewer/terminusRule.js

@@ -0,0 +1,196 @@
+const UTILS = require('../utils');
+
+/**
+ * @file Terminus Rules
+ * @license Apache Version 2
+ * Abstract object to support applying matching rules to result sets and documents
+ * sub-classes are FrameRule and WOQLRule - this just has common functions
+ */
+function TerminusRule() {}
+
+/**
+ * @param {Boolean} tf - the rule will match all literals or all non-literals
+ */
+TerminusRule.prototype.literal = function (tf) {
+  if (typeof tf === 'undefined') {
+    return this.pattern.literal;
+  }
+  this.pattern.literal = tf;
+  return this;
+};
+
+/**
+ * @param {...string} list - parameters are types identified by prefixed URLS (xsd:string...)
+ */
+TerminusRule.prototype.type = function (...list) {
+  if (typeof list === 'undefined' || list.length === 0) {
+    return this.pattern.type;
+  }
+  this.pattern.type = list;
+  return this;
+};
+
+/**
+ * Specifies the scope of a rule - row / cell / object / property / * .. what part
+ * of the result does the rule apply to
+ */
+TerminusRule.prototype.scope = function (scope) {
+  if (typeof scope === 'undefined') {
+    return this.pattern.scope;
+  }
+  this.pattern.scope = scope;
+  return this;
+};
+
+/**
+ * Specifies that the rule matches a specific value
+ */
+TerminusRule.prototype.value = function (...val) {
+  if (typeof val === 'undefined') {
+    return this.pattern.value;
+  }
+  this.pattern.value = val;
+  return this;
+};
+
+/**
+ * Produces a canonical json format to represent the rule
+ */
+TerminusRule.prototype.json = function (mjson) {
+  if (!mjson) {
+    const njson = {};
+    if (this.pattern) njson.pattern = this.pattern.json();
+    if (this.rule) njson.rule = this.rule;
+    return njson;
+  }
+
+  if (mjson.pattern) this.pattern.setPattern(mjson.pattern);
+  if (mjson.rule) this.rule = mjson.rule;
+
+  return this;
+};
+
+/**
+ * Contained Pattern Object to encapsulate pattern matching
+ * @param {Object} pattern
+ */
+// eslint-disable-next-line no-unused-vars
+function TerminusPattern(pattern) {}
+
+TerminusPattern.prototype.setPattern = function (pattern) {
+  if (typeof pattern.literal !== 'undefined') this.literal = pattern.literal;
+  if (pattern.type) this.type = pattern.type;
+  if (pattern.scope) this.scope = pattern.scope;
+  if (pattern.value) this.value = pattern.value;
+};
+
+TerminusPattern.prototype.json = function () {
+  const json = {};
+  if (typeof this.literal !== 'undefined') json.literal = this.literal;
+  if (this.type) json.type = this.type;
+  if (this.scope) json.scope = this.scope;
+  if (this.value) json.value = this.value;
+  return json;
+};
+
+/**
+ * Tests whether the passed values matches the basic pattern
+ */
+TerminusPattern.prototype.testBasics = function (scope, value) {
+  if (this.scope && scope && this.scope !== scope) return false;
+  if (this.type) {
+    const dt = value['@type'];
+    if (!dt || !this.testValue(dt, this.type)) return false;
+  }
+  if (typeof this.literal !== 'undefined') {
+    if (!(this.literal === !(typeof value['@type'] === 'undefined'))) return false;
+  }
+  if (typeof this.value !== 'undefined') {
+    if (!this.testValue(value, this.value)) return false;
+  }
+  return true;// passed all tests
+};
+
+TerminusPattern.prototype.testValue = function (value, constraint) {
+  if (!value) return null;
+  const vundertest = (value['@value'] ? value['@value'] : value);
+  if (typeof constraint === 'function') return constraint(vundertest);
+  // eslint-disable-next-line no-param-reassign
+  if (constraint && !Array.isArray(constraint)) constraint = [constraint];
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < constraint.length; i++) {
+    const nc = constraint[i];
+    if (typeof vundertest === 'string') {
+      if (this.stringMatch(nc, vundertest)) return true;
+    } else if (typeof vundertest === 'number') {
+      if (this.numberMatch(nc, vundertest)) return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * Unpacks an array into a list of arguments
+ * @param {Boolean} nonstring - if set, the values will be double-quoted only when
+ * they are strings, otherwise, all will be quoted as strings
+ */
+TerminusPattern.prototype.unpack = function (arr, nonstring) {
+  let str = '';
+  if (nonstring) {
+    // eslint-disable-next-line no-plusplus
+    for (let i = 0; i < arr.length; i++) {
+      if (typeof arr[i] === 'string') {
+        str += `"${arr[i]}"`;
+      } else {
+        str += arr[i];
+      }
+      if (i < (arr.length - 1)) str += ', ';
+    }
+  } else {
+    str = `"${arr.join('","')}"`;
+  }
+  return str;
+};
+
+TerminusPattern.prototype.IDsMatch = function (ida, idb) {
+  return UTILS.compareIDs(ida, idb);
+};
+
+TerminusPattern.prototype.classIDsMatch = function (ida, idb) {
+  return this.IDsMatch(ida, idb);
+};
+
+TerminusPattern.prototype.propertyIDsMatch = function (ida, idb) {
+  const match = this.IDsMatch(ida, idb);
+  return match;
+};
+
+TerminusPattern.prototype.rangeIDsMatch = function (ida, idb) {
+  return this.IDsMatch(ida, idb);
+};
+
+TerminusPattern.prototype.valuesMatch = function (vala, valb) {
+  return vala === valb;
+};
+TerminusPattern.prototype.numberMatch = function (vala, valb) {
+  if (typeof vala === 'string') {
+    try {
+      // eslint-disable-next-line no-eval
+      return eval(valb + vala);
+    } catch (e) {
+      return false;
+    }
+  }
+  return vala === valb;
+};
+
+TerminusPattern.prototype.stringMatch = function (vala, valb) {
+  if (vala.substring(0, 1) === '/') {
+    const pat = new RegExp(vala.substring(1));
+    return pat.test(valb);
+  }
+
+  return vala === valb;
+};
+
+module.exports = { TerminusRule, TerminusPattern };