@nest-omni/core 3.1.1-12 → 3.1.1-13

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

@@ -0,0 +1,140 @@
+"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.ClsCacheProvider = void 0;
+const nestjs_cls_1 = require("nestjs-cls");
+const base_cache_provider_1 = require("./base-cache.provider");
+class ClsCacheProvider extends base_cache_provider_1.BaseCacheProvider {
+    getName() {
+        return 'CLS';
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const store = nestjs_cls_1.ClsServiceManager.getClsService();
+                const fullKey = this.getFullKey(key);
+                const cached = store.get(fullKey);
+                if (!cached) {
+                    return null;
+                }
+                if (cached.expiresAt && Date.now() > cached.expiresAt) {
+                    yield this.delete(key);
+                    return null;
+                }
+                return cached.value;
+            }
+            catch (_a) {
+                return null;
+            }
+        });
+    }
+    set(key, value, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const store = nestjs_cls_1.ClsServiceManager.getClsService();
+                const fullKey = this.getFullKey(key);
+                const cached = { value };
+                if (ttl && ttl > 0) {
+                    cached.expiresAt = Date.now() + ttl;
+                }
+                store.set(fullKey, cached);
+                this.addKeyToSet(key);
+            }
+            catch (_a) {
+            }
+        });
+    }
+    delete(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const store = nestjs_cls_1.ClsServiceManager.getClsService();
+                const keys = Array.isArray(key) ? key : [key];
+                for (const k of keys) {
+                    const fullKey = this.getFullKey(k);
+                    store.set(fullKey, undefined);
+                    this.removeKeyFromSet(k);
+                }
+            }
+            catch (_a) {
+            }
+        });
+    }
+    deletePattern(pattern) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const allKeys = this.getAllKeys();
+                const regex = this.patternToRegex(pattern);
+                const matchedKeys = allKeys.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 {
+                const allKeys = this.getAllKeys();
+                yield this.delete(allKeys);
+            }
+            catch (_a) {
+            }
+        });
+    }
+    has(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const value = yield this.get(key);
+            return value !== null;
+        });
+    }
+    getFullKey(key) {
+        return `${ClsCacheProvider.CACHE_PREFIX}${key}`;
+    }
+    addKeyToSet(key) {
+        try {
+            const store = nestjs_cls_1.ClsServiceManager.getClsService();
+            const keys = store.get(ClsCacheProvider.KEYS_SET) || new Set();
+            keys.add(key);
+            store.set(ClsCacheProvider.KEYS_SET, keys);
+        }
+        catch (_a) {
+        }
+    }
+    removeKeyFromSet(key) {
+        try {
+            const store = nestjs_cls_1.ClsServiceManager.getClsService();
+            const keys = store.get(ClsCacheProvider.KEYS_SET);
+            if (keys) {
+                keys.delete(key);
+                store.set(ClsCacheProvider.KEYS_SET, keys);
+            }
+        }
+        catch (_a) {
+        }
+    }
+    getAllKeys() {
+        try {
+            const store = nestjs_cls_1.ClsServiceManager.getClsService();
+            const keys = store.get(ClsCacheProvider.KEYS_SET);
+            return keys ? Array.from(keys) : [];
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+}
+exports.ClsCacheProvider = ClsCacheProvider;
+ClsCacheProvider.CACHE_PREFIX = 'cache:cls:';
+ClsCacheProvider.KEYS_SET = 'cache:cls:keys';

package/cache/providers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './base-cache.provider';
+export * from './cls-cache.provider';
+export * from './memory-cache.provider';
+export { REDIS_CLIENT, RedisCacheProvider } from './redis-cache.provider';

package/cache/providers/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisCacheProvider = exports.REDIS_CLIENT = void 0;
+__exportStar(require("./base-cache.provider"), exports);
+__exportStar(require("./cls-cache.provider"), exports);
+__exportStar(require("./memory-cache.provider"), exports);
+var redis_cache_provider_1 = require("./redis-cache.provider");
+Object.defineProperty(exports, "REDIS_CLIENT", { enumerable: true, get: function () { return redis_cache_provider_1.REDIS_CLIENT; } });
+Object.defineProperty(exports, "RedisCacheProvider", { enumerable: true, get: function () { return redis_cache_provider_1.RedisCacheProvider; } });

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

@@ -0,0 +1,23 @@
+import { BaseCacheProvider } from './base-cache.provider';
+export declare class MemoryCacheProvider extends BaseCacheProvider {
+    private keyv;
+    private keys;
+    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>;
+    getAllKeys(): string[];
+    getSize(): number;
+    mget<T>(keys: string[]): Promise<(T | null)[]>;
+    mset(items: Array<{
+        key: string;
+        value: any;
+    }>, ttl?: number): Promise<void>;
+}

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

@@ -0,0 +1,130 @@
+"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 keyv_1 = require("keyv");
+const base_cache_provider_1 = require("./base-cache.provider");
+class MemoryCacheProvider extends base_cache_provider_1.BaseCacheProvider {
+    constructor(options) {
+        super();
+        this.keys = new Set();
+        this.keyv = new keyv_1.default({
+            store: new Map(),
+            ttl: options === null || options === void 0 ? void 0 : options.ttl,
+            namespace: (options === null || options === void 0 ? void 0 : options.namespace) || 'cache:memory',
+        });
+        this.keyv.on('set', (key) => {
+            this.keys.add(key);
+        });
+        this.keyv.on('delete', (key) => {
+            this.keys.delete(key);
+        });
+        this.keyv.on('clear', () => {
+            this.keys.clear();
+        });
+    }
+    getName() {
+        return 'Memory';
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const value = yield this.keyv.get(key);
+                return value !== null && value !== void 0 ? value : null;
+            }
+            catch (_a) {
+                return null;
+            }
+        });
+    }
+    set(key, value, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.keyv.set(key, value, ttl);
+            }
+            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)) {
+                    const promises = key.map((k) => this.keyv.delete(k));
+                    yield Promise.all(promises);
+                }
+                else {
+                    yield this.keyv.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 {
+                yield this.keyv.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 value = yield this.keyv.get(key);
+                return value !== undefined;
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+    }
+    getAllKeys() {
+        return Array.from(this.keys);
+    }
+    getSize() {
+        return this.keys.size;
+    }
+    mget(keys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = keys.map((key) => this.get(key));
+            return Promise.all(promises);
+        });
+    }
+    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/cache/providers/redis-cache.provider.d.ts

