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

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

@@ -1,76 +0,0 @@
-import { AxiosRequestConfig, AxiosResponse } from 'axios';
-import { HttpCacheConfig } from '../interfaces/http-client-config.interface';
-import { CacheService } from '../../cache/cache.service';
-/**
- * HTTP缓存服务
- * 集成现有的三层缓存架构
- */
-export declare class HttpCacheService {
-    private readonly cacheService;
-    private readonly logger;
-    constructor(cacheService: CacheService);
-    /**
-     * 获取缓存的响应
-     */
-    get(config: AxiosRequestConfig, cacheOptions: HttpCacheConfig): Promise<AxiosResponse | null>;
-    /**
-     * 缓存响应
-     */
-    set(config: AxiosRequestConfig, response: AxiosResponse, cacheOptions: HttpCacheConfig): Promise<void>;
-    /**
-     * 清除缓存
-     */
-    clear(pattern?: string): Promise<void>;
-    /**
-     * 获取缓存统计信息
-     */
-    getStats(): Promise<any>;
-    /**
-     * 清理过期缓存
-     */
-    cleanup(): Promise<void>;
-    /**
-     * 预热缓存
-     */
-    warmup(urls: string[], headers?: Record<string, string>): Promise<void>;
-    /**
-     * 获取缓存命中率详情
-     */
-    getDetailedStats(): Promise<any>;
-    /**
-     * 生成缓存键
-     */
-    private generateCacheKey;
-    /**
-     * 构建完整的缓存键
-     */
-    private buildCacheKey;
-    /**
-     * 映射缓存层
-     */
-    private mapLayers;
-    /**
-     * 选择用于缓存键的头信息
-     */
-    private selectHeadersForCacheKey;
-    /**
-     * 判断响应是否可缓存
-     */
-    private isResponseCacheable;
-    /**
-     * 哈希对象
-     */
-    private hashObject;
-    /**
-     * 计算综合命中率
-     */
-    private calculateHitRate;
-    /**
-     * 获取最近的缓存活动
-     */
-    private getRecentCacheActivity;
-    /**
-     * 生成缓存优化建议
-     */
-    private generateRecommendations;
-}

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

