@tuoyuan/gateway-api-select-config 1.2.1

package/src/utils/reqMappingUtils.js

@@ -0,0 +1,147 @@
+/**
+ * 入参配置工具函数
+ */
+
+/**
+ * 解析入参配置
+ * @param {String} text - JSON 文本
+ * @param {String} mode - 模式：fixed/template/function
+ * @returns {Object} 解析后的配置
+ */
+export function parseReqMapping(text, mode) {
+  if (!text || text.trim() === '') {
+    return {};
+  }
+  
+  try {
+    let jsonText = text;
+    
+    // 如果是模板模式，需要处理不带引号的模板变量
+    if (mode === 'template') {
+      // 临时替换：${var} -> "__TEMPLATE_var__"
+      const templateMap = new Map();
+      let counter = 0;
+      
+      jsonText = text.replace(/\$\{([^}]+)\}/g, (match, varName) => {
+        const placeholder = `"__TEMPLATE_${counter}__"`;
+        templateMap.set(placeholder, match);
+        counter++;
+        return placeholder;
+      });
+      
+      // 解析 JSON
+      const parsed = JSON.parse(jsonText);
+      
+      // 还原模板变量
+      const restore = (obj) => {
+        if (typeof obj === 'string') {
+          // 检查是否是占位符
+          for (const [placeholder, original] of templateMap.entries()) {
+            if (obj === placeholder.replace(/"/g, '')) {
+              return original;
+            }
+          }
+          return obj;
+        } else if (typeof obj === 'object' && obj !== null) {
+          if (Array.isArray(obj)) {
+            return obj.map(restore);
+          } else {
+            const result = {};
+            for (const [key, value] of Object.entries(obj)) {
+              result[key] = restore(value);
+            }
+            return result;
+          }
+        }
+        return obj;
+      };
+      
+      return restore(parsed);
+    }
+    
+    // 其他模式直接解析
+    const parsed = JSON.parse(jsonText);
+    
+    // 验证格式
+    if (typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new Error('入参配置必须是对象格式');
+    }
+    
+    return parsed;
+  } catch (err) {
+    throw new Error('JSON 格式错误：' + err.message);
+  }
+}
+
+/**
+ * 验证入参配置
+ * @param {Object} mapping - 入参配置对象
+ * @param {String} mode - 模式
+ * @returns {Object} { valid: Boolean, error: String }
+ */
+export function validateReqMapping(mapping, mode) {
+  if (!mapping || Object.keys(mapping).length === 0) {
+    return { valid: true, error: '' };
+  }
+  
+  try {
+    for (const [key, value] of Object.entries(mapping)) {
+      if (mode === 'template') {
+        // 模板字符串模式：检查是否包含 ${...}
+        if (typeof value === 'string' && !value.includes('${')) {
+          // 允许纯字符串，但给出提示
+          console.warn(`字段 "${key}" 的值不包含模板变量，建议使用固定值模式`);
+        }
+      } else if (mode === 'function') {
+        // 函数模式：检查是否包含箭头函数
+        if (typeof value === 'string' && !value.includes('=>')) {
+          return {
+            valid: false,
+            error: `字段 "${key}" 的值不是有效的函数表达式`
+          };
+        }
+      }
+    }
+    
+    return { valid: true, error: '' };
+  } catch (err) {
+    return { valid: false, error: err.message };
+  }
+}
+
+/**
+ * 格式化入参配置（用于显示）
+ * @param {Object} mapping - 入参配置
+ * @returns {String} 格式化后的 JSON 字符串
+ */
+export function formatReqMapping(mapping) {
+  if (!mapping) return '{}';
+  return JSON.stringify(mapping, null, 2);
+}
+
+/**
+ * 检测入参配置的模式
+ * @param {Object} mapping - 入参配置
+ * @returns {String} 模式：fixed/template/function
+ */
+export function detectReqMappingMode(mapping) {
+  if (!mapping || Object.keys(mapping).length === 0) {
+    return 'fixed';
+  }
+  
+  const values = Object.values(mapping);
+  
+  // 检查是否有函数表达式
+  const hasFunction = values.some(v => 
+    typeof v === 'string' && v.includes('=>')
+  );
+  if (hasFunction) return 'function';
+  
+  // 检查是否有模板变量
+  const hasTemplate = values.some(v => 
+    typeof v === 'string' && v.includes('${')
+  );
+  if (hasTemplate) return 'template';
+  
+  return 'fixed';
+}

package/src/utils/schemaUtils.js

