ronds-metadata 1.3.26 → 1.3.28

package/es/comps/DynamicPorts/graph.d.ts

@@ -68,7 +68,7 @@ declare class DPGraph extends GraphCore<BaseNode, BaseEdge> {
         edges: DPEdge[];
     }): void;
     onContextMenu(data: ContextMenuInfo): any;
-    onAddCopyCells(nodes: DPNode[], edges: DPEdge[]): void;
+    onAddCopyCells(nodes: any[], edges: any[]): void;
     onCopyNodes(args: any[]): void;
     updateNodeNameById(id: string, name: string): void;
     clearContextMenuInfo: () => void;

package/es/comps/DynamicPorts/graph.js

@@ -16,7 +16,7 @@ import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
 /*
  * @Author: wangxian
  * @Date: 2022-05-24 14:31:01
- * @LastEditTime: 2023-12-05 09:54:43
+ * @LastEditTime: 2024-01-16 09:05:26
  */
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 import produce from 'immer';
@@ -30,7 +30,7 @@ import { GraphCore } from '../../framework/graph';
 import NodeElement from './comps/NodeElement';
 import { DPEdge } from './comps/shape/edge';
 import { DPNode } from './comps/shape/node';
-import { formatGraphData, copy, formatNodeInfoToNodeMeta, formattedEdgesToEdgeMeta, isClipboardEmpty, cleanClipboard } from './utils';
+import { formatGraphData, copy, formatNodeInfoToNodeMeta, formattedEdgesToEdgeMeta, isClipboardEmpty, cleanClipboard, getCellsInClipboard } from './utils';
 import { deepClone, guid } from '../../utils';
 import { MetadataService } from '../../framework/metadata/MetadataService';
 import { tr } from '../../framework/locale';
