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

package/cache/cache.warmup.service.js

@@ -0,0 +1,199 @@
+"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 CacheWarmupService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheWarmupService = void 0;
+const common_1 = require("@nestjs/common");
+const cache_service_1 = require("./cache.service");
+let CacheWarmupService = CacheWarmupService_1 = class CacheWarmupService {
+    constructor(cacheService) {
+        this.cacheService = cacheService;
+        this.logger = new common_1.Logger(CacheWarmupService_1.name);
+        this.warmupConfigs = new Map();
+    }
+    registerWarmup(groupName, configs) {
+        this.warmupConfigs.set(groupName, configs);
+        this.logger.debug(`Registered ${configs.length} warmup tasks for group: ${groupName}`);
+    }
+    warmupGroup(groupName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const configs = this.warmupConfigs.get(groupName);
+            if (!configs || configs.length === 0) {
+                this.logger.warn(`No warmup configurations found for group: ${groupName}`);
+                return [];
+            }
+            this.logger.log(`Starting cache warmup for group: ${groupName}`);
+            const startTime = Date.now();
+            const results = [];
+            for (const config of configs) {
+                const result = yield this.executeWarmupTask(config);
+                results.push(result);
+                if (config.critical && !result.success) {
+                    this.logger.error(`Critical warmup task failed: ${config.name}`);
+                    throw new Error(`Critical warmup task failed: ${config.name}`);
+                }
+            }
+            const duration = Date.now() - startTime;
+            const successCount = results.filter((r) => r.success).length;
+            this.logger.log(`Warmup completed for group: ${groupName}. ` +
+                `Success: ${successCount}/${results.length}, Duration: ${duration}ms`);
+            return results;
+        });
+    }
+    warmupAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = new Map();
+            for (const groupName of this.warmupConfigs.keys()) {
+                try {
+                    const groupResults = yield this.warmupGroup(groupName);
+                    results.set(groupName, groupResults);
+                }
+                catch (error) {
+                    this.logger.error(`Failed to warm up group ${groupName}:`, error);
+                    results.set(groupName, [
+                        {
+                            name: groupName,
+                            success: false,
+                            itemCount: 0,
+                            duration: 0,
+                            errors: [error instanceof Error ? error.message : String(error)],
+                        },
+                    ]);
+                }
+            }
+            return results;
+        });
+    }
+    getWarmupStats() {
+        const totalGroups = this.warmupConfigs.size;
+        let totalTasks = 0;
+        const taskDetails = [];
+        for (const [groupName, configs] of this.warmupConfigs) {
+            for (const config of configs) {
+                totalTasks++;
+                taskDetails.push({
+                    group: groupName,
+                    name: config.name,
+                    critical: config.critical || false,
+                    batchSize: config.batchSize,
+                });
+            }
+        }
+        return { totalGroups, totalTasks, taskDetails };
+    }
+    removeWarmupGroup(groupName) {
+        return this.warmupConfigs.delete(groupName);
+    }
+    clearWarmupConfigs() {
+        this.warmupConfigs.clear();
+        this.logger.debug('All warmup configurations cleared');
+    }
+    executeWarmupTask(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            const errors = [];
+            let itemCount = 0;
+            let success = true;
+            try {
+                this.logger.debug(`Executing warmup task: ${config.name}`);
+                const data = yield Promise.resolve(config.dataProvider());
+                if (Array.isArray(data)) {
+                    const batchSize = config.batchSize || 100;
+                    itemCount = data.length;
+                    for (let i = 0; i < data.length; i += batchSize) {
+                        const batch = data.slice(i, i + batchSize);
+                        yield Promise.all(batch.map((item) => __awaiter(this, void 0, void 0, function* () {
+                            try {
+                                const key = typeof config.key === 'function'
+                                    ? config.key(item)
+                                    : config.key;
+                                yield this.cacheService.set(key, item, {
+                                    ttl: config.ttl,
+                                    layers: config.layers,
+                                });
+                            }
+                            catch (error) {
+                                errors.push(`Failed to cache item: ${error instanceof Error ? error.message : String(error)}`);
+                            }
+                        })));
+                    }
+                }
+                else if (data && typeof data === 'object') {
+                    if (data instanceof Map) {
+                        itemCount = data.size;
+                        for (const [key, value] of data) {
+                            try {
+                                yield this.cacheService.set(key, value, {
+                                    ttl: config.ttl,
+                                    layers: config.layers,
+                                });
+                            }
+                            catch (error) {
+                                errors.push(`Failed to cache key ${key}: ${error instanceof Error ? error.message : String(error)}`);
+                            }
+                        }
+                    }
+                    else {
+                        itemCount = 1;
+                        const key = typeof config.key === 'function' ? config.key(data) : config.key;
+                        yield this.cacheService.set(key, data, {
+                            ttl: config.ttl,
+                            layers: config.layers,
+                        });
+                    }
+                }
+                else if (data !== null && data !== undefined) {
+                    itemCount = 1;
+                    const key = typeof config.key === 'function' ? config.key(data) : config.key;
+                    yield this.cacheService.set(key, data, {
+                        ttl: config.ttl,
+                        layers: config.layers,
+                    });
+                }
+                else {
+                    errors.push('Data provider returned null or undefined');
+                    success = false;
+                }
+                if (errors.length > 0) {
+                    success = false;
+                    this.logger.warn(`Warmup task ${config.name} completed with ${errors.length} errors`);
+                }
+            }
+            catch (error) {
+                success = false;
+                errors.push(error instanceof Error ? error.message : String(error));
+                this.logger.error(`Warmup task ${config.name} failed:`, error);
+            }
+            const duration = Date.now() - startTime;
+            return {
+                name: config.name,
+                success,
+                itemCount,
+                duration,
+                errors,
+            };
+        });
+    }
+};
+exports.CacheWarmupService = CacheWarmupService;
+exports.CacheWarmupService = CacheWarmupService = CacheWarmupService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [cache_service_1.CacheService])
+], CacheWarmupService);