@@ -1,333 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var HttpCacheService_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpCacheService = void 0;
-const common_1 = require("@nestjs/common");
-const cache_service_1 = require("../../cache/cache.service");
-const cache_options_interface_1 = require("../../cache/interfaces/cache-options.interface");
-/**
- * HTTP缓存服务
- * 集成现有的三层缓存架构
- */
-let HttpCacheService = HttpCacheService_1 = class HttpCacheService {
-    constructor(cacheService) {
-        this.cacheService = cacheService;
-        this.logger = new common_1.Logger(HttpCacheService_1.name);
-    }
-    /**
-     * 获取缓存的响应
-     */
-    get(config, cacheOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const key = this.generateCacheKey(config, cacheOptions);
-            const cacheKey = this.buildCacheKey(cacheOptions, key);
-            try {
-                const cachedResponse = yield this.cacheService.get(cacheKey, {
-                    layers: this.mapLayers((_a = cacheOptions.options) === null || _a === void 0 ? void 0 : _a.layers),
-                    ttl: cacheOptions.defaultTtl,
-                });
-                if (cachedResponse) {
-                    this.logger.debug(`Cache hit: ${cacheKey}`);
-                    return cachedResponse;
-                }
-                this.logger.debug(`Cache miss: ${cacheKey}`);
-                return null;
-            }
-            catch (error) {
-                this.logger.warn(`Cache get error: ${error.message}`);
-                return null;
-            }
-        });
-    }
-    /**
-     * 缓存响应
-     */
-    set(config, response, cacheOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
-            const key = this.generateCacheKey(config, cacheOptions);
-            const cacheKey = this.buildCacheKey(cacheOptions, key);
-            if (!this.isResponseCacheable(response, cacheOptions)) {
-                this.logger.debug(`Response not cacheable: ${response.status} ${config.url}`);
-                return;
-            }
-            try {
-                yield this.cacheService.set(cacheKey, response, {
-                    layers: this.mapLayers((_a = cacheOptions.options) === null || _a === void 0 ? void 0 : _a.layers),
-                    ttl: cacheOptions.defaultTtl,
-                    namespace: ((_b = cacheOptions.options) === null || _b === void 0 ? void 0 : _b.prefix) || 'http',
-                    condition: (_c = cacheOptions.options) === null || _c === void 0 ? void 0 : _c.condition,
-                    backfill: (_d = cacheOptions.options) === null || _d === void 0 ? void 0 : _d.backfill,
-                });
-                this.logger.debug(`Response cached: ${cacheKey}`);
-            }
-            catch (error) {
-                this.logger.warn(`Cache set error: ${error.message}`);
-            }
-        });
-    }
-    /**
-     * 清除缓存
-     */
-    clear(pattern) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (pattern) {
-                    // 使用通配符清除
-                    yield this.cacheService.deletePattern(pattern);
-                    this.logger.debug(`Cache cleared with pattern: ${pattern}`);
-                }
-                else {
-                    // 清除所有HTTP相关缓存
-                    yield this.cacheService.deletePattern('http:*');
-                    this.logger.debug('All HTTP cache cleared');
-                }
-            }
-            catch (error) {
-                this.logger.warn(`Cache clear error: ${error.message}`);
-            }
-        });
-    }
-    /**
-     * 获取缓存统计信息
-     */
-    getStats() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const stats = this.cacheService.getStats();
-                return stats;
-            }
-            catch (error) {
-                this.logger.warn(`Get cache stats error: ${error.message}`);
-                return null;
-            }
-        });
-    }
-    /**
-     * 清理过期缓存
-     */
-    cleanup() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // CacheService doesn't have cleanup method, so we'll clear HTTP cache patterns
-                yield this.cacheService.deletePattern('http:*');
-                this.logger.debug('HTTP cache cleanup completed');
-            }
-            catch (error) {
-                this.logger.warn(`Cache cleanup error: ${error.message}`);
-            }
-        });
-    }
-    /**
-     * 预热缓存
-     */
-    warmup(urls, headers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.log(`Starting cache warmup for ${urls.length} URLs`);
-            // 这里可以实现预热逻辑
-            // 例如：预先请求这些URL并缓存响应
-            // 实际实现需要访问HTTP客户端服务，可能需要通过事件或其他方式实现
-            this.logger.log('Cache warmup completed');
-        });
-    }
-    /**
-     * 获取缓存命中率详情
-     */
-    getDetailedStats() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const stats = yield this.getStats();
-                const recentHits = yield this.getRecentCacheActivity();
-                return Object.assign(Object.assign({}, stats), { recentActivity: recentHits, recommendations: this.generateRecommendations(stats) });
-            }
-            catch (error) {
-                this.logger.warn(`Get detailed cache stats error: ${error.message}`);
-                return null;
-            }
-        });
-    }
-    /**
-     * 生成缓存键
-     */
-    generateCacheKey(config, cacheOptions) {
-        var _a;
-        if (cacheOptions.keyGenerator) {
-            return cacheOptions.keyGenerator(config);
-        }
-        // 默认键生成逻辑
-        const keyData = {
-            method: (_a = config.method) === null || _a === void 0 ? void 0 : _a.toLowerCase(),
-            url: config.url,
-            params: config.params,
-            data: config.data,
-            headers: this.selectHeadersForCacheKey(config.headers),
-        };
-        // 简单的哈希键生成
-        return this.hashObject(keyData);
-    }
-    /**
-     * 构建完整的缓存键
-     */
-    buildCacheKey(cacheOptions, key) {
-        var _a;
-        const namespace = ((_a = cacheOptions.options) === null || _a === void 0 ? void 0 : _a.prefix) || 'http';
-        return `${namespace}:${key}`;
-    }
-    /**
-     * 映射缓存层
-     */
-    mapLayers(layers) {
-        if (!layers || layers.length === 0) {
-            return [cache_options_interface_1.CacheLayer.MEMORY, cache_options_interface_1.CacheLayer.REDIS]; // 默认使用内存和Redis
-        }
-        return layers.map((layer) => {
-            switch (layer) {
-                case 'cls':
-                    return cache_options_interface_1.CacheLayer.CLS;
-                case 'memory':
-                    return cache_options_interface_1.CacheLayer.MEMORY;
-                case 'redis':
-                    return cache_options_interface_1.CacheLayer.REDIS;
-                default:
-                    return cache_options_interface_1.CacheLayer.MEMORY;
-            }
-        });
-    }
-    /**
-     * 选择用于缓存键的头信息
-     */
-    selectHeadersForCacheKey(headers) {
-        if (!headers)
-            return {};
-        // 只选择影响响应内容的头信息
-        const cacheKeyHeaders = [
-            'accept',
-            'accept-language',
-            'accept-encoding',
-            'content-type',
-            'authorization', // 包含授权信息以确保缓存的安全性
-        ];
-        const selectedHeaders = {};
-        cacheKeyHeaders.forEach((key) => {
-            if (headers[key]) {
-                selectedHeaders[key] = headers[key];
-            }
-        });
-        return selectedHeaders;
-    }
-    /**
-     * 判断响应是否可缓存
-     */
-    isResponseCacheable(response, config) {
-        var _a;
-        // 检查状态码
-        if (!config.cacheableStatusCodes.includes(response.status)) {
-            return false;
-        }
-        // 检查方法
-        const method = (_a = response.config.method) === null || _a === void 0 ? void 0 : _a.toLowerCase();
-        if (!config.cacheableMethods.includes(method || 'get')) {
-            return false;
-        }
-        // 检查缓存控制头
-        const cacheControl = response.headers['cache-control'];
-        if (cacheControl) {
-            if (cacheControl.includes('no-store') ||
-                cacheControl.includes('no-cache')) {
-                return false;
-            }
-            if (cacheControl.includes('private')) {
-                // 私有缓存可能需要特殊处理
-                this.logger.debug('Private cache detected, caching with caution');
-            }
-        }
-        // 检查响应大小
-        if (response.data) {
-            const responseSize = JSON.stringify(response.data).length;
-            if (responseSize > 1024 * 1024) {
-                // 1MB限制
-                this.logger.warn(`Response too large for caching: ${responseSize} bytes`);
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * 哈希对象
-     */
-    hashObject(obj) {
-        const str = JSON.stringify(obj, Object.keys(obj).sort());
-        let hash = 0;
-        for (let i = 0; i < str.length; i++) {
-            const char = str.charCodeAt(i);
-            hash = (hash << 5) - hash + char;
-            hash = hash & hash; // 转换为32位整数
-        }
-        return Math.abs(hash).toString(36);
-    }
-    /**
-     * 计算综合命中率
-     */
-    calculateHitRate(...stats) {
-        let totalHits = 0;
-        let totalRequests = 0;
-        stats.forEach((stat) => {
-            if (stat) {
-                totalHits += stat.hits || 0;
-                totalRequests += (stat.hits || 0) + (stat.misses || 0);
-            }
-        });
-        return totalRequests > 0 ? (totalHits / totalRequests) * 100 : 0;
-    }
-    /**
-     * 获取最近的缓存活动
-     */
-    getRecentCacheActivity() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // 这里可以实现获取最近缓存活动的逻辑
-            // 例如：从Redis获取最近的缓存键访问记录
-            return {
-                recentHits: 0,
-                recentMisses: 0,
-                topCacheKeys: [],
-            };
-        });
-    }
-    /**
-     * 生成缓存优化建议
-     */
-    generateRecommendations(stats) {
-        const recommendations = [];
-        if (stats.combined.hitRate < 50) {
-            recommendations.push('Cache hit rate is low, consider increasing TTL or optimizing cache keys');
-        }
-        if (stats.redis.memoryUsage > 0.8) {
-            recommendations.push('Redis memory usage is high, consider increasing memory or cleaning up old cache entries');
-        }
-        return recommendations;
-    }
-};
-exports.HttpCacheService = HttpCacheService;
-exports.HttpCacheService = HttpCacheService = HttpCacheService_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [cache_service_1.CacheService])
-], HttpCacheService);