@gingkoo/pandora-metabase 1.0.95 → 1.0.96

package/lib/es/hooks/patch.js

@@ -1,594 +1,117 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import { uuidv4 } from '../utils/helper';
-import { buildSqlQuery } from '../utils';
-import { AtomsTypeEnum } from '../store/types';
 import { TypeEnum } from '../store/enum';
-export var dataPatch = function dataPatch(newMeta) {
-  // let item = newMeta.expressions?.[0] || {};
-  // if (item?.type && Object.values(AtomsTypeEnum).includes(item.type)) {
-  //   if (item.type === AtomsTypeEnum.EXPRESSION && item.lhs) {
-  //     return newMeta;
-  //   }
-  // }
-  newMeta.subquery = _patchMetas(newMeta.subquery);
-  return newMeta;
+var setConstantId = function setConstantId(item, constantList) {
+  constantList.map(function (v) {
+    if (v.label === item.val) {
+      item.id = v.value;
+    }
+  });
+  return item;
 };
-export var joinDataPatch = function joinDataPatch(newMeta) {
-  var _fields, _fields2, _fields3, _fields4, _newMeta$expressions;
-  // let item = newMeta.expressions?.[0] || {};
-  // if (item?.type && Object.values(AtomsTypeEnum).includes(item.type)) {
-  //   if (
-  //     (item.type === AtomsTypeEnum.EXPRESSION || item.type === AtomsTypeEnum.JOIN_DEFAULT) &&
-  //     item.lhs
-  //   ) {
-  //     return newMeta;
-  //   }
-  //   if (item.type === AtomsTypeEnum.EXISTS && !item.tableUuid) {
-  //     return newMeta;
-  //   }
-  //   if (item.type === AtomsTypeEnum.NOT_EXISTS && !item.tableUuid) {
-  //     return newMeta;
-  //   }
-  //   if (item.type === AtomsTypeEnum.FIELD && item.fieldName) {
-  //     return newMeta;
-  //   }
-  // }
-  // if (
-  //   newMeta.expressions?.[0]?.type &&
-  //   Object.values(AtomsTypeEnum).includes(newMeta.expressions[0].type)
-  // ) {
-  //   return newMeta;
-  // }
-  var fields1 = newMeta.table1.fields || [];
-  var fields2 = newMeta.table2.fields || [];
-  // 处理老字段
-  var field1 = {
-    fieldAlias: newMeta.table1.fieldAlias || newMeta.table1.column || newMeta.table1.name,
-    fieldUuid: newMeta.table1.fieldUuid || uuidv4('field'),
-    fieldId: newMeta.table1.fieldId,
-    fieldNameZh: newMeta.table1.name_zh,
-    fieldName: newMeta.table1.fieldName || newMeta.table1.name
-    // quotes: newMeta.table1.quotes || newMeta.table1.column,
-    // tableUuid: newMeta.table1.tableUuid,
-    // tableId: newMeta.table1.datasourceId,
-    // tableAlias: newMeta.table1.alias,
-  };
-  var field2 = {
-    fieldAlias: newMeta.table2.fieldAlias || newMeta.table2.column || newMeta.table2.name,
-    fieldUuid: newMeta.table2.fieldUuid || uuidv4('field'),
-    fieldId: newMeta.table2.fieldId,
-    fieldNameZh: newMeta.table2.name_zh,
-    fieldName: newMeta.table2.fieldName || newMeta.table2.name
-  };
-  // 处理多选
-  if (field1.fieldAlias && ((_fields = fields1) === null || _fields === void 0 ? void 0 : _fields.length) < 1) {
-    fields1 = [_objectSpread(_objectSpread({}, field1), {}, {
-      // quotes: field1.quotes,
-      fieldUuid: field1.fieldUuid,
-      fieldAlias: field1.fieldAlias,
-      fieldId: field1.fieldId
-      // fieldNameZh: newMeta.table1.name_zh,
-      // fieldName: newMeta.table1.fieldName || newMeta.table1.name,
-      // tableAlias: newMeta.table1.alias,
-      // tableId: newMeta.table1.id,
-      // tableName: newMeta.table1.name,
-      // tableNameZh: newMeta.table1.name_zh,
-      // tableUuid: newMeta.table1.tableUuid,
-      // datasourceName: newMeta.table1.datasourceName, // 数据源名
-      // datasourceId: newMeta.table1.datasourceId, // 数据源id
-    })];
-  }
-  if (field2.fieldAlias && ((_fields2 = fields2) === null || _fields2 === void 0 ? void 0 : _fields2.length) < 1) {
-    fields2 = [_objectSpread(_objectSpread({}, field2), {}, {
-      // quotes: field2.quotes,
-      fieldUuid: field2.fieldUuid,
-      fieldAlias: field2.fieldAlias,
-      fieldId: field2.fieldId
-      // fieldNameZh: newMeta.table2.name_zh,
-      // fieldName: newMeta.table2.fieldName || newMeta.table2.name,
-      // tableAlias: newMeta.table2.alias,
-      // tableId: newMeta.table2.id,
-      // tableName: newMeta.table2.name,
-      // tableNameZh: newMeta.table2.name_zh,
-      // tableUuid: newMeta.table2.tableUuid,
-      // datasourceName: newMeta.table2.datasourceName, // 数据源名
-      // datasourceId: newMeta.table2.datasourceId, // 数据源id
-    })];
+var setFormulaId = function setFormulaId(item, formulaTemplates) {
+  var obj = formulaTemplates === null || formulaTemplates === void 0 ? void 0 : formulaTemplates[item.name];
+  if (obj) {
+    item.id = obj.id;
   }
-  // newMeta.table1 = {
-  //   ...newMeta.table1,
-  //   ...field1,
-  //   tableUuid: newMeta.table1.tableUuid || uuidv4('table'),
-  //   fields: fields1,
-  // };
-  // newMeta.table2 = {
-  //   ...newMeta.table2,
-  //   ...field2,
-  //   tableUuid: newMeta.table2.tableUuid || uuidv4('table'),
-  //   fields: fields2,
-  // };
-  var beforeExpressions = [];
-  if (((_fields3 = fields1) === null || _fields3 === void 0 ? void 0 : _fields3.length) > 0 || ((_fields4 = fields2) === null || _fields4 === void 0 ? void 0 : _fields4.length) > 0) {
-    beforeExpressions = [{
-      left_constant: '',
-      left_string: '',
-      operator: '等于',
-      left_fields: fields1 || [],
-      left_type: 'field',
-      right_constant: '',
-      right_string: '',
-      right_fields: fields2 || [],
-      right_type: 'field',
-      type: 'default' // 默认是字段模式
-    }];
-  }
-  var expressions = ((_newMeta$expressions = newMeta.expressions) === null || _newMeta$expressions === void 0 ? void 0 : _newMeta$expressions.map(function (v) {
-    var _left_fields, _right_fields;
-    var left_fields = v.left_fields || [];
-    var right_fields = v.right_fields || [];
-    // if (v.type !== 'default') {
-    //   return v;
-    // }
-    // 先处理老数据的字段
-    var left_field = {
-      left_fieldAlias: v.left_fieldAlias || v.left_column,
-      left_fieldUuid: v.left_fieldUuid || uuidv4('field'),
-      left_quotes: v.left_quotes || v.left_column
-    };
-    var right_field = {
-      right_fieldAlias: v.right_fieldAlias || v.right_column,
-      right_fieldUuid: v.right_fieldUuid || uuidv4('field'),
-      right_quotes: v.right_quotes || v.right_column
-    };
-    // 再处理多选
-    if (left_field.left_fieldAlias && ((_left_fields = left_fields) === null || _left_fields === void 0 ? void 0 : _left_fields.length) < 1) {
-      left_fields = [{
-        fieldAlias: left_field.left_fieldAlias,
-        fieldUuid: left_field.left_fieldUuid,
-        quotes: left_field.left_quotes
-        // tableUuid: newMeta.table1.tableUuid,
-        // tableId: newMeta.table1.datasourceId,
-        // tableAlias: newMeta.table1.alias,
-      }];
-    }
-    if (right_field.right_fieldAlias && ((_right_fields = right_fields) === null || _right_fields === void 0 ? void 0 : _right_fields.length) < 1) {
-      right_fields = [{
-        fieldAlias: right_field.right_fieldAlias,
-        fieldUuid: right_field.right_fieldUuid,
-        quotes: right_field.right_quotes
-        // tableUuid: newMeta.table2.tableUuid,
-        // tableId: newMeta.table2.datasourceId,
-        // tableAlias: newMeta.table2.alias,
-      }];
-    }
-    return {
-      left_constant: v.left_constant || '',
-      left_string: v.left_string || '',
-      left_fields: left_fields,
-      left_type: v.left_type || '',
-      operator: v.operator || '',
-      right_constant: v.right_constant || '',
-      right_string: v.right_string || '',
-      right_fields: right_fields,
-      right_type: v.right_type || '',
-      type: v.type || 'default' // 默认是字段模式
-    };
-  })) || [];
-  var _expressions = beforeExpressions.concat(expressions);
-  var newExpressions = [];
-  _expressions === null || _expressions === void 0 || _expressions.map(function (v, i) {
-    var lhs = [];
-    var rhs = [];
-    if (v.left_type === 'string') {
-      lhs = [{
-        val: v.left_string,
-        type: AtomsTypeEnum.INPUT_STRING
-      }];
-    } else if (v.left_type === 'constant') {
-      lhs = [{
-        val: v.left_constant,
-        type: AtomsTypeEnum.CONSTANT
-      }];
-    } else {
-      var _v$left_fields;
-      lhs = (_v$left_fields = v.left_fields) === null || _v$left_fields === void 0 ? void 0 : _v$left_fields.map(function (vv) {
-        return _objectSpread({
-          fieldNameZh: newMeta.table1.name_zh,
-          fieldName: vv.fieldName || vv.quotes || vv.fieldAlias || newMeta.table1.fieldName || newMeta.table1.name,
-          tableAlias: newMeta.table1.alias,
-          tableId: newMeta.table1.id,
-          tableName: newMeta.table1.name,
-          tableNameZh: newMeta.table1.name_zh,
-          tableUuid: newMeta.table1.tableUuid,
-          datasourceName: newMeta.table1.datasourceName,
-          // 数据源名
-          datasourceId: newMeta.table1.datasourceId,
-          // 数据源id
-          type: AtomsTypeEnum.FIELD
-        }, vv);
-      });
-    }
-    if (v.right_type === 'string') {
-      rhs = [{
-        val: v.right_string,
-        type: AtomsTypeEnum.INPUT_STRING
-      }];
-    } else if (v.right_type === 'constant') {
-      rhs = [{
-        val: v.right_constant,
-        type: AtomsTypeEnum.CONSTANT
-      }];
-    } else {
-      var _v$right_fields;
-      rhs = (_v$right_fields = v.right_fields) === null || _v$right_fields === void 0 ? void 0 : _v$right_fields.map(function (vv) {
-        return _objectSpread({
-          fieldNameZh: newMeta.table2.name_zh,
-          fieldName: vv.fieldName || vv.quotes || vv.fieldAlias || newMeta.table2.fieldName || newMeta.table2.name,
-          tableAlias: newMeta.table2.alias,
-          tableId: newMeta.table2.id,
-          tableName: newMeta.table2.name,
-          tableNameZh: newMeta.table2.name_zh,
-          tableUuid: newMeta.table2.tableUuid,
-          datasourceName: newMeta.table2.datasourceName,
-          // 数据源名
-          datasourceId: newMeta.table2.datasourceId,
-          // 数据源id
-          type: AtomsTypeEnum.FIELD
-        }, vv);
-      });
-    }
-    var item = {
-      lhs: lhs,
-      rhs: rhs,
-      // database_type: '',
-      condition: '',
-      // quotes: '',
-      type: AtomsTypeEnum.JOIN_DEFAULT
-    };
-    newExpressions.push(item);
-    if (_expressions.length - 1 > i) {
-      newExpressions.push({
-        val: 'AND',
-        type: AtomsTypeEnum.OPERATOR
-      });
-    }
-    return item;
+  return item;
+};
+// 关联
+export var joinDataPatch = function joinDataPatch(newMeta, constantList, formulaTemplates) {
+  var _newMeta$expressions;
+  newMeta.expressions = (_newMeta$expressions = newMeta.expressions) === null || _newMeta$expressions === void 0 ? void 0 : _newMeta$expressions.map(function (v, i) {
+    v.lhs = v.lhs.map(function (vv) {
+      if (vv.type === 'constant' && !vv.id) {
+        return setConstantId(vv, constantList);
+      }
+      return vv;
+    });
+    v.rhs = v.rhs.map(function (vv) {
+      if (vv.type === 'constant' && !vv.id) {
+        return setConstantId(vv, constantList);
+      }
+      return vv;
+    });
+    return v;
   });
-  // 清除table1中不用字段
-  delete newMeta.table1.fields;
-  // 清除table2中不用字段
-  delete newMeta.table2.fields;
-  newMeta.subquery = _patchMetas(newMeta.subquery);
-  newMeta.expressions = newExpressions;
   return newMeta;
 };
-export var filterPatch = function filterPatch(newMeta) {
+// 过滤器
+export var filterPatch = function filterPatch(newMeta, constantList, formulaTemplates) {
   var _newMeta$filter;
-  // let item = newMeta.filter?.[0] || {};
-  // if (item?.type && Object.values(AtomsTypeEnum).includes(item.type)) {
-  //   if (item.type === AtomsTypeEnum.EXPRESSION && item.lhs) {
-  //     return newMeta;
-  //   }
-  //   if (item.type === AtomsTypeEnum.EXISTS && !item.tableUuid) {
-  //     return newMeta;
-  //   }
-  //   if (item.type === AtomsTypeEnum.NOT_EXISTS && !item.tableUuid) {
-  //     return newMeta;
-  //   }
-  //   if (item.type === AtomsTypeEnum.FIELD && item.fieldName) {
-  //     return newMeta;
-  //   }
-  // }
   var _filter = (_newMeta$filter = newMeta.filter) === null || _newMeta$filter === void 0 ? void 0 : _newMeta$filter.map(function (v) {
-    // 表达式
-    var tem;
-    if (typeof v === 'string') {
-      return {
-        val: v,
-        type: AtomsTypeEnum.OPERATOR
-      };
-    } else if (v.type === 'expression') {
-      var rhs;
-      if (v.valType === 'field') {
-        rhs = [{
-          fieldName: v.table2.name,
-          fieldNameZh: v.table2.name_zh,
-          fieldAlias: v.table2.fieldAlias,
-          fieldUuid: v.table2.fieldUuid,
-          fieldId: v.table2.id,
-          tableName: v.table2.table,
-          tableNameZh: '',
-          tableId: v.table2.tableId,
-          tableAlias: v.table2.alias,
-          tableUuid: v.table2.tableUuid,
-          datasourceName: v.table2.datasourceName,
-          datasourceId: v.table2.datasourceId,
-          type: AtomsTypeEnum.FIELD
-        }];
-      } else if (v.valType === 'constant') {
-        var _v$val;
-        rhs = [{
-          val: ((_v$val = v.val) === null || _v$val === void 0 ? void 0 : _v$val[0]) || '',
-          type: AtomsTypeEnum.CONSTANT
-        }];
-      } else {
-        var _v$val2;
-        if (((_v$val2 = v.val) === null || _v$val2 === void 0 ? void 0 : _v$val2.length) > 1) {
-          rhs = [{
-            val: v.val,
-            type: AtomsTypeEnum.INPUT_STRING_LIST
-          }];
-        } else {
-          var _v$val3;
-          rhs = [{
-            val: ((_v$val3 = v.val) === null || _v$val3 === void 0 ? void 0 : _v$val3[0]) || '',
-            type: AtomsTypeEnum.INPUT_STRING
-          }];
+    if (v.type === 'constant' && !v.id) {
+      return setConstantId(v, constantList);
+    }
+    if (v.type === 'expression') {
+      v.rhs = v.rhs.map(function (item) {
+        if (item.type === 'constant' && !item.id) {
+          return setConstantId(item, constantList);
         }
-      }
-      tem = {
-        lhs: [{
-          fieldName: v.name,
-          fieldNameZh: v.name_zh,
-          fieldAlias: v.fieldAlias || v.name,
-          fieldUuid: v.fieldUuid,
-          fieldId: v.id,
-          tableName: v.table,
-          tableNameZh: '',
-          tableId: v.tableId,
-          tableAlias: v.alias,
-          tableUuid: v.tableUuid,
-          datasourceName: v.datasourceName,
-          datasourceId: v.datasourceId,
-          type: AtomsTypeEnum.FIELD
-        }],
-        rhs: rhs,
-        database_type: v.database_type,
-        condition: v.condition,
-        quotes: v.quotes,
-        formula: v.formula,
-        type: AtomsTypeEnum.EXPRESSION
-      };
-      return tem;
-    } else if (v.type === 'notExists') {
-      var notExists = _patchMetas(v.notExists);
-      return {
-        notExists: notExists,
-        quotes: buildSqlQuery(notExists, v.type),
-        type: AtomsTypeEnum.NOT_EXISTS
-      };
-    } else if (v.type === 'exists') {
-      var _notExists = _patchMetas(v.notExists);
-      return {
-        notExists: _notExists,
-        quotes: buildSqlQuery(_notExists, v.type),
-        type: AtomsTypeEnum.EXISTS
-      };
+        return item;
+      });
+    }
+    if (v.type === 'FORMULA' && !v.id) {
+      return setFormulaId(v, formulaTemplates);
+    }
+    if (v.type === 'exists' || v.type === 'notExists') {
+      v.notExists = _patchMetas(v.notExists, constantList, formulaTemplates);
     }
     return v;
   });
   newMeta.filter = _filter;
   return newMeta;
 };
-export var customColumnPatch = function customColumnPatch(newMeta) {
+// 自定义
+export var customColumnPatch = function customColumnPatch(newMeta, constantList, formulaTemplates) {
   var _newMeta$customColumn;
-  // let item = newMeta.customColumn?.[0]?.formulaList?.[0] || {};
-  // if (item?.type && Object.values(AtomsTypeEnum).includes(item.type)) {
-  //   if (item.type === AtomsTypeEnum.EXPRESSION && item.lhs) {
-  //     return newMeta;
-  //   }
-  //   if (item.type === AtomsTypeEnum.EXISTS && !item.tableUuid) {
-  //     return newMeta;
-  //   }
-  //   if (item.type === AtomsTypeEnum.NOT_EXISTS && !item.tableUuid) {
-  //     return newMeta;
-  //   }
-  //   if (item.type === AtomsTypeEnum.FIELD && item.fieldName) {
-  //     return newMeta;
-  //   }
-  // }
   newMeta.customColumn = (newMeta === null || newMeta === void 0 || (_newMeta$customColumn = newMeta.customColumn) === null || _newMeta$customColumn === void 0 ? void 0 : _newMeta$customColumn.map(function (v) {
     var _formulaList = v.formulaList.map(function (formula) {
-      var tem = formula;
       if (formula.type === 'expression') {
-        var rhs;
-        if (formula.expression.valType === 'field') {
-          rhs = [{
-            fieldName: formula.expression.table2.name,
-            fieldNameZh: formula.expression.table2.name_zh,
-            fieldAlias: formula.expression.table2.fieldAlias,
-            fieldUuid: formula.expression.table2.fieldUuid,
-            fieldId: formula.expression.table2.id,
-            tableName: formula.expression.table2.table,
-            tableNameZh: '',
-            tableId: formula.expression.table2.tableId,
-            tableAlias: formula.expression.table2.alias,
-            tableUuid: formula.expression.table2.tableUuid,
-            datasourceName: formula.expression.table2.datasourceName,
-            datasourceId: formula.expression.table2.datasourceId,
-            // quotes: formula.expression.table2.quotes,
-            type: AtomsTypeEnum.FIELD
-          }];
-        } else if (formula.expression.valType === 'constant') {
-          var _formula$expression$v;
-          rhs = [{
-            val: ((_formula$expression$v = formula.expression.val) === null || _formula$expression$v === void 0 ? void 0 : _formula$expression$v[0]) || '',
-            type: AtomsTypeEnum.CONSTANT
-          }];
-        } else {
-          var _formula$expression$v2;
-          if (((_formula$expression$v2 = formula.expression.val) === null || _formula$expression$v2 === void 0 ? void 0 : _formula$expression$v2.length) > 1) {
-            rhs = [{
-              val: formula.expression.val,
-              type: AtomsTypeEnum.INPUT_STRING_LIST
-            }];
-          } else {
-            var _formula$expression$v3;
-            rhs = [{
-              val: ((_formula$expression$v3 = formula.expression.val) === null || _formula$expression$v3 === void 0 ? void 0 : _formula$expression$v3[0]) || '',
-              type: AtomsTypeEnum.INPUT_STRING
-            }];
+        formula.lhs = formula.lhs.map(function (vv) {
+          if (vv.type === 'constant' && !vv.id) {
+            return setConstantId(vv, constantList);
           }
-        }
-        tem = {
-          lhs: [{
-            fieldName: formula.expression.name,
-            fieldNameZh: formula.expression.name_zh,
-            fieldAlias: formula.expression.fieldAlias || formula.expression.name,
-            fieldUuid: formula.expression.fieldUuid,
-            fieldId: formula.expression.id,
-            tableName: formula.expression.table,
-            tableNameZh: '',
-            tableId: formula.expression.tableId,
-            tableAlias: formula.expression.alias,
-            tableUuid: formula.expression.tableUuid,
-            datasourceName: formula.expression.datasourceName,
-            datasourceId: formula.expression.datasourceId,
-            // quotes: formula.expression.name,
-            type: AtomsTypeEnum.FIELD
-          }],
-          rhs: rhs,
-          database_type: formula.expression.database_type,
-          condition: formula.expression.condition,
-          quotes: formula.expression.quotes,
-          formula: formula.expression.formula,
-          type: AtomsTypeEnum.EXPRESSION
-        };
-      } else if (formula.type === 'field') {
-        tem = {
-          fieldName: formula.expression.name,
-          fieldNameZh: formula.expression.name_zh,
-          fieldAlias: formula.expression.fieldAlias,
-          fieldUuid: formula.expression.fieldUuid,
-          fieldId: formula.expression.id,
-          tableName: formula.expression.table,
-          tableNameZh: '',
-          tableId: formula.expression.tableId,
-          tableAlias: formula.expression.alias,
-          tableUuid: formula.expression.tableUuid,
-          datasourceName: formula.expression.datasourceName,
-          datasourceId: formula.expression.datasourceId,
-          // quotes: formula.expression.quotes,
-          type: AtomsTypeEnum.FIELD
-        };
-      } else if (formula.type === 'operator') {
-        tem = {
-          val: formula.operator,
-          type: AtomsTypeEnum.OPERATOR
-        };
-      } else if (formula.type === 'other') {
-        tem = {
-          val: formula.operator,
-          type: AtomsTypeEnum.OPERATOR
-        };
-      } else if (formula.type === 'input') {
-        tem = {
-          val: formula.operator,
-          type: AtomsTypeEnum.INPUT_STRING
-        };
-      } else if (formula.type === 'notExists') {
-        //应该是多余
-        return {
-          notExists: v.expression.notExists,
-          quotes: v.expression.quotes,
-          type: AtomsTypeEnum.NOT_EXISTS
-        };
+          return vv;
+        });
+        formula.rhs = formula.rhs.map(function (vv) {
+          if (vv.type === 'constant' && !vv.id) {
+            return setConstantId(vv, constantList);
+          }
+          return vv;
+        });
+      } else if (formula.type === 'constant' && !formula.id) {
+        return setConstantId(formula, constantList);
+      } else if (formula.type === 'FORMULA' && !formula.id) {
+        return setFormulaId(formula, formulaTemplates);
+      } else if (formula.type === 'exists' || formula.type === 'notExists') {
+        return _objectSpread(_objectSpread({}, formula), {}, {
+          notExists: _patchMetas(formula.notExists, constantList, formulaTemplates)
+        });
       }
-      return tem;
+      return formula;
     });
-    {}
     return _objectSpread(_objectSpread({}, v), {}, {
       formulaList: _formulaList
     });
   })) || newMeta.customColumn;
   return newMeta;
 };
-export var sortPatch = function sortPatch(newMeta) {
-  var _newMeta$sort;
-  // let item = newMeta.sort?.[0].expression?.[0] || {};
-  // if (item?.type && Object.values(AtomsTypeEnum).includes(item.type)) {
-  //   if (item.type === AtomsTypeEnum.EXPRESSION && item.lhs) {
-  //     return newMeta;
-  //   }
-  //   if (item.type === AtomsTypeEnum.EXISTS && !item.tableUuid) {
-  //     return newMeta;
-  //   }
-  //   if (item.type === AtomsTypeEnum.NOT_EXISTS && !item.tableUuid) {
-  //     return newMeta;
-  //   }
-  //   if (item.type === AtomsTypeEnum.FIELD && item.fieldName) {
-  //     return newMeta;
-  //   }
-  // }
-  var _sort = (_newMeta$sort = newMeta.sort) === null || _newMeta$sort === void 0 ? void 0 : _newMeta$sort.map(function (v) {
-    return {
-      expression: [{
-        fieldName: v.name,
-        fieldNameZh: v.name_zh,
-        fieldAlias: v.fieldAlias || v.name,
-        fieldUuid: v.fieldUuid,
-        fieldId: v.id,
-        tableName: v.table,
-        tableNameZh: '',
-        tableId: v.tableId,
-        tableAlias: v.alias,
-        tableUuid: v.tableUuid,
-        datasourceName: v.datasourceName,
-        datasourceId: v.datasourceId,
-        type: AtomsTypeEnum.FIELD
-      }],
-      sort: v.sort
-    };
-  });
-  newMeta.sort = _sort;
-  return newMeta;
-};
-var _patchMetas = function patchMetas(items) {
+// 兼容
+var _patchMetas = function patchMetas(items, constantList, formulaTemplates) {
   return (items === null || items === void 0 ? void 0 : items.map(function (v) {
-    if (v.type === TypeEnum.data) {
-      v = dataPatch(v);
-    }
     if (v.type === TypeEnum.joinData) {
-      v = joinDataPatch(v);
+      v = joinDataPatch(v, constantList, formulaTemplates);
     }
     if (v.type === TypeEnum.filter) {
-      v = filterPatch(v);
-    }
-    if (v.type === TypeEnum.sort) {
-      v = sortPatch(v);
+      v = filterPatch(v, constantList, formulaTemplates);
     }
     if (v.type === TypeEnum.customColumn) {
-      v = customColumnPatch(v);
+      v = customColumnPatch(v, constantList, formulaTemplates);
     }
     if (v.type === TypeEnum.union) {
-      v.subquery = _patchMetas(v.subquery || []);
+      v.subquery = _patchMetas(v.subquery || [], constantList, formulaTemplates);
     }
     return v;
   })) || [];
 };
-// export const patchMetas1 = (items: MetaListType[]) => {
-//   return (
-//     items?.map((v: MetaListType): MetaListType => {
-//       // if (v.type === TypeEnum.data) {
-//       //   v = dataPatch(v);
-//       // }
-//       // if (v.type === TypeEnum.joinData) {
-//       //   v = joinDataPatch(v);
-//       // }
-//       // if (v.type === TypeEnum.filter) {
-//       //   v = filterPatch(v);
-//       // }
-//       // if (v.type === TypeEnum.sort) {
-//       //   v = sortPatch(v);
-//       // }
-//       // if (v.type === TypeEnum.customColumn) {
-//       //   v = customColumnPatch(v);
-//       // }
-//       if (v.type === TypeEnum.union) {
-//         v.subquery = patchMetas(v.subquery || []);
-//       }
-//       return v;
-//     }) || []
-//   );
-// };
 export { _patchMetas as patchMetas };

package/lib/es/hooks/patch2.d.ts

@@ -0,0 +1,7 @@
+import { MetaListType } from '../store/types';
+export declare const dataPatch: (newMeta: any) => any;
+export declare const joinDataPatch: (newMeta: any) => any;
+export declare const filterPatch: (newMeta: any) => any;
+export declare const customColumnPatch: (newMeta: any) => any;
+export declare const sortPatch: (newMeta: any) => any;
+export declare const patchMetas: (items: MetaListType[]) => MetaListType[];