@nest-omni/core 4.1.3-2 → 4.1.3-20

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;
 }

package/http-client/services/http-replay.service.js

@@ -23,25 +23,39 @@ exports.HttpReplayService = void 0;
 const common_1 = require("@nestjs/common");
 const http_client_service_1 = require("./http-client.service");
 const http_log_query_service_1 = require("./http-log-query.service");
+/**
+ * HTTP请求重放服务
+ * 提供基于HTTP日志的请求重放功能，支持单个请求和批量请求重放
+ */
 let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
     constructor(httpClient, logQueryService) {
         this.httpClient = httpClient;
         this.logQueryService = logQueryService;
         this.logger = new common_1.Logger(HttpReplayService_1.name);
     }
+    /**
+     * 根据日志ID重放请求
+     * @param logId 日志ID
+     * @param options 重放选项
+     * @returns 重放结果
+     */
     replayByLogId(logId_1) {
         return __awaiter(this, arguments, void 0, function* (logId, options = {}) {
             const startTime = Date.now();
             const replayId = this.generateReplayId();
             try {
+                // 获取原始日志
                 const originalLog = yield this.logQueryService.findLogById(logId, true);
                 if (!originalLog) {
                     throw new Error(`Log with ID ${logId} not found`);
                 }
+                // 构建重放配置
                 const requestConfig = this.buildReplayConfig(originalLog, options);
+                // 记录重放开始
                 if (options.logReplay !== false) {
                     this.logger.log(`Starting replay for log ${logId} (replay ID: ${replayId})`);
                 }
+                // 执行重放请求
                 const response = yield this.executeReplayRequest(requestConfig, options);
                 const endTime = Date.now();
                 const responseTime = endTime - startTime;
@@ -77,6 +91,12 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
             }
         });
     }
+    /**
+     * 根据请求ID重放请求
+     * @param requestId 请求ID
+     * @param options 重放选项
+     * @returns 重放结果
+     */
     replayByRequestId(requestId_1) {
         return __awaiter(this, arguments, void 0, function* (requestId, options = {}) {
             const originalLog = yield this.logQueryService.findLogByRequestId(requestId);
@@ -86,10 +106,18 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
             return this.replayByLogId(originalLog.id, options);
         });
     }
+    /**
+     * 批量重放请求
+     * @param logIds 日志ID数组
+     * @param options 重放选项
+     * @param concurrency 并发数
+     * @returns 批量重放结果
+     */
     batchReplay(logIds_1) {
         return __awaiter(this, arguments, void 0, function* (logIds, options = {}, concurrency = 5) {
             const startTime = Date.now();
             this.logger.log(`Starting batch replay for ${logIds.length} logs`);
+            // 分批处理
             const results = [];
             const chunks = this.chunkArray(logIds, concurrency);
             for (const chunk of chunks) {
@@ -114,6 +142,7 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
                 const chunkResults = yield Promise.all(chunkPromises);
                 results.push(...chunkResults);
             }
+            // 统计结果
             const successfulRequests = results.filter((r) => r.success).length;
             const failedRequests = results.length - successfulRequests;
             const totalResponseTime = results.reduce((sum, r) => sum + r.responseTime, 0);
@@ -131,9 +160,18 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
             return batchResult;
         });
     }
+    /**
+     * 根据查询条件批量重放请求
+     * @param queryOptions 查询选项
+     * @param replayOptions 重放选项
+     * @param concurrency 并发数
+     * @returns 批量重放结果
+     */
     batchReplayByQuery() {
         return __awaiter(this, arguments, void 0, function* (queryOptions = {}, replayOptions = {}, concurrency = 5) {
+            // 限制查询数量以避免过大的批量操作
             const limitedQueryOptions = Object.assign(Object.assign({}, queryOptions), { limit: Math.min(queryOptions.limit || 50, 100) });
+            // 查询日志
             const queryResult = yield this.logQueryService.findLogs(limitedQueryOptions);
             const logIds = queryResult.logs.map((log) => log.id);
             if (logIds.length === 0) {
@@ -152,6 +190,12 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
             return this.batchReplay(logIds, replayOptions, concurrency);
         });
     }
+    /**
+     * 重放请求并比较结果
+     * @param logId 日志ID
+     * @param options 重放选项
+     * @returns 包含原始和重放结果的比较
+     */
     replayAndCompare(logId_1) {
         return __awaiter(this, arguments, void 0, function* (logId, options = {}) {
             var _a, _b, _c;
@@ -160,6 +204,7 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
                 throw new Error(`Log with ID ${logId} not found`);
             }
             const replayResult = yield this.replayByLogId(logId, options);
+            // 比较结果
             const comparison = {
                 statusMatch: originalLog.statusCode === ((_a = replayResult.response) === null || _a === void 0 ? void 0 : _a.status),
                 responseTimeDifference: replayResult.responseTime - originalLog.responseTime,
@@ -173,6 +218,12 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
             };
         });
     }
