@nest-omni/core 4.1.3-1 → 4.1.3-3

package/http-client/services/http-log-query.service.js

@@ -24,6 +24,9 @@ const common_1 = require("@nestjs/common");
 const typeorm_1 = require("typeorm");
 const http_log_entity_1 = require("../entities/http-log.entity");
 const curl_generator_util_1 = require("../utils/curl-generator.util");
+/**
+ * HTTP日志查询服务
+ */
 let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
     constructor(dataSource) {
         this.dataSource = dataSource;
@@ -31,6 +34,9 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
         this.logRepository = null;
         this.initializeRepository();
     }
+    /**
+     * 查询HTTP日志
+     */
     findLogs() {
         return __awaiter(this, arguments, void 0, function* (options = {}) {
             if (!this.logRepository) {
@@ -38,9 +44,12 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             }
             const { page = 1, limit = 50, sortBy = 'createdAt', sortOrder = 'DESC', includeDetails = false, } = options;
             const queryBuilder = this.buildQuery(options, includeDetails);
+            // 分页
             const offset = (page - 1) * limit;
             queryBuilder.skip(offset).take(limit);
+            // 排序
             queryBuilder.orderBy(`log.${sortBy}`, sortOrder);
+            // 执行查询
             const [logs, total] = yield queryBuilder.getManyAndCount();
             return {
                 logs,
@@ -51,6 +60,9 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             };
         });
     }
+    /**
+     * 根据ID查询单条日志
+     */
     findLogById(id_1) {
         return __awaiter(this, arguments, void 0, function* (id, includeDetails = false) {
             if (!this.logRepository) {
@@ -63,6 +75,9 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             return queryBuilder.where('log.id = :id', { id }).getOne();
         });
     }
+    /**
+     * 根据请求ID查询日志
+     */
     findLogByRequestId(requestId) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.logRepository) {
@@ -74,12 +89,18 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             });
         });
     }
+    /**
+     * 查询错误日志
+     */
     findErrorLogs() {
         return __awaiter(this, arguments, void 0, function* (options = {}) {
             const queryOptions = Object.assign(Object.assign({}, options), { success: false });
             return this.findLogs(queryOptions);
         });
     }