package/cache/decorators/cache-evict.decorator.d.ts

@@ -0,0 +1,2 @@
+import type { CacheEvictOptions } from '../interfaces';
+export declare function CacheEvict(options?: CacheEvictOptions): MethodDecorator;

package/cache/decorators/cache-evict.decorator.js

@@ -0,0 +1,72 @@
+"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.CacheEvict = CacheEvict;
+const common_1 = require("@nestjs/common");
+const cacheable_decorator_1 = require("./cacheable.decorator");
+function CacheEvict(options = {}) {
+    const logger = new common_1.Logger('CacheEvictDecorator');
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const methodName = String(propertyKey);
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const cacheService = (0, cacheable_decorator_1.getCacheService)();
+                if (!cacheService) {
+                    logger.warn(`CacheService not initialized. Skipping cache eviction for ${target.constructor.name}.${methodName}`);
+                    return originalMethod.apply(this, args);
+                }
+                const evictCache = (result) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        if (options.condition) {
+                            const shouldEvict = yield Promise.resolve(options.condition(...args, result));
+                            if (!shouldEvict) {
+                                return;
+                            }
+                        }
+                        if (options.keys && options.keys.length > 0) {
+                            const resolvedKeys = options.keys.map((keyOrFn) => typeof keyOrFn === 'function' ? keyOrFn(...args) : keyOrFn);
+                            yield cacheService.delete(resolvedKeys, options.layers);
+                        }
+                        if (options.patterns && options.patterns.length > 0) {
+                            for (const pattern of options.patterns) {
+                                yield cacheService.deletePattern(pattern, options.layers);
+                            }
+                        }
+                        if (options.tags && options.tags.length > 0) {
+                            yield cacheService.invalidateTags(options.tags);
+                        }
+                    }
+                    catch (error) {
+                        logger.error(`Cache eviction error in ${target.constructor.name}.${methodName}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                });
+                try {
+                    if (options.timing === 'before') {
+                        yield evictCache();
+                    }
+                    const result = yield originalMethod.apply(this, args);
+                    if (options.timing !== 'before') {
+                        yield evictCache(result);
+                    }
+                    return result;
+                }
+                catch (error) {
+                    if (options.timing === 'before') {
+                        throw error;
+                    }
+                    throw error;
+                }
+            });
+        };
+        return descriptor;
+    };
+}

package/cache/decorators/cache-put.decorator.d.ts

@@ -0,0 +1,2 @@
+import type { CachePutOptions } from '../interfaces';
+export declare function CachePut(options?: CachePutOptions): MethodDecorator;

package/cache/decorators/cache-put.decorator.js

@@ -0,0 +1,48 @@
+"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.CachePut = CachePut;
+const common_1 = require("@nestjs/common");
+const utils_1 = require("../utils");
+const cacheable_decorator_1 = require("./cacheable.decorator");
+function CachePut(options = {}) {
+    const logger = new common_1.Logger('CachePutDecorator');
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const methodName = String(propertyKey);
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const cacheService = (0, cacheable_decorator_1.getCacheService)();
+                if (!cacheService) {
+                    logger.warn(`CacheService not initialized. Skipping cache put for ${target.constructor.name}.${methodName}`);
+                    return originalMethod.apply(this, args);
+                }
+                try {
+                    const result = yield originalMethod.apply(this, args);
+                    if (options.condition) {
+                        const shouldCache = yield Promise.resolve(options.condition(...args));
+                        if (!shouldCache) {
+                            return result;
+                        }
+                    }
+                    const key = utils_1.KeyGenerator.generate(options, args);
+                    yield cacheService.set(key, result, options);
+                    return result;
+                }
+                catch (error) {
+                    logger.error(`Cache put error in ${target.constructor.name}.${methodName}: ${error instanceof Error ? error.message : String(error)}`);
+                    throw error;
+                }
+            });
+        };
+        return descriptor;
+    };
+}

package/cache/decorators/cacheable.decorator.d.ts

@@ -0,0 +1,4 @@
+import type { CacheableOptions } from '../interfaces';
+export declare function setCacheService(cacheService: any): void;
+export declare function getCacheService(): any;
+export declare function Cacheable(options?: CacheableOptions): MethodDecorator;

package/cache/decorators/cacheable.decorator.js

@@ -0,0 +1,68 @@
+"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.setCacheService = setCacheService;
+exports.getCacheService = getCacheService;
+exports.Cacheable = Cacheable;
+const common_1 = require("@nestjs/common");
+const utils_1 = require("../utils");
+let globalCacheService = null;
+function setCacheService(cacheService) {
+    globalCacheService = cacheService;
+}
+function getCacheService() {
+    return globalCacheService;
+}
+function Cacheable(options = {}) {
+    const logger = new common_1.Logger('CacheableDecorator');
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const methodName = String(propertyKey);
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const cacheService = getCacheService();
+                if (!cacheService) {
+                    logger.warn(`CacheService not initialized. Skipping cache for ${target.constructor.name}.${methodName}`);
+                    return originalMethod.apply(this, args);
+                }
+                try {
+                    const key = utils_1.KeyGenerator.generate(options, args);
+                    if (options.condition) {
+                        const shouldCache = yield Promise.resolve(options.condition(...args));
+                        if (!shouldCache) {
+                            return originalMethod.apply(this, args);
+                        }
+                    }
+                    const dependencies = options.dependencies
+                        ? yield resolveDependenciesWithContext(options.dependencies, args)
+                        : undefined;
+                    return yield cacheService.getOrSet(key, () => originalMethod.apply(this, args), Object.assign(Object.assign({}, options), { dependencies }));
+                }
+                catch (error) {
+                    logger.error(`Cache error in ${target.constructor.name}.${methodName}: ${error instanceof Error ? error.message : String(error)}`);
+                    return originalMethod.apply(this, args);
+                }
+            });
+        };
+        return descriptor;
+    };
+}
+function resolveDependenciesWithContext(dependencies, args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return dependencies.map((dep) => {
+            if (dep.paramsFactory && typeof dep.paramsFactory === 'function') {
+                const params = dep.paramsFactory(...args);
+                return new dep.constructor(dep.sql, () => params, dep.name);
+            }
+            return dep;
+        });
+    });
+}

package/cache/decorators/index.d.ts

@@ -0,0 +1,3 @@
+export { Cacheable, getCacheService, setCacheService, } from './cacheable.decorator';
+export { CacheEvict } from './cache-evict.decorator';
+export { CachePut } from './cache-put.decorator';

package/cache/decorators/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachePut = exports.CacheEvict = exports.setCacheService = exports.getCacheService = exports.Cacheable = void 0;
+var cacheable_decorator_1 = require("./cacheable.decorator");
+Object.defineProperty(exports, "Cacheable", { enumerable: true, get: function () { return cacheable_decorator_1.Cacheable; } });
+Object.defineProperty(exports, "getCacheService", { enumerable: true, get: function () { return cacheable_decorator_1.getCacheService; } });
+Object.defineProperty(exports, "setCacheService", { enumerable: true, get: function () { return cacheable_decorator_1.setCacheService; } });
+var cache_evict_decorator_1 = require("./cache-evict.decorator");
+Object.defineProperty(exports, "CacheEvict", { enumerable: true, get: function () { return cache_evict_decorator_1.CacheEvict; } });
+var cache_put_decorator_1 = require("./cache-put.decorator");
+Object.defineProperty(exports, "CachePut", { enumerable: true, get: function () { return cache_put_decorator_1.CachePut; } });

package/cache/dependencies/callback.dependency.d.ts

@@ -0,0 +1,11 @@
+import type { CacheDependency } from '../interfaces/cache-dependency.interface';
+export declare class CallbackDependency implements CacheDependency {
+    private readonly callback;
+    private readonly name?;
+    constructor(callback: () => Promise<any> | any, name?: string);
+    getKey(): string;
+    getData(): Promise<any>;
+    isChanged(oldData: any): Promise<boolean>;
+    private isEqual;
+    private hashCode;
+}

package/cache/dependencies/callback.dependency.js

@@ -0,0 +1,92 @@
+"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.CallbackDependency = void 0;
+class CallbackDependency {
+    constructor(callback, name) {
+        this.callback = callback;
+        this.name = name;
+        if (typeof callback !== 'function') {
+            throw new Error('CallbackDependency requires a valid callback function');
+        }
+    }
+    getKey() {
+        const callbackName = this.name || this.callback.name || 'anonymous';
+        return `callback:${callbackName}:${this.hashCode(this.callback.toString())}`;
+    }
+    getData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield Promise.resolve(this.callback());
+            }
+            catch (error) {
+                throw new Error(`CallbackDependency getData failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    isChanged(oldData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const currentData = yield this.getData();
+                return !this.isEqual(oldData, currentData);
+            }
+            catch (_a) {
+                return true;
+            }
+        });
+    }
+    isEqual(a, b) {
+        if (a === b) {
+            return true;
+        }
+        if (a == null || b == null) {
+            return a === b;
+        }
+        if (typeof a !== typeof b) {
+            return false;
+        }
+        if (typeof a !== 'object') {
+            return a === b;
+        }
+        if (Array.isArray(a) && Array.isArray(b)) {
+            if (a.length !== b.length) {
+                return false;
+            }
+            for (let i = 0; i < a.length; i++) {
+                if (!this.isEqual(a[i], b[i])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        const keysA = Object.keys(a);
+        const keysB = Object.keys(b);
+        if (keysA.length !== keysB.length) {
+            return false;
+        }
+        for (const key of keysA) {
+            if (!keysB.includes(key) || !this.isEqual(a[key], b[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    hashCode(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash;
+        }
+        return Math.abs(hash).toString(36);
+    }
+}
+exports.CallbackDependency = CallbackDependency;

package/cache/dependencies/chain.dependency.d.ts

@@ -0,0 +1,20 @@
+import type { CacheDependency } from '../interfaces/cache-dependency.interface';
+export declare class ChainDependency implements CacheDependency {
+    private readonly dependencies;
+    constructor(dependencies: CacheDependency[]);
+    getKey(): string;
+    getData(): Promise<Array<{
+        key: string;
+        data: any;
+    }>>;
+    isChanged(oldData: Array<{
+        key: string;
+        data: any;
+    }>): Promise<boolean>;
+    reset(): Promise<void>;
+    getDependencies(): CacheDependency[];
+    getChangedDependencies(oldData: Array<{
+        key: string;
+        data: any;
+    }>): Promise<CacheDependency[]>;
+}

package/cache/dependencies/chain.dependency.js

@@ -0,0 +1,113 @@
+"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.ChainDependency = void 0;
+class ChainDependency {
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+        if (!Array.isArray(dependencies) || dependencies.length === 0) {
+            throw new Error('ChainDependency requires at least one dependency');
+        }
+        for (const dep of dependencies) {
+            if (!dep.getKey || !dep.getData || !dep.isChanged) {
+                throw new Error('All dependencies must implement CacheDependency interface');
+            }
+        }
+    }
+    getKey() {
+        const keys = this.dependencies.map((dep) => dep.getKey());
+        return `chain:${keys.join('+')}`;
+    }
+    getData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = [];
+            for (const dep of this.dependencies) {
+                try {
+                    const data = yield dep.getData();
+                    results.push({
+                        key: dep.getKey(),
+                        data,
+                    });
+                }
+                catch (error) {
+                    results.push({
+                        key: dep.getKey(),
+                        data: {
+                            error: error instanceof Error ? error.message : String(error),
+                        },
+                    });
+                }
+            }
+            return results;
+        });
+    }
+    isChanged(oldData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!Array.isArray(oldData) ||
+                oldData.length !== this.dependencies.length) {
+                return true;
+            }
+            for (let i = 0; i < this.dependencies.length; i++) {
+                const dep = this.dependencies[i];
+                const oldDepData = oldData[i];
+                if (oldDepData.key !== dep.getKey()) {
+                    return true;
+                }
+                try {
+                    const changed = yield dep.isChanged(oldDepData.data);
+                    if (changed) {
+                        return true;
+                    }
+                }
+                catch (_a) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    reset() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const dep of this.dependencies) {
+                if (dep.reset) {
+                    yield dep.reset();
+                }
+            }
+        });
+    }
+    getDependencies() {
+        return [...this.dependencies];
+    }
+    getChangedDependencies(oldData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!Array.isArray(oldData) ||
+                oldData.length !== this.dependencies.length) {
+                return this.dependencies;
+            }
+            const changed = [];
+            for (let i = 0; i < this.dependencies.length; i++) {
+                const dep = this.dependencies[i];
+                const oldDepData = oldData[i];
+                try {
+                    if (oldDepData.key !== dep.getKey() ||
+                        (yield dep.isChanged(oldDepData.data))) {
+                        changed.push(dep);
+                    }
+                }
+                catch (_a) {
+                    changed.push(dep);
+                }
+            }
+            return changed;
+        });
+    }
+}
+exports.ChainDependency = ChainDependency;