terminusdb 12.0.2

package/lib/viewer/documentFrame.js

@@ -0,0 +1,206 @@
+/* eslint-disable no-unused-vars */
+/* eslint-disable consistent-return */
+/* eslint-disable no-unused-expressions */
+/* eslint-disable no-param-reassign */
+const ObjectFrame = require('./objectFrame');
+const FrameConfig = require('./frameConfig');
+const FrameHelper = require('../utils');
+
+/**
+ * @file Document Frame
+ * @license Apache Version 2
+ */
+
+function DocumentFrame(client, config) {
+  this.client = client;
+  this.config = (config || new FrameConfig());
+  this.load_schema = false;
+}
+
+DocumentFrame.prototype.options = function (opts) {
+  this.config = opts;
+  return this;
+};
+
+DocumentFrame.prototype.db = function (dburl) {
+  this.client.db(dburl);
+  return this;
+};
+
+/**
+ *  @param {String} url - loads the document frame from the document API in frame form
+ *  - loads the frame encapsulates more meta-data in the json and reduces the
+ * number of api calls we need to make
+ *  @returns {Promise}
+ */
+DocumentFrame.prototype.loadDocument = function (url, encoding) {
+  encoding = encoding || 'system:frame';
+  return this.client.getDocument(url, { 'system:encoding': encoding })
+    .then((response) => {
+      (encoding === 'system:frame' ? this.loadDataFrames(response) : this.loadJSON(response));
+    });
+};
+
+DocumentFrame.prototype.loadSchema = function (cls, dbURL) {
+  const ncls = FrameHelper.unshorten(cls);
+  return this.client.getClassFrame(dbURL, ncls)
+    .then((response) => this.loadSchemaFrames(response, ncls));
+};
+
+/**
+ *  @param {String} url - loads the document frame along with its class frame
+ *  @param {String} [cls] - optional class id of the document - if absent class frames
+ * will be loaded from the document class once it is loaded
+ *  @returns {Promise}
+ *  - loads a document frame and it's class frame in unison
+ */
+
+DocumentFrame.prototype.loadComplete = function (url, cls) {
+  if (cls) {
+    return Promise.all([this.loadDocument(url), this.loadDocumentSchema(cls)]);
+  }
+
+  return this.loadDocument(url)
+    .then(() => {
+      this.loadSchema(this.document.cls);
+    });
+};
+
+DocumentFrame.prototype.loadJSON = function (json, type) {
+  if (this.docid) {
+    return this.loadDocument(this.docid);
+  }
+  if (this.clsid) {
+    return this.loadDocumentSchema(this.clsid);
+  }
+  // eslint-disable-next-line no-console
+  console.error('Either docid or clid must be set before load is called');
+};
+
+DocumentFrame.prototype.loadData = function (jsonld, cls, classframes) {
+  if (!cls) {
+    if (this.document) cls = this.document.cls;
+    else if (jsonld && jsonld['@type']) {
+      cls = jsonld['@type'];
+    }
+  }
+  if (cls) {
+    if (!this.document) {
+      this.document = new ObjectFrame(cls, jsonld, classframes);
+    } else {
+      this.document.loadJSONLDDocument(jsonld);
+    }
+  } else {
+    // eslint-disable-next-line no-console
+    console.log('Missing Class Failed to add dataframes due to missing class');
+  }
+};
+
+DocumentFrame.prototype.load = function (classframes, doc) {
+  this.document = new ObjectFrame(doc['@type'], doc, classframes);
+};
+
+DocumentFrame.prototype.loadSchemaFrames = function (classframes, cls) {
+  if (!cls) {
+    if (classframes && classframes.length && classframes[0] && classframes[0].domain) {
+      cls = classframes[0].domain;
+    }
+  }
+  if (cls) {
+    if (!this.document) {
+      this.document = new ObjectFrame(cls);
+    }
+    if (classframes) {
+      this.document.loadClassFrames(classframes);
+      if (!this.document.subjid) {
+        this.document.newDoc = true;
+        this.document.fillFromSchema(FrameHelper.genBNID(`${FrameHelper.urlFragment(cls)}_`));
+      }
+    }
+  } else {
+    // eslint-disable-next-line no-console
+    console.log('Missing Class', 'Failed to add class frames due to missing both class and classframes');
+  }
+};
+
+DocumentFrame.prototype.filterFrame = function (loadRenderer) {
+  const myfilt = function (frame, rule) {
+    if (typeof rule.render() !== 'undefined') {
+      frame.render = rule.render();
+    }
+    /* else {
+    if(rule.renderer()){
+      var renderer = loadRenderer(rule.renderer(), frame, rule.args);
+    }
+    if(renderer){
+      frame.render = function(fframe){
+        return renderer(fframe);
+      }
+    }
+  } */
+    if (rule.compare()) {
+      frame.compare = rule.compare();
+    }
+    if (rule.errors()) {
+      frame.errors = frame.errors ? frame.errors.concat(rule.errors()) : rule.errors();
+    } else if (rule.errors() === false) delete frame.errors;
+  };
+  this.applyRules(false, false, myfilt);
+};
+
+DocumentFrame.prototype.setErrors = function (errors, frameconf) {
+  this.clearErrors(frameconf);
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < errors.length; i++) {
+    // eslint-disable-next-line no-use-before-define
+    addRuleForVio(frameconf, errors[i]);
+  }
+  const myfilt = function (frame, rule) {
+    if (rule.errors()) {
+      frame.errors = frame.errors ? frame.errors.concat(rule.errors()) : rule.errors();
+    }
+  };
+  this.applyRules(false, frameconf, myfilt);
+};
+
+DocumentFrame.prototype.clearErrors = function (frameconf) {
+  frameconf.all();
+  const myfilt = function (frame, rule) {
+    if (frame.errors) delete (frame.errors);
+  };
+  this.applyRules(false, frameconf, myfilt);
+  frameconf.rules = [];
+};
+
+function addRuleForVio(docview, error) {
+  const prop = (error['vio:property'] ? error['vio:property']['@value'] : false);
+  const subj = (error['vio:subject'] ? error['vio:subject']['@value'] : false);
+  const msg = (error['vio:message'] ? error['vio:message']['@value'] : false);
+  let val = (error['api:value'] ? error['api:value'] : false);
+  if (val && val[0] === '"' && val[val.length - 1] === '"') val = val.substring(1, val.length - 1);
+  const type = (error['api:type'] ? error['api:type'] : false);
+  if (type && val) { // api:BadCast
+    docview.data().value(val).type(type).errors([error]);
+  }
+  if (prop && subj) { // untypedInstanceViolation
+    const shrt = FrameHelper.shorten(subj);
+    if (shrt.substring(0, 5) === 'woql:') shrt === shrt.substring(5);
+    docview.data().property(prop).value(shrt, subj).errors([error]);
+  }
+}
+
+/* "
+ * adds render and compare functions to object frames
+ */
+DocumentFrame.prototype.applyRules = function (doc, config, mymatch) {
+  doc = doc || this.document;
+  if (!doc) return;
+  config = (config || this.config);
+  const onmatch = function (frame, rule) {
+    config.setFrameDisplayOptions(frame, rule);
+    if (mymatch) mymatch(frame, rule);
+  };
+  doc.mfilter(config.rules, onmatch);
+};
+
+module.exports = DocumentFrame;

