@gingkoo/pandora-metabase 1.0.117 → 1.0.119

package/lib/es/components/dialog/formula-list/utils.d.ts

@@ -1,11 +1,4 @@
 import { AtomsTypeEnum, AtomsItem } from '../../../store/types';
-/**
- *
- * @param type 当前选择的类型
- * @param list 当前数组
- * @param index 需要讲模版插入的位置
- * @returns
- */
 export declare const insertTemplateAt: (oldType: string, type: string, list: any[], index: number) => any[];
 export declare const operatorList: string[];
 export declare const customTypes: ({

package/lib/es/components/dialog/formula-list/utils.js

@@ -2,18 +2,9 @@ import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIt
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import { __ } from '../../../locale';
 import { AtomsTypeEnum } from '../../../store/types';
-// import { FUNCTION_TEMPLATES } from '../function/utils';
-/**
- *
- * @param type 当前选择的类型
- * @param list 当前数组
- * @param index 需要讲模版插入的位置
- * @returns
- */
 export var insertTemplateAt = function insertTemplateAt(oldType, type, list, index) {
   var temList = [];
   var needChange = ['RANK()', 'DENSE_RANK()', 'ROW_NUMBER()', 'when', 'case', 'then'].includes(oldType);
-  // 只改变类型不需要插入模版
   if (needChange) {
     return list;
   }
@@ -65,58 +56,34 @@ export var insertTemplateAt = function insertTemplateAt(oldType, type, list, ind
       type: AtomsTypeEnum.OPERATOR
     }, {
       fieldName: '',
-      // 字段名
       fieldNameZh: '',
-      // 字段中文名
       fieldAlias: '',
-      // 别名
       fieldUuid: '',
-      // uuid
       fieldId: '',
-      // 字段id
-      // quotes?: string; // 字段展示的 不知道有没有用
       tableName: '',
-      // 表名
       tableNameZh: '',
       tableId: '',
-      // 表名
       tableAlias: '',
-      // 别名
       tableUuid: '',
-      // 表唯一标识
       datasourceName: '',
-      // 数据源名
       datasourceId: '',
-      // 数据源id
       type: AtomsTypeEnum.FIELD
     }, {
       val: 'ORDER BY',
       type: AtomsTypeEnum.OPERATOR
     }, {
       fieldName: '',
-      // 字段名
       fieldNameZh: '',
-      // 字段中文名
       fieldAlias: '',
-      // 别名
       fieldUuid: '',
-      // uuid
       fieldId: '',
-      // 字段id
-      // quotes?: string; // 字段展示的 不知道有没有用
       tableName: '',
-      // 表名
       tableNameZh: '',
       tableId: '',
-      // 表名
       tableAlias: '',
-      // 别名
       tableUuid: '',
-      // 表唯一标识
       datasourceName: '',
-      // 数据源名
       datasourceId: '',
-      // 数据源id
       type: AtomsTypeEnum.FIELD
     }, {
       val: ')',
@@ -127,46 +94,30 @@ export var insertTemplateAt = function insertTemplateAt(oldType, type, list, ind
   return list;
 };
 export var operatorList = ['and', 'or', '(', ')', ',', '+', '-', '*', '/', '!', '!=', '<=', '>=', '<', '>', '=', 'case', 'when', 'then', 'else', 'end', 'NULL', 'DESC', 'ASC', 'OVER', 'PARTITION BY', 'ORDER BY', 'RANK()', 'DENSE_RANK()', 'ROW_NUMBER()'];
-export var customTypes = [
-// 字段
-{
+export var customTypes = [{
   value: AtomsTypeEnum.FIELD,
   label: __('customColumn.field')
-},
-// 表达式
-{
+}, {
   value: AtomsTypeEnum.EXPRESSION,
   label: __('customColumn.expression')
-},
-// 输入框
-{
+}, {
   value: AtomsTypeEnum.INPUT_STRING,
   label: __('customColumn.input')
-},
-// 数字输入框
-{
+}, {
   value: AtomsTypeEnum.INPUT_NUMBER,
   label: __('customColumn.numberInput')
-},
-// 数字输入框
-{
+}, {
   value: AtomsTypeEnum.CONSTANT,
   label: __('customColumn.constant')
-},
-// 连接符
-{
+}, {
   value: AtomsTypeEnum.OPERATOR,
   label: __('customColumn.operator'),
   children: operatorList
-},
-// 函数
-{
+}, {
   value: AtomsTypeEnum.FORMULA,
   label: __('customColumn.formula'),
   children: operatorList
-},
-// EXISTS
-{
+}, {
   value: AtomsTypeEnum.NOT_EXISTS,
   label: 'NOT_EXISTS'
 }, {
@@ -178,38 +129,23 @@ export var customTypes = [
 }];
 export var getTemplateItem = function getTemplateItem(type, item) {
   var temItem;
-  // 字段
   if (type === AtomsTypeEnum.FIELD) {
     temItem = {
       fieldName: '',
-      // 字段名
       fieldNameZh: '',
-      // 字段中文名
       fieldAlias: '',
-      // 别名
       fieldUuid: '',
-      // uuid
       fieldId: '',
-      // 字段id
-      // quotes?: string; // 字段展示的 不知道有没有用
       tableName: '',
-      // 表名
       tableNameZh: '',
       tableId: '',
-      // 表名
       tableAlias: '',
-      // 别名
       tableUuid: '',
-      // 表唯一标识
       datasourceName: '',
-      // 数据源名
       datasourceId: '',
-      // 数据源id
       type: AtomsTypeEnum.FIELD
     };
-  }
-  // 表达式
-  else if (type === AtomsTypeEnum.EXPRESSION || type === AtomsTypeEnum.JOIN_DEFAULT) {
+  } else if (type === AtomsTypeEnum.EXPRESSION || type === AtomsTypeEnum.JOIN_DEFAULT) {
     return {
       lhs: [],
       rhs: [],
@@ -220,21 +156,17 @@ export var getTemplateItem = function getTemplateItem(type, item) {
   } else if (type === AtomsTypeEnum.EXISTS || type === AtomsTypeEnum.NOT_EXISTS) {
     return {
       quotes: '',
-      // 展示用户看的 组装的文字
       notExists: [],
       type: type
     };
   } else if (type === AtomsTypeEnum.SUB_QUERY) {
     return {
       quotes: '',
-      // 展示用户看的 组装的文字
       subQuery: [],
       type: type
     };
   } else if (type === AtomsTypeEnum.UNKNOWN) {
     return {
-      // quotes: '', // 展示用户看的 组装的文字
-      // notExists: [],
       val: (item === null || item === void 0 ? void 0 : item["default"]) || '',
       type: type
     };
@@ -251,12 +183,37 @@ export var getTemplateItem = function getTemplateItem(type, item) {
   } else if (type === AtomsTypeEnum.FORMULA) {
     temItem = {
       args: [],
-      // params: FUNCTION_TEMPLATES?.[type]?.params || [],
-      // arity: FUNCTION_TEMPLATES?.[type]?.arity || {},
       name: '',
       quotes: '',
       type: type
     };
+  } else if (type === AtomsTypeEnum.CASE_WHEN) {
+    return {
+      caseValue: [],
+      branches: [{
+        when: [{
+          val: '',
+          type: AtomsTypeEnum.UNKNOWN
+        }],
+        then: [{
+          val: '',
+          type: AtomsTypeEnum.UNKNOWN
+        }]
+      }],
+      elseValue: [],
+      quotes: '',
+      type: type
+    };
+  } else if (type === AtomsTypeEnum.AND_OR) {
+    return {
+      operator: 'and',
+      list: [{
+        val: '',
+        type: AtomsTypeEnum.UNKNOWN
+      }],
+      quotes: '',
+      type: type
+    };
   } else if (type === AtomsTypeEnum.COLLECTION) {
     return {
       list: [],
@@ -273,7 +230,6 @@ export var getTemplateItem = function getTemplateItem(type, item) {
       type: type
     };
   } else {
-    // 其他
     temItem = {
       val: '',
       type: type
@@ -286,30 +242,35 @@ var _isOk = function isOk(rhsVal) {
     if (v.type === AtomsTypeEnum.UNKNOWN) {
       return false;
     } else if (v.type === AtomsTypeEnum.JOIN_DEFAULT) {
-      // 这个情况应该是不存在的
-      return true; // 或者根据业务逻辑决定是否算“有效”
+      return true;
     } else if (v.type === AtomsTypeEnum.FIELD) {
-      return Boolean(v.fieldName); // 确保 fieldName 存在且非空
+      return Boolean(v.fieldName);
     } else if (v.type === AtomsTypeEnum.EXPRESSION || v.type === AtomsTypeEnum.EXISTS || v.type === AtomsTypeEnum.NOT_EXISTS || v.type === AtomsTypeEnum.SUB_QUERY) {
-      return Boolean(v.quotes); // 确保 quotes 存在
+      return Boolean(v.quotes);
     } else if (v.type === AtomsTypeEnum.INPUT_STRING_LIST) {
       return Array.isArray(v.val) && v.val.every(function (vv) {
         return Boolean(vv);
       });
     } else if (v.type === AtomsTypeEnum.COLLECTION) {
       return _isOk(v.list || []);
+    } else if (v.type === AtomsTypeEnum.CASE_WHEN) {
+      return (v.branches || []).length > 0 && (v.branches || []).every(function (branch) {
+        return _isOk(branch.when || []) && _isOk(branch.then || []);
+      }) && _isOk(v.caseValue || []) && _isOk(v.elseValue || []);
+    } else if (v.type === AtomsTypeEnum.AND_OR) {
+      return Boolean(v.operator) && _isOk(v.list || []);
     } else if (v.type === AtomsTypeEnum.FORMULA) {
       if (!v.quotes) {
         return false;
       }
       return _isOk(v.args || []);
+    } else if (v.type === AtomsTypeEnum.SELECT) {
+      return Array.isArray(v.val) ? v.val.length > 0 : Boolean(v.val);
     } else {
-      return Boolean(v.val) || v.val === 0; // 兜底，确保 val 存在
+      return 'val' in v ? Boolean(v.val) || v.val === 0 : false;
     }
   });
 };
-// 校验表达式完整性
-// 括号不匹配
 export { _isOk as isOk };
 function validateParentheses(list) {
   var depth = 0;
@@ -332,14 +293,13 @@ function validateParentheses(list) {
   }
   return depth === 0;
 }
-// CASE 语句不完整（缺少 END 或 WHEN/THEN）
 function validateCaseStructure(list) {
   for (var i = 0; i < list.length; i++) {
     var item = list[i];
     if (item.type === AtomsTypeEnum.OPERATOR && item.val === 'case') {
       var depth = 1;
       var hasValidWhenThen = false;
-      var lastWasWhen = false; // 用于确保 then 前是 when
+      var lastWasWhen = false;
       for (var j = i + 1; j < list.length; j++) {
         var token = list[j];
         if (token.type !== AtomsTypeEnum.OPERATOR) continue;
@@ -349,13 +309,11 @@ function validateCaseStructure(list) {
         } else if (val === 'end') {
           depth--;
           if (depth === 0) {
-            // 当前 case 块结束
             if (!hasValidWhenThen) {
-              return false; // 至少需要一个 when-then
+              return false;
             }
-            break; // 成功找到匹配的 end
+            break;
           }
-          // 如果 depth < 0，说明 end 多余，但这里我们只关心当前 case，可忽略或报错
         } else if (val === 'when') {
           if (depth === 1) {
             lastWasWhen = true;
@@ -363,28 +321,24 @@ function validateCaseStructure(list) {
         } else if (val === 'then') {
           if (depth === 1) {
             if (!lastWasWhen) {
-              return false; // then 前没有 when
+              return false;
             }
             hasValidWhenThen = true;
-            lastWasWhen = false; // then 消费掉 when
+            lastWasWhen = false;
           }
         }
-        // 注意：其他操作符（如 else）可在此扩展
       }
-      // 如果循环结束还没找到匹配的 end（即 depth > 0）
       if (depth > 0) {
-        return false; // 缺少 end
+        return false;
       }
     }
   }
   return true;
 }
-// 窗口函数结构不完整（缺少 OVER 或括号）
 function validateWindowFunction(list) {
   for (var i = 0; i < list.length; i++) {
     var item = list[i];
     if (item.type === AtomsTypeEnum.OPERATOR && ['RANK()', 'DENSE_RANK()', 'ROW_NUMBER()'].includes(item.val)) {
-      // 找后面的 OVER (
       var foundOver = false;
       var parenDepth = 0;
       for (var j = i + 1; j < list.length; j++) {
@@ -394,41 +348,95 @@ function validateWindowFunction(list) {
           foundOver = true;
         } else if (foundOver && next.val === '(') {
           parenDepth = 1;
-          // 继续找匹配的 )
           for (var k = j + 1; k < list.length; k++) {
             if (list[k].type !== AtomsTypeEnum.OPERATOR) continue;
             if (list[k].val === '(') parenDepth++;else if (list[k].val === ')') {
               parenDepth--;
-              if (parenDepth === 0) return true; // 完整
+              if (parenDepth === 0) return true;
             }
           }
-          return false; // 有 ( 但没匹配 )
+          return false;
         }
       }
-      return false; // 没找到 OVER 或 (
+      return false;
     }
   }
   return true;
 }
-// 表达式末尾不能是操作符（如 +, AND, WHEN 等）
 function validateNoTrailingOperator(list) {
-  // 从后往前找第一个非空 OPERATOR
   for (var i = list.length - 1; i >= 0; i--) {
     var item = list[i];
     if (item.type === AtomsTypeEnum.UNKNOWN && item.val === '') continue;
     if (item.type === AtomsTypeEnum.OPERATOR) {
       var val = item.val;
-      // 二元操作符、逗号、(、when、then 等不能结尾
       if (['+', '-', '*', '/', '=', '!=', '<', '>', 'and', 'or', ',', '(', 'when', 'then'].includes(val)) {
         return false;
       }
     }
-    break; // 找到第一个有效项就停
+    break;
   }
   return true;
 }
 export function validateExpressionIntegrity(list) {
-  // 过滤掉空的 UNKNOWN 项（可选）
+  var _iterator2 = _createForOfIteratorHelper(list),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var item = _step2.value;
+      if (item.type === AtomsTypeEnum.AND_OR) {
+        if (!item.operator) {
+          return {
+            isError: true,
+            error: 'AND / OR 结构缺少操作符'
+          };
+        }
+        var nestedError = validateExpressionIntegrity(item.list || []);
+        if (nestedError.isError) {
+          return nestedError;
+        }
+      }
+      if (item.type === AtomsTypeEnum.CASE_WHEN) {
+        if ((item.branches || []).length < 1) {
+          return {
+            isError: true,
+            error: 'CASE WHEN 至少需要一个 when / then 分支',
+            isCase: true
+          };
+        }
+        var caseValueError = validateExpressionIntegrity(item.caseValue || []);
+        if (caseValueError.isError) {
+          return caseValueError;
+        }
+        var _iterator3 = _createForOfIteratorHelper(item.branches || []),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var branch = _step3.value;
+            var whenError = validateExpressionIntegrity(branch.when || []);
+            if (whenError.isError) {
+              return whenError;
+            }
+            var thenError = validateExpressionIntegrity(branch.then || []);
+            if (thenError.isError) {
+              return thenError;
+            }
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+        var elseError = validateExpressionIntegrity(item.elseValue || []);
+        if (elseError.isError) {
+          return elseError;
+        }
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
   var cleanList = list.filter(function (item) {
     return !(item.type === AtomsTypeEnum.UNKNOWN && item.val === '');
   });
@@ -453,9 +461,6 @@ export function validateExpressionIntegrity(list) {
       isOver: true
     };
   }
-  // if (!validateNoTrailingOperator(cleanList)) {
-  //   return { isError: true, error: '表达式末尾不能是操作符（如 +, AND, WHEN 等）' };
-  // }
   return {
     isError: false
   };

package/lib/es/components/dialog/index.js

@@ -6,6 +6,6 @@ export { default as SelectSummarize } from './select-summarize/index';
 export { default as SelectJoin } from './select-join/index';
 export { default as SelectTable } from './select-table/index';
 export { default as SelectPermissionTable } from './select-permission-table/index';
-export { default as FormulaList } from './formula-list/index'; // 自定义公式列表
-export { default as Expression } from './expression/index'; // 表达式编辑器
-export { getTemplateItem } from './formula-list/utils'; // 表达式编辑器
+export { default as FormulaList } from './formula-list/index';
+export { default as Expression } from './expression/index';
+export { getTemplateItem } from './formula-list/utils';

package/lib/es/components/dialog/select-column/index.d.ts

@@ -1,9 +1,3 @@
-/**
- * 选择保留哪些表字段
- * 谁在用？
- * 1、数据模块
- * 2、关联模块
- */
 import './index.less';
 import { MetaData_ColumnsType } from '../../../store/types';
 interface PropsType {

package/lib/es/components/dialog/select-column/index.js

@@ -3,12 +3,6 @@ import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * 选择保留哪些表字段
- * 谁在用？
- * 1、数据模块
- * 2、关联模块
- */
 import './index.less';
 import { useEffect, useMemo, useState } from 'react';
 import cloneDeep from 'lodash/cloneDeep';
@@ -21,7 +15,6 @@ import { useStore } from '../../../hooks/use-provider';
 import { uuidv4 } from '../../../utils/helper';
 import { changeFieldAlias, isValidSQLAlias } from '../../../utils';
 import { SearchIcon } from '../../icons';
-// 选择表中参数
 var SelectColumn = function SelectColumn(_ref) {
   var _ref$data = _ref.data,
     data = _ref$data === void 0 ? [] : _ref$data,
@@ -77,12 +70,12 @@ var SelectColumn = function SelectColumn(_ref) {
     }
   }, [isAllSelect]);
   function onSelect(columns, newMetaList) {
-    var originalData = cloneDeep(originList); // 原始数据
+    var originalData = cloneDeep(originList);
     var mergedColumns = originalData.map(function (item) {
       var match = columns.find(function (col) {
         return col.fieldUuid === item.fieldUuid;
       });
-      return match ? cloneDeep(match) : item; // 可选：是否需要深拷贝 match
+      return match ? cloneDeep(match) : item;
     });
     setColumns(columns);
     setOriginList(mergedColumns);
@@ -92,7 +85,6 @@ var SelectColumn = function SelectColumn(_ref) {
     var fieldAlias = val || '';
     Modal.confirm({
       title: __('SqlQueryBuilder.alias'),
-      // 设置别名
       content: _jsx(Input, {
         defaultValue: fieldAlias,
         onChange: function onChange(val) {
@@ -100,7 +92,7 @@ var SelectColumn = function SelectColumn(_ref) {
         }
       }),
       onOk: function () {
-        var _onOk = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var _onOk = _asyncToGenerator(_regeneratorRuntime.mark(function _callee() {
           var newColumns, newMetaList;
           return _regeneratorRuntime.wrap(function (_context) {
             while (1) switch (_context.prev = _context.next) {
@@ -149,9 +141,7 @@ var SelectColumn = function SelectColumn(_ref) {
       children: [_jsxs("div", {
         className: 'Sqb-SelectColumn--header pt-2',
         children: [_jsx("div", {
-          className: cx("SelectColumn-border mb-2 pb-2 px-2 flex items-center", {
-            // 'events-none': isAllSelect
-          }),
+          className: cx("SelectColumn-border mb-2 pb-2 px-2 flex items-center", {}),
           onClick: function onClick() {
             var newColumns = columns.map(function (v) {
               return _objectSpread(_objectSpread({}, v), {}, {

package/lib/es/components/dialog/select-column-multiple/index.d.ts

@@ -1,11 +1,3 @@
-/**
- * 选择表字段当条件
- * 谁在用？
- * 1、关联模块
- * 2、过滤器模块
- * 3、聚合模块
- * 4、排序模块
- */
 import './index.less';
 import { ColumnsPopupThemeEnum, SQL_COLUMN_TYPE } from '../../../store/enum';
 import { MetaData_ColumnsType, MetaJoin_TalbeType, AtomsField } from '../../../store/types';