terminusdb 12.0.2

package/lib/const.js

@@ -0,0 +1,59 @@
+/**
+ * @file Terminus Constants
+ * @license Apache Version 2
+ * Constants representing API actions
+ */
+
+module.exports = Object.freeze({
+  POST: 'POST',
+  GET: 'GET',
+  DELETE: 'DELETE',
+  PUT: 'PUT',
+  HEAD: 'HEAD',
+  QUERY_DOCUMENT: 'QUERY_DOCUMENT',
+  SQUASH_BRANCH: 'SQUASH_BRANCH',
+  UPDATE_SCHEMA: 'UPDATE_SCHEMA',
+  CONNECT: 'connect',
+  CREATE_DATABASE: 'create_database',
+  READ_DATABASE: 'read_database',
+  UPDATE_DATABASE: 'update_database',
+  CREATE_USER: 'create_user',
+  READ_USER: 'read_user',
+  UPDATE_USER: 'update_user',
+  CREATE_ORGANIZATION: 'create_organization',
+  READ_ORGANIZATION: 'read_organization',
+  UPDATE_ORGANIZATION: 'update_organization',
+  GET_ROLES: 'get_roles',
+  UPDATE_ROLES: 'update_roles',
+  CREATE_GRAPH: 'create_graph',
+  GET_TRIPLES: 'get_triples',
+  INSERT_TRIPLES: 'insert_triples',
+  UPDATE_TRIPLES: 'update_triples',
+  CLASS_FRAME: 'class_frame',
+  WOQL_QUERY: 'woql_query',
+  CLONE: 'clone',
+  CSV: 'csv',
+  WOQL: 'woql',
+  FRAME: 'frame',
+  PUSH: 'push',
+  PULL: 'pull',
+  FETCH: 'fetch',
+  REBASE: 'rebase',
+  RESET: 'reset',
+  BRANCH: 'branch',
+  REMOTE: 'remote',
+  CREATE_REMOTE: 'create_remote',
+  GET_REMOTE: 'get_remote',
+  UPDATE_REMOTE: 'update_remote',
+  DELETE_REMOTE: 'delete_remote',
+  RESET_BRANCH: 'reset_branch',
+  ADD_CSV: 'add_csv',
+  GET_CSV: 'get_csv',
+  UPDATE_CSV: 'update_csv',
+  MESSAGE: 'message',
+  ACTION: 'action',
+  INFO: 'info',
+  OPTIMIZE_SYSTEM: 'optimize_system',
+  GET_DIFF: 'getDiff',
+  PATCH: 'patch',
+});

package/lib/dispatchRequest.js