@@ -0,0 +1,197 @@
+/**
+ * Schema 工具函数
+ */
+
+/**
+ * 从 schema 中提取所有字段
+ * @param {Object} schema - JSON Schema
+ * @param {String} prefix - 字段前缀
+ * @param {Number} level - 嵌套层级
+ * @returns {Array} 字段列表
+ */
+export function extractSchemaFields(schema, prefix = '', level = 0) {
+  const fields = [];
+  
+  if (!schema) return fields;
+  
+  // 处理新格式：type 是 object 但有 items（包装的数组）
+  if (schema.type === 'object' && schema.items && !schema.properties) {
+    // 当作数组处理
+    if (schema.items.type === 'object' && schema.items.properties) {
+      const itemFields = extractSchemaFields(schema.items, prefix, level);
+      fields.push(...itemFields);
+    }
+    return fields;
+  }
+  
+  // 处理数组类型
+  if (schema.type === 'array' && schema.items) {
+    // 递归处理数组元素（不添加 [*] 前缀，因为这是顶层数组）
+    if (schema.items.type === 'object' && schema.items.properties) {
+      const itemFields = extractSchemaFields(schema.items, prefix, level);
+      fields.push(...itemFields);
+    }
+    
+    return fields;
+  }
+  
+  // 处理对象类型
+  if (schema.type === 'object' && schema.properties) {
+    // 获取必填字段列表
+    const requiredFields = schema.required || [];
+    
+    for (const [fieldName, fieldSchema] of Object.entries(schema.properties)) {
+      const fieldKey = prefix ? `${prefix}.${fieldName}` : fieldName;
+      
+      // 如果是嵌套对象或数组，递归处理
+      if (fieldSchema.type === 'object' || fieldSchema.type === 'array') {
+        const nestedFields = extractSchemaFields(fieldSchema, fieldKey, level + 1);
+        fields.push(...nestedFields);
+      } else {
+        // 基础类型字段
+        fields.push({
+          key: fieldKey,
+          name: fieldName,
+          label: fieldSchema.label || fieldSchema.title || fieldName,
+          type: fieldSchema.type,
+          description: fieldSchema.description || '',
+          level: level,
+          required: requiredFields.includes(fieldName)  // 从父对象的 required 数组中判断
+        });
+      }
+    }
+  }
+  
+  return fields;
+}
+
+/**
+ * 构建带路径的 res_schema
+ * @param {Object} schema - 原始 schema
+ * @param {Object} fieldPaths - 字段路径映射
+ * @param {Object} fieldFormats - 字段格式化映射
+ * @returns {Object} 带路径的 schema
+ */
+export function buildResSchema(schema, fieldPaths, fieldFormats = {}) {
+  if (!schema) return null;
+  
+  const result = { ...schema };
+  
+  // 移除 required 数组（对于列表展示场景通常不需要）
+  delete result.required;
+  
+  // 处理数组类型
+  if (schema.type === 'array' && schema.items) {
+    result.items = buildResSchema(schema.items, fieldPaths, fieldFormats);
+    return result;
+  }
+  
+  // 处理对象类型
+  if (schema.type === 'object' && schema.properties) {
+    result.properties = {};
+    
+    for (const [fieldName, fieldSchema] of Object.entries(schema.properties)) {
+      const fieldKey = fieldName;
+      const newFieldSchema = { ...fieldSchema };
+      
+      // 如果是嵌套结构，递归处理
+      if (fieldSchema.type === 'object' || fieldSchema.type === 'array') {
+        result.properties[fieldName] = buildResSchema(fieldSchema, fieldPaths, fieldFormats);
+      } else {
+        // 基础类型，添加 path 和 format
+        const path = fieldPaths[fieldKey];
+        if (path) {
+          newFieldSchema.x_path = path;
+        }
+        
+        const format = fieldFormats[fieldKey];
+        if (format) {
+          newFieldSchema.format = format;
+        }
+        
+        result.properties[fieldName] = newFieldSchema;
+      }
+    }
+  }
+  
+  return result;
+}
+
+
+
+/**
+ * 从 res_schema 中提取实际会输出的字段（用于显示）
+ * @param {Object} schema - res_schema
+ * @returns {Object} 格式化后的字段信息
+ */
+export function extractOutputFields(schema) {
+  if (!schema) return {};
+  
+  // 检查 schema 是否不完整
+  const checkIncomplete = (s) => {
+    if (s?.items?.properties) {
+      return Object.keys(s.items.properties).length === 0;
+    }
+    if (s?.properties) {
+      return Object.keys(s.properties).length === 0;
+    }
+    return false;
+  };
+  
+  if (checkIncomplete(schema)) {
+    return {
+      模式: '自动推断',
+      说明: 'Schema 不完整，将返回完整的原始数据',
+      数据路径: schema.x_path || schema.x_value || '@'
+    };
+  }
+  
+  // 提取实际字段配置
+  const fields = {};
+  
+  // 处理数组类型
+  if (schema.items?.properties) {
+    const props = schema.items.properties;
+    for (const [key, value] of Object.entries(props)) {
+      fields[key] = {
+        类型: value.type,
+        路径: value.x_path,
+        格式: value.format || '无'
+      };
+    }
+  }
+  // 处理对象类型
+  else if (schema.properties) {
+    const props = schema.properties;
+    for (const [key, value] of Object.entries(props)) {
+      // 跳过嵌套对象，只显示基础字段
+      if (value.type !== 'object' && value.type !== 'array') {
+        fields[key] = {
+          类型: value.type,
+          路径: value.x_path,
+          格式: value.format || '无'
+        };
+      }
+    }
+  }
+  
+  return {
+    数据路径: schema.x_path || schema.x_value || '@',
+    输出字段: fields
+  };
+}
+
+/**
+ * 格式化配置显示
+ * @param {Object} config - 配置对象
+ * @returns {Object} 格式化后的配置
+ */
+export function formatConfig(config) {
+  if (!config) return null;
+  
+  return {
+    接口路径: config.apiPath,
+    入参配置: config.reqMapping || {},
+    输出配置: extractOutputFields(config.res_schema)
+  };
+}