@@ -123,7 +123,7 @@ var DPGraph = /*#__PURE__*/function (_GraphCore) {
           var targetPort = targetNode.getPort(targetPortId);
           // 如果设置输出port类型，则需要校验类型是否相等
           // 只有类型相等才可以联线
-          if ((sourcePort === null || sourcePort === void 0 ? void 0 : sourcePort.type) !== '-1' && (sourcePort === null || sourcePort === void 0 ? void 0 : sourcePort.type) && (targetPort === null || targetPort === void 0 ? void 0 : targetPort.type) && sourcePort.type !== targetPort.type) {
+          if ((sourcePort === null || sourcePort === void 0 ? void 0 : sourcePort.type) !== '-1' && (sourcePort === null || sourcePort === void 0 ? void 0 : sourcePort.type) && (targetPort === null || targetPort === void 0 ? void 0 : targetPort.type) && targetPort.type.indexOf(sourcePort.type) === -1) {
             return false;
           }
           // 判断目标链接桩是否可连接
@@ -738,7 +738,7 @@ var DPGraph = /*#__PURE__*/function (_GraphCore) {
       var cells = [];
       var randomId = guid().substring(0, 4);
       nodes.map(function (cell) {
-        var _node = cell.getData();
+        var _node = cell.data;
         _node = _objectSpread(_objectSpread({}, _node), {}, {
           id: "".concat(_node.id, "_copy_").concat(randomId),
           x: _node.x + 30,
@@ -749,7 +749,7 @@ var DPGraph = /*#__PURE__*/function (_GraphCore) {
         _this2.addNode(newNode);
       });
       edges.map(function (cell) {
-        var _edge = cell.getData();
+        var _edge = cell.data;
         _edge = _objectSpread(_objectSpread({}, _edge), {}, {
           source: "".concat(_edge.source, "_copy_").concat(randomId),
           target: "".concat(_edge.target, "_copy_").concat(randomId)
@@ -762,7 +762,7 @@ var DPGraph = /*#__PURE__*/function (_GraphCore) {
       // 回显选中复制的之后的节点
       nodes.map(function (cell) {
         var _this2$graph;
-        var _node = cell.getData();
+        var _node = cell.data;
         var _cell = (_this2$graph = _this2.graph) === null || _this2$graph === void 0 ? void 0 : _this2$graph.getCellById("".concat(_node.id, "_copy_").concat(randomId));
         cells.push(_cell);
       });
@@ -787,12 +787,12 @@ var DPGraph = /*#__PURE__*/function (_GraphCore) {
           if (isClipboardEmpty()) {
             _message.info(tr('剪切板为空，不可粘贴'));
           } else {
-            var clipboardCells = this.graph.getCellsInClipboard();
-            var selectedNodes = clipboardCells.filter(function (cell) {
-              return cell.isNode();
+            var clipboardCells = getCellsInClipboard();
+            var selectedNodes = clipboardCells === null || clipboardCells === void 0 ? void 0 : clipboardCells.filter(function (cell) {
+              return (cell === null || cell === void 0 ? void 0 : cell.type) === 'node';
             });
-            var selectedEdges = clipboardCells.filter(function (cell) {
-              return cell.isEdge();
+            var selectedEdges = clipboardCells === null || clipboardCells === void 0 ? void 0 : clipboardCells.filter(function (cell) {
+              return (cell === null || cell === void 0 ? void 0 : cell.shape) === 'DPEdge';
             });
             this.onAddCopyCells(selectedNodes, selectedEdges);
             _message.success(tr('粘贴成功'));

package/es/framework/jsonQl/index.js

@@ -0,0 +1,881 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+var JsonQL = /*#__PURE__*/function () {
+  function JsonQL(schema) {
+    _classCallCheck(this, JsonQL);
+    this.schema = schema;
+    this.errors = [];
+    this.fatalError = false;
+    this.joinTables = [];
+    this.all = false;
+    this.select = [];
+    this.from = {
+      db: '',
+      table: ''
+    };
+    this.join = [];
+    this.having = [];
+    this.where = [];
+    this.limit = [];
+    this.columns = [];
+    this.values = [];
+    this.orderBy = '';
+    this.ascOrDesc = '';
+  }
+
+  // █▀▀ █▀▀█ █░░█ █▀▀▄   █▀▄▀█ █▀▀ ▀▀█▀▀ █░░█ █▀▀█ █▀▀▄ █▀▀
+  // █░░ █▄▄▀ █░░█ █░░█   █░▀░█ █▀▀ ░░█░░ █▀▀█ █░░█ █░░█ ▀▀█
+  // ▀▀▀ ▀░▀▀ ░▀▀▀ ▀▀▀░   ▀░░░▀ ▀▀▀ ░░▀░░ ▀░░▀ ▀▀▀▀ ▀▀▀░ ▀▀▀
+  _createClass(JsonQL, [{
+    key: "selectQL",
+    value: function selectQL(_ref) {
+      var db = _ref.db,
+        table = _ref.table,
+        columns = _ref.columns,
+        where = _ref.where,
+        having = _ref.having,
+        limit = _ref.limit,
+        orderBy = _ref.orderBy;
+      this.initJsonQL({
+        db: db,
+        table: table,
+        columns: columns,
+        where: where,
+        having: having,
+        limit: limit,
+        orderBy: orderBy
+      });
+      var selectString = this.buildSelect();
+      if (this.fatalError) {
+        return {
+          status: 'error',
+          query: selectString,
+          errors: this.errors
+        };
+      }
+      return {
+        status: 'success',
+        query: selectString,
+        errors: this.errors
+      };
+    }
+  }, {
+    key: "createQL",
+    value: function createQL(_ref2, data) {
+      var db = _ref2.db,
+        table = _ref2.table,
+        columns = _ref2.columns,
+        where = _ref2.where,
+        having = _ref2.having,
+        limit = _ref2.limit;
+      if (!data) {
+        this.errors.push('Data must be provided in a createQL');
+        this.fatalError = true;
+      }
+      this.initJsonQL({
+        db: db,
+        table: table,
+        columns: columns,
+        where: where,
+        having: having,
+        limit: limit
+      }, data);
+      this.pushPrimaryKey(db, table);
+      var selectString = this.buildCreate();
+      if (this.fatalError) {
+        return {
+          status: 'error',
+          query: selectString,
+          errors: this.errors
+        };
+      }
+      return {
+        status: 'success',
+        query: selectString,
+        errors: this.errors
+      };
+    }
+  }, {
+    key: "updateQL",
+    value: function updateQL(_ref3, data) {
+      var db = _ref3.db,
+        table = _ref3.table,
+        columns = _ref3.columns,
+        where = _ref3.where,
+        having = _ref3.having,
+        limit = _ref3.limit,
+        affectAll = _ref3.affectAll;
+      if (!data) {
+        this.errors.push('Data must be provided in a updateQL');
+        this.fatalError = true;
+      }
+      this.initJsonQL({
+        db: db,
+        table: table,
+        columns: columns,
+        where: where,
+        having: having,
+        limit: limit,
+        affectAll: affectAll
+      }, data);
+      var selectString = this.buildUpdate();
+      if (this.fatalError) {
+        return {
+          status: 'error',
+          query: selectString,
+          errors: this.errors
+        };
+      }
+      return {
+        status: 'success',
+        query: selectString,
+        errors: this.errors
+      };
+    }
+  }, {
+    key: "deleteQL",
+    value: function deleteQL(_ref4) {
+      var db = _ref4.db,
+        table = _ref4.table,
+        columns = _ref4.columns,
+        where = _ref4.where,
+        having = _ref4.having,
+        limit = _ref4.limit,
+        affectAll = _ref4.affectAll;
+      this.initJsonQL({
+        db: db,
+        table: table,
+        columns: columns,
+        where: where,
+        having: having,
+        limit: limit,
+        affectAll: affectAll
+      });
+      var selectString = this.buildDelete();
+      if (this.fatalError) {
+        return {
+          status: 'error',
+          query: selectString,
+          errors: this.errors
+        };
+      }
+      return {
+        status: 'success',
+        query: selectString,
+        errors: this.errors
+      };
+    }
+
+    // █▀▀ █▀▀▄ ▀▀█▀▀ █▀▀█ █░░█ █▀▀█ █▀▀█ ░▀░ █▀▀▄ ▀▀█▀▀
+    // █▀▀ █░░█ ░░█░░ █▄▄▀ █▄▄█ █░░█ █░░█ ▀█▀ █░░█ ░░█░░
+    // ▀▀▀ ▀░░▀ ░░▀░░ ▀░▀▀ ▄▄▄█ █▀▀▀ ▀▀▀▀ ▀▀▀ ▀░░▀ ░░▀░░
+  }, {
+    key: "initJsonQL",
+    value: function initJsonQL(_ref5, data) {
+      var db = _ref5.db,
+        table = _ref5.table,
+        columns = _ref5.columns,
+        where = _ref5.where,
+        having = _ref5.having,
+        limit = _ref5.limit,
+        orderBy = _ref5.orderBy,
+        affectAll = _ref5.affectAll;
+      if (this.validBySchema(db, table)) {
+        this.from = {
+          db: db,
+          table: table
+        };
+      } else {
+        this.fatalError = true;
+        return;
+      }
+      if (affectAll) {
+        this.affectAll = affectAll;
+      }
+      if (data) {
+        this.parseData(db, table, data);
+      }
+      if (columns && (columns || []).length > 0) {
+        this.pushCols({
+          dbName: db,
+          dbAlias: db
+        }, {
+          tableName: table,
+          tableAlias: table
+        }, columns);
+      }
+
+      // If there's no selections then get all non-hidden columns from the schema
+      if (this.select.length === 0) {
+        this.pushSelFromSchema(db, table);
+      }
+      if (where && (where || []).length > 0) {
+        this.pushWhere({
+          dbName: db,
+          dbAlias: db
+        }, {
+          tableName: table,
+          tableAlias: table
+        }, where);
+      }
+      if (having && (having || []).length > 0) {
+        this.pushHaving(having);
+      }
+      if (orderBy) {
+        this.pushOrderBy(db, table, orderBy);
+      }
+      if (limit) {
+        this.limit = limit;
+      }
+    }
+
+    // █▀▀▄ █▀▀█ ▀▀█▀▀ █▀▀█
+    // █░░█ █▄▄█ ░░█░░ █▄▄█
+    // ▀▀▀░ ▀░░▀ ░░▀░░ ▀░░▀
+  }, {
+    key: "parseData",
+    value: function parseData(db, table, data) {
+      var _this = this;
+      Object.keys(data).forEach(function (key) {
+        if (_this.validJQString(db, table, key)) {
+          _this.pushJQString(db, table, key, data[key]);
+          return;
+        }
+        if (!_this.validBySchema(db, table, key)) return;
+        if (typeof data[key] === 'number') {
+          _this.values.push(data[key]);
+        } else if (typeof data[key] === 'string') {
+          _this.values.push("'".concat(data[key], "'"));
+        } else {
+          return;
+        }
+        _this.columns.push(key);
+      });
+    }
+
+    // █▀▀█ █░░█ █▀▀ █░░█   █▀▀ █░░█ █▀▀▄ █▀▀ ▀▀█▀▀ ░▀░ █▀▀█ █▀▀▄ █▀▀
+    // █░░█ █░░█ ▀▀█ █▀▀█   █▀▀ █░░█ █░░█ █░░ ░░█░░ ▀█▀ █░░█ █░░█ ▀▀█
+    // █▀▀▀ ░▀▀▀ ▀▀▀ ▀░░▀   ▀░░ ░▀▀▀ ▀░░▀ ▀▀▀ ░░▀░░ ▀▀▀ ▀▀▀▀ ▀░░▀ ▀▀▀
+  }, {
+    key: "pushPrimaryKey",
+    value: function pushPrimaryKey(db, table) {
+      var _this2 = this;
+      var tableSchema = this.schema[db][table];
+      Object.keys(tableSchema).forEach(function (key) {
+        if (_this2.columns.includes(key)) return;
+        if (tableSchema[key].primaryKey && typeof tableSchema[key].primaryKey === 'function') {
+          if (tableSchema[key].type === 'json') {
+            _this2.errors.push('primaryKey must be either number or string type, check your schema for ' + db + '.' + table);
+            return;
+          }
+          _this2.columns.push("".concat(key));
+          var primaryKey = tableSchema[key].primaryKey();
+          if (tableSchema[key].type === 'string') _this2.values.push("'".concat(primaryKey, "'"));else if (tableSchema[key].type === 'number') _this2.values.push("".concat(primaryKey));else if (!tableSchema[key].type) _this2.values.push("'".concat(primaryKey, "'"));
+        }
+      });
+    }
+  }, {
+    key: "pushQuery",
+    value: function pushQuery(db, table, key, value) {
+      // let key = '$jsonForm[?Booking Month].value';
+
+      var column = this.extractColFromJQString(db, table, key);
+      column = "".concat(db, ".").concat(table, ".").concat(column);
+      value = "IF(\n        ".concat(this.jQSet(db, table, key, value), " IS NOT NULL,\n        ").concat(this.jQSet(db, table, key, value), ",\n        ").concat(column, "\n      )");
+      this.columns.push("".concat(column));
+      this.values.push(value);
+    }
+  }, {
+    key: "pushOrderBy",
+    value: function pushOrderBy(db, table, orderBy) {
+      if (this.validJQString(db, table, orderBy.name)) {
+        this.orderBy = this.jQExtract(db, table, orderBy.name);
+      } else if (this.validBySchema(db, table, orderBy.name)) {
+        this.orderBy = orderBy.name;
+      }
+      if (this.orderBy.length === 0) {
+        return;
+      }
+      if (orderBy.desc && typeof orderBy.desc !== 'boolean') {
+        this.errors.push('orderBy.desc must be a Boolean type value.');
+        return;
+      }
+      this.ascOrDesc = orderBy.desc ? 'DESC' : 'ASC';
+    }
+  }, {
+    key: "pushCols",
+    value: function pushCols(dbObj, tableObj, columns) {
+      if (!this.validBySchema(dbObj.dbName, tableObj.tableName)) {
+        return;
+      }
+      var nameCols = columns.filter(function (col) {
+        return col.name || col.number || col.string || col.count;
+      });
+      var joinCols = columns.filter(function (col) {
+        return col.join;
+      });
+      var fnCols = columns.filter(function (col) {
+        return col.fn;
+      });
+      if (nameCols.length > 0) {
+        this.pushNameCols(dbObj, tableObj, nameCols);
+      }
+      if (joinCols.length > 0) {
+        this.pushJoinCols(dbObj, tableObj, joinCols);
+      }
+      if (fnCols.length > 0) {
+        this.pushFnCols(dbObj, tableObj, fnCols);
+      }
+    }
+  }, {
+    key: "pushSelFromSchema",
+    value: function pushSelFromSchema(db, table) {
+      var _this3 = this;
+      var fromTable = this.schema[db][table];
+      return "".concat(Object.keys(fromTable).filter(function (key) {
+        return fromTable[key].hidden !== true;
+      }).forEach(function (key) {
+        _this3.select.push("".concat(db, ".").concat(table, ".").concat(key));
+      }));
+    }
+  }, {
+    key: "pushNameCols",
+    value: function pushNameCols(dbObj, tableObj, nameCols) {
+      var _this4 = this;
+      nameCols.forEach(function (col) {
+        var selectStr = '';
+        if (col.name && _this4.validJQString(dbObj.dbName, tableObj.tableName, col.name)) {
+          selectStr = _this4.jQExtract(dbObj.dbName, tableObj.tableName, col.name);
+        } else if (col.name && _this4.validBySchema(dbObj.dbName, tableObj.tableName, col.name)) {
+          selectStr = "".concat(dbObj.dbAlias, ".").concat(tableObj.tableAlias, ".").concat(col.name);
+        } else if (col.number && typeof col.number === 'number') {
+          selectStr = "".concat(col.number);
+        } else if (col.number) {
+          _this4.errors.push(col.number + ' is not a number');
+        } else if (col.string && _this4.validString(col.string)) {
+          selectStr = "'".concat(col.string, "'");
+        } else if (col.jsonExtract && _this4.validString(col.jsonExtract.search) && _this4.validString(col.jsonExtract.target)) {
+          selectStr = "JSON_EXTRACT(JSON_EXTRACT(".concat(selectStr, ", CONCAT('$[', SUBSTR(JSON_SEARCH(").concat(selectStr, ", 'one', '").concat(col.jsonExtract.search, "'), 4, 1), ']')), '$.").concat(col.jsonExtract.target, "')");
+        }
+        if (col.count) {
+          selectStr += _this4.countString(dbObj.dbName, tableObj.tableName, col.count);
+        }
+        // We can't have an `as` without something before it so also check the selectStr length
+        if (col.as && _this4.validString(col.as) && selectStr.length > 0) {
+          selectStr += " AS ".concat(col.as);
+        }
+        if (selectStr.length > 0) {
+          _this4.select.push(selectStr);
+        }
+      });
+    }
+  }, {
+    key: "pushJoinCols",
+    value: function pushJoinCols(dbObj, tableObj, joinCols) {
+      var _this5 = this;
+      joinCols.forEach(function (col) {
+        if (!_this5.validBySchema(dbObj.dbName, tableObj.tableName, col.join.where[0].name)) {
+          return;
+        }
+        if (col.join.where[0].isnot) {
+          if (!_this5.validBySchema(col.join.db, col.join.table, col.join.where[0].isnot)) return;
+        }
+        if (col.join.where[0].is) {
+          if (!_this5.validBySchema(col.join.db, col.join.table, col.join.where[0].is)) return;
+        }
+        var joinStr = '';
+        var aliasTableName = _this5.aliasReplicaTableNames(col.join.table);
+        var aliasString = '';
+        if (col.join.table !== aliasTableName) {
+          aliasString = " AS ".concat(aliasTableName);
+        }
+        if (col.join.where[0].isnot) {
+          joinStr = "".concat(col.join.db, ".").concat(col.join.table).concat(aliasString, " ON ").concat(dbObj.dbName, ".").concat(tableObj.tableName, ".").concat(col.join.where[0].name, " != ").concat(col.join.db, ".").concat(aliasTableName, ".").concat(col.join.where[0].isnot);
+        }
+        if (col.join.where[0].is) {
+          joinStr = "".concat(col.join.db, ".").concat(col.join.table).concat(aliasString, " ON ").concat(dbObj.dbName, ".").concat(tableObj.tableName, ".").concat(col.join.where[0].name, " = ").concat(col.join.db, ".").concat(aliasTableName, ".").concat(col.join.where[0].is);
+        }
+        if (joinStr.length > 0) {
+          _this5.join.push(joinStr);
+        }
+        _this5.pushCols({
+          dbName: col.join.db,
+          dbAlias: col.join.db
+        }, {
+          tableName: col.join.table,
+          tableAlias: aliasTableName
+        }, col.join.columns);
+      });
+    }
+  }, {
+    key: "pushFnCols",
+    value: function pushFnCols(dbObj, tableObj, fnCols) {
+      var _this6 = this;
+      fnCols.forEach(function (col) {
+        var selectStr = '';
+        if (!_this6.validBySchema(dbObj.dbName, tableObj.tableName)) {
+          return;
+        }
+        selectStr = _this6.fnString(dbObj.dbAlias, tableObj.tableAlias, col.fn, col.args);
+        if (col.as && _this6.validString(col.as)) {
+          selectStr += " AS ".concat(col.as);
+        }
+        if (selectStr.length > 0) {
+          _this6.select.push(selectStr);
+        }
+      });
+    }
+  }, {
+    key: "pushOrArrWhere",
+    value: function pushOrArrWhere(dbObj, tableObj, or) {
+      var _this7 = this;
+      var whereStr = '';
+      or.forEach(function (wh, i) {
+        if (_this7.validJQString(dbObj.dbName, tableObj.tableName, wh.name)) {
+          if (i !== 0) {
+            whereStr += ' OR ';
+          }
+          whereStr += "".concat(_this7.whString(dbObj.dbName, tableObj.tableName, wh));
+          return;
+        }
+        if (_this7.validBySchema(dbObj.dbName, tableObj.tableName, wh.name)) {
+          if (i !== 0) {
+            whereStr += ' OR ';
+          }
+          whereStr += "".concat(_this7.whString(dbObj.dbName, tableObj.tableName, wh));
+          return;
+        }
+      });
+      if (whereStr.length > 0) {
+        this.where.push(whereStr);
+      }
+    }
+  }, {
+    key: "pushOrArrHaving",
+    value: function pushOrArrHaving(or) {
+      var _this8 = this;
+      var havingStr = "(".concat(or.filter(function (ha) {
+        return _this8.validString(ha.name) && (_this8.validString(ha.is) || _this8.validString(ha.isnot));
+      }).map(function (ha) {
+        var value = ha.is && typeof ha.is === 'number' ? "= ".concat(ha.is) : ha.is && typeof ha.is === 'string' ? "= '".concat(ha.is, "'") : ha.isnot && typeof ha.isnot === 'number' ? "!= ".concat(ha.isnot) : ha.isnot && typeof ha.isnot === 'string' ? "!= '".concat(ha.isnot, "'") : '';
+        return "".concat(ha.name, " ").concat(value);
+      }).join(' OR '), ")");
+      if (havingStr.length > 0) {
+        this.having.push(havingStr);
+      }
+    }
+  }, {
+    key: "pushWhere",
+    value: function pushWhere(dbObj, tableObj, where) {
+      var _this9 = this;
+      where.forEach(function (wh) {
+        var whereStr = '';
+        if ((wh || []).length > 0) {
+          _this9.pushOrArrWhere(dbObj, tableObj, wh);
+          return;
+        }
+        if (_this9.validJQString(dbObj.dbName, tableObj.tableName, wh.name)) {
+          whereStr = "".concat(_this9.whString(dbObj.dbName, tableObj.tableName, wh));
+          if (whereStr.length > 0) {
+            _this9.where.push(whereStr);
+            return;
+          }
+        }
+        if (_this9.validBySchema(dbObj.dbName, tableObj.tableName, wh.name)) {
+          whereStr = "".concat(_this9.whString(dbObj.dbName, tableObj.tableName, wh));
+          if (whereStr.length > 0) {
+            _this9.where.push(whereStr);
+            return;
+          }
+        }
+      });
+    }
+  }, {
+    key: "pushHaving",
+    value: function pushHaving(having) {
+      var _this10 = this;
+      having.forEach(function (ha) {
+        // This check here is a bit out of place but we want to keep
+        // the old nested OR syntax so there it is.
+        if (!ha.name && ha.or && (ha.or || []).length > 0) {
+          _this10.pushOrArrHaving(ha.or);
+          return;
+        }
+        var havingStr = "".concat(_this10.haString(ha));
+        if (havingStr.length > 0) {
+          _this10.having.push(havingStr);
+        }
+      });
+    }
+
+    // █▀▀ ▀▀█▀▀ █▀▀█ ░▀░ █▀▀▄ █▀▀▀   █▀▀ █░░█ █▀▀▄ █▀▀ ▀▀█▀▀ ░▀░ █▀▀█ █▀▀▄ █▀▀
+    // ▀▀█ ░░█░░ █▄▄▀ ▀█▀ █░░█ █░▀█   █▀▀ █░░█ █░░█ █░░ ░░█░░ ▀█▀ █░░█ █░░█ ▀▀█
+    // ▀▀▀ ░░▀░░ ▀░▀▀ ▀▀▀ ▀░░▀ ▀▀▀▀   ▀░░ ░▀▀▀ ▀░░▀ ▀▀▀ ░░▀░░ ▀▀▀ ▀▀▀▀ ▀░░▀ ▀▀▀
+  }, {
+    key: "countString",
+    value: function countString(db, table, count) {
+      var _this11 = this;
+      var whereStr = count.where.map(function (wh) {
+        return _this11.whString(count.db, count.table, wh);
+      }).join();
+      return "(SELECT COUNT(*) FROM ".concat(count.db, ".").concat(count.table, " WHERE ").concat(whereStr, ")");
+    }
+  }, {
+    key: "orWhString",
+    value: function orWhString(db, table, orArr) {
+      var _this12 = this;
+      return "".concat(orArr.filter(function (or) {
+        return or.name && (_this12.validBySchema(db, table, or.name) || _this12.validJQString(db, table, or.name));
+      }).map(function (or) {
+        return _this12.whString(db, table, or);
+      }).join(' OR '));
+    }
+  }, {
+    key: "orHaString",
+    value: function orHaString(orArr) {
+      var _this13 = this;
+      return "".concat(orArr.filter(function (or) {
+        return or.name && _this13.validString(or.name);
+      }).map(function (or) {
+        return _this13.haString(or);
+      }).join(' OR '));
+    }
+  }, {
+    key: "whString",
+    value: function whString(db, table, wh) {
+      if (wh.is && !this.validString(wh.is)) return '';
+      if (wh.isnot && !this.validString(wh.isnot)) return '';
+      if (wh.isbetween && !this.validString(wh.isbetween[0])) return '';
+      if (wh.isbetween && !this.validString(wh.isbetween[1])) return '';
+      var value = typeof wh.is === 'number' ? "= ".concat(wh.is) : typeof wh.is === 'string' ? "= '".concat(wh.is, "'") : typeof wh.isnot === 'number' ? "!= ".concat(wh.isnot) : typeof wh.isnot === 'string' ? "!= '".concat(wh.isnot, "'") : wh.isbetween ? "BETWEEN ".concat(wh.isbetween.map(function (val) {
+        return typeof val === 'string' ? "'".concat(val, "'") : val;
+      }).join(' AND ')) : '';
+      var name = this.validJQString(db, table, wh.name) ? this.jQExtract(db, table, wh.name) : "".concat(db, ".").concat(table, ".").concat(wh.name);
+      return "".concat(name, " ").concat(value);
+    }
+  }, {
+    key: "haString",
+    value: function haString(ha) {
+      if (ha.name && !this.validString(ha.name)) {
+        return '';
+      }
+      if (ha.isnot && !this.validString(ha.isnot)) {
+        return '';
+      }
+      if (ha.is && !this.validString(ha.is)) {
+        return '';
+      }
+      if ((ha || []).length > 0 && _typeof(ha) === 'object') {
+        return this.orHaString(ha);
+      }
+      var value = typeof ha.is === 'number' ? "= ".concat(ha.is) : typeof ha.is === 'string' ? "= '".concat(ha.is, "'") : typeof ha.isnot === 'number' ? "!= ".concat(ha.isnot) : typeof ha.isnot === 'string' ? "!= '".concat(ha.isnot, "'") : ha.isbetween ? "BETWEEN ".concat(ha.isbetween.map(function (val) {
+        return typeof val === 'string' ? "'".concat(val, "'") : val;
+      }).join(' AND ')) : '';
+      var name = this.validPlainJQString(ha.name) ? this.plainjQExtract(ha.name) : "".concat(ha.name);
+      return "".concat(name, " ").concat(value);
+    }
+  }, {
+    key: "fnString",
+    value: function fnString(db, table, fn, args) {
+      var _this14 = this;
+      if (!this.validString(fn)) return '';
+      return "".concat(fn, "(").concat(args.map(function (arg) {
+        if (_this14.validJQString(db, table, arg.name)) {
+          return _this14.jQExtract(db, table, arg.name);
+        } else if (arg.name) {
+          return "".concat(db, ".").concat(table, ".").concat(arg.name);
+        }
+        if (arg.number && typeof arg.number === 'number') {
+          return "".concat(arg.number);
+        } else if (arg.number) {
+          _this14.errors(arg.number + ' in fn object is not a number type');
+        }
+        if (arg.string && _this14.validString(arg.string)) {
+          return "'".concat(arg.string, "'");
+        }
+        if (arg.fn) {
+          return _this14.fnString(db, table, arg.fn, arg.args);
+        }
+      }).join(), ")");
+    }
+
+    // █▀▀▄ █░░█ ░▀░ █░░ █▀▀▄ █▀▀ █▀▀█ █▀▀
+    // █▀▀▄ █░░█ ▀█▀ █░░ █░░█ █▀▀ █▄▄▀ ▀▀█
+    // ▀▀▀░ ░▀▀▀ ▀▀▀ ▀▀▀ ▀▀▀░ ▀▀▀ ▀░▀▀ ▀▀▀
+  }, {
+    key: "buildSelect",
+    value: function buildSelect() {
+      var select = '';
+      if (this.select.length > 0) {
+        select = "SELECT ".concat(this.select.map(function (selStr) {
+          return selStr;
+        }).join());
+      }
+      var from = "FROM ".concat(this.from.db, ".").concat(this.from.table);
+      var join = '';
+      if (this.join.length > 0) {
+        join = "".concat(this.join.map(function (jStr) {
+          return "LEFT JOIN ".concat(jStr);
+        }).join(' '));
+      }
+      var where = '';
+      if (this.where.length > 0) {
+        where = "WHERE ".concat(this.where.map(function (whStr) {
+          return "(".concat(whStr, ")");
+        }).join(' AND '));
+      }
+      var having = '';
+      if (this.having.length > 0) {
+        having = "HAVING ".concat(this.having.map(function (haStr) {
+          return "(".concat(haStr, ")");
+        }).join(' AND '));
+      }
+      var orderBy = '';
+      if (this.orderBy.length > 0) {
+        orderBy = "ORDER BY ".concat(this.orderBy);
+      }
+      var ascOrDesc = '';
+      if (this.ascOrDesc.length > 0) {
+        ascOrDesc = this.ascOrDesc;
+      }
+      var limit = '';
+      if (this.limit.length > 0) {
+        limit = "LIMIT ".concat(this.limit.map(function (num) {
+          return num;
+        }).join());
+      }
+      return "".concat(select, " ").concat(from, " ").concat(join, " ").concat(where, " ").concat(having, " ").concat(orderBy, " ").concat(ascOrDesc, " ").concat(limit);
+    }
+  }, {
+    key: "buildCreate",
+    value: function buildCreate() {
+      var from = "INSERT INTO ".concat(this.from.db, ".").concat(this.from.table);
+      var columns = '';
+      if (this.columns.length > 0) {
+        columns = "(".concat(this.columns.join(), ")");
+      }
+      var values = '';
+      if (this.values.length > 0) {
+        values = "VALUES (".concat(this.values.join(), ")");
+      }
+      return "".concat(from, " ").concat(columns, " ").concat(values);
+    }
+  }, {
+    key: "buildUpdate",
+    value: function buildUpdate() {
+      var _this15 = this;
+      var from = "UPDATE ".concat(this.from.db, ".").concat(this.from.table);
+      var set = '';
+      if (this.columns.length === this.values.length && this.columns.length > 0 && this.values.length > 0) {
+        set = "SET ".concat(this.columns.map(function (col, i) {
+          return "".concat(col, " = ").concat(_this15.values[i]);
+        }).join());
+      }
+      var where = '';
+      if (this.where.length > 0) {
+        where = "WHERE ".concat(this.where.map(function (whStr) {
+          return "(".concat(whStr, ")");
+        }).join(' AND '));
+      } else if (!this.affectAll) {
+        this.fatalError = true;
+        this.errors.push('No where clause provided. If you want to update all records then add `affectAll: true` to your queryObject');
+      }
+      var having = '';
+      if (this.having.length > 0) {
+        having = "HAVING ".concat(this.having.map(function (haStr) {
+          return "(".concat(haStr, ")");
+        }).join(' AND '));
+      }
+      return "".concat(from, " ").concat(set, " ").concat(where, " ").concat(having);
+    }
+  }, {
+    key: "buildDelete",
+    value: function buildDelete() {
+      var from = "DELETE FROM ".concat(this.from.db, ".").concat(this.from.table);
+      var where = '';
+      if (this.where.length > 0) {
+        where = "WHERE ".concat(this.where.map(function (whStr) {
+          return "(".concat(whStr, ")");
+        }).join(' AND '));
+      } else if (!this.affectAll) {
+        this.fatalError = true;
+        this.errors.push('No where clause provided. If you want to delete all records then add `affectAll: true` to your queryObject');
+      }
+      return "".concat(from, " ").concat(where);
+    }
+
+    // █░░█ ▀▀█▀▀ ░▀░ █░░ ░▀░ ▀▀█▀▀ ░▀░ █▀▀ █▀▀
+    // █░░█ ░░█░░ ▀█▀ █░░ ▀█▀ ░░█░░ ▀█▀ █▀▀ ▀▀█
+    // ░▀▀▀ ░░▀░░ ▀▀▀ ▀▀▀ ▀▀▀ ░░▀░░ ▀▀▀ ▀▀▀ ▀▀▀
+  }, {
+    key: "aliasReplicaTableNames",
+    value: function aliasReplicaTableNames(table) {
+      var aliasTableName;
+      var numOfReplicas = this.joinTables.filter(function (tableName) {
+        return tableName === table;
+      }).length;
+      if (numOfReplicas > 0) {
+        aliasTableName = this.aliasReplicaTableNames(table + Math.floor(Math.random() * Math.floor(1000)));
+        return aliasTableName;
+      } else {
+        this.joinTables.push(table);
+        return table;
+      }
+    }
+
+    // ▀█░█▀ █▀▀█ █░░ ░▀░ █▀▀▄ █▀▀█ ▀▀█▀▀ ░▀░ █▀▀█ █▀▀▄
+    // ░█▄█░ █▄▄█ █░░ ▀█▀ █░░█ █▄▄█ ░░█░░ ▀█▀ █░░█ █░░█
+    // ░░▀░░ ▀░░▀ ▀▀▀ ▀▀▀ ▀▀▀░ ▀░░▀ ░░▀░░ ▀▀▀ ▀▀▀▀ ▀░░▀
+  }, {
+    key: "validIndex",
+    value: function validIndex(index) {
+      if (Number(index) === NaN) {
+        this.errors.push("The index given to the json selector is not a number, if you're trying to search add a ? to the start of your string");
+        this.fatalError = true;
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "validBySchema",
+    value: function validBySchema(db, table, name) {
+      if (!this.schema) {
+        this.errors.push('A schema must be provided in order to use JsonQL');
+        this.fatalError = true;
+        return;
+      }
+      if (!db || (db || '').length === 0) {
+        this.errors.push('No db name provided');
+        this.fatalError = true;
+        return false;
+      }
+      if (!this.schema[db]) {
+        this.errors.push(db + ' db not found in schema');
+        this.fatalError = true;
+        return false;
+      }
+      if (table && !(this.schema[db] || {})[table]) {
+        this.errors.push(db + '.' + table + ' not found in schema');
+        this.fatalError = true;
+        return false;
+      }
+      if (name && !((this.schema[db] || {})[table] || {})[name]) {
+        this.errors.push(db + '.' + table + '.' + name + ' not found in schema');
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "validString",
+    value: function validString(string) {
+      var regex = /(drop )|;|(update )( truncate)/gi;
+      if (regex.test(string)) {
+        this.errors.push("The string '" + string + "' is not allowed");
+        this.fatalError = true;
+        return false;
+      } else {
+        return true;
+      }
+    }
+
+    // ░░▀ █▀▀█ █▀▀ ▀▀█▀▀ █▀▀█ ░▀░ █▀▀▄ █▀▀▀ █▀▀
+    // ░░█ █░░█ ▀▀█ ░░█░░ █▄▄▀ ▀█▀ █░░█ █░▀█ ▀▀█
+    // █▄█ ▀▀▀█ ▀▀▀ ░░▀░░ ▀░▀▀ ▀▀▀ ▀░░▀ ▀▀▀▀ ▀▀▀
+  }, {
+    key: "extractColFromJQString",
+    value: function extractColFromJQString(db, table, jQString) {
+      var column = jQString.slice(1, jQString.search(/[\.\[]/));
+      if (!this.validBySchema(db, table, column)) return;
+      return column;
+    }
+  }, {
+    key: "validJQString",
+    value: function validJQString(db, table, jQString) {
+      if (/^\$/.test(jQString)) {
+        // Add a match here and check any string inside that begins with a $, that way we can target more than one column in a jqstring.
+        var column = jQString.slice(1, jQString.search(/[\.\[]/));
+        if (!this.validBySchema(db, table, column)) return false;
+        return true;
+      }
+      return false;
+    }
+  }, {
+    key: "validPlainJQString",
+    value: function validPlainJQString(jQString) {
+      if (/^\$/.test(jQString)) {
+        // Add a match here and check any string inside that begins with a $, that way we can target more than one column in a jqstring.
+        var column = jQString.slice(1, jQString.search(/[\.\[]/));
+        if (!this.validString(column)) return false;
+        return true;
+      }
+      return false;
+    }
+  }, {
+    key: "jQString",
+    value: function jQString(name, string, prevString) {
+      var nameReg = /\$\w+/;
+      var index = /\[\d\]/;
+      var target = /\.\w+/;
+      var search = /\[\?[\w\s@#:;{},.!"£$%^&*()/?|`¬\-=+~]*\]/;
+      if (nameReg.test(string)) {
+        return "CONCAT(\"$\")";
+      }
+      if (index.test(string)) {
+        // 'index';
+        if (!this.validString(string)) return;
+        return "CONCAT(".concat(prevString, ", \"").concat(string, "\")");
+      }
+      if (target.test(string)) {
+        // 'target';
+        if (!this.validString(string)) return;
+        return "CONCAT(".concat(prevString, ", \"").concat(string, "\")");
+      }
+      if (search.test(string)) {
+        // 'search';
+        string = string.slice(2, -1);
+        if (!this.validString(string)) return;
+        return "CONCAT(".concat(prevString, ", CONCAT('[',SUBSTR(JSON_SEARCH(JSON_EXTRACT(").concat(name, ", \"$\"),'one','").concat(string, "'), 4,LOCATE(']',JSON_SEARCH(JSON_EXTRACT(").concat(name, ", \"$\"), 'one', '").concat(string, "'))-4),']'))");
+      }
+    }
+  }, {
+    key: "jQStringMaker",
+    value: function jQStringMaker(name, matches) {
+      var _this16 = this;
+      var result = matches.reduce(function (arr, match, i) {
+        return [].concat(_toConsumableArray(arr), [_this16.jQString(name, match, arr[i - 1])]);
+      }, []);
+      return result[result.length - 1];
+    }
+  }, {
+    key: "plainjQExtract",
+    value: function plainjQExtract(jQStr) {
+      var regx = /(\$\w+)|(\[\d\])|(\.\w+)|(\[\?[\w\s@#:;{},.!"£$%^&*()/?|`¬\-=+~]*\])/g;
+      var matches = jQStr.match(regx);
+      var name = "".concat(matches[0].slice(1));
+      return "JSON_UNQUOTE(JSON_EXTRACT(".concat(name, ", ").concat(this.jQStringMaker(name, matches), "))");
+    }
+  }, {
+    key: "jQExtract",
+    value: function jQExtract(db, table, jQStr) {
+      var regx = /(\$\w+)|(\[\d\])|(\.\w+)|(\[\?[\w\s@#:;{},.!"£$%^&*()/?|`¬\-=+~]*\])/g;
+      var matches = jQStr.match(regx);
+      var name = "".concat(db, ".").concat(table, ".").concat(matches[0].slice(1));
+      return "JSON_UNQUOTE(JSON_EXTRACT(".concat(name, ", ").concat(this.jQStringMaker(name, matches), "))");
+    }
+  }, {
+    key: "jQSet",
+    value: function jQSet(db, table, jQStr, value) {
+      if (typeof value === 'string') {
+        value = "'".concat(value, "'");
+      }
+      var regx = /(\$\w+)|(\[\d\])|(\.\w+)|(\[\?[\w\s@#:;{},.!"£$%^&*()/?|`¬\-=+~]*\])/g;
+      var matches = jQStr.match(regx);
+      var name = "".concat(db, ".").concat(table, ".").concat(matches[0].slice(1));
+      return "JSON_SET(".concat(name, ", ").concat(this.jQStringMaker(name, matches), ", ").concat(value, ")");
+    }
+  }]);
+  return JsonQL;
+}();
+export default JsonQL;

package/package.json

@@ -1,7 +1,7 @@
 {
   "public": true,
   "name": "ronds-metadata",
-  "version": "1.3.26",
+  "version": "1.3.28",
   "scripts": {
     "start": "dumi dev",
     "docs:build": "dumi build",