@@ -0,0 +1,236 @@
+/* eslint-disable camelcase */
+const pako = require('pako');
+const axiosInstance = require('./axiosInstance');
+const UTILS = require('./utils');
+const CONST = require('./const');
+const ErrorMessage = require('./errorMessage');
+const { version } = require('../package.json');
+// eslint-disable-next-line no-unused-vars
+const typedef = require('./typedef');
+/**
+ * base 64 encodes a string using either the btoa implementation if available or the Buffer object.
+ * @param {String} str string to be base 64 encoded
+ */
+function btoaImplementation(str) {
+  try {
+    return btoa(str);
+  } catch (err) {
+    return Buffer.from(str).toString('base64');
+  }
+}
+
+/**
+ * @param {object} response
+ * @returns {object} Object having two properties result and dataVersion
+ */
+function getResultWithDataVersion(response) {
+  return {
+    result: response.data,
+    dataVersion: response.headers['terminusdb-data-version']
+      ? response.headers['terminusdb-data-version']
+      : '',
+  };
+}
+/**
+ * Create the authorization header string
+ * @param {object} auth_obj
+ * @returns {object} Object with the Authorization header
+ */
+
+function formatAuthHeader(auth_obj) {
+  if (!auth_obj) return '';
+  const authType = { jwt: 'Bearer', basic: 'Basic', apikey: 'Token' };
+  let auth_key = auth_obj.key;
+
+  if (auth_obj.type === 'basic') {
+    auth_key = btoaImplementation(`${auth_obj.user}:${auth_obj.key}`);
+  }
+  return `${authType[auth_obj.type]} ${auth_key}`;
+}
+
+function checkPayload(payload, options, compress) {
+  if (!payload || typeof payload !== 'object') return false;
+  const jsonStringPost = JSON.stringify(payload);
+  if (jsonStringPost && jsonStringPost.length > 1024 && compress) {
+    // eslint-disable-next-line no-param-reassign
+    options.headers['Content-Encoding'] = 'gzip';
+    return pako.gzip(jsonStringPost);
+  }
+  return false;
+}
+
+/**
+ * @file Dispatch Request
+ * @license Apache Version 2
+ * @description Functions for dispatching API requests via the axios library.
+ * @param {string} url  API endpoint URL
+ * @param {string} action API action
+ * @param {object} payload data to be transmitted to endpoint
+ * @param {typedef.CredentialObj} local_auth the local authorization object
+ * @param {typedef.CredentialObj} remote_auth the remote authoriuzation object
+ * @param {object} customHeaders all the custom header to add to your call
+ * @param {boolean} [getDataVersion] If true the function will return object having result
+ * and dataVersion.
+ * @param {boolean} [compress] If true, compress the data with gzip if its size is bigger than 1024
+ */
+
+// eslint-disable-next-line max-len
+function DispatchRequest(url, action, payload, local_auth, remote_auth = null, customHeaders = null, getDataVersion = false, compress = false) {
+  /*
+     *CORS is only required when trying to fetch data from a browser,
+     *as browsers by default will block requests to different origins
+     */
+  const options = {
+    mode: 'cors', // no-cors, cors, *same-origin
+    redirect: 'follow', // manual, *follow, error
+    referrer: 'client',
+    maxContentLength: Infinity,
+    maxBodyLength: Infinity,
+    headers: {},
+    // url:url,
+    // no-referrer, *client
+  };
+  // Only allow self signed certs on 127.0.0.1
+  // and on node
+  if (url.startsWith('https://127.0.0.1') && typeof window === 'undefined') {
+    // eslint-disable-next-line global-require
+    const https = require('https');
+    const agent = new https.Agent({
+      rejectUnauthorized: false,
+    });
+    options.httpsAgent = agent;
+  }
+
+  /*
+     * I can call the local database using the local authorization key or
+     * a jwt token
+     */
+  /* if (local_auth && local_auth.type === 'basic') {
+    const encoded = btoaImplementation(`${local_auth.user}:${local_auth.key}`);
+    options.headers = { Authorization: `Basic ${encoded}` };
+  } else if (local_auth && local_auth.type === 'jwt') {
+    options.headers = { Authorization: `Bearer ${local_auth.key}` };
+  } else if (local_auth && local_auth.type === 'apikey') {
+    options.headers = { Authorization: `Token ${local_auth.key}` };
+  } */
+  /*
+     * I can call the local database or a custom installation using the local authorization key or
+     * I Can call TerminusX using the jwt token or an apiToken
+     */
+  if (local_auth && typeof local_auth === 'object') {
+    options.headers.Authorization = formatAuthHeader(local_auth);
+  }
+
+  /*
+   * pass the Authorization information of another
+   * terminusdb server to the local terminusdb
+   * for authentication you can use jwt or the apiKey token in TerminusX or
+   * the Basic autentication if is allowed in the custom server
+   */
+  if (remote_auth && typeof remote_auth === 'object') {
+    options.headers['Authorization-Remote'] = formatAuthHeader(remote_auth);
+  }
+
+  if (customHeaders && typeof customHeaders === 'object') {
+    // eslint-disable-next-line array-callback-return
+    Object.keys(customHeaders).map((key) => {
+      options.headers[key] = customHeaders[key];
+    });
+  }
+
+  if (typeof window === 'undefined') {
+    options.headers['User-Agent'] = `terminusdb-client-js/${version}`;
+  }
+
+  switch (action) {
+    case CONST.DELETE: {
+      if (payload) {
+        options.headers = options.headers ? options.headers : {};
+        options.headers['Content-Type'] = 'application/json; charset=utf-8';
+        options.data = payload;
+      }
+      return axiosInstance
+        .delete(url, options)
+        .then((response) => (getDataVersion ? getResultWithDataVersion(response) : response.data))
+        .catch((err) => {
+          throw ErrorMessage.apiErrorFormatted(url, options, err);
+        });
+    }
+    case CONST.HEAD: {
+      return axiosInstance
+        .head(url, options)
+        .then((response) => (getDataVersion ? getResultWithDataVersion(response) : response.data))
+        .catch((err) => {
+          throw ErrorMessage.apiErrorFormatted(url, options, err);
+        });
+    }
+    case CONST.GET: {
+      if (payload) {
+        const ext = UTILS.URIEncodePayload(payload);
+        // eslint-disable-next-line no-param-reassign
+        if (ext) url += `?${ext}`;
+      }
+      return axiosInstance
+        .get(url, options)
+        .then((response) => {
+          const r = getDataVersion ? getResultWithDataVersion(response) : response.data;
+          return r;
+        })
+        .catch((err) => {
+          throw ErrorMessage.apiErrorFormatted(url, options, err);
+        });
+    }
+    case CONST.ADD_CSV:
+    case CONST.INSERT_TRIPLES: {
+      options.headers = options.headers ? options.headers : {};
+      options.headers['Content-Type'] = 'application/form-data; charset=utf-8';
+      return axiosInstance
+        .put(url, payload, options)
+        .then((response) => (getDataVersion ? getResultWithDataVersion(response) : response.data))
+        .catch((err) => {
+          throw ErrorMessage.apiErrorFormatted(url, options, err);
+        });
+    }
+    case CONST.PUT: {
+      options.headers = options.headers ? options.headers : {};
+      options.headers['Content-Type'] = 'application/json; charset=utf-8';
+      let compressedContent = null;
+      const jsonString = JSON.stringify(payload);
+
+      if (jsonString.length > 1024 && compress) {
+        options.headers['Content-Encoding'] = 'gzip';
+        compressedContent = pako.gzip(jsonString);
+      }
+      return axiosInstance
+        .put(url, compressedContent || payload, options)
+        .then((response) => (getDataVersion ? getResultWithDataVersion(response) : response.data))
+        .catch((err) => {
+          throw ErrorMessage.apiErrorFormatted(url, options, err);
+        });
+    }
+    case CONST.QUERY_DOCUMENT: {
+      options.headers = options.headers ? options.headers : {};
+      options.headers['X-HTTP-Method-Override'] = 'GET';
+      // eslint-disable-next-line no-fallthrough
+    }
+    // eslint-disable-next-line no-fallthrough
+    default: {
+      options.headers = options.headers ? options.headers : {};
+      if (!options.headers['content-type'] && !options.headers['Content-Type']) {
+        options.headers['Content-Type'] = 'application/json; charset=utf-8';
+      }
+      const compressedContentPost = checkPayload(payload, options, compress);
+      return axiosInstance
+        .post(url, compressedContentPost || payload || {}, options)
+        .then((response) => {
+          const r = getDataVersion ? getResultWithDataVersion(response) : response.data;
+          return r;
+        })
+        .catch((err) => {
+          throw ErrorMessage.apiErrorFormatted(url, options, err);
+        });
+    }
+  }
+}
+
+module.exports = DispatchRequest;