+    /**
+     * 构建重放配置
+     * @param log 原始日志
+     * @param options 重放选项
+     * @returns 请求配置
+     */
     buildReplayConfig(log, options) {
         const config = {
             method: log.method,
@@ -180,6 +231,7 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
             headers: Object.assign({}, log.headers),
             params: Object.assign({}, log.params),
         };
+        // 处理请求体
         if (log.body) {
             try {
                 config.data =
@@ -189,6 +241,7 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
                 config.data = log.body;
             }
         }
+        // 应用覆盖选项
         if (options.overrideHeaders) {
             config.headers = Object.assign(Object.assign({}, config.headers), options.additionalHeaders);
         }
@@ -196,29 +249,49 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
             config.headers = Object.assign(Object.assign({}, config.headers), options.additionalHeaders);
         }
         if (options.overrideBody && options.additionalHeaders) {
+            // 如果有额外的body数据，在这里处理
         }
         if (options.overrideParams && options.metadata) {
             config.params = Object.assign(Object.assign({}, config.params), options.metadata);
         }
+        // 添加超时
         if (options.timeout) {
             config.timeout = options.timeout;
         }
+        // 添加重放元数据（作为自定义属性）
         config.metadata = Object.assign({ originalLogId: log.id, originalRequestId: log.requestId, replayTimestamp: new Date().toISOString(), replayedBy: 'http-replay-service' }, options.metadata);
         return config;
     }
+    /**
+     * 执行重放请求
+     * @param config 请求配置
+     * @param options 重放选项
+     * @returns 响应结果
+     */
     executeReplayRequest(config, options) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 return yield this.httpClient.request(config);
             }
             catch (error) {
+                // 如果请求失败，重新抛出错误
                 throw error;
             }
         });
     }