package/src/utils/treeUtils.js

@@ -0,0 +1,134 @@
+/**
+ * 树形结构工具函数
+ */
+
+/**
+ * 过滤 API 树（根据搜索关键词）
+ * @param {Array} tree - API 树
+ * @param {String} keyword - 搜索关键词
+ * @returns {Array} 过滤后的树
+ */
+export function filterApiTree(tree, keyword) {
+  if (!keyword) return tree;
+  
+  const lowerKeyword = keyword.toLowerCase();
+  
+  const filterNode = (node) => {
+    // 检查当前节点是否匹配
+    const nameMatch = node.name?.toLowerCase().includes(lowerKeyword);
+    const pathMatch = node.apiPath?.toLowerCase().includes(lowerKeyword);
+    const isMatch = nameMatch || pathMatch;
+    
+    // 判断是否是叶子节点
+    const isLeaf = node.isLeaf || node.apiPath || !node.children || node.children.length === 0;
+    
+    // 如果是叶子节点
+    if (isLeaf) {
+      return isMatch ? { ...node, highlighted: true } : null;
+    }
+    
+    // 如果是分类节点，递归过滤子节点
+    if (node.children && node.children.length > 0) {
+      const filteredChildren = node.children
+        .map(child => filterNode(child))
+        .filter(child => child !== null);
+      
+      // 如果当前节点名称匹配，保留所有原始子节点（不过滤）
+      if (isMatch) {
+        return {
+          ...node,
+          children: node.children,  // 保留所有子节点
+          expanded: true,
+          highlighted: true
+        };
+      }
+      
+      // 如果有匹配的子节点，则保留（当前节点不匹配，但子节点匹配）
+      if (filteredChildren.length > 0) {
+        return {
+          ...node,
+          children: filteredChildren,
+          expanded: true
+        };
+      }
+    }
+    
+    return null;
+  };
+  
+  return tree.map(node => filterNode(node)).filter(node => node !== null);
+}
+
+/**
+ * 检查路径是否匹配模式（支持通配符 *）
+ * @param {String} path - API 路径
+ * @param {String} pattern - 匹配模式
+ * @returns {Boolean}
+ */
+export function matchesPattern(path, pattern) {
+  if (!path || !pattern) return false;
+  
+  // 将模式转换为正则表达式
+  // 例如：*.get_list -> ^.*\.get_list$
+  // 例如：system.* -> ^system\..*$
+  const regexPattern = pattern
+    .replace(/\./g, '\\.') // 转义点号
+    .replace(/\*/g, '.*');  // 通配符转为正则
+  
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(path);
+}
+
+/**
+ * 在树中查找节点
+ * @param {Array} tree - API 树
+ * @param {String} apiPath - API 路径
+ * @returns {Object|null} 找到的节点
+ */
+export function findNodeByPath(tree, apiPath) {
+  for (const node of tree) {
+    if (node.apiPath === apiPath) {
+      return node;
+    }
+    
+    if (node.children && node.children.length > 0) {
+      const found = findNodeByPath(node.children, apiPath);
+      if (found) return found;
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * 展开到指定节点的路径
+ * @param {Array} tree - API 树
+ * @param {String} targetId - 目标节点 ID
+ * @returns {Boolean} 是否找到并展开
+ */
+export function expandToNode(tree, targetId) {
+  const expandNode = (node) => {
+    if (node.id === targetId) {
+      return true;
+    }
+    
+    if (node.children && node.children.length > 0) {
+      for (const child of node.children) {
+        if (expandNode(child)) {
+          node.expanded = true;
+          return true;
+        }
+      }
+    }
+    
+    return false;
+  };
+  
+  for (const node of tree) {
+    if (expandNode(node)) {
+      return true;
+    }
+  }
+  
+  return false;
+}