package/lib/errorMessage.js

@@ -0,0 +1,110 @@
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable prefer-destructuring */
+/* eslint-disable no-use-before-define */
+/* eslint-disable no-param-reassign */
+function getErrorAsMessage(url, api, err) {
+  let str = '';
+  if (err.response) {
+    err = err.response;
+    if (err.data) str += `${formatErrorMessage(err.data)}`;
+  } else if (err.body) str += `${formatErrorMessage(err.body)}`;
+  url = url.split('?')[0];
+
+  if (err.status) str += `Code: ${err.status}`;
+  if (err.action) str += ` Action: ${err.action}`;
+  if (err.type) str += ` Type: ${err.type}`;
+  if (url) str += ` url: ${url}`;
+  if (api && api.method) str += ` method: ${api.method}`;
+  if (err.stack) str = [str, err.stack].join('\n');
+  return str;
+}
+
+function formatErrorMessage(msg) {
+  if (typeof msg === 'object') {
+    let nmsg = '';
+    for (const key of Object.keys(msg)) {
+      if (msg[key] && typeof msg[key] !== 'object') nmsg += `${key} ${msg[key]} `;
+    }
+    return nmsg;
+  }
+  return msg;
+}
+
+function accessDenied(action, db, server) {
+  const err = {};
+  err.status = 403;
+  err.url = (server || '') + (db || '');
+  err.type = 'client';
+  err.action = action;
+  err.body = `${err.action} not permitted for ${err.url}`;
+  return err;
+}
+
+function getAPIErrorMessage(url, api, err) {
+  return `API Error ${getErrorAsMessage(url, api, err)}`;
+}
+
+function getAccessDeniedMessage(url, api, err) {
+  return `Access Denied ${getErrorAsMessage(url, api, err)}`;
+}
+
+function getInvalidURIMessage(url, call) {
+  const str = `Invalid argument to
+            ${call}. 
+            ${url}
+            is not a valid Terminus DB API endpoint`;
+  return str;
+}
+
+function getInvalidParameterMessage(call, msg) {
+  const str = `Invalid Parameter to
+            ${call}. 
+            ${msg}`;
+  return str;
+}
+
+/**
+ * Utility functions for generating and retrieving error messages
+ * and storing error state
+ */
+
+function parseAPIError(response) {
+  const err = {};
+  err.status = response.status;
+  err.type = response.type;
+  if (response.data && typeof response.data === 'object') {
+    let msg;
+    try {
+      msg = response.text();
+    } catch (e) {
+      try {
+        msg = response.json();
+      } catch (error) {
+        msg = response.toString();
+      }
+    }
+    err.body = msg;
+  } else if (response.data) err.body = response.data;
+  err.url = response.url;
+  err.headers = response.headers;
+  err.redirected = response.redirected;
+  return err;
+}
+
+function apiErrorFormatted(url, options, err) {
+  const e = new Error(getAPIErrorMessage(url, options, err));
+  if (err.response && err.response.data) e.data = err.response.data;
+  if (err.response && err.response.status) e.status = err.response.status;
+  return e;
+}
+
+module.exports = {
+  apiErrorFormatted,
+  getErrorAsMessage,
+  getAPIErrorMessage,
+  getAccessDeniedMessage,
+  accessDenied,
+  getInvalidURIMessage,
+  getInvalidParameterMessage,
+  parseAPIError,
+};

