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

package/vault/vault-config.service.js

@@ -172,7 +172,7 @@ let VaultConfigService = VaultConfigService_1 = class VaultConfigService {
             }
             try {
                 const health = yield this.vaultClient.health();
-                return health && !health.sealed;
+                return !!(health && !health.sealed);
             }
             catch (error) {
                 this.logger.error('Vault health check failed', error.message);

package/cache/providers/memory-cache.provider.d.ts

@@ -1,49 +0,0 @@
-import { BaseCacheProvider } from './base-cache.provider';
-/**
- * Memory cache provider using native Map with TTL support
- *
- * This is the L2 cache layer - process-level caching.
- * Data is stored in memory and shared across all requests in the same process.
- *
- * Faster than Redis but not shared across multiple processes/servers.
- */
-export declare class MemoryCacheProvider extends BaseCacheProvider {
-    private cache;
-    private keys;
-    private defaultTtl?;
-    private namespace;
-    constructor(options?: {
-        ttl?: number;
-        namespace?: string;
-    });
-    getName(): string;
-    get<T>(key: string): Promise<T | null>;
-    set<T>(key: string, value: T, ttl?: number): Promise<void>;
-    delete(key: string | string[]): Promise<void>;
-    deletePattern(pattern: string): Promise<number>;
-    clear(): Promise<void>;
-    has(key: string): Promise<boolean>;
-    /**
-     * Get all keys (for debugging/testing)
-     */
-    getAllKeys(): string[];
-    /**
-     * Get cache size
-     */
-    getSize(): number;
-    /**
-     * Clean up expired items (optional maintenance method)
-     */
-    cleanup(): number;
-    /**
-     * Optimized mget with batch cleanup
-     */
-    mget<T>(keys: string[]): Promise<(T | null)[]>;
-    /**
-     * Optimized mset
-     */
-    mset(items: Array<{
-        key: string;
-        value: any;
-    }>, ttl?: number): Promise<void>;
-}

package/cache/providers/memory-cache.provider.js

@@ -1,197 +0,0 @@
-"use strict";
-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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryCacheProvider = void 0;
-const base_cache_provider_1 = require("./base-cache.provider");
-/**
- * Memory cache provider using native Map with TTL support
- *
- * This is the L2 cache layer - process-level caching.
- * Data is stored in memory and shared across all requests in the same process.
- *
- * Faster than Redis but not shared across multiple processes/servers.
- */
-class MemoryCacheProvider extends base_cache_provider_1.BaseCacheProvider {
-    constructor(options) {
-        super();
-        this.cache = new Map();
-        this.keys = new Set();
-        this.defaultTtl = options === null || options === void 0 ? void 0 : options.ttl;
-        this.namespace = (options === null || options === void 0 ? void 0 : options.namespace) || 'cache:memory';
-    }
-    getName() {
-        return 'Memory';
-    }
-    get(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const item = this.cache.get(key);
-                if (!item) {
-                    return null;
-                }
-                // Check if item has expired
-                if (item.expiresAt && Date.now() > item.expiresAt) {
-                    this.cache.delete(key);
-                    this.keys.delete(key);
-                    return null;
-                }
-                return item.value;
-            }
-            catch (_a) {
-                return null;
-            }
-        });
-    }
-    set(key, value, ttl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const effectiveTtl = ttl !== null && ttl !== void 0 ? ttl : this.defaultTtl;
-                const expiresAt = effectiveTtl ? Date.now() + effectiveTtl : undefined;
-                const item = {
-                    value,
-                    expiresAt,
-                };
-                this.cache.set(key, item);
-                this.keys.add(key);
-            }
-            catch (error) {
-                throw new Error(`MemoryCacheProvider: Failed to set key ${key}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        });
-    }
-    delete(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (Array.isArray(key)) {
-                    key.forEach((k) => {
-                        this.cache.delete(k);
-                        this.keys.delete(k);
-                    });
-                }
-                else {
-                    this.cache.delete(key);
-                    this.keys.delete(key);
-                }
-            }
-            catch (error) {
-                throw new Error(`MemoryCacheProvider: Failed to delete key(s): ${error instanceof Error ? error.message : String(error)}`);
-            }
-        });
-    }
-    deletePattern(pattern) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const regex = this.patternToRegex(pattern);
-                const matchedKeys = Array.from(this.keys).filter((key) => regex.test(key));
-                if (matchedKeys.length > 0) {
-                    yield this.delete(matchedKeys);
-                }
-                return matchedKeys.length;
-            }
-            catch (_a) {
-                return 0;
-            }
-        });
-    }
-    clear() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                this.cache.clear();
-                this.keys.clear();
-            }
-            catch (error) {
-                throw new Error(`MemoryCacheProvider: Failed to clear cache: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        });
-    }
-    has(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const item = this.cache.get(key);
-                if (!item) {
-                    return false;
-                }
-                // Check if item has expired
-                if (item.expiresAt && Date.now() > item.expiresAt) {
-                    this.cache.delete(key);
-                    this.keys.delete(key);
-                    return false;
-                }
-                return true;
-            }
-            catch (_a) {
-                return false;
-            }
-        });
-    }
-    /**
-     * Get all keys (for debugging/testing)
-     */
-    getAllKeys() {
-        return Array.from(this.keys);
-    }
-    /**
-     * Get cache size
-     */
-    getSize() {
-        return this.keys.size;
-    }
-    /**
-     * Clean up expired items (optional maintenance method)
-     */
-    cleanup() {
-        let cleaned = 0;
-        const now = Date.now();
-        for (const [key, item] of this.cache.entries()) {
-            if (item.expiresAt && now > item.expiresAt) {
-                this.cache.delete(key);
-                this.keys.delete(key);
-                cleaned++;
-            }
-        }
-        return cleaned;
-    }
-    /**
-     * Optimized mget with batch cleanup
-     */
-    mget(keys) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = [];
-            const now = Date.now();
-            for (const key of keys) {
-                const item = this.cache.get(key);
-                if (!item) {
-                    results.push(null);
-                    continue;
-                }
-                // Check if item has expired
-                if (item.expiresAt && now > item.expiresAt) {
-                    this.cache.delete(key);
-                    this.keys.delete(key);
-                    results.push(null);
-                    continue;
-                }
-                results.push(item.value);
-            }
-            return results;
-        });
-    }
-    /**
-     * Optimized mset
-     */
-    mset(items, ttl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const promises = items.map((item) => this.set(item.key, item.value, ttl));
-            yield Promise.all(promises);
-        });
-    }
-}
-exports.MemoryCacheProvider = MemoryCacheProvider;

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

package/shared/services/validator.service.d.ts

@@ -1,3 +0,0 @@
-export declare class ValidatorService {
-    isImage(mimeType: string): boolean;
-}

package/shared/services/validator.service.js

@@ -1,20 +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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidatorService = void 0;
-const common_1 = require("@nestjs/common");
-let ValidatorService = class ValidatorService {
-    isImage(mimeType) {
-        const imageMimeTypes = ['image/jpeg', 'image/png'];
-        return imageMimeTypes.includes(mimeType);
-    }
-};
-exports.ValidatorService = ValidatorService;
-exports.ValidatorService = ValidatorService = __decorate([
-    (0, common_1.Injectable)()
-], ValidatorService);