package/lib/viewer/frameConfig.js

@@ -0,0 +1,469 @@
+/* eslint-disable no-undef */
+/* eslint-disable no-redeclare */
+/* eslint-disable block-scoped-var */
+/* eslint-disable no-var */
+/* eslint-disable vars-on-top */
+/* eslint-disable guard-for-in */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-use-before-define */
+/* eslint-disable no-plusplus */
+/* eslint-disable import/extensions */
+const Config = require('./viewConfig.js');
+const { FrameRule } = require('./frameRule.js');
+const DocumentFrame = require('./documentFrame.js');
+
+/**
+ * @file Frame Config
+ * @license Apache Version 2
+ */
+function FrameConfig() {
+  Config.ViewConfig.call(this);
+  this.type = 'document';
+}
+
+Object.setPrototypeOf(FrameConfig.prototype, Config.ViewConfig.prototype);
+
+FrameConfig.prototype.create = function (client) {
+  const tf = new DocumentFrame(client, this);
+  return tf;
+};
+
+FrameConfig.prototype.prettyPrint = function () {
+  let str = 'view = View.document();\n';
+  str += this.getBasicPrettyPrint();
+  if (typeof this.load_schema() !== 'undefined') {
+    str += `view.load_schema(${this.load_schema()})\n`;
+  }
+  for (let i = 0; i < this.rules.length; i++) {
+    str += `view.${this.rules[i].prettyPrint()}\n`;
+  }
+  return str;
+};
+
+FrameConfig.prototype.json = function () {
+  const conf = this.getBasicJSON();
+  if (typeof this.load_schema() !== 'undefined') {
+    conf.load_schema = this.load_schema();
+  }
+  const mj = { frame: conf, rules: this.getRulesJSON() };
+  return mj;
+};
+
+FrameConfig.prototype.loadJSON = function (config, rules) {
+  const jr = [];
+  for (let i = 0; i < rules.length; i++) {
+    const nr = new DocumentRule();
+    nr.json(rules[i]);
+    jr.push(nr);
+  }
+  this.rules = jr;
+  this.loadBasicJSON(config);
+  if (typeof config.load_schema !== 'undefined') {
+    this.load_schema(config.load_schema);
+  }
+  return this;
+};
+
+FrameConfig.prototype.json_rules = function () {
+  const jr = [];
+  for (let i = 0; i < this.rules.length; i++) {
+    jr.push(this.rules[i].json());
+  }
+  return jr;
+};
+
+FrameConfig.prototype.load_schema = function (tf) {
+  if (typeof tf === 'undefined') return this.get_schema;
+  this.get_schema = tf;
+  return this;
+};
+
+FrameConfig.prototype.show_all = function (r) {
+  this.all().renderer(r);
+  return this;
+};
+
+FrameConfig.prototype.show_parts = function (o, p, d) {
+  this.object().renderer(o);
+  this.property().renderer(p);
+  this.data().renderer(d);
+  return this;
+};
+
+FrameConfig.prototype.object = function () {
+  const fp = new DocumentRule().scope('object');
+  this.rules.push(fp);
+  return fp;
+};
+
+FrameConfig.prototype.property = function () {
+  const fp = new DocumentRule().scope('property');
+  this.rules.push(fp);
+  return fp;
+};
+
+FrameConfig.prototype.scope = function (scope) {
+  const fp = new DocumentRule().scope(scope);
+  this.rules.push(fp);
+  return fp;
+};
+
+FrameConfig.prototype.data = function () {
+  const fp = new DocumentRule().scope('data');
+  this.rules.push(fp);
+  return fp;
+};
+
+FrameConfig.prototype.all = function () {
+  const fp = new DocumentRule().scope('*');
+  this.rules.push(fp);
+  return fp;
+};
+
+/**
+ * Attaches display options to frames from matching rules
+ */
+FrameConfig.prototype.setFrameDisplayOptions = function (frame, rule) {
+  if (typeof frame.display_options === 'undefined') frame.display_options = {};
+  if (typeof rule.mode() !== 'undefined') { frame.display_options.mode = rule.mode(); }
+  if (typeof rule.view() !== 'undefined') frame.display_options.view = rule.view();
+  if (typeof rule.showDisabledButtons() !== 'undefined') frame.display_options.show_disabled_buttons = rule.showDisabledButtons();
+  if (typeof rule.hidden() !== 'undefined') frame.display_options.hidden = rule.hidden();
+  if (typeof rule.collapse() !== 'undefined') frame.display_options.collapse = rule.collapse();
+  if (typeof rule.style() !== 'undefined') frame.display_options.style = rule.style();
+  if (typeof rule.headerStyle() !== 'undefined') frame.display_options.header_style = rule.headerStyle();
+  if (typeof rule.features() !== 'undefined') { frame.display_options.features = this.setFrameFeatures(frame.display_options.features, rule.features()); }
+  if (typeof rule.headerFeatures() !== 'undefined') frame.display_options.header_features = this.setFrameFeatures(frame.display_options.header_features, rule.headerFeatures());
+  if (typeof rule.header() !== 'undefined') frame.display_options.header = rule.header();
+  if (typeof rule.showEmpty() !== 'undefined') frame.display_options.show_empty = rule.showEmpty();
+  if (typeof rule.dataviewer() !== 'undefined') frame.display_options.dataviewer = rule.dataviewer();
+  if (typeof rule.args() !== 'undefined') frame.display_options.args = this.setFrameArgs(frame.display_options.args, rule.args());
+};
+
+/*
+Consolidates properties of features sent in in different rules
+*/
+FrameConfig.prototype.setFrameFeatures = function (existing, fresh) {
+  // preserve order of existing
+  if (!existing || !existing.length) return fresh;
+  if (!fresh || !fresh.length) return existing;
+  const got = [];
+  for (let i = 0; i < existing.length; i++) {
+    const key = (typeof existing[i] === 'string' ? existing[i] : Object.keys(existing[i])[0]);
+    got.push(key);
+  }
+  for (let j = 0; j < fresh.length; j++) {
+    const fkey = (typeof fresh[j] === 'string' ? fresh[j] : Object.keys(fresh[j])[0]);
+    const rep = got.indexOf(fkey);
+    if (rep === -1) existing.push(fresh[j]);
+    else if (typeof fresh[j] === 'object') {
+      const val = existing[rep];
+      if (typeof val === 'string') existing[rep] = fresh[j];
+      else if (typeof val === 'object') {
+        const props = fresh[j][fkey];
+        // eslint-disable-next-line no-restricted-syntax
+        for (const p in props) {
+          existing[rep][fkey][p] = props[p];
+        }
+      }
+    }
+  }
+  return existing;
+};
+
+FrameConfig.prototype.setFrameArgs = function (existing, fresh) {
+  if (!existing) return fresh;
+  if (!fresh) return existing;
+  for (const k in fresh) {
+    existing[k] = fresh[k];
+  }
+  return existing;
+};
+
+/**
+ * @file Document Rule
+ * @license Apache Version 2
+ */
+
+function DocumentRule() {
+  FrameRule.call(this);
+  this.rule = {};
+}
+
+Object.setPrototypeOf(DocumentRule.prototype, FrameRule.prototype);
+
+DocumentRule.prototype.renderer = function (rend) {
+  if (typeof rend === 'undefined') {
+    return this.rule.renderer;
+  }
+  this.rule.renderer = rend;
+  return this;
+};
+
+DocumentRule.prototype.compare = function (func) {
+  if (typeof func === 'undefined') {
+    return this.rule.compare;
+  }
+  this.rule.compare = func;
+  return this;
+};
+
+DocumentRule.prototype.mode = function (mode) {
+  if (typeof mode === 'undefined') {
+    return this.rule.mode;
+  }
+  this.rule.mode = mode;
+  return this;
+};
+
+DocumentRule.prototype.collapse = function (func) {
+  if (typeof func === 'undefined') {
+    return this.rule.collapse;
+  }
+  this.rule.collapse = func;
+  return this;
+};
+
+DocumentRule.prototype.view = function (m) {
+  if (!m) return this.rule.view;
+  this.rule.view = m;
+  return this;
+};
+
+/**
+ * Should actions which are disabled in the given context be displayed?
+ */
+DocumentRule.prototype.showDisabledButtons = function (m) {
+  if (typeof m === 'undefined') return this.rule.show_disabled_buttons;
+  this.rule.show_disabled_buttons = m;
+  return this;
+};
+
+DocumentRule.prototype.header = function (m) {
+  if (!m) return this.rule.header;
+  this.rule.header = m;
+  return this;
+};
+
+DocumentRule.prototype.errors = function (errs) {
+  if (!errs) return this.rule.errors;
+  this.rule.errors = errs;
+  return this;
+};
+
+DocumentRule.prototype.headerStyle = function (m) {
+  if (!m) return this.rule.headerStyle;
+  this.rule.headerStyle = m;
+  return this;
+};
+
+DocumentRule.prototype.showEmpty = function (m) {
+  if (!m) return this.rule.show_empty;
+  this.rule.show_empty = m;
+  return this;
+};
+
+DocumentRule.prototype.dataviewer = function (m) {
+  if (!m) return this.rule.dataviewer;
+  this.rule.dataviewer = m;
+  return this;
+};
+
+DocumentRule.prototype.features = function (...m) {
+  if (typeof m === 'undefined' || m.length === 0) return this.rule.features;
+  this.rule.features = m;
+  return this;
+};
+
+DocumentRule.prototype.headerFeatures = function (...m) {
+  if (typeof m === 'undefined' || m.length === 0) return this.rule.header_features;
+  this.rule.header_features = m;
+  return this;
+};
+
+DocumentRule.prototype.render = function (func) {
+  if (!func) return this.rule.render;
+  const hf = this.headerFeatures();
+  const f = this.features();
+  if (hf && hf.length) {
+    var feats = this.applyFeatureProperty(hf, 'render', func);
+    this.headerFeatures(...feats);
+  } else if (f && f.length) {
+    // eslint-disable-next-line no-redeclare
+    var feats = this.applyFeatureProperty(f, 'render', func);
+    this.features(...feats);
+  } else {
+    this.rule.render = func;
+  }
+  return this;
+};
+
+DocumentRule.prototype.style = function (style) {
+  if (typeof style === 'undefined') return this.rule.style;
+  const hf = this.headerFeatures();
+  const f = this.features();
+  if (hf && hf.length) {
+    var feats = this.applyFeatureProperty(hf, 'style', style);
+    this.headerFeatures(...feats);
+  } else if (f && f.length) {
+    var feats = this.applyFeatureProperty(f, 'style', style);
+    this.features(...feats);
+  } else {
+    this.rule.style = style;
+  }
+  return this;
+};
+
+/**
+ * The frame or feature will be hidden or unhidden (boolean)
+ */
+DocumentRule.prototype.hidden = function (m) {
+  if (typeof m === 'undefined') return this.rule.hidden;
+  const hf = this.headerFeatures();
+  const f = this.features();
+  if (hf && hf.length) {
+    var feats = this.applyFeatureProperty(hf, 'hidden', m);
+    this.headerFeatures(...feats);
+  } else if (f && f.length) {
+    var feats = this.applyFeatureProperty(f, 'hidden', m);
+    this.features(...feats);
+  } else {
+    this.rule.hidden = m;
+  }
+  return this;
+};
+
+/**
+ * Specifies arguments to a renderer
+ */
+DocumentRule.prototype.args = function (json) {
+  if (!json) return this.rule.args;
+  const hf = this.headerFeatures();
+  const f = this.features();
+  if (hf && hf.length) {
+    var feats = this.applyFeatureProperty(hf, 'args', json);
+    this.headerFeatures(...feats);
+  } else if (f && f.length) {
+    var feats = this.applyFeatureProperty(f, 'args', json);
+    this.features(...feats);
+  } else {
+    this.rule.args = json;
+  }
+  return this;
+};
+
+/**
+ * Adds a property to a feature array
+ */
+DocumentRule.prototype.applyFeatureProperty = function (feats, prop, val) {
+  const nfeats = [];
+  for (let i = 0; i < feats.length; i++) {
+    if (typeof feats[i] === 'string') {
+      var nfeat = {};
+      nfeat[feats[i]] = {};
+      nfeat[feats[i]][prop] = val;
+      nfeats.push(nfeat);
+    } else if (typeof feats[i] === 'object') {
+      const fkey = Object.keys(feats[i])[0];
+      if (fkey) {
+        var nfeat = feats[i];
+        nfeat[fkey][prop] = val;
+        nfeats.push(nfeat);
+      }
+    }
+  }
+  return nfeats;
+};
+
+DocumentRule.prototype.unpackFeatures = function (feats) {
+  const extensions = {};
+  let fstr = '';
+  for (let i = 0; i < feats.length; i++) {
+    if (typeof feats[i] === 'string') {
+      fstr += `"${feats[i]}"`;
+    } else if (typeof feats[i] === 'object') {
+      const fid = Object.keys(feats[i])[0];
+      fstr += `"${fid}"`;
+      for (const prop in feats[i][fid]) {
+        extensions[prop] = feats[i][fid][prop];
+      }
+    }
+    if (i < feats.length - 1) {
+      fstr += ', ';
+    }
+  }
+  for (let k = 0; k < Object.keys(extensions).length; k++) {
+    const ext = Object.keys(extensions)[k];
+    const val = extensions[ext];
+    fstr += `).${ext}(`;
+    if (typeof val === 'function') {
+      fstr += val;
+    } else if (typeof val === 'string') {
+      fstr += `"${val}"`;
+    } else if (typeof val === 'object') {
+      fstr += JSON.stringify(val);
+    }
+  }
+  return fstr;
+};
+
+DocumentRule.prototype.prettyPrint = function () {
+  if (this.pattern) {
+    str = this.pattern.prettyPrint();
+  }
+  if (typeof this.renderer() !== 'undefined') {
+    str += `.renderer('${this.renderer()}')`;
+  }
+  if (typeof this.render() !== 'undefined') {
+    str += `.render(${this.render})`;
+  }
+  if (typeof this.compare() !== 'undefined') {
+    str += `.compare(${this.compare()})`;
+  }
+  if (typeof this.mode() !== 'undefined') {
+    str += `.mode('${this.mode()}')`;
+  }
+  if (typeof this.collapse() !== 'undefined') {
+    str += `.collapse(${this.collapse()})`;
+  }
+  if (typeof this.hidden() !== 'undefined') {
+    str += `.hidden(${this.hidden()})`;
+  }
+  if (typeof this.view() !== 'undefined') {
+    str += `.view('${this.view()}')`;
+  }
+  if (typeof this.showDisabledButtons() !== 'undefined') {
+    str += `.showDisabledButtons(${this.showDisabledButtons()})`;
+  }
+  if (typeof this.header() !== 'undefined') {
+    str += `.header(${this.header()})`;
+  }
+  if (typeof this.style() !== 'undefined') {
+    str += `.style("${this.style()}")`;
+  }
+  if (typeof this.headerStyle() !== 'undefined') {
+    str += `.headerStyle("${this.headerStyle()}")`;
+  }
+  if (typeof this.args() !== 'undefined') {
+    str += `.args(${JSON.stringify(this.args())})`;
+  }
+  if (typeof this.errors() !== 'undefined') {
+    str += `.errors(${JSON.stringify(this.errors())})`;
+  }
+  if (typeof this.showEmpty() !== 'undefined') {
+    str += `.showEmpty(${this.show_empty()})`;
+  }
+  if (typeof this.dataviewer() !== 'undefined') {
+    str += `.dataviewer("${this.dataviewer()}")`;
+  }
+  if (typeof this.features() !== 'undefined') {
+    str += `.features(${this.unpackFeatures(this.features())})`;
+  }
+  if (typeof this.headerFeatures() !== 'undefined') {
+    str += `.headerFeatures(${this.unpackFeatures(this.headerFeatures())})`;
+  }
+  return str;
+};
+
+module.exports = FrameConfig;