+    /**
+     * 查询慢请求日志
+     */
     findSlowRequests() {
         return __awaiter(this, arguments, void 0, function* (minResponseTime = 5000, options = {}) {
             if (!this.logRepository) {
@@ -97,6 +118,9 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             return { logs, total };
         });
     }
+    /**
+     * 查询重试日志
+     */
     findRetryLogs() {
         return __awaiter(this, arguments, void 0, function* (options = {}) {
             if (!this.logRepository) {
@@ -115,12 +139,16 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             return { logs, total };
         });
     }
+    /**
+     * 获取统计信息
+     */
     getStats() {
         return __awaiter(this, arguments, void 0, function* (options = {}) {
             if (!this.logRepository) {
                 throw new Error('HTTP log repository not available');
             }
             const { startDate, endDate, userId, serviceName } = options;
+            // 基础查询构建器
             const baseQuery = this.logRepository.createQueryBuilder('log');
             if (startDate) {
                 baseQuery.andWhere('log.createdAt >= :startDate', { startDate });
@@ -134,6 +162,7 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             if (serviceName) {
                 baseQuery.andWhere('log.serviceName = :serviceName', { serviceName });
             }
+            // 总体统计
             const [total, successful, failed] = yield Promise.all([
                 baseQuery.getCount(),
                 baseQuery
@@ -145,36 +174,43 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
                     .andWhere('log.success = :success', { success: false })
                     .getCount(),
             ]);
+            // 响应时间统计
             const responseTimeStats = yield baseQuery
                 .select('AVG(log.responseTime)', 'avg')
                 .addSelect('MIN(log.responseTime)', 'min')
                 .addSelect('MAX(log.responseTime)', 'max')
                 .getRawOne();
+            // 按HTTP方法统计
             const httpMethodStats = yield baseQuery
                 .select('log.method', 'method')
                 .addSelect('COUNT(*)', 'count')
                 .groupBy('log.method')
                 .getRawMany();
+            // 按状态码统计
             const statusStats = yield baseQuery
                 .select('log.statusCode', 'statusCode')
                 .addSelect('COUNT(*)', 'count')
                 .groupBy('log.statusCode')
                 .getRawMany();
+            // 按服务统计
             const serviceStats = yield baseQuery
                 .select('log.serviceName', 'serviceName')
                 .addSelect('COUNT(*)', 'count')
                 .groupBy('log.serviceName')
                 .getRawMany();
+            // 按操作统计
             const operationStats = yield baseQuery
                 .select('log.operationName', 'operationName')
                 .addSelect('COUNT(*)', 'count')
                 .groupBy('log.operationName')
                 .getRawMany();
+            // 按来源统计
             const sourceStats = yield baseQuery
                 .select('log.source', 'source')
                 .addSelect('COUNT(*)', 'count')
                 .groupBy('log.source')
                 .getRawMany();
+            // 错误统计
             const errorStats = yield baseQuery
                 .clone()
                 .where('log.success = :success', { success: false })
@@ -182,17 +218,20 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
                 .addSelect('COUNT(*)', 'count')
                 .groupBy('log.errorCode')
                 .getRawMany();
+            // 重试统计
             const retryStats = yield baseQuery
                 .select('AVG(log.attemptCount)', 'avgAttempts')
                 .addSelect('MAX(log.attemptCount)', 'maxAttempts')
                 .addSelect('SUM(log.attemptCount - 1)', 'totalRetries')
                 .addSelect('COUNT(*)', 'totalRequests')
                 .getRawOne();
+            // 缓存统计
             const cacheStats = yield baseQuery
                 .select('SUM(CASE WHEN log.cacheHit = true THEN 1 ELSE 0 END)', 'cacheHits')
                 .addSelect('SUM(CASE WHEN log.cacheHit = false OR log.cacheHit IS NULL THEN 1 ELSE 0 END)', 'cacheMisses')
                 .addSelect('COUNT(*)', 'total')
                 .getRawOne();
+            // 百分位数计算（简化版）
             const percentiles = yield this.calculatePercentiles(baseQuery);
             return {
                 totalRequests: total,
@@ -230,6 +269,9 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             };
         });
     }
+    /**
+     * 删除旧日志
+     */
     deleteOldLogs() {
         return __awaiter(this, arguments, void 0, function* (daysToKeep = 30) {
             if (!this.logRepository) {
@@ -246,6 +288,9 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             return result.affected || 0;
         });
     }
+    /**
+     * 清空所有日志
+     */
     clearAllLogs() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.logRepository) {
@@ -253,9 +298,14 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             }
             yield this.logRepository.clear();
             this.logger.warn('Cleared all HTTP logs');
-            return 0;
+            return 0; // Cannot get affected count from clear()
         });
     }
+    /**
+     * 根据日志ID生成curl命令
+     * @param logId 日志ID
+     * @returns curl命令字符串
+     */
     generateCurlFromLog(logId) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.logRepository) {
@@ -269,7 +319,9 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
                 return null;
             }
             try {
+                // 清理敏感信息
                 const sanitizedHeaders = this.sanitizeHeadersForCurl(log.headers || {});
+                // 构建请求配置
                 const requestConfig = {
                     method: log.method,
                     url: log.url,
@@ -277,6 +329,7 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
                     data: log.body,
                     params: log.params,
                 };
+                // 使用CurlGenerator生成curl命令
                 const curlCommand = curl_generator_util_1.CurlGenerator.generateCurlCommand(requestConfig);
                 this.logger.log(`Generated curl command for log ${logId}`);
                 return curlCommand;
@@ -287,6 +340,11 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             }
         });
     }
+    /**
+     * 根据请求ID生成curl命令
+     * @param requestId 请求ID
+     * @returns curl命令字符串
+     */
     generateCurlFromRequestId(requestId) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.logRepository) {
@@ -303,6 +361,11 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             return this.generateCurlFromLog(log.id);
         });
     }