+    /**
+     * 生成重放ID
+     * @returns 重放ID
+     */
     generateReplayId() {
         return `replay-${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
     }
+    /**
+     * 数组分块
+     * @param array 原始数组
+     * @param size 块大小
+     * @returns 分块后的数组
+     */
     chunkArray(array, size) {
         const chunks = [];
         for (let i = 0; i < array.length; i += size) {
@@ -226,7 +299,14 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
         }
         return chunks;
     }
+    /**
+     * 比较响应头
+     * @param original 原始响应头
+     * @param replay 重放响应头
+     * @returns 是否匹配
+     */
     compareHeaders(original, replay) {
+        // 简化比较：忽略时间相关的头部
         const ignoreHeaders = ['date', 'expires', 'last-modified', 'etag'];
         const originalFiltered = Object.keys(original)
             .filter((key) => !ignoreHeaders.includes(key.toLowerCase()))
@@ -242,6 +322,12 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
         }, {});
         return JSON.stringify(originalFiltered) === JSON.stringify(replayFiltered);
     }
+    /**
+     * 比较响应体
+     * @param original 原始响应体
+     * @param replay 重放响应体
+     * @returns 是否匹配
+     */
     compareBodies(original, replay) {
         if (!original && !replay)
             return true;

package/http-client/services/index.d.ts

@@ -1,7 +1,6 @@
 export * from './http-client.service';
 export * from './circuit-breaker.service';
 export * from './logging.service';
-export * from './cache.service';
 export * from './http-log-query.service';
 export * from './log-cleanup.service';
 export * from './api-client-registry.service';

package/http-client/services/index.js

@@ -17,7 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./http-client.service"), exports);
 __exportStar(require("./circuit-breaker.service"), exports);
 __exportStar(require("./logging.service"), exports);
-__exportStar(require("./cache.service"), exports);
 __exportStar(require("./http-log-query.service"), exports);
 __exportStar(require("./log-cleanup.service"), exports);
 __exportStar(require("./api-client-registry.service"), exports);

package/http-client/services/log-cleanup.service.d.ts

@@ -1,31 +1,61 @@
 import { OnModuleInit } from '@nestjs/common';
 import { CronExpression } from '@nestjs/schedule';
 import { HttpLogQueryService } from './http-log-query.service';
+/**
+ * 日志清理配置接口
+ */
 export interface LogCleanupConfig {
+    /** 是否启用自动清理 */
     enabled: boolean;
+    /** 清理策略 */
     strategy: 'retention' | 'size' | 'combination';
+    /** 保留天数 */
     retentionDays: number;
+    /** 最大记录数 */
     maxRecords?: number;
+    /** 定时清理表达式 */
     schedule?: CronExpression;
+    /** 批处理大小 */
     batchSize?: number;
+    /** 是否保留错误日志 */
     preserveErrorLogs?: boolean;
+    /** 错误日志保留天数 */
     errorLogRetentionDays?: number;
+    /** 是否保留重要日志 */
     preserveImportantLogs?: boolean;
+    /** 重要日志保留天数 */
     importantLogRetentionDays?: number;
+    /** 是否保留慢请求日志 */
     preserveSlowRequests?: boolean;
+    /** 慢请求日志保留天数 */
     slowRequestRetentionDays?: number;
+    /** 慢请求阈值（毫秒） */
     slowRequestThreshold?: number;
 }
+/**
+ * 清理统计信息
+ */
 export interface CleanupStats {
+    /** 清理时间 */
     cleanupTime: Date;
+    /** 清理策略 */
     strategy: string;
+    /** 清理前记录数 */
     beforeCount: number;
+    /** 清理后记录数 */
     afterCount: number;
+    /** 删除的记录数 */
     deletedCount: number;
+    /** 处理的批次数量 */
     batchCount: number;
+    /** 耗时（毫秒） */
     duration: number;
+    /** 错误信息 */
     errors: string[];
 }
+/**
+ * HTTP日志清理服务
+ */
 export declare class HttpLogCleanupService implements OnModuleInit {
     private readonly logQueryService;
     private readonly logger;
@@ -33,16 +63,34 @@ export declare class HttpLogCleanupService implements OnModuleInit {
     constructor(logQueryService: HttpLogQueryService, config?: Partial<LogCleanupConfig>);
     private get cleanupConfig();
     onModuleInit(): void;
+    /**
+     * 定时清理任务
+     */
     scheduledCleanup(): Promise<CleanupStats>;
+    /**
+     * 执行手动清理
+     */
     manualCleanup(options?: Partial<LogCleanupConfig>): Promise<CleanupStats>;
+    /**
+     * 获取清理配置
+     */
     getConfig(): LogCleanupConfig;
+    /**
+     * 更新清理配置
+     */
     updateConfig(config: Partial<LogCleanupConfig>): void;
+    /**
+     * 检查清理状态
+     */
     getCleanupStatus(): Promise<{
         enabled: boolean;
         config: LogCleanupConfig;
         currentStats: any;
         recommendations: string[];
     }>;
+    /**
+     * 预览清理操作（不实际执行）
+     */
     previewCleanup(config?: Partial<LogCleanupConfig>): Promise<{
         strategy: string;
         currentRecords: number;
@@ -56,9 +104,24 @@ export declare class HttpLogCleanupService implements OnModuleInit {
             importantLogs: number;
         };
     }>;
+    /**
+     * 执行清理操作
+     */
     private performCleanup;
+    /**
+     * 基于时间的清理策略
+     */
     private cleanupByRetention;
+    /**
+     * 基于数量的清理策略
+     */
     private cleanupBySize;
+    /**
+     * 组合清理策略
+     */
     private cleanupByCombination;
+    /**
+     * 创建清理统计
+     */
     private createCleanupStats;
 }