@nest-omni/core 3.1.1-18 → 3.1.1-19

package/cache/cache-serialization.service.d.ts

@@ -1,9 +1,6 @@
 export interface CacheSerializationOptions {
     compress?: boolean;
     compressThreshold?: number;
-    serializer?: (value: any) => string;
-    deserializer?: (data: string) => any;
-    preserveTypes?: boolean;
 }
 export interface SerializationResult {
     data: Buffer;
@@ -14,16 +11,12 @@ export interface SerializationResult {
 export interface DeserializationResult<T> {
     data: T;
     wasCompressed: boolean;
-    wasSerialized: boolean;
 }
 export declare class CacheSerializationService {
     private readonly logger;
     serialize<T>(value: T, options?: CacheSerializationOptions): Promise<SerializationResult>;
-    deserialize<T>(buffer: Buffer, options?: CacheSerializationOptions): Promise<DeserializationResult<T>>;
-    getSerializationStats(value: any, options?: CacheSerializationOptions): any;
-    validateSerializedData(buffer: Buffer): boolean;
-    getOptimalOptions(value: any): CacheSerializationOptions;
-    private preserveTypeSerialization;
-    private preserveTypeDeserialization;
-    private hasComplexTypes;
+    deserialize<T>(buffer: Buffer): Promise<DeserializationResult<T>>;
+    private serializeWithDates;
+    private preProcessDates;
+    private deserializeWithDates;
 }

package/cache/cache-serialization.service.js

@@ -28,35 +28,24 @@ let CacheSerializationService = CacheSerializationService_1 = class CacheSeriali
     }
     serialize(value_1) {
         return __awaiter(this, arguments, void 0, function* (value, options = {}) {
-            const { compress = false, compressThreshold = 1024, serializer, preserveTypes = true, } = options;
+            const { compress = false, compressThreshold = 1024 } = options;
             try {
-                let serializedData;
-                let wasSerialized = false;
-                if (serializer) {
-                    serializedData = serializer(value);
-                    wasSerialized = true;
-                }
-                else {
-                    serializedData = preserveTypes
-                        ? this.preserveTypeSerialization(value)
-                        : JSON.stringify(value);
-                    wasSerialized = true;
-                }
-                const originalSize = Buffer.byteLength(serializedData, 'utf8');
+                const serialized = this.serializeWithDates(value);
+                const originalSize = Buffer.byteLength(serialized, 'utf8');
                 let data;
                 let wasCompressed = false;
                 if (compress && originalSize >= compressThreshold) {
                     try {
-                        data = yield gzipAsync(Buffer.from(serializedData, 'utf8'));
+                        data = yield gzipAsync(Buffer.from(serialized, 'utf8'));
                         wasCompressed = true;
                     }
                     catch (error) {
                         this.logger.warn('Compression failed, using uncompressed data:', error);
-                        data = Buffer.from(serializedData, 'utf8');
+                        data = Buffer.from(serialized, 'utf8');
                     }
                 }
                 else {
-                    data = Buffer.from(serializedData, 'utf8');
+                    data = Buffer.from(serialized, 'utf8');
                 }
                 return {
                     data,
@@ -71,9 +60,8 @@ let CacheSerializationService = CacheSerializationService_1 = class CacheSeriali
             }
         });
     }
-    deserialize(buffer_1) {
-        return __awaiter(this, arguments, void 0, function* (buffer, options = {}) {
-            const { deserializer, preserveTypes = true } = options;
+    deserialize(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
             try {
                 let dataString;
                 let wasCompressed = false;
@@ -84,20 +72,10 @@ let CacheSerializationService = CacheSerializationService_1 = class CacheSeriali
                 else {
                     dataString = buffer.toString('utf8');
                 }
-                let data;
-                let wasSerialized = true;
-                if (deserializer) {
-                    data = deserializer(dataString);
-                }
-                else {
-                    data = preserveTypes
-                        ? this.preserveTypeDeserialization(dataString)
-                        : JSON.parse(dataString);
-                }
+                const data = this.deserializeWithDates(dataString);
                 return {
                     data,
                     wasCompressed,
-                    wasSerialized,
                 };
             }
             catch (error) {
@@ -106,110 +84,37 @@ let CacheSerializationService = CacheSerializationService_1 = class CacheSeriali
             }
         });
     }
-    getSerializationStats(value, options = {}) {
-        const valueStr = JSON.stringify(value);
-        const valueSize = Buffer.byteLength(valueStr, 'utf8');
-        return {
-            originalSize: valueSize,
-            estimatedCompressedSize: Math.floor(valueSize * 0.6),
-            recommendedCompression: valueSize >= (options.compressThreshold || 1024),
-            hasComplexTypes: this.hasComplexTypes(value),
-        };
+    serializeWithDates(value) {
+        const processed = this.preProcessDates(value);
+        return JSON.stringify(processed);
     }
-    validateSerializedData(buffer) {
-        if (!Buffer.isBuffer(buffer)) {
-            return false;
+    preProcessDates(obj) {
+        if (obj === null || obj === undefined) {
+            return obj;
         }
-        if (buffer.length === 0) {
-            return false;
+        if (obj instanceof Date) {
+            return { __type: 'Date', value: obj.toISOString() };
         }
-        if (!(buffer.length >= 2 && buffer[0] === 0x1f && buffer[1] === 0x8b)) {
-            try {
-                buffer.toString('utf8');
-                return true;
-            }
-            catch (_a) {
-                return false;
-            }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => this.preProcessDates(item));
         }
-        return true;
-    }
-    getOptimalOptions(value) {
-        const stats = this.getSerializationStats(value);
-        const options = {};
-        if (stats.recommendedCompression) {
-            options.compress = true;
-            options.compressThreshold = 1024;
-        }
-        if (stats.hasComplexTypes) {
-            options.preserveTypes = true;
-        }
-        return options;
-    }
-    preserveTypeSerialization(value) {
-        return JSON.stringify(value, (key, val) => {
-            if (val instanceof Date) {
-                return { __type: 'Date', value: val.toISOString() };
+        if (typeof obj === 'object') {
+            const processed = {};
+            for (const [key, value] of Object.entries(obj)) {
+                processed[key] = this.preProcessDates(value);
             }
-            if (val instanceof RegExp) {
-                return { __type: 'RegExp', value: val.source, flags: val.flags };
-            }
-            if (val instanceof Set) {
-                return { __type: 'Set', value: Array.from(val) };
-            }
-            if (val instanceof Map) {
-                return { __type: 'Map', value: Array.from(val.entries()) };
-            }
-            if (typeof val === 'bigint') {
-                return { __type: 'BigInt', value: val.toString() };
-            }
-            if (Buffer.isBuffer(val)) {
-                return { __type: 'Buffer', value: Array.from(val) };
-            }
-            return val;
-        });
+            return processed;
+        }
+        return obj;
     }
-    preserveTypeDeserialization(dataString) {
+    deserializeWithDates(dataString) {
         return JSON.parse(dataString, (key, val) => {
-            if (val && typeof val === 'object' && val.__type) {
-                switch (val.__type) {
-                    case 'Date':
-                        return new Date(val.value);
-                    case 'RegExp':
-                        return new RegExp(val.value, val.flags);
-                    case 'Set':
-                        return new Set(val.value);
-                    case 'Map':
-                        return new Map(val.value);
-                    case 'BigInt':
-                        return BigInt(val.value);
-                    case 'Buffer':
-                        return Buffer.from(val.value);
-                    default:
-                        return val;
-                }
+            if (val && typeof val === 'object' && val.__type === 'Date') {
+                return new Date(val.value);
             }
             return val;
         });
     }
-    hasComplexTypes(value) {
-        if (value instanceof Date ||
-            value instanceof RegExp ||
-            value instanceof Set ||
-            value instanceof Map) {
-            return true;
-        }
-        if (Buffer.isBuffer(value) || typeof value === 'bigint') {
-            return true;
-        }
-        if (Array.isArray(value)) {
-            return value.some((item) => this.hasComplexTypes(item));
-        }
-        if (value && typeof value === 'object') {
-            return Object.values(value).some((item) => this.hasComplexTypes(item));
-        }
-        return false;
-    }
 };
 exports.CacheSerializationService = CacheSerializationService;
 exports.CacheSerializationService = CacheSerializationService = CacheSerializationService_1 = __decorate([

package/cache/cache.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const CACHE_COMPRESSION_ENABLED: unique symbol;
+export declare const CACHE_COMPRESSION_THRESHOLD: unique symbol;

package/cache/cache.constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CACHE_COMPRESSION_THRESHOLD = exports.CACHE_COMPRESSION_ENABLED = void 0;
+exports.CACHE_COMPRESSION_ENABLED = Symbol('CACHE_COMPRESSION_ENABLED');
+exports.CACHE_COMPRESSION_THRESHOLD = Symbol('CACHE_COMPRESSION_THRESHOLD');

package/cache/cache.module.d.ts

@@ -9,6 +9,8 @@ export interface CacheModuleOptions {
     dataSource?: DataSource;
     memoryTtl?: number;
     memoryNamespace?: string;
+    enableCompression?: boolean;
+    compressionThreshold?: number;
 }
 export declare class CacheModule implements OnModuleInit {
     private readonly cacheService;

package/cache/cache.module.js

@@ -13,16 +13,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheModule = exports.CACHE_SERVICE = void 0;
 const common_1 = require("@nestjs/common");
 const cache_service_1 = require("./cache.service");
+const cache_warmup_service_1 = require("./cache.warmup.service");
+const cache_metrics_service_1 = require("./cache-metrics.service");
+const cache_serialization_service_1 = require("./cache-serialization.service");
 const dependencies_1 = require("./dependencies");
 const decorators_1 = require("./decorators");
 const providers_1 = require("./providers");
+const cache_constants_1 = require("./cache.constants");
 exports.CACHE_SERVICE = Symbol('CACHE_SERVICE');
 let CacheModule = CacheModule_1 = class CacheModule {
     constructor(cacheService) {
         this.cacheService = cacheService;
     }
     static forRoot(options = {}) {
-        const { isGlobal = true, redisClient, dataSource, memoryTtl, memoryNamespace, } = options;
+        const { isGlobal = true, redisClient, dataSource, memoryTtl, memoryNamespace, enableCompression = false, compressionThreshold = 1024, } = options;
         if (dataSource) {
             dependencies_1.DbDependency.setDataSource(dataSource);
         }
@@ -47,13 +51,33 @@ let CacheModule = CacheModule_1 = class CacheModule {
                     ]
                     : []),
                 providers_1.RedisCacheProvider,
+                {
+                    provide: cache_constants_1.CACHE_COMPRESSION_ENABLED,
+                    useValue: enableCompression,
+                },
+                {
+                    provide: cache_constants_1.CACHE_COMPRESSION_THRESHOLD,
+                    useValue: compressionThreshold,
+                },
+                cache_warmup_service_1.CacheWarmupService,
+                cache_metrics_service_1.CacheMetricsService,
+                {
+                    provide: cache_serialization_service_1.CacheSerializationService,
+                    useFactory: () => new cache_serialization_service_1.CacheSerializationService(),
+                },
                 {
                     provide: exports.CACHE_SERVICE,
                     useClass: cache_service_1.CacheService,
                 },
                 cache_service_1.CacheService,
             ],
-            exports: [exports.CACHE_SERVICE, cache_service_1.CacheService],
+            exports: [
+                exports.CACHE_SERVICE,
+                cache_service_1.CacheService,
+                cache_warmup_service_1.CacheWarmupService,
+                cache_metrics_service_1.CacheMetricsService,
+                cache_serialization_service_1.CacheSerializationService,
+            ],
         };
     }
     static forRootAsync(options) {
@@ -88,13 +112,35 @@ let CacheModule = CacheModule_1 = class CacheModule {
                     inject: ['CACHE_MODULE_OPTIONS'],
                 },
                 providers_1.RedisCacheProvider,
+                cache_warmup_service_1.CacheWarmupService,
+                cache_metrics_service_1.CacheMetricsService,
+                {
+                    provide: cache_serialization_service_1.CacheSerializationService,
+                    useFactory: () => new cache_serialization_service_1.CacheSerializationService(),
+                },
+                {
+                    provide: cache_constants_1.CACHE_COMPRESSION_ENABLED,
+                    useFactory: (moduleOptions) => moduleOptions.enableCompression || false,
+                    inject: ['CACHE_MODULE_OPTIONS'],
+                },
+                {
+                    provide: cache_constants_1.CACHE_COMPRESSION_THRESHOLD,
+                    useFactory: (moduleOptions) => moduleOptions.compressionThreshold || 1024,
+                    inject: ['CACHE_MODULE_OPTIONS'],
+                },
                 {
                     provide: exports.CACHE_SERVICE,
                     useClass: cache_service_1.CacheService,
                 },
                 cache_service_1.CacheService,
             ],
-            exports: [exports.CACHE_SERVICE, cache_service_1.CacheService],
+            exports: [
+                exports.CACHE_SERVICE,
+                cache_service_1.CacheService,
+                cache_warmup_service_1.CacheWarmupService,
+                cache_metrics_service_1.CacheMetricsService,
+                cache_serialization_service_1.CacheSerializationService,
+            ],
         };
     }
     onModuleInit() {

package/cache/cache.service.d.ts

@@ -5,10 +5,12 @@ export declare class CacheService {
     private readonly clsProvider;
     private readonly memoryProvider;
     private readonly redisProvider;
+    private readonly enableCompression;
+    private readonly compressionThreshold;
     private readonly logger;
     private readonly providers;
     private readonly stats;
-    constructor(clsProvider: ClsCacheProvider, memoryProvider: MemoryCacheProvider, redisProvider: RedisCacheProvider);
+    constructor(clsProvider: ClsCacheProvider, memoryProvider: MemoryCacheProvider, redisProvider: RedisCacheProvider, enableCompression?: boolean, compressionThreshold?: number);
     getOrSet<T>(key: string, factory: () => Promise<T>, options?: CacheOptions): Promise<T>;
     get<T>(key: string, options?: CacheOptions): Promise<T | null>;
     set<T>(key: string, value: T, options?: CacheOptions | number): Promise<void>;

package/cache/cache.service.js

@@ -8,6 +8,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 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) {
@@ -25,11 +28,15 @@ const dependencies_1 = require("./dependencies");
 const interfaces_1 = require("./interfaces");
 const providers_1 = require("./providers");
 const utils_1 = require("./utils");
+const cache_serialization_service_1 = require("./cache-serialization.service");
+const cache_constants_1 = require("./cache.constants");
 let CacheService = CacheService_1 = class CacheService {
-    constructor(clsProvider, memoryProvider, redisProvider) {
+    constructor(clsProvider, memoryProvider, redisProvider, enableCompression = false, compressionThreshold = 1024) {
         this.clsProvider = clsProvider;
         this.memoryProvider = memoryProvider;
         this.redisProvider = redisProvider;
+        this.enableCompression = enableCompression;
+        this.compressionThreshold = compressionThreshold;
         this.logger = new common_1.Logger(CacheService_1.name);
         this.providers = new Map();
         this.stats = {
@@ -72,8 +79,13 @@ let CacheService = CacheService_1 = class CacheService {
                 try {
                     const wrapped = yield provider.get(fullKey);
                     if (wrapped !== null) {
-                        const value = yield utils_1.DependencyManager.unwrapAndValidate(wrapped, options === null || options === void 0 ? void 0 : options.dependencies);
+                        let value = yield utils_1.DependencyManager.unwrapAndValidate(wrapped, options === null || options === void 0 ? void 0 : options.dependencies);
                         if (value !== null) {
+                            if (this.enableCompression && Buffer.isBuffer(value)) {
+                                const serializationService = new cache_serialization_service_1.CacheSerializationService();
+                                const decompressed = yield serializationService.deserialize(value);
+                                value = decompressed.data;
+                            }
                             this.recordHit(layer);
                             if ((options === null || options === void 0 ? void 0 : options.backfill) !== false && i > 0) {
                                 yield this.backfillUpperLayers(fullKey, wrapped, layers.slice(0, i), options === null || options === void 0 ? void 0 : options.ttl);
@@ -197,7 +209,19 @@ let CacheService = CacheService_1 = class CacheService {
             }
             const layers = this.resolveLayers(options === null || options === void 0 ? void 0 : options.layers);
             const fullKey = this.buildKey(key, options === null || options === void 0 ? void 0 : options.namespace);
-            const wrapped = yield utils_1.DependencyManager.wrapWithDependencies(value, options === null || options === void 0 ? void 0 : options.dependencies);
+            let processedValue = value;
+            if (this.enableCompression &&
+                value !== null &&
+                value !== undefined &&
+                JSON.stringify(value).length >= this.compressionThreshold) {
+                const serializationService = new cache_serialization_service_1.CacheSerializationService();
+                const compressed = yield serializationService.serialize(value, {
+                    compress: true,
+                    compressThreshold: this.compressionThreshold,
+                });
+                processedValue = compressed.data;
+            }
+            const wrapped = yield utils_1.DependencyManager.wrapWithDependencies(processedValue, options === null || options === void 0 ? void 0 : options.dependencies);
             const promises = layers.map((layer) => __awaiter(this, void 0, void 0, function* () {
                 const provider = this.providers.get(layer);
                 if (!provider) {
@@ -274,7 +298,11 @@ let CacheService = CacheService_1 = class CacheService {
 exports.CacheService = CacheService;
 exports.CacheService = CacheService = CacheService_1 = __decorate([
     (0, common_1.Injectable)(),
+    __param(3, (0, common_1.Optional)()),
+    __param(3, (0, common_1.Inject)(cache_constants_1.CACHE_COMPRESSION_ENABLED)),
+    __param(4, (0, common_1.Optional)()),
+    __param(4, (0, common_1.Inject)(cache_constants_1.CACHE_COMPRESSION_THRESHOLD)),
     __metadata("design:paramtypes", [providers_1.ClsCacheProvider,
         providers_1.MemoryCacheProvider,
-        providers_1.RedisCacheProvider])
+        providers_1.RedisCacheProvider, Boolean, Number])
 ], CacheService);

package/cache/examples/basic-usage.d.ts

@@ -0,0 +1,58 @@
+import { CacheService } from '../index';
+interface User {
+    id: string;
+    name: string;
+    email: string;
+    profile: {
+        bio: string;
+        avatar: string;
+    };
+}
+interface Post {
+    id: string;
+    title: string;
+    content: string;
+    authorId: string;
+    createdAt: Date;
+}
+declare class UserRepository {
+    findOne(id: string): Promise<User>;
+    findMany(ids: string[]): Promise<User[]>;
+    findAll(): Promise<User[]>;
+    save(user: Partial<User>): Promise<User>;
+    delete(id: string): Promise<void>;
+}
+declare class PostRepository {
+    findByAuthor(authorId: string): Promise<Post[]>;
+}
+export declare class UserService {
+    private cacheService;
+    private userRepository;
+    constructor(cacheService: CacheService, userRepository: UserRepository);
+    getUser(id: string): Promise<User>;
+    getUserProfile(id: string): Promise<User>;
+    getUserData(id: string): Promise<User>;
+    getUsersBatch(ids: string[]): Promise<User[]>;
+    updateUser(id: string, data: Partial<User>): Promise<User>;
+    deleteUser(id: string): Promise<void>;
+    invalidateAllProfiles(): Promise<void>;
+    cacheLargeData(id: string): Promise<void>;
+    getLargeData(id: string): Promise<any>;
+}
+export declare class PostService {
+    private cacheService;
+    private postRepository;
+    constructor(cacheService: CacheService, postRepository: PostRepository);
+    getPostsByAuthor(authorId: string): Promise<Post[]>;
+    getFeaturedPosts(): Promise<Post[]>;
+    private getConfigVersion;
+}
+export declare class CacheMonitoringService {
+    private cacheService;
+    constructor(cacheService: CacheService);
+    getCacheStats(): import("../index").CacheStats;
+    resetStats(): void;
+    startMonitoring(intervalMs?: number): void;
+}
+declare function demonstrateCacheUsage(): Promise<void>;
+export { demonstrateCacheUsage };