+    /**
+     * 根据日志生成可重放的请求配置
+     * @param logId 日志ID
+     * @returns 请求配置对象
+     */
     generateReplayConfigFromLog(logId) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.logRepository) {
@@ -316,6 +379,7 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
                 return null;
             }
             try {
+                // 构建重放配置
                 const replayConfig = {
                     method: log.method,
                     url: log.url,
@@ -326,6 +390,7 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
                             : log.body
                         : undefined,
                     params: log.params || {},
+                    // 添加重放标记
                     metadata: {
                         originalLogId: log.id,
                         originalRequestId: log.requestId,
@@ -342,6 +407,11 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             }
         });
     }
+    /**
+     * 根据请求ID生成可重放的请求配置
+     * @param requestId 请求ID
+     * @returns 请求配置对象
+     */
     generateReplayConfigFromRequestId(requestId) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.logRepository) {
@@ -358,11 +428,17 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             return this.generateReplayConfigFromLog(log.id);
         });
     }
+    /**
+     * 批量生成curl命令
+     * @param options 查询选项
+     * @returns curl命令数组
+     */
     generateBatchCurlCommands() {
         return __awaiter(this, arguments, void 0, function* (options = {}) {
             if (!this.logRepository) {
                 throw new Error('HTTP log repository not available');
             }
+            // 限制返回数量以避免过大的响应
             const limitedOptions = Object.assign(Object.assign({}, options), { limit: Math.min(options.limit || 10, 50) });
             const result = yield this.findLogs(limitedOptions);
             const curlCommands = [];
@@ -385,6 +461,11 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             return curlCommands;
         });
     }
+    /**
+     * 获取日志的完整重放信息
+     * @param logId 日志ID
+     * @returns 包含curl命令和重放配置的对象
+     */
     getLogReplayInfo(logId) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.logRepository) {
@@ -405,6 +486,11 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             };
         });
     }
+    /**
+     * 根据请求ID获取日志的完整重放信息
+     * @param requestId 请求ID
+     * @returns 包含curl命令和重放配置的对象
+     */
     getLogReplayInfoByRequestId(requestId) {
         return __awaiter(this, void 0, void 0, function* () {
             const log = yield this.findLogByRequestId(requestId);
@@ -414,6 +500,9 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             return this.getLogReplayInfo(log.id);
         });
     }
+    /**
+     * 初始化仓库
+     */
     initializeRepository() {
         if (this.dataSource) {
             try {
@@ -425,9 +514,13 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             }
         }
     }
+    /**
+     * 计算响应时间百分位数
+     */
     calculatePercentiles(queryBuilder) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                // 获取所有响应时间
                 const results = yield queryBuilder
                     .select('log.responseTime', 'responseTime')
                     .where('log.responseTime IS NOT NULL')
@@ -456,6 +549,9 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             }
         });
     }
+    /**
+     * 格式化统计结果
+     */
     formatStats(stats, keyField, valueField) {
         return stats.reduce((acc, item) => {
             const key = item[keyField] || 'unknown';
@@ -464,14 +560,19 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
             return acc;
         }, {});
     }
