@tuoyuan/gateway-api-select-config 1.2.1

package/src/utils/dataExtractor.js

@@ -0,0 +1,359 @@
+/**
+ * 数据提取和格式化工具
+ */
+
+/**
+ * 根据 schema 提取数据
+ * @param {Object} data - 原始数据
+ * @param {Object} schema - res_schema 配置
+ * @returns {any} 提取后的数据
+ */
+export function extractDataBySchema(data, schema) {
+  // 安全检查
+  if (!schema || typeof schema !== 'object') {
+    return data;
+  }
+  
+  // 优先使用 x_path 定位数据（最外层）
+  if (schema.x_path) {
+    data = getValueByPath(data, schema.x_path);
+  }
+  // 其次使用 x_value（兼容旧版）
+  else if (schema.x_value) {
+    data = getValueByPath(data, schema.x_value);
+  }
+  
+  // 判断实际的数据类型
+  if (Array.isArray(data)) {
+    // 如果 schema 有 items，说明这是个数组 schema
+    if (schema.items) {
+      return extractArrayData(data, { type: 'array', items: schema.items });
+    }
+  } else if (schema.type === 'object' && schema.properties) {
+    return extractObjectData(data, schema);
+  }
+  
+  // 如果 schema 有 format，应用格式化
+  if (schema.format && data !== undefined && data !== null) {
+    data = applyFormat(data, schema.format);
+  }
+  
+  return data;
+}
+
+/**
+ * 提取数组数据
+ * @param {Array} data - 数组数据
+ * @param {Object} schema - 数组 schema
+ * @returns {Array} 提取后的数组
+ */
+function extractArrayData(data, schema) {
+  const result = [];
+  
+  if (!Array.isArray(data)) {
+    return [];
+  }
+  
+  // 安全检查
+  if (!schema || !schema.items || typeof schema.items !== 'object') {
+    return data;
+  }
+  
+  // 检查 schema 是否完整
+  const properties = schema.items?.properties;
+  const hasValidSchema = properties && Object.keys(properties).length > 0;
+  
+  // 如果 schema 不完整，检查是否有顶层的 x_path 或 x_value
+  if (!hasValidSchema) {
+    // 如果 items 有 x_path，对每个元素应用路径提取
+    if (schema.items?.x_path) {
+      return data.map(item => {
+        let value = getValueByPath(item, schema.items.x_path);
+        
+        // 应用格式化
+        if (schema.items.format && value !== undefined && value !== null) {
+          value = applyFormat(value, schema.items.format);
+        }
+        
+        return value;
+      });
+    }
+    
+    // 否则直接返回原始数据
+    return data;
+  }
+  
+  // 提取每个元素
+  data.forEach((item) => {
+    const extractedItem = {};
+    
+    for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+      // 安全检查 fieldSchema
+      if (!fieldSchema || typeof fieldSchema !== 'object') {
+        extractedItem[fieldName] = undefined;
+        continue;
+      }
+      
+      const itemPath = fieldSchema.x_path;
+      
+      if (itemPath) {
+        let value = getValueByPath(item, itemPath);
+        
+        // 应用格式化
+        const format = fieldSchema.format;
+        if (format && value !== undefined && value !== null) {
+          value = applyFormat(value, format);
+        }
+        
+        extractedItem[fieldName] = value;
+      } else {
+        extractedItem[fieldName] = undefined;
+      }
+    }
+    
+    result.push(extractedItem);
+  });
+  
+  return result;
+}
+
+/**
+ * 提取对象数据
+ * @param {Object} data - 对象数据
+ * @param {Object} schema - 对象 schema
+ * @returns {Object} 提取后的对象
+ */
+function extractObjectData(data, schema) {
+  const result = {};
+  
+  // 安全检查
+  if (!schema || typeof schema !== 'object') {
+    return data;
+  }
+  
+  // 检查 schema 是否完整
+  const properties = schema.properties;
+  const hasValidSchema = properties && Object.keys(properties).length > 0;
+  
+  // 如果 schema 不完整，检查是否有 x_path
+  if (!hasValidSchema) {
+    // 如果有 x_path，按路径提取
+    if (schema.x_path) {
+      let value = getValueByPath(data, schema.x_path);
+      
+      // 应用格式化
+      if (schema.format && value !== undefined && value !== null) {
+        value = applyFormat(value, schema.format);
+      }
+      
+      return value;
+    }
+    
+    // 否则直接返回原始数据
+    return data;
+  }
+  
+  for (const [fieldName, fieldSchema] of Object.entries(schema.properties)) {
+    // 安全检查 fieldSchema
+    if (!fieldSchema || typeof fieldSchema !== 'object') {
+      result[fieldName] = undefined;
+      continue;
+    }
+    
+    // 只有当 x_path 存在时才提取
+    if (fieldSchema.x_path) {
+      let value = getValueByPath(data, fieldSchema.x_path);
+      
+      // 应用格式化
+      const format = fieldSchema.format;
+      if (format && value !== undefined && value !== null) {
+        value = applyFormat(value, format);
+      }
+      
+      result[fieldName] = value;
+    } else {
+      result[fieldName] = undefined;
+    }
+  }
+  
+  return result;
+}
+
+/**
+ * 根据路径获取值
+ * @param {Object} obj - 对象
+ * @param {String} path - 路径（支持 $ 和 @ 前缀）
+ * @returns {any} 值
+ */
+function getValueByPath(obj, path) {
+  // 如果 path 为空，返回 undefined
+  if (!path || typeof path !== 'string') {
+    return undefined;
+  }
+  
+  // 去掉 JSONPath 的 $ 或 @ 前缀
+  let cleanPath = path.replace(/^[$@]\.?/, '');
+  
+  // 分割路径
+  const keys = cleanPath.split(/[\.\[\]]/).filter(k => k !== '' && k !== '*');
+  
+  let value = obj;
+  
+  for (const key of keys) {
+    if (value === null || value === undefined) {
+      return undefined;
+    }
+    value = value[key];
+  }
+  
+  return value;
+}
+
+/**
+ * 应用格式化
+ * @param {any} value - 原始值
+ * @param {String} format - 格式化类型
+ * @returns {any} 格式化后的值
+ */
+export function applyFormat(value, format) {
+  try {
+    switch (format) {
+      // 日期格式
+      case 'YYYY-MM-DD':
+        return formatDate(value, 'YYYY-MM-DD');
+      case 'YYYY-MM-DD HH:mm:ss':
+        return formatDate(value, 'YYYY-MM-DD HH:mm:ss');
+      case 'YYYY/MM/DD':
+        return formatDate(value, 'YYYY/MM/DD');
+      case 'timestamp':
+        return new Date(value).getTime();
+      case 'timestamp_s':
+        return Math.floor(new Date(value).getTime() / 1000);
+      
+      // 数字格式
+      case 'number':
+        return Number(value);
+      case 'integer':
+        return Math.floor(Number(value));
+      case 'currency':
+        return '¥' + Number(value).toLocaleString('zh-CN', { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+      case 'percent':
+        return (Number(value) * 100).toFixed(2) + '%';
+      
+      // 字符串格式
+      case 'uppercase':
+        return String(value).toUpperCase();
+      case 'lowercase':
+        return String(value).toLowerCase();
+      case 'trim':
+        return String(value).trim();
+      
+      // 通用格式
+      case 'string':
+        return String(value);
+      case 'boolean':
+        return Boolean(value);
+      case 'json':
+        return JSON.stringify(value);
+      
+      default:
+        return value;
+    }
+  } catch (err) {
+    console.error('格式化失败:', err);
+    return value;
+  }
+}
+
+/**
+ * 日期格式化辅助函数
+ * @param {any} value - 日期值
+ * @param {String} format - 格式
+ * @returns {String} 格式化后的日期字符串
+ */
+function formatDate(value, format) {
+  const date = new Date(value);
+  if (isNaN(date.getTime())) return String(value);
+  
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  const hours = String(date.getHours()).padStart(2, '0');
+  const minutes = String(date.getMinutes()).padStart(2, '0');
+  const seconds = String(date.getSeconds()).padStart(2, '0');
+  
+  return format
+    .replace('YYYY', String(year))
+    .replace('MM', month)
+    .replace('DD', day)
+    .replace('HH', hours)
+    .replace('mm', minutes)
+    .replace('ss', seconds)
+    .replace('/', '/');
+}
+
+/**
+ * 执行 reqMapping 中的函数表达式
+ * @param {Object} reqMapping - 请求参数映射
+ * @param {Object} context - 上下文数据
+ * @returns {Object} 执行后的参数
+ */
+export function executeReqMapping(reqMapping, context = {}) {
+  if (!reqMapping) return {};
+  
+  const result = {};
+  
+  for (const [key, value] of Object.entries(reqMapping)) {
+    if (typeof value === 'string') {
+      // 检查是否是函数表达式
+      if (value.includes('=>')) {
+        try {
+          // 将字符串转换为函数并执行
+          // eslint-disable-next-line no-new-func
+          const fn = new Function('ctx', `return (${value})(ctx)`);
+          result[key] = fn(context);
+        } catch (err) {
+          console.error(`执行函数表达式失败 [${key}]:`, err);
+          result[key] = value; // 失败时使用原始值
+        }
+      } 
+      // 检查是否是纯模板变量（不带引号的）：${varName}
+      else if (value.match(/^\$\{[^}]+\}$/)) {
+        const varName = value.match(/^\$\{([^}]+)\}$/)[1];
+        const contextValue = context[varName];
+        result[key] = contextValue !== undefined ? contextValue : value;
+      }
+      // 检查是否是模板字符串（带其他内容）
+      else if (value.includes('${')) {
+        try {
+          // 替换模板变量
+          let replaced = value.replace(/\$\{([^}]+)\}/g, (match, varName) => {
+            return context[varName] !== undefined ? context[varName] : match;
+          });
+          
+          // 尝试转换类型：如果替换后的值看起来像数字，转换为数字
+          if (replaced !== value) {  // 确实发生了替换
+            // 如果整个字符串都是数字，转换为数字
+            const num = Number(replaced);
+            if (!isNaN(num) && replaced.trim() !== '') {
+              result[key] = num;
+            } else {
+              result[key] = replaced;
+            }
+          } else {
+            result[key] = replaced;
+          }
+        } catch (err) {
+          console.error(`解析模板字符串失败 [${key}]:`, err);
+          result[key] = value;
+        }
+      } else {
+        result[key] = value;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  
+  return result;
+}

package/src/utils/dataFilters.js

@@ -0,0 +1,300 @@
+/**
+ * 通用数据过滤器工具
+ * 提供动态、可配置的数据处理能力
+ */
+
+import { applyFormat } from './dataExtractor.js';
+
+/**
+ * 通用数据提取器
+ * 自动从响应中提取数组数据
+ * @param {*} response - 接口响应数据
+ * @param {string} path - 可选的提取路径,如 'data.list' 或 '@.data.list'
+ * @returns {Array} 提取出的数组数据
+ */
+export function extractArray(response, path = null) {
+  // 如果指定了路径,按路径提取
+  if (path) {
+    const cleanPath = path.replace(/^@\./, ''); // 移除 @ 前缀
+    const keys = cleanPath.split('.');
+    let result = response;
+    
+    for (const key of keys) {
+      if (result && typeof result === 'object') {
+        result = result[key];
+      } else {
+        result = null;
+        break;
+      }
+    }
+    
+    if (Array.isArray(result)) {
+      return result;
+    }
+  }
+  
+  // 如果已经是数组,直接返回
+  if (Array.isArray(response)) {
+    return response;
+  }
+  
+  // 如果是对象,尝试提取常见的列表字段
+  if (typeof response === 'object' && response !== null) {
+    const possibleKeys = ['data', 'list', 'items', 'records', 'rows', 'result', 'content'];
+    
+    for (const key of possibleKeys) {
+      if (Array.isArray(response[key])) {
+        return response[key];
+      }
+      
+      // 递归查找一层 (如 data.list)
+      if (response[key] && typeof response[key] === 'object') {
+        for (const subKey of possibleKeys) {
+          if (Array.isArray(response[key][subKey])) {
+            return response[key][subKey];
+          }
+        }
+      }
+    }
+    
+    // 如果找不到数组,返回包含该对象的数组
+    return [response];
+  }
+  
+  // 其他情况返回空数组
+  return [];
+}
+
+/**
+ * 通用字段映射器
+ * 根据映射配置提取和转换字段
+ * @param {Object} item - 原始数据项
+ * @param {Object} fieldMapping - 字段映射配置 { targetField: sourceField | Function }
+ * @param {Object} fieldTypes - 字段类型配置 { targetField: 'string' | 'number' | 'integer' | 'boolean' | 'date' }
+ * @param {Object} fieldFormats - 字段格式化配置 { targetField: formatString }
+ * @returns {Object} 映射后的对象
+ */
+export function mapFields(item, fieldMapping, fieldTypes = {}, fieldFormats = {}) {
+  if (!item || typeof item !== 'object') return item;
+  
+  const result = {};
+  
+  for (const [targetField, source] of Object.entries(fieldMapping)) {
+    let value;
+    
+    // 如果是函数,执行函数
+    if (typeof source === 'function') {
+      value = source(item);
+    }
+    // 如果是字符串,从原始对象中提取
+    else if (typeof source === 'string') {
+      // 支持嵌套路径,如 'user.name'
+      const keys = source.split('.');
+      value = item;
+      for (const key of keys) {
+        if (value && typeof value === 'object') {
+          value = value[key];
+        } else {
+          value = undefined;
+          break;
+        }
+      }
+    }
+    // 如果是数组,尝试多个字段 (fallback)
+    else if (Array.isArray(source)) {
+      for (const field of source) {
+        const fieldValue = item[field];
+        if (fieldValue !== undefined && fieldValue !== null && fieldValue !== '') {
+          value = fieldValue;
+          break;
+        }
+      }
+    }
+    // 直接赋值
+    else {
+      value = source;
+    }
+    
+    // 应用类型转换
+    const fieldType = fieldTypes[targetField];
+    if (fieldType && value !== undefined && value !== null) {
+      value = convertType(value, fieldType);
+    }
+    
+    // 应用格式化
+    const fieldFormat = fieldFormats[targetField];
+    if (fieldFormat && value !== undefined && value !== null) {
+      value = applyFormat(value, fieldFormat);
+    }
+    
+    result[targetField] = value;
+  }
+  
+  return result;
+}
+
+/**
+ * 类型转换辅助函数
+ * @param {any} value - 原始值
+ * @param {string} type - 目标类型
+ * @returns {any} 转换后的值
+ */
+function convertType(value, type) {
+  try {
+    switch (type) {
+      case 'string':
+        // 如果值是对象,不要转换(保持原样),除非配置了 json 格式化
+        if (typeof value === 'object' && value !== null) {
+          return value;
+        }
+        return String(value);
+      case 'number':
+        return Number(value);
+      case 'integer':
+        return Math.floor(Number(value));
+      case 'boolean':
+        return Boolean(value);
+      case 'date':
+        // 保持原始值，让格式化函数处理
+        return value;
+      default:
+        return value;
+    }
+  } catch (err) {
+    console.error('类型转换失败:', err);
+    return value;
+  }
+}
+
+/**
+ * 通用过滤器
+ * 组合 extractArray 和 mapFields
+ * @param {*} response - 接口响应
+ * @param {Object} config - 过滤器配置
+ * @param {string} config.arrayPath - 数组提取路径
+ * @param {Object} config.fieldMapping - 字段映射配置
+ * @param {Object} config.fieldTypes - 字段类型配置
+ * @param {Object} config.fieldFormats - 字段格式化配置
+ * @param {Function} config.itemFilter - 可选的项过滤函数
+ * @param {Function} config.itemTransform - 可选的项转换函数
+ * @returns {Array} 处理后的数组
+ */
+export function applyFilter(response, config) {
+  console.log('=== applyFilter 调试信息 ===');
+  console.log('1. 原始响应:', response);
+  console.log('2. 过滤器配置:', config);
+  
+  // 1. 提取数组
+  let items = extractArray(response, config.arrayPath);
+  console.log('3. 提取的数组 (extractArray):', items);
+  
+  // 2. 过滤项 (可选)
+  if (config.itemFilter && typeof config.itemFilter === 'function') {
+    items = items.filter(config.itemFilter);
+    console.log('4. 过滤后 (itemFilter):', items);
+  }
+  
+  // 3. 映射字段 (可选)
+  if (config.fieldMapping) {
+    console.log('5. 应用字段映射:', config.fieldMapping);
+    items = items.map(item => mapFields(
+      item, 
+      config.fieldMapping,
+      config.fieldTypes || {},
+      config.fieldFormats || {}
+    ));
+    console.log('6. 映射后的数据:', items);
+  } else {
+    console.log('5. 没有配置字段映射，返回原始数据');
+  }
+  
+  // 4. 自定义转换 (可选)
+  if (config.itemTransform && typeof config.itemTransform === 'function') {
+    items = items.map(config.itemTransform);
+    console.log('7. 自定义转换后:', items);
+  }
+  
+  console.log('8. 最终返回的数据:', items);
+  console.log('=== applyFilter 结束 ===');
+  
+  return items;
+}
+
+// 兼容旧的简单过滤器（已废弃，保留用于兼容）
+export const noticeFilter = (data) => {
+  const items = extractArray(data);
+  return items.map(item => {
+    if (typeof item === 'string') return item;
+    if (typeof item === 'object') {
+      return item.content || item.title || item.message || item.text || item.notice || '';
+    }
+    return String(item);
+  });
+};
+
+export const newsFilter = (data) => extractArray(data);
+export const menuFilter = (data) => extractArray(data);
+export const userFilter = (data) => data;
+
+export const filters = {
+  notice: noticeFilter,
+  news: newsFilter,
+  menu: menuFilter,
+  user: userFilter
+};
+
+export function applyFilterByName(response, filterName) {
+  const filter = filters[filterName];
+  if (filter) {
+    return filter(response);
+  }
+  return extractArray(response);
+}
+
+/**
+ * 统一的数据获取函数
+ * 根据配置获取并处理数据,返回最终结果
+ * @param {Object} gatewayConfig - 网关配置对象(从 ApiConfig 组件保存的配置)
+ * @param {Function} requestFunc - 请求函数(例如 gateway-request-lib 的 request)
+ * @param {Object} context - 上下文数据(用于入参模板和函数)
+ * @returns {Promise<Array>} 处理后的数据数组
+ */
+export async function fetchGatewayData(gatewayConfig, requestFunc, context = {}) {
+  if (!gatewayConfig || !gatewayConfig.apiPath) {
+    throw new Error('缺少必要的配置: apiPath');
+  }
+
+  // 1. 执行入参映射
+  let params = {};
+  if (gatewayConfig.reqMapping) {
+    const { executeReqMapping } = await import('./dataExtractor.js');
+    params = executeReqMapping(gatewayConfig.reqMapping, context);
+  }
+
+  // 2. 调用接口
+  const response = await requestFunc({
+    api: gatewayConfig.apiPath,
+    params: params,
+    config: {
+      access_token: true,
+      ...gatewayConfig.requestConfig
+    }
+  });
+
+  // 3. 提取业务数据
+  // gateway-request-lib 返回: { axiosResponse, response, data }
+  // 业务数据在 response 字段中
+  const businessData = response.response || response.data || response;
+
+  // 4. 应用过滤器
+  if (gatewayConfig.mode === 'filter' && gatewayConfig.filterConfig) {
+    return applyFilter(businessData, gatewayConfig.filterConfig);
+  } else if (gatewayConfig.res_schema) {
+    // 兼容 Schema 模式
+    const { extractDataBySchema } = await import('./dataExtractor.js');
+    return extractDataBySchema(businessData, gatewayConfig.res_schema);
+  } else {
+    // 默认: 尝试提取数组
+    return extractArray(businessData);
+  }
+}