@cloudglab/yapi-cli 0.0.1

package/dist/services/yapi/api.js

@@ -0,0 +1,700 @@
+import { pbkdf2Sync } from 'node:crypto';
+import { logger } from './logger.js';
+// ==================== 密码加密 ====================
+/**
+ * PBKDF2 密码加密（YApi LDAP 模式用）。
+ * YApi 服务端使用固定的 salt 和迭代次数。
+ */
+export function encryptPassword(password, salt) {
+    return pbkdf2Sync(password, salt, 100, 64, 'sha512').toString('hex');
+}
+// ==================== 错误类型 ====================
+export class YApiError extends Error {
+    constructor(message, code, statusCode) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = 'YApiError';
+    }
+}
+export class YApiAuthError extends YApiError {
+    constructor(message = '认证失败，请重新登录') {
+        super(message, 'AUTH_FAILED', 401);
+        this.name = 'YApiAuthError';
+    }
+}
+export class YApiNetworkError extends YApiError {
+    constructor(cause) {
+        super(`网络错误: ${cause.message}`, 'NETWORK_ERROR');
+        this.name = 'YApiNetworkError';
+    }
+}
+export class YApiTimeoutError extends YApiError {
+    constructor(url) {
+        super(`请求超时: ${url}`, 'TIMEOUT');
+        this.name = 'YApiTimeoutError';
+    }
+}
+// ==================== 重试配置 ====================
+const DEFAULT_TIMEOUT_MS = 30000;
+const MAX_RETRIES = 3;
+const RETRYABLE_STATUS_CODES = new Set([408, 429, 502, 503, 504]);
+const RETRYABLE_ERROR_MESSAGES = ['ECONNRESET', 'ETIMEDOUT', 'ENOTFOUND', 'socket hang up', 'network'];
+function isRetryable(error) {
+    if (error instanceof YApiTimeoutError)
+        return true;
+    if (error instanceof YApiNetworkError)
+        return true;
+    if (error instanceof YApiError && error.statusCode && RETRYABLE_STATUS_CODES.has(error.statusCode))
+        return true;
+    if (error instanceof Error && RETRYABLE_ERROR_MESSAGES.some((msg) => error.message.toLowerCase().includes(msg.toLowerCase())))
+        return true;
+    return false;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** YApi API 客户端 */
+export class YApiService {
+    constructor(serverUrl, getHeaders, getToken, timeoutMs = DEFAULT_TIMEOUT_MS, maxRetries = MAX_RETRIES) {
+        this.serverUrl = serverUrl;
+        this.getHeaders = getHeaders;
+        this.getToken = getToken;
+        this.timeoutMs = timeoutMs;
+        this.maxRetries = maxRetries;
+        this.requestId = 0;
+    }
+    /** 发送 API 请求（带重试和超时） */
+    async request(method, path, body) {
+        this.requestId += 1;
+        const requestId = this.requestId;
+        const url = `${this.serverUrl.replace(/\/+$/, '')}/api${path}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            ...this.getHeaders(),
+        };
+        const token = this.getToken();
+        if (token) {
+            headers['Authorization'] = token;
+        }
+        let lastError;
+        for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+            try {
+                logger.info(`[${requestId}] ${method} ${url}${attempt > 1 ? ` (重试 ${attempt - 1}/${this.maxRetries - 1})` : ''}`);
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+                let response;
+                try {
+                    response = await fetch(url, {
+                        method,
+                        headers,
+                        body: body ? JSON.stringify(body) : undefined,
+                        signal: controller.signal,
+                    });
+                }
+                finally {
+                    clearTimeout(timeoutId);
+                }
+                const text = await response.text();
+                if (!response.ok) {
+                    const error = new YApiError(`HTTP ${response.status}: ${text.slice(0, 200)}`, 'HTTP_ERROR', response.status);
+                    if (response.status === 401) {
+                        throw new YApiAuthError();
+                    }
+                    if (isRetryable(error) && attempt < this.maxRetries) {
+                        lastError = error;
+                        await sleep(Math.min(1000 * 2 ** attempt, 8000));
+                        continue;
+                    }
+                    throw error;
+                }
+                let result;
+                try {
+                    result = JSON.parse(text);
+                }
+                catch {
+                    throw new YApiError(`JSON 解析失败: ${text.slice(0, 200)}`, 'PARSE_ERROR');
+                }
+                if (result.errcode !== 0) {
+                    const apiError = new YApiError(`API 错误: ${result.errmsg}`, `API_ERROR_${result.errcode}`);
+                    // errcode 402 表示登录过期
+                    if (result.errcode === 402) {
+                        throw new YApiAuthError('登录已过期，请重新登录');
+                    }
+                    // 服务端错误可能可重试
+                    if (result.errcode >= 500 && attempt < this.maxRetries) {
+                        lastError = apiError;
+                        await sleep(Math.min(1000 * 2 ** attempt, 8000));
+                        continue;
+                    }
+                    throw apiError;
+                }
+                return result;
+            }
+            catch (error) {
+                if (error instanceof YApiAuthError) {
+                    throw error; // 认证错误不重试
+                }
+                if (error instanceof YApiError) {
+                    if (isRetryable(error) && attempt < this.maxRetries) {
+                        lastError = error;
+                        await sleep(Math.min(1000 * 2 ** attempt, 8000));
+                        continue;
+                    }
+                    throw error;
+                }
+                // fetch 抛出的原生错误（网络中断、超时等）
+                if (error instanceof DOMException && error.name === 'AbortError') {
+                    const timeoutError = new YApiTimeoutError(url);
+                    if (attempt < this.maxRetries) {
+                        lastError = timeoutError;
+                        await sleep(Math.min(1000 * 2 ** attempt, 8000));
+                        continue;
+                    }
+                    throw timeoutError;
+                }
+                const networkError = new YApiNetworkError(error instanceof Error ? error : new Error(String(error)));
+                if (attempt < this.maxRetries) {
+                    lastError = networkError;
+                    await sleep(Math.min(1000 * 2 ** attempt, 8000));
+                    continue;
+                }
+                throw networkError;
+            }
+        }
+        // 所有重试都失败
+        throw lastError ?? new YApiError('请求失败（已达最大重试次数）', 'MAX_RETRIES');
+    }
+    /** GET 请求 */
+    async get(path, params) {
+        let queryString = '';
+        if (params) {
+            const entries = Object.entries(params)
+                .filter(([, v]) => v !== undefined)
+                .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+            if (entries.length > 0) {
+                queryString = `?${entries.join('&')}`;
+            }
+        }
+        return this.request('GET', `${path}${queryString}`);
+    }
+    /** POST 请求 */
+    async post(path, body) {
+        return this.request('POST', path, body);
+    }
+    /** PUT 请求 */
+    async put(path, body) {
+        return this.request('PUT', path, body);
+    }
+    /** DELETE 请求 */
+    async del(path, params) {
+        let queryString = '';
+        if (params) {
+            const entries = Object.entries(params)
+                .filter(([, v]) => v !== undefined)
+                .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+            if (entries.length > 0)
+                queryString = `?${entries.join('&')}`;
+        }
+        return this.request('DELETE', `${path}${queryString}`);
+    }
+    /** HEAD 请求 */
+    async head(path, params) {
+        let queryString = '';
+        if (params) {
+            const entries = Object.entries(params)
+                .filter(([, v]) => v !== undefined)
+                .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+            if (entries.length > 0)
+                queryString = `?${entries.join('&')}`;
+        }
+        return this.request('HEAD', `${path}${queryString}`);
+    }
+    /** OPTIONS 请求 */
+    async options(path, body) {
+        return this.request('OPTIONS', path, body);
+    }
+    /** PATCH 请求 */
+    async patch(path, body) {
+        return this.request('PATCH', path, body);
+    }
+    // ==================== 认证相关 ====================
+    /** 密码登录 */
+    async loginWithPassword(email, password) {
+        return this.post('/user/login', { email, password });
+    }
+    /** LDAP 登录（密码已加密） */
+    async loginByLdap(email, encryptedPassword) {
+        const url = `${this.serverUrl.replace(/\/+$/, '')}/api/user/login_by_ldap`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this.getHeaders(),
+            },
+            body: JSON.stringify({ email, password: encryptedPassword }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new YApiError(`LDAP 登录失败 (${response.status}): ${text.slice(0, 200)}`);
+        }
+        const result = await response.json();
+        if (result.errcode !== 0) {
+            throw new YApiError(`LDAP 登录失败: ${result.errmsg}`);
+        }
+        // 从 Set-Cookie 头提取 _yapi_token 和 _yapi_uid
+        const setCookie = response.headers.get('set-cookie') || '';
+        const tokenMatch = setCookie.match(/_yapi_token=([^;]+)/);
+        const uidMatch = setCookie.match(/_yapi_uid=([^;]+)/);
+        const token = tokenMatch?.[1];
+        const uid = uidMatch?.[1] || '';
+        if (!token) {
+            throw new YApiError('LDAP 登录成功但未获取到 _yapi_token');
+        }
+        return { token, uid, username: result.data?.username || email };
+    }
+    /** 获取登录状态 */
+    async getLoginStatus() {
+        return this.get('/user/status');
+    }
+    /** 登出 */
+    async userLogout() {
+        return this.get('/user/logout');
+    }
+    /** 获取用户信息 */
+    async getUserInfo() {
+        return this.get('/user/info');
+    }
+    // ==================== 搜索 ====================
+    /** 搜索接口（YApi 实际通过 GET /interface/list?q=xxx 实现） */
+    async searchInterfaces(params) {
+        return this.get('/interface/list', params);
+    }
+    // ==================== 分组相关 ====================
+    /** 获取分组列表 */
+    async listGroups() {
+        return this.get('/group/list');
+    }
+    /** 获取分组详情 */
+    async getGroup(groupId) {
+        return this.get('/group/get', { id: groupId });
+    }
+    /** 获取我的分组 */
+    async getMyGroup() {
+        return this.get('/group/get_mygroup');
+    }
+    /** 创建分组 */
+    async groupAdd(data) {
+        return this.post('/group/add', data);
+    }
+    /** 更新分组 */
+    async groupUp(data) {
+        return this.post('/group/up', data);
+    }
+    /** 删除分组 */
+    async groupDel(groupId) {
+        return this.post('/group/del', { id: groupId });
+    }
+    /** 添加分组成员 */
+    async groupAddMember(data) {
+        return this.post('/group/add_member', data);
+    }
+    /** 修改分组成员角色 */
+    async groupChangeMemberRole(data) {
+        return this.post('/group/change_member_role', data);
+    }
+    /** 删除分组成员 */
+    async groupDelMember(data) {
+        return this.post('/group/del_member', data);
+    }
+    // ==================== 项目相关 ====================
+    /** 获取项目列表 */
+    async listProjects(params = {}) {
+        return this.get('/project/list', params);
+    }
+    /** 获取项目详情 */
+    async getProject(projectId) {
+        return this.get('/project/get', { project_id: projectId });
+    }
+    /** 通过 token 获取项目信息 */
+    async getProjectByToken(token) {
+        return this.get('/project/get_by_token', { token });
+    }
+    /** 创建项目 */
+    async createProject(data) {
+        return this.post('/project/add', data);
+    }
+    /** 更新项目 */
+    async updateProject(data) {
+        return this.post('/project/up', data);
+    }
+    /** 搜索项目 */
+    async searchProjects(query) {
+        return this.get('/project/search', { q: query });
+    }
+    /** 更新项目环境 */
+    async updateProjectEnv(data) {
+        return this.post('/project/up_env', data);
+    }
+    /** 更新项目标签 */
+    async updateProjectTag(data) {
+        return this.post('/project/up_tag', data);
+    }
+    /** 更新项目 Token（重新生成） */
+    async updateProjectToken(projectId) {
+        return this.get('/project/update_token', { project_id: projectId });
+    }
+    /** 检查项目名是否可用 */
+    async checkProjectName(name, groupId) {
+        return this.get('/project/check_project_name', { name, group_id: groupId });
+    }
+    /** 复制项目 */
+    async copyProject(projectId, name) {
+        return this.post('/project/copy', { project_id: projectId, name });
+    }
+    /** 获取 Swagger URL */
+    async getProjectSwaggerUrl(projectId) {
+        return this.get('/project/swagger_url', { project_id: projectId });
+    }
+    /** 添加项目成员 */
+    async addProjectMember(data) {
+        return this.post('/project/add_member', data);
+    }
+    /** 更新项目设置（upset 覆盖全部字段） */
+    async upSetProject(data) {
+        return this.post('/project/upset', data);
+    }
+    /** 删除项目 */
+    async deleteProject(projectId) {
+        return this.post('/project/del', { id: projectId });
+    }
+    /** 删除项目成员 */
+    async delProjectMember(data) {
+        return this.post('/project/del_member', data);
+    }
+    /** 修改项目成员角色 */
+    async changeProjectMemberRole(data) {
+        return this.post('/project/change_member_role', data);
+    }
+    /** 修改成员邮件通知 */
+    async changeProjectMemberEmailNotice(data) {
+        return this.post('/project/change_member_email_notice', data);
+    }
+    // ==================== 分类/目录相关 ====================
+    /** 获取分类（目录）列表 */
+    async listCategories(projectId) {
+        return this.get('/interface/getCatMenu', { project_id: projectId });
+    }
+    /** 获取分类详情 */
+    async getCategory(catId) {
+        return this.get('/interface/list_cat', { catid: catId });
+    }
+    /** 添加分类 */
+    async addCategory(data) {
+        return this.post('/interface/add_cat', data);
+    }
+    /** 更新分类 */
+    async updateCategory(data) {
+        return this.post('/interface/up_cat', data);
+    }
+    /** 删除分类 */
+    async deleteCategory(catId) {
+        return this.post('/interface/del_cat', { catid: catId });
+    }
+    // ==================== 接口相关 ====================
+    /** 获取接口列表 */
+    async listInterfaces(params = {}) {
+        return this.get('/interface/list', params);
+    }
+    /** 获取接口详情 */
+    async getInterfaceDetail(interfaceId) {
+        return this.get('/interface/get', { id: interfaceId });
+    }
+    /** 创建接口 */
+    async createInterface(data) {
+        return this.post('/interface/add', data);
+    }
+    /** 更新接口 */
+    async updateInterface(data) {
+        return this.put('/interface/up', data);
+    }
+    /** 删除接口 */
+    async deleteInterface(interfaceId) {
+        return this.post('/interface/del', { id: interfaceId });
+    }
+    /** 批量删除接口 */
+    async batchDeleteInterfaces(ids) {
+        return this.post('/interface/del_batch', { ids });
+    }
+    /** 获取接口列表（按分类） */
+    async listInterfacesByCategory(catId) {
+        return this.get('/interface/list_cat', { catid: catId });
+    }
+    /** 保存接口（若 id 存在则更新，否则创建） */
+    async saveInterface(data) {
+        return this.post('/interface/save', data);
+    }
+    /** 获取接口列表（公开项目） */
+    async listPublicInterfaces(params) {
+        return this.get('/interface/list_open', params);
+    }
+    /** schema 转 JSON */
+    async schemaToJson(schema) {
+        return this.post('/interface/schema2json', { schema });
+    }
+    /** 获取接口列表（菜单模式） */
+    async listInterfacesByMenu(projectId) {
+        return this.get('/interface/list_menu', { project_id: projectId });
+    }
+    /** 获取自定义字段 */
+    async getCustomField(projectId) {
+        return this.get('/interface/get_custom_field', { project_id: projectId });
+    }
+    /** 更新接口排序 */
+    async upInterfaceIndex(data) {
+        return this.post('/interface/up_index', data);
+    }
+    /** 更新分类排序 */
+    async upCatIndex(data) {
+        return this.post('/interface/up_cat_index', data);
+    }
+    /** 导入接口（swagger 等格式） */
+    async interUpload(data) {
+        return this.post('/interface/interUpload', data);
+    }
+    /** 下载浏览器扩展 CRX */
+    async downloadCrx() {
+        return this.get('/interface/download_crx');
+    }
+    // ==================== 日志相关 ====================
+    /** 获取接口变更日志 */
+    async listInterfaceLogs(params) {
+        return this.get('/log/list', params);
+    }
+    /** 获取日志列表（按更新时间排序） */
+    async listLogsByUpdate(params) {
+        return this.post('/log/list_by_update', params);
+    }
+    // ==================== 收藏/关注相关 ====================
+    /** 获取关注的项目列表 */
+    async listFollowedProjects() {
+        return this.get('/follow/list');
+    }
+    /** 关注项目 */
+    async followProject(projectId) {
+        return this.post('/follow/add', { project_id: projectId });
+    }
+    /** 取消关注项目 */
+    async unfollowProject(projectId) {
+        return this.post('/follow/del', { project_id: projectId });
+    }
+    // ==================== Token 管理 ====================
+    /** 获取项目 token */
+    async getProjectToken(projectId) {
+        return this.get('/project/token', { project_id: projectId });
+    }
+    // ==================== 环境相关 ====================
+    /** 获取项目环境列表 */
+    async listProjectEnvs(projectId) {
+        return this.get('/project/get_env', { project_id: projectId });
+    }
+    // ==================== 成员相关 ====================
+    /** 获取项目成员列表 */
+    async listProjectMembers(projectId) {
+        return this.get('/project/get_member_list', { project_id: projectId });
+    }
+    /** 获取分组成员列表 */
+    async listGroupMembers(groupId) {
+        return this.get('/group/get_member_list', { group_id: groupId });
+    }
+    // ==================== 用户相关 ====================
+    /** 获取用户列表（需要管理员权限） */
+    async listUsers(params = {}) {
+        return this.get('/user/list', params);
+    }
+    /** 搜索用户 */
+    async searchUsers(query) {
+        return this.get('/user/search', { q: query });
+    }
+    /** 查找用户 by ID */
+    async findUserById(uid) {
+        return this.get('/user/find', { id: uid });
+    }
+    /** 更新用户 */
+    async updateUser(data) {
+        return this.post('/user/update', data);
+    }
+    /** 修改密码 */
+    async changePassword(data) {
+        return this.post('/user/change_password', data);
+    }
+    /** 获取用户项目列表 */
+    async listUserProjects() {
+        return this.get('/user/project');
+    }
+    /** 标记用户学习教程 */
+    async upStudy() {
+        return this.get('/user/up_study');
+    }
+    /** 用户注册（需要管理员权限） */
+    async userRegister(data) {
+        return this.post('/user/reg', data);
+    }
+    /** 删除用户（需要管理员权限） */
+    async userDelete(uid) {
+        return this.post('/user/del', { id: uid });
+    }
+    /** Token 登录（静默认证，不需要交互） */
+    async loginByToken(token) {
+        return this.request('POST', '/user/login_by_token', { token });
+    }
+    /** 获取用户头像 URL */
+    async getUserAvatar(uid) {
+        return this.get('/user/avatar', { uid });
+    }
+    /** 上传头像 */
+    async uploadUserAvatar(data) {
+        return this.post('/user/upload_avatar', data);
+    }
+    // ==================== 集合相关（col） ====================
+    /** 获取项目测试集合列表 */
+    async listCollections(projectId) {
+        return this.get('/col/list', { project_id: projectId });
+    }
+    /** 创建测试集合 */
+    async createCollection(data) {
+        return this.post('/col/add_col', data);
+    }
+    /** 获取集合测试用例列表 */
+    async listCollectionCases(colId) {
+        return this.get('/col/case_list', { col_id: colId });
+    }
+    /** 添加测试用例 */
+    async addTestCase(data) {
+        return this.post('/col/add_case', data);
+    }
+    /** 更新测试用例 */
+    async updateTestCase(data) {
+        return this.post('/col/up_case', data);
+    }
+    /** 获取测试用例详情 */
+    async getTestCase(caseId) {
+        return this.get('/col/case', { id: caseId });
+    }
+    /** 更新测试集合 */
+    async updateCollection(data) {
+        return this.post('/col/up_col', data);
+    }
+    /** 删除测试集合 */
+    async deleteCollection(colId) {
+        return this.get('/col/del_col', { col_id: colId });
+    }
+    /** 删除测试用例 */
+    async deleteTestCase(caseId) {
+        return this.get('/col/del_case', { case_id: caseId });
+    }
+    /** 批量添加测试用例 */
+    async addTestCaseList(data) {
+        return this.post('/col/add_case_list', data);
+    }
+    /** 克隆用例列表 */
+    async cloneTestCaseList(data) {
+        return this.post('/col/clone_case_list', data);
+    }
+    /** 运行测试用例脚本 */
+    async runTestCaseScript(data) {
+        return this.post('/col/run_script', data);
+    }
+    /** 获取测试用例环境变量列表 */
+    async getTestCaseEnvList(caseId) {
+        return this.get('/col/case_env_list', { case_id: caseId });
+    }
+    /** 获取用例列表（支持变量参数） */
+    async getCaseListByVariableParams(colId) {
+        return this.get('/col/case_list_by_var_params', { col_id: colId });
+    }
+    /** 更新用例排序 */
+    async upCaseIndex(data) {
+        return this.post('/col/up_case_index', data);
+    }
+    /** 更新集合排序 */
+    async upColIndex(data) {
+        return this.post('/col/up_col_index', data);
+    }
+    // ==================== 导出相关 ====================
+    /** 导出项目 JSON 格式 */
+    async exportProjectJson(projectId) {
+        return this.get('/export/json', { project_id: projectId });
+    }
+    /** 导出项目 Swagger 格式 */
+    async exportProjectSwagger(projectId) {
+        return this.get('/export/swagger', { project_id: projectId });
+    }
+    /** 导出项目 OpenAPI 3.0 格式 */
+    async exportProjectOpenAPI3(projectId) {
+        return this.get('/export/openapi3', { project_id: projectId });
+    }
+    // ==================== 数据导入相关 ====================
+    /** 导入数据到项目 */
+    async importData(data) {
+        return this.post('/open/import_data', data);
+    }
+    /** 获取开放接口数据（Open API） */
+    async projectInterfaceData(params) {
+        return this.get('/open/project_interface_data', params);
+    }
+    /** 运行自动测试（Open API） */
+    async runAutoTest(params) {
+        return this.get('/open/run_auto_test', params);
+    }
+    // ==================== 测试相关（/test/） ====================
+    /** 测试 POST 请求 */
+    async testPost(url, body) {
+        return this.post('/test/post', { url, body });
+    }
+    /** 测试 GET 请求 */
+    async testGet(url) {
+        return this.get('/test/get', { url });
+    }
+    /** 测试 PUT 请求 */
+    async testPut(url, body) {
+        return this.put('/test/put', { url, body });
+    }
+    /** 测试 DELETE 请求 */
+    async testDelete(url) {
+        return this.del('/test/delete', { url });
+    }
+    /** 测试 HEAD 请求 */
+    async testHead(url) {
+        return this.head('/test/head', { url });
+    }
+    /** 测试 OPTIONS 请求 */
+    async testOptions(url) {
+        return this.options('/test/options', { url });
+    }
+    /** 测试 PATCH 请求 */
+    async testPatch(url, body) {
+        return this.patch('/test/patch', { url, body });
+    }
+    /** 测试文件上传 */
+    async testFilesUpload(data) {
+        return this.post('/test/files/upload', data);
+    }
+    /** 测试单文件上传 */
+    async testSingleUpload(data) {
+        return this.post('/test/single/upload', data);
+    }
+    /** 测试 HTTP 状态码 */
+    async testHttpCode(data) {
+        return this.post('/test/http/code', data);
+    }
+    /** 测试原始请求 */
+    async testRaw(data) {
+        return this.post('/test/raw', data);
+    }
+    /** 获取测试响应 */
+    async testResponse(url) {
+        return this.get('/test/response', { url });
+    }
+}
+//# sourceMappingURL=api.js.map