@gingkoo/pandora-metabase 1.0.140 → 1.0.141-alpha.4

package/lib/es/utils.js

@@ -1,10 +1,13 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 import _typeof from "@babel/runtime/helpers/esm/typeof";
 import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-var _excluded = ["list"];
+var _excluded = ["operator", "leftAtoms", "rightAtoms", "atoms"],
+  _excluded2 = ["operator", "leftAtoms", "rightAtoms", "atoms"],
+  _excluded3 = ["operator", "leftAtoms", "rightAtoms", "atoms", "items"],
+  _excluded4 = ["list"];
 import { __, isEn } from './locale';
 import { TypeEnum, SQL_COLUMN_TYPE } from './store/enum';
 import { MetaSummarize_Enum, AtomsTypeEnum } from './store/types';
@@ -312,14 +315,13 @@ var _syncSubQueryFieldItems = function syncSubQueryFieldItems() {
         elseAtoms: _syncSubQueryFieldItems(item.elseAtoms || [], table, columns, oldColumns)
       });
     } else if (item.type === AtomsTypeEnum.AND_OR) {
-      var hasBinarySides = Array.isArray(item.leftAtoms) || Array.isArray(item.rightAtoms);
-      nextItem = _objectSpread(_objectSpread({}, item), hasBinarySides ? {
-        atoms: undefined,
-        leftAtoms: _syncSubQueryFieldItems(item.leftAtoms || [], table, columns, oldColumns),
-        rightAtoms: _syncSubQueryFieldItems(item.rightAtoms || [], table, columns, oldColumns)
-      } : {
-        atoms: _syncSubQueryFieldItems(item.atoms || [], table, columns, oldColumns)
-      });
+      nextItem = syncAndOrBinaryFields(_objectSpread(_objectSpread({}, item), {}, {
+        items: normalizeAndOrItems(item).map(function (logicItem) {
+          return _objectSpread(_objectSpread({}, logicItem), {}, {
+            atoms: _syncSubQueryFieldItems(logicItem.atoms || [], table, columns, oldColumns)
+          });
+        })
+      }));
     } else {
       nextItem = item;
     }
@@ -619,15 +621,250 @@ var buildFormulaQuotes = function buildFormulaQuotes(item) {
   var argsText = (item.args || []).map(_getAtomDisplayText).join(' , ');
   return normalizeAtomQuotes("".concat(item.name || '', " ( ").concat(argsText, " )"));
 };
