zhangguoyun
a6978c948b
- 删除所有console.log调试输出 - 移除未使用的fs模块导入 - 优化ApifoxService初始化配置 - 使用新的MCP SDK注册方式替代旧版prompt处理 - 添加环境变量默认值设置
307 lines
8.7 KiB
JavaScript
307 lines
8.7 KiB
JavaScript
import axios from "axios";
|
|
import NodeCache from 'node-cache';
|
|
// import fs from 'fs'
|
|
|
|
const APIFOX_API_BASE = "https://apifox.gzmiyuan.com/api/v1";
|
|
|
|
export class ApifoxService {
|
|
constructor(config = {}) {
|
|
const { projectId, token, baseUrl } = config;
|
|
this.projectId = projectId;
|
|
this.branchId = null;
|
|
this.apiTreeList = null;
|
|
this.http = axios.create({
|
|
baseURL: baseUrl || APIFOX_API_BASE,
|
|
headers: {
|
|
"X-Client-Mode": "web",
|
|
"X-Client-Version": "2.7.19",
|
|
"X-Device-Id": "bd94aea0-7b65-48ba-9274-4b1177897954",
|
|
"Authorization": `Bearer ${token}`
|
|
}
|
|
});
|
|
|
|
// 初始化node-cache，设置默认5分钟过期时间
|
|
this.cache = new NodeCache({
|
|
stdTTL: 5 * 60, // 5分钟，单位秒
|
|
checkperiod: 60, // 每分钟检查一次过期缓存
|
|
useClones: false // 创建缓存对象的克隆以避免引用问题
|
|
});
|
|
|
|
this.init();
|
|
}
|
|
|
|
/**
|
|
* 清除特定缓存
|
|
* @param {string} cacheKey - 缓存键名
|
|
*/
|
|
clearCache(cacheKey) {
|
|
if (cacheKey) {
|
|
this.cache.del(cacheKey);
|
|
} else {
|
|
// 清除所有缓存
|
|
this.cache.flushAll();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 初始化服务，获取branchId
|
|
* @returns {Promise<void>}
|
|
*/
|
|
async init() {
|
|
try {
|
|
this.branchId = await this.getBranchId();
|
|
} catch (error) {
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 发送GET请求
|
|
* @param {string} url - 请求的URL路径
|
|
* @param {object} config - axios配置对象
|
|
* @returns {Promise} 返回响应数据中的data字段
|
|
*/
|
|
async get(url, config = {}) {
|
|
try {
|
|
const response = await this.http.get(url, {
|
|
...config,
|
|
headers: {
|
|
...config.headers,
|
|
"X-Project-Id": this.projectId,
|
|
"X-Branch-Id": this.branchId,
|
|
},
|
|
});
|
|
return response.data;
|
|
} catch (error) {
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 发送POST请求
|
|
* @param {string} url - 请求的URL路径
|
|
* @param {object} data - 请求体数据
|
|
* @param {object} config - axios配置对象
|
|
* @returns {Promise} 返回响应数据中的data字段
|
|
*/
|
|
async post(url, data = {}, config = {}) {
|
|
try {
|
|
const response = await this.http.post(url, data, {
|
|
...config,
|
|
headers: {
|
|
...config.headers,
|
|
"X-Project-Id": this.projectId,
|
|
"X-Branch-Id": this.branchId,
|
|
},
|
|
});
|
|
return response.data;
|
|
} catch (error) {
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
|
|
async getBranchId() {
|
|
const branches = await this.get(`/projects/${this.projectId}/api-versions`);
|
|
return branches.data[0].id;
|
|
}
|
|
|
|
async getApiTreeList() {
|
|
const apiTree = await this.get(`/projects/${this.projectId}/api-tree-list`);
|
|
this.apiTreeList = apiTree;
|
|
return apiTree;
|
|
}
|
|
|
|
async getFolderList() {
|
|
// 定义缓存键
|
|
const cacheKey = 'folderList';
|
|
|
|
// 检查缓存是否有效
|
|
const cachedData = this.cache.get(cacheKey);
|
|
if (cachedData) {
|
|
return cachedData;
|
|
}
|
|
|
|
const {data: folderList} = await this.get(`/projects/${this.projectId}/api-detail-folders`);
|
|
|
|
// 设置缓存
|
|
this.cache.set(cacheKey, folderList);
|
|
return folderList;
|
|
}
|
|
|
|
async getFolderByName(folderName) {
|
|
const folderList = await this.getFolderList();
|
|
const folder = folderList.find((item) => item.name === folderName);
|
|
if (!folder) {
|
|
throw new Error(`Folder with name ${folderName} not found`);
|
|
}
|
|
return folder;
|
|
}
|
|
async getDataSchema() {
|
|
// 定义缓存键
|
|
const cacheKey = 'dataSchema';
|
|
|
|
// 检查缓存是否有效
|
|
const cachedData = this.cache.get(cacheKey);
|
|
if (cachedData) {
|
|
return cachedData;
|
|
}
|
|
|
|
const {data:schemasTreeList} = await this.get(`/projects/${this.projectId}/data-schemas?locale=zh-CN`);
|
|
|
|
// 设置缓存
|
|
this.cache.set(cacheKey, schemasTreeList);
|
|
return schemasTreeList;
|
|
}
|
|
|
|
async getApiDetails() {
|
|
// 定义缓存键
|
|
const cacheKey = 'apiDetails';
|
|
|
|
// 检查缓存是否有效
|
|
const cachedData = this.cache.get(cacheKey);
|
|
if (cachedData) {
|
|
return cachedData;
|
|
}
|
|
|
|
const {data:apiDetails} = await this.get(`/api-details?locale=zh-CN`, {});
|
|
|
|
// 设置缓存
|
|
this.cache.set(cacheKey, apiDetails);
|
|
return apiDetails;
|
|
}
|
|
|
|
getSchemaRefId(obj) {
|
|
if (!obj || !obj.$ref) {
|
|
return;
|
|
}
|
|
const schemaName = obj.$ref.split('/').pop();
|
|
return schemaName;
|
|
}
|
|
|
|
/**
|
|
* 根据schema ID获取完整的schema定义,递归替换所有$ref引用
|
|
* @param {number|string} schemaId - schema的ID
|
|
* @param {Array} allSchemas - 所有schema数据数组(可选,用于递归)
|
|
* @param {Set} visitedIds - 已访问的ID集合,用于防止循环引用
|
|
* @returns {Promise<object>} 返回完整解析后的schema对象
|
|
*/
|
|
async getSchemaById(schemaId, allSchemas = null, visitedIds = new Set()) {
|
|
if (!schemaId) {
|
|
return null;
|
|
}
|
|
// 如果没有传入allSchemas,则获取所有schema数据
|
|
if (!allSchemas) {
|
|
allSchemas = await this.getDataSchema();
|
|
}
|
|
|
|
// 查找对应ID的schema
|
|
const schema = allSchemas.find((item) => item.id.toString() === schemaId.toString());
|
|
if (!schema) {
|
|
throw new Error(`Schema with id ${schemaId} not found`);
|
|
}
|
|
|
|
// 防止循环引用
|
|
if (visitedIds.has(schemaId.toString())) {
|
|
return { type: 'object', description: `循环引用: ${schema.name}` };
|
|
}
|
|
visitedIds.add(schemaId.toString());
|
|
|
|
// 深拷贝schema以避免修改原始数据
|
|
const resolvedSchema = JSON.parse(JSON.stringify(schema));
|
|
|
|
// 递归替换jsonSchema中的所有$ref
|
|
resolvedSchema.jsonSchema = await this.resolveRefs(
|
|
resolvedSchema.jsonSchema,
|
|
allSchemas,
|
|
new Set(visitedIds)
|
|
);
|
|
|
|
// 移除不需要的字段
|
|
const { description, folderId, projectId, moduleId, ordering, creatorId, editorId, createdAt, updatedAt, visibility, ...cleanSchema } = resolvedSchema;
|
|
|
|
return cleanSchema;
|
|
}
|
|
|
|
/**
|
|
* 递归解析对象中的所有$ref引用
|
|
* @param {object} obj - 要解析的对象
|
|
* @param {Array} allSchemas - 所有schema数据数组
|
|
* @param {Set} visitedIds - 已访问的ID集合
|
|
* @returns {Promise<object>} 返回解析后的对象
|
|
*/
|
|
async resolveRefs(obj, allSchemas, visitedIds) {
|
|
if (!obj || typeof obj !== 'object') {
|
|
return obj;
|
|
}
|
|
|
|
// 如果是数组,递归处理每个元素
|
|
if (Array.isArray(obj)) {
|
|
const resolved = [];
|
|
for (const item of obj) {
|
|
resolved.push(await this.resolveRefs(item, allSchemas, visitedIds));
|
|
}
|
|
return resolved;
|
|
}
|
|
|
|
// 如果对象包含$ref,替换为实际的schema定义
|
|
if (obj.$ref) {
|
|
const refId = this.getSchemaRefId(obj);
|
|
const referencedSchema = await this.getSchemaById(refId, allSchemas, visitedIds);
|
|
// 返回引用的jsonSchema内容
|
|
return referencedSchema.jsonSchema;
|
|
}
|
|
|
|
// 递归处理对象的所有属性
|
|
const resolved = {};
|
|
for (const [key, value] of Object.entries(obj)) {
|
|
resolved[key] = await this.resolveRefs(value, allSchemas, visitedIds);
|
|
}
|
|
return resolved;
|
|
}
|
|
|
|
async getApiDetailResp(apiDetail) {
|
|
const dataSchema = await this.getDataSchema();
|
|
const requestSchemaId = this.getSchemaRefId(apiDetail.requestBody.jsonSchema);
|
|
const responseSchema = Array.isArray(apiDetail.responses) ? apiDetail.responses[0].jsonSchema : apiDetail.responses.jsonSchema;
|
|
const responseSchemaId = this.getSchemaRefId(responseSchema);
|
|
const respDataSchemaId = this.getSchemaRefId(dataSchema.find((item) => item.id.toString() === responseSchemaId).jsonSchema.properties.data)
|
|
return {
|
|
path: apiDetail.path,
|
|
name: apiDetail.name,
|
|
method: apiDetail.method,
|
|
url: apiDetail.url,
|
|
requestSchema: await this.getSchemaById(requestSchemaId),
|
|
responseSchema: await this.getSchemaById(respDataSchemaId),
|
|
};
|
|
}
|
|
|
|
async getApiDetailByPath(path) {
|
|
const apiDetails = await this.getApiDetails();
|
|
const apiDetail = apiDetails.find((item) => item.path === path);
|
|
if (!apiDetail) {
|
|
throw new Error(`API with path ${path} not found`);
|
|
}
|
|
return this.getApiDetailResp(apiDetail);
|
|
}
|
|
|
|
async getApiDetailsById(apiId) {
|
|
const apiDetails = await this.getApiDetails();
|
|
const apiDetail = apiDetails.find((item) => item.id === apiId);
|
|
if (!apiDetail) {
|
|
throw new Error(`API with id ${id} not found`);
|
|
}
|
|
return this.getApiDetailResp(apiDetail);
|
|
}
|
|
|
|
|
|
// TODO:
|
|
async getApiListByFolderName(folderName) {
|
|
const folder = await this.getFolderByName(folderName);
|
|
const apiDetails = await this.getApiDetails();
|
|
const apiList = apiDetails.filter((item) => item.folderId === folder.id);
|
|
return Promise.all(apiList.map((api) => this.getApiDetailResp(api)));
|
|
}
|
|
|
|
}
|