+    /**
+     * 构建查询
+     */
     buildQuery(options, includeDetails = false) {
         if (!this.logRepository) {
             throw new Error('HTTP log repository not available');
         }
         const queryBuilder = this.logRepository.createQueryBuilder('log');
+        // 关联查询重试记录
         if (includeDetails) {
             queryBuilder.leftJoinAndSelect('log.retryRecords', 'retryRecords');
         }
+        // 基础条件
         if (options.requestId) {
             queryBuilder.andWhere('log.requestId = :requestId', {
                 requestId: options.requestId,
@@ -480,6 +581,7 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
         if (options.userId) {
             queryBuilder.andWhere('log.userId = :userId', { userId: options.userId });
         }
+        // 方法过滤
         if (options.method) {
             if (Array.isArray(options.method)) {
                 queryBuilder.andWhere('log.method IN (:...methods)', {
@@ -492,9 +594,11 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
                 });
             }
         }
+        // URL过滤
         if (options.url) {
             queryBuilder.andWhere('log.url LIKE :url', { url: `%${options.url}%` });
         }
+        // 状态码过滤
         if (options.statusCode) {
             if (Array.isArray(options.statusCode)) {
                 queryBuilder.andWhere('log.statusCode IN (:...statusCodes)', {
@@ -507,39 +611,47 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
                 });
             }
         }
+        // 成功状态过滤
         if (options.success !== undefined) {
             queryBuilder.andWhere('log.success = :success', {
                 success: options.success,
             });
         }
+        // 服务名称过滤
         if (options.serviceName) {
             queryBuilder.andWhere('log.serviceName = :serviceName', {
                 serviceName: options.serviceName,
             });
         }
+        // 操作名称过滤
         if (options.operationName) {
             queryBuilder.andWhere('log.operationName = :operationName', {
                 operationName: options.operationName,
             });
         }
+        // 客户端IP过滤
         if (options.clientIp) {
             queryBuilder.andWhere('log.clientIp = :clientIp', {
                 clientIp: options.clientIp,
             });
         }
+        // 来源过滤
         if (options.source) {
             queryBuilder.andWhere('log.source = :source', { source: options.source });
         }
+        // 标签过滤
         if (options.tags && options.tags.length > 0) {
             queryBuilder.andWhere('JSON_CONTAINS(log.tags, :tags)', {
                 tags: JSON.stringify(options.tags),
             });
         }
+        // 错误代码过滤
         if (options.errorCode) {
             queryBuilder.andWhere('log.errorCode = :errorCode', {
                 errorCode: options.errorCode,
             });
         }
+        // 响应时间范围过滤
         if (options.minResponseTime) {
             queryBuilder.andWhere('log.responseTime >= :minResponseTime', {
                 minResponseTime: options.minResponseTime,
@@ -550,6 +662,7 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
                 maxResponseTime: options.maxResponseTime,
             });
         }
+        // 时间范围过滤
         if (options.startDate) {
             queryBuilder.andWhere('log.createdAt >= :startDate', {
                 startDate: options.startDate,
@@ -560,11 +673,18 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
                 endDate: options.endDate,
             });
         }
+        // 关键词搜索
         if (options.keyword) {
             queryBuilder.andWhere('(log.url LIKE :keyword OR log.errorMessage LIKE :keyword OR log.body LIKE :keyword)', { keyword: `%${options.keyword}%` });
         }
         return queryBuilder;
     }
+    /**
+     * 清理敏感信息用于生成curl命令
+     * 移除或替换敏感的请求头和认证信息
+     * @param headers 原始请求头
+     * @returns 清理后的请求头
+     */
     sanitizeHeadersForCurl(headers) {
         const sensitiveHeaders = [
             'authorization',
@@ -577,6 +697,7 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
         const sanitized = Object.assign({}, headers);
         for (const header of sensitiveHeaders) {
             if (sanitized[header]) {
+                // 保留头部但替换值为占位符
                 sanitized[header] = '***REDACTED***';
             }
         }

package/http-client/services/http-replay.service.d.ts

@@ -2,43 +2,110 @@ import { AxiosRequestConfig } from 'axios';
 import { HttpClientService } from './http-client.service';
 import { HttpLogQueryService } from './http-log-query.service';
 import { HttpLogEntity } from '../entities/http-log.entity';
+/**
+ * 请求重放选项
+ */
 export interface HttpReplayOptions {
+    /** 是否覆盖原始请求头 */
     overrideHeaders?: boolean;
+    /** 是否覆盖原始请求体 */
     overrideBody?: boolean;
+    /** 是否覆盖原始参数 */
     overrideParams?: boolean;
+    /** 重放时的额外请求头 */
     additionalHeaders?: Record<string, string>;
+    /** 重放时的额外元数据 */
     metadata?: Record<string, any>;
+    /** 是否记录重放日志 */
     logReplay?: boolean;
+    /** 重放超时时间（毫秒） */
     timeout?: number;
 }
+/**
+ * 请求重放结果
+ */
 export interface HttpReplayResult {
+    /** 重放的日志信息 */
     originalLog: HttpLogEntity;
+    /** 重放的请求配置 */
     requestConfig: AxiosRequestConfig;
+    /** 重放的响应结果 */
     response: any;
+    /** 重放耗时（毫秒） */
     responseTime: number;
+    /** 重放是否成功 */
     success: boolean;
+    /** 错误信息（如果失败） */
     error?: string;
+    /** 重放时间戳 */
     replayTimestamp: string;
+    /** 重放ID */
     replayId: string;
 }
+/**
+ * 批量重放结果
+ */
 export interface BatchReplayResult {
+    /** 总请求数 */
     totalRequests: number;
+    /** 成功请求数 */
     successfulRequests: number;
+    /** 失败请求数 */
     failedRequests: number;
+    /** 成功率 */
     successRate: number;
+    /** 总耗时（毫秒） */
     totalResponseTime: number;
+    /** 平均响应时间（毫秒） */
     averageResponseTime: number;
+    /** 单个重放结果 */
     results: HttpReplayResult[];
 }
+/**
+ * HTTP请求重放服务
+ * 提供基于HTTP日志的请求重放功能，支持单个请求和批量请求重放
+ */
 export declare class HttpReplayService {
     private readonly httpClient;
     private readonly logQueryService;
     private readonly logger;
     constructor(httpClient: HttpClientService, logQueryService: HttpLogQueryService);
+    /**
+     * 根据日志ID重放请求
+     * @param logId 日志ID
+     * @param options 重放选项
+     * @returns 重放结果
+     */
     replayByLogId(logId: string, options?: HttpReplayOptions): Promise<HttpReplayResult>;
+    /**
+     * 根据请求ID重放请求
+     * @param requestId 请求ID
+     * @param options 重放选项
+     * @returns 重放结果
+     */
     replayByRequestId(requestId: string, options?: HttpReplayOptions): Promise<HttpReplayResult>;
+    /**
+     * 批量重放请求
+     * @param logIds 日志ID数组
+     * @param options 重放选项
+     * @param concurrency 并发数
+     * @returns 批量重放结果
+     */
     batchReplay(logIds: string[], options?: HttpReplayOptions, concurrency?: number): Promise<BatchReplayResult>;
+    /**
+     * 根据查询条件批量重放请求
+     * @param queryOptions 查询选项
+     * @param replayOptions 重放选项
+     * @param concurrency 并发数
+     * @returns 批量重放结果
+     */
     batchReplayByQuery(queryOptions?: any, replayOptions?: HttpReplayOptions, concurrency?: number): Promise<BatchReplayResult>;
+    /**
+     * 重放请求并比较结果
+     * @param logId 日志ID
+     * @param options 重放选项
+     * @returns 包含原始和重放结果的比较
+     */
     replayAndCompare(logId: string, options?: HttpReplayOptions): Promise<{
         original: HttpLogEntity;
         replay: HttpReplayResult;
@@ -49,10 +116,44 @@ export declare class HttpReplayService {
             bodyMatch: boolean;
         };
     }>;
+    /**
+     * 构建重放配置
+     * @param log 原始日志
+     * @param options 重放选项
+     * @returns 请求配置
+     */
     private buildReplayConfig;
+    /**
+     * 执行重放请求
+     * @param config 请求配置
+     * @param options 重放选项
+     * @returns 响应结果
+     */
     private executeReplayRequest;
+    /**
+     * 生成重放ID
+     * @returns 重放ID
+     */
     private generateReplayId;
+    /**
+     * 数组分块
+     * @param array 原始数组
+     * @param size 块大小
+     * @returns 分块后的数组
+     */
     private chunkArray;
+    /**
+     * 比较响应头
+     * @param original 原始响应头
+     * @param replay 重放响应头
+     * @returns 是否匹配
+     */
     private compareHeaders;
+    /**
+     * 比较响应体
+     * @param original 原始响应体
+     * @param replay 重放响应体
+     * @returns 是否匹配
+     */
     private compareBodies;
 }