@@ -0,0 +1,23 @@
+import type Redis from 'ioredis';
+import { BaseCacheProvider } from './base-cache.provider';
+export declare const REDIS_CLIENT: unique symbol;
+export declare class RedisCacheProvider extends BaseCacheProvider {
+    private readonly redis?;
+    private readonly keyPrefix;
+    constructor(redis?: Redis);
+    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>;
+    mget<T>(keys: string[]): Promise<(T | null)[]>;
+    mset(items: Array<{
+        key: string;
+        value: any;
+    }>, ttl?: number): Promise<void>;
+    isAvailable(): boolean;
+    getClient(): Redis | undefined;
+    private getFullKey;
+}

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

@@ -0,0 +1,215 @@
+"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 __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) {
+        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.RedisCacheProvider = exports.REDIS_CLIENT = void 0;
+const common_1 = require("@nestjs/common");
+const base_cache_provider_1 = require("./base-cache.provider");
+exports.REDIS_CLIENT = Symbol('REDIS_CLIENT');
+let RedisCacheProvider = class RedisCacheProvider extends base_cache_provider_1.BaseCacheProvider {
+    constructor(redis) {
+        super();
+        this.redis = redis;
+        this.keyPrefix = 'cache:';
+        if (!redis) {
+            console.warn('RedisCacheProvider: Redis client not injected. Redis caching will be disabled.');
+        }
+    }
+    getName() {
+        return 'Redis';
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redis) {
+                return null;
+            }
+            try {
+                const fullKey = this.getFullKey(key);
+                const value = yield this.redis.get(fullKey);
+                if (!value) {
+                    return null;
+                }
+                return JSON.parse(value);
+            }
+            catch (error) {
+                console.warn(`RedisCacheProvider: Failed to get key ${key}: ${error instanceof Error ? error.message : String(error)}`);
+                return null;
+            }
+        });
+    }
+    set(key, value, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redis) {
+                return;
+            }
+            try {
+                const fullKey = this.getFullKey(key);
+                const serialized = JSON.stringify(value);
+                if (ttl && ttl > 0) {
+                    yield this.redis.setex(fullKey, Math.ceil(ttl / 1000), serialized);
+                }
+                else {
+                    yield this.redis.set(fullKey, serialized);
+                }
+            }
+            catch (error) {
+                throw new Error(`RedisCacheProvider: Failed to set key ${key}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    delete(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redis) {
+                return;
+            }
+            try {
+                const keys = Array.isArray(key) ? key : [key];
+                const fullKeys = keys.map((k) => this.getFullKey(k));
+                if (fullKeys.length > 0) {
+                    yield this.redis.del(...fullKeys);
+                }
+            }
+            catch (error) {
+                throw new Error(`RedisCacheProvider: Failed to delete key(s): ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    deletePattern(pattern) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redis) {
+                return 0;
+            }
+            try {
+                const fullPattern = this.getFullKey(pattern);
+                let cursor = '0';
+                let deletedCount = 0;
+                do {
+                    const [nextCursor, keys] = yield this.redis.scan(cursor, 'MATCH', fullPattern, 'COUNT', 100);
+                    cursor = nextCursor;
+                    if (keys.length > 0) {
+                        yield this.redis.del(...keys);
+                        deletedCount += keys.length;
+                    }
+                } while (cursor !== '0');
+                return deletedCount;
+            }
+            catch (error) {
+                console.warn(`RedisCacheProvider: deletePattern failed: ${error instanceof Error ? error.message : String(error)}`);
+                return 0;
+            }
+        });
+    }
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redis) {
+                return;
+            }
+            try {
+                yield this.deletePattern('*');
+            }
+            catch (error) {
+                throw new Error(`RedisCacheProvider: Failed to clear cache: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    has(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redis) {
+                return false;
+            }
+            try {
+                const fullKey = this.getFullKey(key);
+                const exists = yield this.redis.exists(fullKey);
+                return exists === 1;
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+    }
+    mget(keys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redis || keys.length === 0) {
+                return keys.map(() => null);
+            }
+            try {
+                const fullKeys = keys.map((k) => this.getFullKey(k));
+                const values = yield this.redis.mget(...fullKeys);
+                return values.map((value) => {
+                    if (!value) {
+                        return null;
+                    }
+                    try {
+                        return JSON.parse(value);
+                    }
+                    catch (_a) {
+                        return null;
+                    }
+                });
+            }
+            catch (error) {
+                console.warn(`RedisCacheProvider: mget failed: ${error instanceof Error ? error.message : String(error)}`);
+                return keys.map(() => null);
+            }
+        });
+    }
+    mset(items, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redis || items.length === 0) {
+                return;
+            }
+            try {
+                const pipeline = this.redis.pipeline();
+                for (const item of items) {
+                    const fullKey = this.getFullKey(item.key);
+                    const serialized = JSON.stringify(item.value);
+                    if (ttl && ttl > 0) {
+                        pipeline.setex(fullKey, Math.ceil(ttl / 1000), serialized);
+                    }
+                    else {
+                        pipeline.set(fullKey, serialized);
+                    }
+                }
+                yield pipeline.exec();
+            }
+            catch (error) {
+                throw new Error(`RedisCacheProvider: mset failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    isAvailable() {
+        return !!this.redis && this.redis.status === 'ready';
+    }
+    getClient() {
+        return this.redis;
+    }
+    getFullKey(key) {
+        return `${this.keyPrefix}${key}`;
+    }
+};
+exports.RedisCacheProvider = RedisCacheProvider;
+exports.RedisCacheProvider = RedisCacheProvider = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)(exports.REDIS_CLIENT)),
+    __metadata("design:paramtypes", [Function])
+], RedisCacheProvider);

package/cache/utils/dependency-manager.util.d.ts

@@ -0,0 +1,15 @@
+import type { CacheDependency, DependencyData } from '../interfaces';
+export interface CachedValueWithDependencies<T> {
+    value: T;
+    dependencies?: DependencyData[];
+    cachedAt: number;
+}
+export declare class DependencyManager {
+    static wrapWithDependencies<T>(value: T, dependencies?: CacheDependency[]): Promise<CachedValueWithDependencies<T>>;
+    static captureDependencies(dependencies: CacheDependency[]): Promise<DependencyData[]>;
+    static areDependenciesChanged(dependencies: CacheDependency[], cachedDependencies?: DependencyData[]): Promise<boolean>;
+    static unwrapAndValidate<T>(wrapped: CachedValueWithDependencies<T> | null, dependencies?: CacheDependency[]): Promise<T | null>;
+    static getChangedDependencies(dependencies: CacheDependency[], cachedDependencies?: DependencyData[]): Promise<string[]>;
+    static serializeDependencies(dependencies: DependencyData[]): string;
+    static deserializeDependencies(serialized: string): DependencyData[];
+}