+var normalizeAndOrItems = function normalizeAndOrItems(item) {
+  if (Array.isArray(item.items) && item.items.length > 0) {
+    return item.items.map(function (logicItem, index) {
+      var operator = logicItem.operator,
+        leftAtoms = logicItem.leftAtoms,
+        rightAtoms = logicItem.rightAtoms,
+        atoms = logicItem.atoms,
+        nextLogicItem = _objectWithoutProperties(logicItem, _excluded);
+      return _objectSpread(_objectSpread(_objectSpread({}, nextLogicItem), index > 0 ? {
+        operator: operator || item.operator || 'and'
+      } : {}), {}, {
+        atoms: Array.isArray(atoms) && atoms.length > 0 ? atoms : []
+      });
+    });
+  }
+  if (Array.isArray(item.leftAtoms) || Array.isArray(item.rightAtoms)) {
+    return [{
+      atoms: Array.isArray(item.leftAtoms) ? item.leftAtoms : []
+    }, {
+      operator: item.operator || 'and',
+      atoms: Array.isArray(item.rightAtoms) ? item.rightAtoms : []
+    }];
+  }
+  return [{
+    atoms: Array.isArray(item.atoms) ? item.atoms : []
+  }];
+};
 var buildAndOrQuotes = function buildAndOrQuotes(item) {
-  var hasBinarySides = Array.isArray(item.leftAtoms) || Array.isArray(item.rightAtoms);
-  if (hasBinarySides) {
-    var leftText = (item.leftAtoms || []).map(_getAtomDisplayText).join(' ');
-    var rightText = (item.rightAtoms || []).map(_getAtomDisplayText).join(' ');
-    return normalizeAtomQuotes("( ".concat(leftText, " ").concat(item.operator || 'and', " ").concat(rightText, " )"));
-  }
-  var atomsText = (item.atoms || []).map(_getAtomDisplayText).join(' ');
-  return normalizeAtomQuotes("".concat(item.operator || 'and', " ( ").concat(atomsText, " )"));
+  var itemsText = normalizeAndOrItems(item).map(function (logicItem, index) {
+    var atomsText = (logicItem.atoms || []).map(_getAtomDisplayText).join(' ');
+    return index === 0 ? atomsText : "".concat(logicItem.operator || 'and', " ").concat(atomsText);
+  }).join(' ');
+  return normalizeAtomQuotes("( ".concat(itemsText, " )"));
+};
+var syncAndOrBinaryFields = function syncAndOrBinaryFields(item) {
+  var operator = item.operator,
+    leftAtoms = item.leftAtoms,
+    rightAtoms = item.rightAtoms,
+    atoms = item.atoms,
+    nextItem = _objectWithoutProperties(item, _excluded2);
+  return _objectSpread(_objectSpread({}, nextItem), {}, {
+    items: normalizeAndOrItems(item)
+  });
+};
+var _normalizeAndOrStructureInner = function normalizeAndOrStructureInner(data, cache) {
+  if (!data || _typeof(data) !== 'object') return data;
+  if (cache.has(data)) return cache.get(data);
+  if (Array.isArray(data)) {
+    var nextList = [];
+    cache.set(data, nextList);
+    data.forEach(function (item) {
+      nextList.push(_normalizeAndOrStructureInner(item, cache));
+    });
+    return nextList;
+  }
+  var item = data;
+  if (item.type === AtomsTypeEnum.AND_OR) {
+    var operator = item.operator,
+      leftAtoms = item.leftAtoms,
+      rightAtoms = item.rightAtoms,
+      atoms = item.atoms,
+      items = item.items,
+      nextItem = _objectWithoutProperties(item, _excluded3);
+    var normalizedItem = _objectSpread(_objectSpread({}, nextItem), {}, {
+      items: []
+    });
+    cache.set(item, normalizedItem);
+    normalizedItem.items = normalizeAndOrItems(item).map(function (logicItem) {
+      return _objectSpread(_objectSpread({}, logicItem.operator ? {
+        operator: logicItem.operator
+      } : {}), {}, {
+        atoms: _normalizeAndOrStructureInner(logicItem.atoms || [], cache)
+      });
+    });
+    normalizedItem.quotes = buildAndOrQuotes(normalizedItem);
+    return normalizedItem;
+  }
+  if (item.type === AtomsTypeEnum.JOIN_DEFAULT || item.type === AtomsTypeEnum.EXPRESSION) {
+    var _nextItem = _objectSpread({}, item);
+    cache.set(item, _nextItem);
+    if (Array.isArray(item.lhs)) {
+      _nextItem.lhs = _normalizeAndOrStructureInner(item.lhs, cache);
+    }
+    if (Array.isArray(item.rhs)) {
+      _nextItem.rhs = _normalizeAndOrStructureInner(item.rhs, cache);
+    }
+    return _nextItem;
+  }
+  if (item.type === AtomsTypeEnum.FORMULA) {
+    var _nextItem2 = _objectSpread({}, item);
+    cache.set(item, _nextItem2);
+    if (Array.isArray(item.args)) {
+      _nextItem2.args = _normalizeAndOrStructureInner(item.args, cache);
+    }
+    return _nextItem2;
+  }
+  if (item.type === AtomsTypeEnum.COLLECTION) {
+    var _nextItem3 = _objectSpread({}, item);
+    cache.set(item, _nextItem3);
+    if (Array.isArray(item.list)) {
+      _nextItem3.list = _normalizeAndOrStructureInner(item.list, cache);
+    }
+    return _nextItem3;
+  }
+  if (item.type === AtomsTypeEnum.CASE_WHEN) {
+    var _nextItem4 = _objectSpread({}, item);
+    cache.set(item, _nextItem4);
+    if (Array.isArray(item.caseAtoms)) {
+      _nextItem4.caseAtoms = _normalizeAndOrStructureInner(item.caseAtoms, cache);
+    }
+    if (Array.isArray(item.whenClauses)) {
+      _nextItem4.whenClauses = item.whenClauses.map(function (clause) {
+        if (!clause || _typeof(clause) !== 'object') return clause;
+        if (cache.has(clause)) return cache.get(clause);
+        var nextClause = _objectSpread({}, clause);
+        cache.set(clause, nextClause);
+        if (Array.isArray(clause.whenAtoms)) {
+          nextClause.whenAtoms = _normalizeAndOrStructureInner(clause.whenAtoms, cache);
+        }
+        if (Array.isArray(clause.thenAtoms)) {
+          nextClause.thenAtoms = _normalizeAndOrStructureInner(clause.thenAtoms, cache);
+        }
+        return nextClause;
+      });
+    }
+    if (Array.isArray(item.elseAtoms)) {
+      _nextItem4.elseAtoms = _normalizeAndOrStructureInner(item.elseAtoms, cache);
+    }
+    return _nextItem4;
+  }
+  if (item.type === AtomsTypeEnum.EXISTS || item.type === AtomsTypeEnum.NOT_EXISTS || item.type === AtomsTypeEnum.SUB_QUERY) {
+    var _nextItem5 = _objectSpread({}, item);
+    cache.set(item, _nextItem5);
+    if (Array.isArray(item.notExists)) {
+      _nextItem5.notExists = _normalizeAndOrStructureInner(item.notExists, cache);
+    }
+    if (Array.isArray(item.subQuery)) {
+      _nextItem5.subQuery = _normalizeAndOrStructureInner(item.subQuery, cache);
+    }
+    return _nextItem5;
+  }
+  if (item.type === TypeEnum.data) {
+    var _nextItem6 = _objectSpread({}, item);
+    cache.set(item, _nextItem6);
+    if (Array.isArray(item.subquery)) {
+      _nextItem6.subquery = _normalizeAndOrStructureInner(item.subquery, cache);
+    }
+    return _nextItem6;
+  }
+  if (item.type === TypeEnum.joinData) {
+    var _nextItem7 = _objectSpread({}, item);
+    cache.set(item, _nextItem7);
+    if (Array.isArray(item.expressions)) {
+      _nextItem7.expressions = _normalizeAndOrStructureInner(item.expressions, cache);
+    }
+    if (Array.isArray(item.subquery)) {
+      _nextItem7.subquery = _normalizeAndOrStructureInner(item.subquery, cache);
+    }
+    return _nextItem7;
+  }
+  if (item.type === TypeEnum.customColumn) {
+    var _nextItem8 = _objectSpread({}, item);
+    cache.set(item, _nextItem8);
+    if (Array.isArray(item.customColumn)) {
+      _nextItem8.customColumn = item.customColumn.map(function (column) {
+        if (!column || _typeof(column) !== 'object') return column;
+        if (cache.has(column)) return cache.get(column);
+        var nextColumn = _objectSpread({}, column);
+        cache.set(column, nextColumn);
+        if (Array.isArray(column.formulaList)) {
+          nextColumn.formulaList = _normalizeAndOrStructureInner(column.formulaList, cache);
+        }
+        return nextColumn;
+      });
+    }
+    return _nextItem8;
+  }
+  if (item.type === TypeEnum.filter) {
+    var _nextItem9 = _objectSpread({}, item);
+    cache.set(item, _nextItem9);
+    if (Array.isArray(item.filter)) {
+      _nextItem9.filter = _normalizeAndOrStructureInner(item.filter, cache);
+    }
+    return _nextItem9;
+  }
+  if (item.type === TypeEnum.summarize) {
+    var _nextItem0 = _objectSpread({}, item);
+    cache.set(item, _nextItem0);
+    if (Array.isArray(item.group)) {
+      _nextItem0.group = item.group.map(function (record) {
+        if (!record || _typeof(record) !== 'object') return record;
+        if (cache.has(record)) return cache.get(record);
+        var nextRecord = _objectSpread({}, record);
+        cache.set(record, nextRecord);
+        if (Array.isArray(record.atoms)) {
+          nextRecord.atoms = _normalizeAndOrStructureInner(record.atoms, cache);
+        }
+        return nextRecord;
+      });
+    }
+    if (Array.isArray(item.by)) {
+      _nextItem0.by = item.by.map(function (record) {
+        if (!record || _typeof(record) !== 'object') return record;
+        if (cache.has(record)) return cache.get(record);
+        var nextRecord = _objectSpread({}, record);
+        cache.set(record, nextRecord);
+        if (Array.isArray(record.atoms)) {
+          nextRecord.atoms = _normalizeAndOrStructureInner(record.atoms, cache);
+        }
+        return nextRecord;
+      });
+    }
+    return _nextItem0;
+  }
+  if (item.type === TypeEnum.sort) {
+    var _nextItem1 = _objectSpread({}, item);
+    cache.set(item, _nextItem1);
+    if (Array.isArray(item.sort)) {
+      _nextItem1.sort = item.sort.map(function (record) {
+        if (!record || _typeof(record) !== 'object') return record;
+        if (cache.has(record)) return cache.get(record);
+        var nextRecord = _objectSpread({}, record);
+        cache.set(record, nextRecord);
+        if (Array.isArray(record.expression)) {
+          nextRecord.expression = _normalizeAndOrStructureInner(record.expression, cache);
+        }
+        return nextRecord;
+      });
+    }
+    return _nextItem1;
+  }
+  if (item.type === TypeEnum.union) {
+    var _nextItem10 = _objectSpread({}, item);
+    cache.set(item, _nextItem10);
+    if (Array.isArray(item.subquery)) {
+      _nextItem10.subquery = _normalizeAndOrStructureInner(item.subquery, cache);
+    }
+    return _nextItem10;
+  }
+  cache.set(item, item);
+  return item;
+};
+export var normalizeAndOrStructure = function normalizeAndOrStructure(data) {
+  return _normalizeAndOrStructureInner(data, new WeakMap());
 };
 var buildCaseWhenQuotes = function buildCaseWhenQuotes(item) {
   var caseAtomsText = (item.caseAtoms || []).map(_getAtomDisplayText).join(' ');
@@ -734,23 +971,23 @@ var syncAtomQuotes = function syncAtomQuotes(item) {
     });
   }
   if (item.type === AtomsTypeEnum.FORMULA) {
-    var _nextItem = _objectSpread(_objectSpread({}, item), {}, {
+    var _nextItem11 = _objectSpread(_objectSpread({}, item), {}, {
       args: syncAtomQuotesList(item.args || [])
     });
-    return _objectSpread(_objectSpread({}, _nextItem), {}, {
-      quotes: buildFormulaQuotes(_nextItem)
+    return _objectSpread(_objectSpread({}, _nextItem11), {}, {
+      quotes: buildFormulaQuotes(_nextItem11)
     });
   }
   if (item.type === AtomsTypeEnum.COLLECTION) {
-    var _nextItem2 = _objectSpread(_objectSpread({}, item), {}, {
+    var _nextItem12 = _objectSpread(_objectSpread({}, item), {}, {
       list: syncAtomQuotesList(item.list || [])
     });
-    return _objectSpread(_objectSpread({}, _nextItem2), {}, {
-      quotes: (_nextItem2.list || []).map(_getAtomDisplayText).join(' ')
+    return _objectSpread(_objectSpread({}, _nextItem12), {}, {
+      quotes: (_nextItem12.list || []).map(_getAtomDisplayText).join(' ')
     });
   }
   if (item.type === AtomsTypeEnum.CASE_WHEN) {
-    var _nextItem3 = _objectSpread(_objectSpread({}, item), {}, {
+    var _nextItem13 = _objectSpread(_objectSpread({}, item), {}, {
       caseAtoms: syncAtomQuotesList(item.caseAtoms || []),
       whenClauses: (item.whenClauses || []).map(function (clause) {
         return _objectSpread(_objectSpread({}, clause), {}, {
@@ -760,21 +997,20 @@ var syncAtomQuotes = function syncAtomQuotes(item) {
       }),
       elseAtoms: syncAtomQuotesList(item.elseAtoms || [])
     });
-    return _objectSpread(_objectSpread({}, _nextItem3), {}, {
-      quotes: buildCaseWhenQuotes(_nextItem3)
+    return _objectSpread(_objectSpread({}, _nextItem13), {}, {
+      quotes: buildCaseWhenQuotes(_nextItem13)
     });
   }
   if (item.type === AtomsTypeEnum.AND_OR) {
-    var hasBinarySides = Array.isArray(item.leftAtoms) || Array.isArray(item.rightAtoms);
-    var _nextItem4 = _objectSpread(_objectSpread({}, item), hasBinarySides ? {
-      atoms: undefined,
-      leftAtoms: syncAtomQuotesList(item.leftAtoms || []),
-      rightAtoms: syncAtomQuotesList(item.rightAtoms || [])
-    } : {
-      atoms: syncAtomQuotesList(item.atoms || [])
-    });
-    return _objectSpread(_objectSpread({}, _nextItem4), {}, {
-      quotes: buildAndOrQuotes(_nextItem4)
+    var _nextItem14 = syncAndOrBinaryFields(_objectSpread(_objectSpread({}, item), {}, {
+      items: normalizeAndOrItems(item).map(function (logicItem) {
+        return _objectSpread(_objectSpread({}, logicItem), {}, {
+          atoms: syncAtomQuotesList(logicItem.atoms || [])
+        });
+      })
+    }));
+    return _objectSpread(_objectSpread({}, _nextItem14), {}, {
+      quotes: buildAndOrQuotes(_nextItem14)
     });
   }
   return item;
@@ -893,14 +1129,13 @@ var _changeAlias = function changeAlias(items, val, type) {
         elseAtoms: _changeAlias(v.elseAtoms || [], val, type)
       });
     } else if (v.type === AtomsTypeEnum.AND_OR) {
-      var hasBinarySides = Array.isArray(v.leftAtoms) || Array.isArray(v.rightAtoms);
-      nextItem = _objectSpread(_objectSpread({}, v), hasBinarySides ? {
-        atoms: undefined,
-        leftAtoms: _changeAlias(v.leftAtoms || [], val, type),
-        rightAtoms: _changeAlias(v.rightAtoms || [], val, type)
-      } : {
-        atoms: _changeAlias(v.atoms || [], val, type)
-      });
+      nextItem = syncAndOrBinaryFields(_objectSpread(_objectSpread({}, v), {}, {
+        items: normalizeAndOrItems(v).map(function (logicItem) {
+          return _objectSpread(_objectSpread({}, logicItem), {}, {
+            atoms: _changeAlias(logicItem.atoms || [], val, type)
+          });
+        })
+      }));
     } else {
       nextItem = v;
     }
@@ -1105,7 +1340,7 @@ export function splitByUnion(data) {
       i++;
     } else if (item.type === 'union') {
       var list = item.list,
-        otehr = _objectWithoutProperties(item, _excluded);
+        otehr = _objectWithoutProperties(item, _excluded4);
       var nextItem = original[i + 1];
       if (nextItem && nextItem.type === 'group') {
         result.push(_objectSpread(_objectSpread({}, otehr), {}, {
@@ -1176,7 +1411,7 @@ var normalizeSummarizeByForSave = function normalizeSummarizeByForSave(record) {
 };
 var _normalizeLegacySummarizeForSave = function normalizeLegacySummarizeForSave() {
   var metas = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-  return metas.map(function (meta) {
+  var normalizedMetas = metas.map(function (meta) {
     if (meta.type === TypeEnum.summarize) {
       return _objectSpread(_objectSpread({}, meta), {}, {
         group: meta.group.map(function (item) {
@@ -1194,6 +1429,7 @@ var _normalizeLegacySummarizeForSave = function normalizeLegacySummarizeForSave(
     }
     return meta;
   });
+  return normalizeAndOrStructure(normalizedMetas);
 };
 export { _normalizeLegacySummarizeForSave as normalizeLegacySummarizeForSave };
 export var getObjTem = function getObjTem(arr) {
@@ -1497,14 +1733,13 @@ var _changeCopyField = function changeCopyField(items, data) {
       v.args = _changeCopyField(v.args, data);
       return v;
     } else if (v.type === AtomsTypeEnum.AND_OR) {
-      var hasBinarySides = Array.isArray(v.leftAtoms) || Array.isArray(v.rightAtoms);
-      return _objectSpread(_objectSpread({}, v), hasBinarySides ? {
-        atoms: undefined,
-        leftAtoms: _changeCopyField(v.leftAtoms || [], data),
-        rightAtoms: _changeCopyField(v.rightAtoms || [], data)
-      } : {
-        atoms: _changeCopyField(v.atoms || [], data)
-      });
+      return syncAndOrBinaryFields(_objectSpread(_objectSpread({}, v), {}, {
+        items: normalizeAndOrItems(v).map(function (logicItem) {
+          return _objectSpread(_objectSpread({}, logicItem), {}, {
+            atoms: _changeCopyField(logicItem.atoms || [], data)
+          });
+        })
+      }));
     } else if (v.type === AtomsTypeEnum.COLLECTION) {
       v.list = _changeCopyField(v.list, data);
       return v;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gingkoo/pandora-metabase",
-  "version": "1.0.140",
+  "version": "1.0.141-alpha.4",
   "description": "",
   "main": "lib/es/index.js",
   "module": "lib/es/index.js",