package/lib/query/woqlBuilder.js

@@ -0,0 +1,234 @@
+/* eslint-disable guard-for-in */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable no-self-assign */
+/* eslint-disable camelcase */
+/* eslint-disable no-param-reassign */
+// WOQLQuery
+/**
+ * module WOQLQuery
+ *
+ */
+
+/**
+ * defines the internal functions of the woql query object - the
+ * language API is defined in WOQLQuery
+ * @module WOQLQuery
+ * @constructor
+ * @param {object} [query] json-ld query for initialisation
+ * @returns {WOQLQuery}
+ */
+
+const WOQLQueryExt = require('./woqlQuery');
+
+// eslint-disable-next-line no-unused-vars
+const typedef = require('../typedef');
+// const WOQLLibrary = require('./woqlLibrary');
+
+class WOQLQuery extends WOQLQueryExt {
+  // eslint-disable-next-line no-useless-constructor
+  constructor(query) {
+    super(query);
+  }
+}
+
+// WOQLQuery.prototype.counter = 1;
+/**
+ * @param {typedef.GraphRef} [Graph] - the resource identifier of a graph possible
+ * @param {string|Var} [Subj] - The IRI of a triple’s subject or a variable
+ * @param {string|Var} [Pred] - The IRI of a property or a variable
+ * @param {string|Var} [Obj] - The IRI of a node or a variable, or a literal
+ * @returns {WOQLQuery} - A WOQLQuery which contains the pattern matching expression
+ */
+/**
+ * Simple composite functions which produce WOQL queries
+ */
+WOQLQuery.prototype.star = function (Graph, Subj, Pred, Obj) {
+  Subj = Subj || 'v:Subject';
+  Pred = Pred || 'v:Predicate';
+  Obj = Obj || 'v:Object';
+  Graph = Graph || false;
+  if (Graph) {
+    return this.quad(Subj, Pred, Obj, Graph);
+  }
+  return this.triple(Subj, Pred, Obj);
+};
+
+/**
+ * @param {string|Var} [Subj] - The IRI of a triple’s subject or a variable
+ * @param {string|Var} [Pred] - The IRI of a property or a variable
+ * @param {string|Var} [Obj] - The IRI of a node or a variable, or a literal
+ * @param {typedef.GraphRef} [Graph] - the resource identifier of a graph possible
+ * @returns {WOQLQuery} - A WOQLQuery which contains the pattern matching expression
+ */
+
+WOQLQuery.prototype.all = function (Subj, Pred, Obj, Graph) {
+  return this.star(Graph, Subj, Pred, Obj);
+};
+
+/**
+ * @param {string} s
+ * @returns {object}
+ */
+
+WOQLQuery.prototype.string = function (s) {
+  return { '@type': 'xsd:string', '@value': String(s) };
+};
+
+/**
+ * @param {boolean} tf
+ * @returns {object}
+ */
+
+WOQLQuery.prototype.boolean = function (tf) {
+  tf = tf || false;
+  return this.literal(tf, 'boolean');
+};
+
+/**
+ * @param {any} s - the value of the literal
+ * @param {string} t - the type of the literal, e.g. 'xsd:string', 'xsd:boolean'
+ * @returns {object} - a WOQL DataValue object with the given type and value
+ */
+WOQLQuery.prototype.literal = function (s, t) {
+  t = t.indexOf(':') === -1 ? `xsd:${t}` : t;
+  return { '@type': t, '@value': s };
+};
+
+/**
+ * @param {string} s
+ * @returns {object}
+ */
+
+WOQLQuery.prototype.iri = function (s) {
+  return {
+    '@type': 'NodeValue',
+    node: s,
+  };
+};
+
+/**
+ * Update a pattern matching rule for the triple (Subject, Predicate, oldObjValue) with the
+ * new one (Subject, Predicate, newObjValue)
+ * @param {string|Var} subject - The IRI of a triple’s subject or a variable
+ * @param {string|Var} predicate - The IRI of a property or a variable
+ * @param {string|Var} newObjValue - The value to update or a literal
+ * @param {string|Var} oldObjValue - The old value of the object
+ * @returns {WOQLQuery} A WOQLQuery which contains the a Update Triple Statement
+ */
+
+WOQLQuery.prototype.update_triple = function (subject, predicate, newObjValue, oldObjValue) {
+  const tmp_name = oldObjValue || `v:AnyObject__${this.counter += 1}`;
+  return this.and(
+    new WOQLQuery().opt(
+      new WOQLQuery()
+        .triple(subject, predicate, tmp_name)
+        .delete_triple(subject, predicate, tmp_name)
+        .not()
+        .triple(subject, predicate, newObjValue),
+    ),
+    new WOQLQuery().add_triple(subject, predicate, newObjValue),
+  );
+};
+
+/**
+ * @description Update a pattern matching rule for the quad [S, P, O, G]
+ * (Subject, Predicate, Object, Graph)
+ * @param {string} subject - The IRI of a triple’s subject or a variable
+ * @param {string} predicate - The IRI of a property or a variable
+ * @param {string} newObject - The value to update or a literal
+ * @param {string} graph - the resource identifier of a graph possible value are
+ * schema/{main - myschema - *} | instance/{main - myschema - *}  | inference/{main - myschema - *}
+ * @returns {WOQLQuery} A WOQLQuery which contains the a Update Quad Statement
+ */
+
+WOQLQuery.prototype.update_quad = function (subject, predicate, newObject, graph) {
+  const tmp_name = `v:AnyObject__${this.counter += 1}`;
+  return this.and(
+    new WOQLQuery().opt(
+      new WOQLQuery()
+        .quad(subject, predicate, tmp_name, graph)
+        .delete_quad(subject, predicate, tmp_name, graph)
+        .not()
+        .quad(subject, predicate, newObject, graph),
+    ),
+    new WOQLQuery().add_quad(subject, predicate, newObject, graph),
+  );
+};
+
+/**
+ * Deletes all triples in the passed graph (defaults to instance/main)
+ * @param {typedef.GraphRef} [graphRef] - Resource String identifying the graph from
+ * which all triples will be removed
+ * @returns {WOQLQuery} - A WOQLQuery which contains the deletion expression
+ */
+
+WOQLQuery.prototype.nuke = function (graphRef) {
+  if (graphRef) {
+    return this.quad('v:A', 'v:B', 'v:C', graphRef).delete_quad('v:A', 'v:B', 'v:C', graphRef);
+  }
+  return this.triple('v:A', 'v:B', 'v:C').delete_triple('v:A', 'v:B', 'v:C');
+};
+
+/**
+ * @param {string|Var} node -  The IRI of a node or a variable containing an IRI which will
+ * be the subject of the builder functions
+ * @param {typedef.FuntionType} [type] - Optional type of builder function to build
+ * (default is triple)
+ * @returns {WOQLQuery} - A WOQLQuery which contains the partial Node pattern matching expression
+ */
+
+WOQLQuery.prototype.node = function (node, type) {
+  type = type || false;
+  if (type === 'add_quad') type = 'AddTriple';
+  else if (type === 'delete_quad') type = 'DeleteTriple';
+  else if (type === 'add_triple') type = 'AddTriple';
+  else if (type === 'delete_triple') type = 'DeleteTriple';
+  else if (type === 'quad') type = 'Triple';
+  else if (type === 'triple') type = 'Triple';
+  if (type && type.indexOf(':') === -1) type = type;
+  const ctxt = { subject: node };
+  if (type) ctxt.action = type;
+  this._set_context(ctxt);
+  return this;
+};
+
+// do not remove
+/**
+ * Sets the graph resource ID that will be used for subsequent chained function calls
+ * @param {typedef.GraphRef} [graphRef] Resource String identifying the graph which will
+ * be used for subsequent chained schema calls
+ * @returns {WOQLQuery} A WOQLQuery which contains the partial Graph pattern matching expression
+ */
+WOQLQuery.prototype.graph = function (graphRef) {
+  return this._set_context({
+    graph: graphRef,
+  });
+};
+// do not remove
+WOQLQuery.prototype._set_context = function (ctxt) {
+  if (!this.triple_builder_context) this.triple_builder_context = {};
+
+  for (const k in ctxt) {
+    this.triple_builder_context[k] = ctxt[k];
+  }
+
+  return this;
+};
+
+/**
+ * @param {string|Var} id - IRI string or variable containing
+ * @param {string|Var} type  -  IRI string or variable containing the IRI of the
+ * @param {typedef.GraphRef} [refGraph] - Optional Graph resource identifier
+ * @returns {WOQLQuery} A WOQLQuery which contains the insert expression
+ */
+
+WOQLQuery.prototype.insert = function (id, type, refGraph) {
+  refGraph = refGraph || (this.triple_builder_context ? this.triple_builder_context.graph : false);
+  if (refGraph) {
+    return this.add_quad(id, 'rdf:type', `@schema:${type}`, refGraph);
+  }
+  return this.add_triple(id, 'rdf:type', `@schema:${type}`);
+};
+
+module.exports = WOQLQuery;