snow-flow 3.0.8 → 3.0.10

package/dist/api/performance-optimizer.js

@@ -1,706 +0,0 @@
-"use strict";
-/**
- * Performance Optimization and Caching Strategy
- * Advanced caching and performance optimization for ServiceNow API calls
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PerformanceOptimizer = void 0;
-const logger_js_1 = require("../utils/logger.js");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
-class PerformanceOptimizer {
-    constructor(client, config) {
-        this.cache = new Map();
-        this.batchQueue = new Map();
-        this.rateLimiter = new Map();
-        this.connectionPool = new Map();
-        this.client = client;
-        this.logger = new logger_js_1.Logger('PerformanceOptimizer');
-        this.config = {
-            max_size: 1000,
-            default_ttl: 300000, // 5 minutes
-            cleanup_interval: 60000, // 1 minute
-            persistence_enabled: true,
-            compression_enabled: true,
-            ...config
-        };
-        this.metrics = {
-            cache_hit_rate: 0,
-            cache_miss_rate: 0,
-            average_response_time: 0,
-            api_call_count: 0,
-            cache_size: 0,
-            memory_usage: 0,
-            bandwidth_saved: 0
-        };
-        this.startCleanupTimer();
-        this.loadPersistedCache();
-    }
-    /**
-     * Optimized API call with caching and performance monitoring
-     */
-    async optimizedAPICall(request) {
-        const startTime = Date.now();
-        const cacheKey = request.cache_key || this.generateCacheKey(request);
-        // Check cache first
-        if (request.cacheable) {
-            const cached = this.getFromCache(cacheKey);
-            if (cached) {
-                const responseTime = Date.now() - startTime;
-                this.updateMetrics(true, responseTime);
-                return {
-                    success: true,
-                    data: cached,
-                    cached: true,
-                    response_time: responseTime,
-                    cache_hit: true
-                };
-            }
-        }
-        // Apply rate limiting
-        if (this.isRateLimited(request.url)) {
-            await this.waitForRateLimit(request.url);
-        }
-        try {
-            // Execute API call
-            const response = await this.executeAPICall(request);
-            const responseTime = Date.now() - startTime;
-            // Cache successful responses
-            if (request.cacheable && response.success && response.data) {
-                this.setInCache(cacheKey, response.data, {
-                    ttl: this.getTTLForRequest(request),
-                    tags: this.getTagsForRequest(request)
-                });
-            }
-            this.updateMetrics(false, responseTime);
-            return {
-                ...response,
-                cached: false,
-                response_time: responseTime,
-                cache_hit: false
-            };
-        }
-        catch (error) {
-            const responseTime = Date.now() - startTime;
-            this.updateMetrics(false, responseTime);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                cached: false,
-                response_time: responseTime,
-                cache_hit: false
-            };
-        }
-    }
-    /**
-     * Batch multiple API requests for better performance
-     */
-    async batchAPIRequests(requests) {
-        const batchId = `batch_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        const batchRequest = {
-            id: batchId,
-            requests: requests.sort((a, b) => b.priority - a.priority),
-            priority: 'medium',
-            timeout: 30000,
-            retry_count: 0
-        };
-        this.batchQueue.set(batchId, batchRequest);
-        try {
-            // Group requests by type for optimization
-            const groupedRequests = this.groupRequestsByType(requests);
-            const results = [];
-            // Execute groups in parallel
-            const groupPromises = Object.entries(groupedRequests).map(async ([type, groupRequests]) => {
-                return await this.executeBatchGroup(groupRequests, type);
-            });
-            const groupResults = await Promise.all(groupPromises);
-            // Flatten results
-            for (const groupResult of groupResults) {
-                results.push(...groupResult);
-            }
-            return results;
-        }
-        finally {
-            this.batchQueue.delete(batchId);
-        }
-    }
-    /**
-     * Preload commonly accessed data
-     */
-    async preloadData(preloadConfig) {
-        const preloadTasks = [];
-        if (preloadConfig.action_types) {
-            preloadTasks.push(this.preloadActionTypes());
-        }
-        if (preloadConfig.trigger_types) {
-            preloadTasks.push(this.preloadTriggerTypes());
-        }
-        if (preloadConfig.flow_templates) {
-            preloadTasks.push(this.preloadFlowTemplates());
-        }
-        if (preloadConfig.user_preferences) {
-            preloadTasks.push(this.preloadUserPreferences());
-        }
-        await Promise.all(preloadTasks);
-        this.logger.info('Data preloading completed');
-    }
-    /**
-     * Analyze performance and provide optimization suggestions
-     */
-    analyzePerformance() {
-        const bottlenecks = [];
-        const optimizationHints = [];
-        // Analyze cache hit rate
-        if (this.metrics.cache_hit_rate < 0.5) {
-            bottlenecks.push('Low cache hit rate');
-            optimizationHints.push({
-                type: 'cache',
-                description: 'Increase cache TTL for frequently accessed data',
-                estimated_improvement: 0.3,
-                implementation_complexity: 'low'
-            });
-        }
-        // Analyze response times
-        if (this.metrics.average_response_time > 2000) {
-            bottlenecks.push('High response times');
-            optimizationHints.push({
-                type: 'parallel',
-                description: 'Implement parallel processing for independent requests',
-                estimated_improvement: 0.5,
-                implementation_complexity: 'medium'
-            });
-        }
-        // Analyze cache size
-        if (this.cache.size > this.config.max_size * 0.8) {
-            bottlenecks.push('Cache nearing capacity');
-            optimizationHints.push({
-                type: 'compress',
-                description: 'Enable compression for cached data',
-                estimated_improvement: 0.4,
-                implementation_complexity: 'medium'
-            });
-        }
-        // Analyze API call patterns
-        const batchableRequests = this.identifyBatchableRequests();
-        if (batchableRequests.length > 0) {
-            optimizationHints.push({
-                type: 'batch',
-                description: `Batch ${batchableRequests.length} similar requests`,
-                estimated_improvement: 0.6,
-                implementation_complexity: 'high'
-            });
-        }
-        return {
-            metrics: this.metrics,
-            bottlenecks,
-            optimization_hints: optimizationHints
-        };
-    }
-    /**
-     * Implement adaptive caching based on usage patterns
-     */
-    optimizeCaching() {
-        const cacheAnalysis = this.analyzeCacheUsage();
-        // Adjust TTL based on access patterns
-        for (const [key, entry] of this.cache) {
-            const accessFrequency = entry.access_count / (Date.now() - entry.timestamp.getTime());
-            if (accessFrequency > 0.01) { // Frequently accessed
-                entry.ttl = this.config.default_ttl * 2;
-            }
-            else if (accessFrequency < 0.001) { // Rarely accessed
-                entry.ttl = this.config.default_ttl * 0.5;
-            }
-        }
-        // Implement cache warming for predicted requests
-        this.warmCache(cacheAnalysis.predicted_requests);
-    }
-    /**
-     * Get from cache with LRU eviction
-     */
-    getFromCache(key) {
-        const entry = this.cache.get(key);
-        if (!entry) {
-            return null;
-        }
-        // Check if expired
-        if (Date.now() - entry.timestamp.getTime() > entry.ttl) {
-            this.cache.delete(key);
-            return null;
-        }
-        // Update access statistics
-        entry.access_count++;
-        entry.last_accessed = new Date();
-        return entry.value;
-    }
-    /**
-     * Set in cache with size management
-     */
-    setInCache(key, value, options = {}) {
-        // Check if cache is full
-        if (this.cache.size >= this.config.max_size) {
-            this.evictLeastRecent();
-        }
-        const entry = {
-            key,
-            value,
-            timestamp: new Date(),
-            ttl: options.ttl || this.config.default_ttl,
-            access_count: 1,
-            last_accessed: new Date(),
-            tags: options.tags || [],
-            size: this.estimateSize(value)
-        };
-        this.cache.set(key, entry);
-        this.updateCacheMetrics();
-    }
-    /**
-     * Execute API call with connection pooling
-     */
-    async executeAPICall(request) {
-        const connection = this.getPooledConnection(request.url);
-        const startTime = Date.now();
-        try {
-            let response;
-            switch (request.method) {
-                case 'GET':
-                    response = await this.client.getRecords(this.extractTable(request.url), request.data);
-                    break;
-                case 'POST':
-                    response = await this.client.createRecord(this.extractTable(request.url), request.data);
-                    break;
-                case 'PUT':
-                case 'PATCH':
-                    response = await this.client.updateRecord(this.extractTable(request.url), request.data.sys_id, request.data);
-                    break;
-                case 'DELETE':
-                    response = await this.client.deleteRecord(this.extractTable(request.url), request.data.sys_id);
-                    break;
-                default:
-                    throw new Error(`Unsupported method: ${request.method}`);
-            }
-            return {
-                success: response.success,
-                data: response.data,
-                error: response.error,
-                cached: false,
-                response_time: Date.now() - startTime,
-                cache_hit: false
-            };
-        }
-        finally {
-            this.returnPooledConnection(request.url, connection);
-        }
-    }
-    /**
-     * Group requests by type for batch processing
-     */
-    groupRequestsByType(requests) {
-        const groups = {};
-        for (const request of requests) {
-            const type = `${request.method}_${this.extractTable(request.url)}`;
-            if (!groups[type]) {
-                groups[type] = [];
-            }
-            groups[type].push(request);
-        }
-        return groups;
-    }
-    /**
-     * Execute batch group with parallel processing
-     */
-    async executeBatchGroup(requests, type) {
-        const batchSize = this.getBatchSizeForType(type);
-        const results = [];
-        // Process requests in batches
-        for (let i = 0; i < requests.length; i += batchSize) {
-            const batch = requests.slice(i, i + batchSize);
-            const batchPromises = batch.map(request => this.optimizedAPICall(request));
-            const batchResults = await Promise.all(batchPromises);
-            results.push(...batchResults);
-        }
-        return results;
-    }
-    /**
-     * Preload action types
-     */
-    async preloadActionTypes() {
-        const request = {
-            id: 'preload_action_types',
-            method: 'GET',
-            url: '/api/now/table/sys_hub_action_type_base',
-            cacheable: true,
-            priority: 1
-        };
-        await this.optimizedAPICall(request);
-    }
-    /**
-     * Preload trigger types
-     */
-    async preloadTriggerTypes() {
-        const request = {
-            id: 'preload_trigger_types',
-            method: 'GET',
-            url: '/api/now/table/sys_hub_trigger_type',
-            cacheable: true,
-            priority: 1
-        };
-        await this.optimizedAPICall(request);
-    }
-    /**
-     * Preload flow templates
-     */
-    async preloadFlowTemplates() {
-        const request = {
-            id: 'preload_flow_templates',
-            method: 'GET',
-            url: '/api/now/table/sys_hub_flow_template',
-            cacheable: true,
-            priority: 1
-        };
-        await this.optimizedAPICall(request);
-    }
-    /**
-     * Preload user preferences
-     */
-    async preloadUserPreferences() {
-        const request = {
-            id: 'preload_user_preferences',
-            method: 'GET',
-            url: '/api/now/table/sys_user_preference',
-            cacheable: true,
-            priority: 1
-        };
-        await this.optimizedAPICall(request);
-    }
-    /**
-     * Analyze cache usage patterns
-     */
-    analyzeCacheUsage() {
-        const sortedEntries = Array.from(this.cache.entries())
-            .sort((a, b) => b[1].access_count - a[1].access_count);
-        const mostAccessed = sortedEntries.slice(0, 10).map(([key]) => key);
-        const leastAccessed = sortedEntries.slice(-10).map(([key]) => key);
-        // Predict likely requests based on patterns
-        const predictedRequests = this.predictLikelyRequests(mostAccessed);
-        return {
-            most_accessed: mostAccessed,
-            least_accessed: leastAccessed,
-            predicted_requests: predictedRequests
-        };
-    }
-    /**
-     * Warm cache with predicted requests
-     */
-    async warmCache(predictedRequests) {
-        const warmingTasks = predictedRequests.map(async (cacheKey) => {
-            if (!this.cache.has(cacheKey)) {
-                const request = this.reconstructRequestFromCacheKey(cacheKey);
-                if (request) {
-                    await this.optimizedAPICall(request);
-                }
-            }
-        });
-        await Promise.all(warmingTasks);
-    }
-    /**
-     * Evict least recently used entries
-     */
-    evictLeastRecent() {
-        const entries = Array.from(this.cache.entries())
-            .sort((a, b) => a[1].last_accessed.getTime() - b[1].last_accessed.getTime());
-        const entriesToEvict = entries.slice(0, Math.ceil(this.config.max_size * 0.1));
-        for (const [key] of entriesToEvict) {
-            this.cache.delete(key);
-        }
-    }
-    /**
-     * Update performance metrics
-     */
-    updateMetrics(cacheHit, responseTime) {
-        this.metrics.api_call_count++;
-        if (cacheHit) {
-            this.metrics.cache_hit_rate = (this.metrics.cache_hit_rate * (this.metrics.api_call_count - 1) + 1) / this.metrics.api_call_count;
-        }
-        else {
-            this.metrics.cache_miss_rate = (this.metrics.cache_miss_rate * (this.metrics.api_call_count - 1) + 1) / this.metrics.api_call_count;
-        }
-        this.metrics.average_response_time = (this.metrics.average_response_time * (this.metrics.api_call_count - 1) + responseTime) / this.metrics.api_call_count;
-    }
-    /**
-     * Update cache metrics
-     */
-    updateCacheMetrics() {
-        this.metrics.cache_size = this.cache.size;
-        this.metrics.memory_usage = Array.from(this.cache.values())
-            .reduce((total, entry) => total + entry.size, 0);
-    }
-    /**
-     * Generate cache key for request
-     */
-    generateCacheKey(request) {
-        const keyParts = [
-            request.method,
-            request.url,
-            JSON.stringify(request.data),
-            JSON.stringify(request.headers)
-        ];
-        return Buffer.from(keyParts.join('|')).toString('base64');
-    }
-    /**
-     * Get TTL for specific request type
-     */
-    getTTLForRequest(request) {
-        const url = request.url.toLowerCase();
-        if (url.includes('action_type') || url.includes('trigger_type')) {
-            return 3600000; // 1 hour for metadata
-        }
-        if (url.includes('flow_template')) {
-            return 1800000; // 30 minutes for templates
-        }
-        if (url.includes('user_preference')) {
-            return 600000; // 10 minutes for preferences
-        }
-        return this.config.default_ttl;
-    }
-    /**
-     * Get tags for request
-     */
-    getTagsForRequest(request) {
-        const tags = [];
-        const url = request.url.toLowerCase();
-        if (url.includes('action_type'))
-            tags.push('action_type');
-        if (url.includes('trigger_type'))
-            tags.push('trigger_type');
-        if (url.includes('flow'))
-            tags.push('flow');
-        if (url.includes('user'))
-            tags.push('user');
-        return tags;
-    }
-    /**
-     * Estimate size of cached value
-     */
-    estimateSize(value) {
-        return JSON.stringify(value).length * 2; // Rough estimate
-    }
-    /**
-     * Extract table name from URL
-     */
-    extractTable(url) {
-        const match = url.match(/\/table\/([^\/\?]+)/);
-        return match ? match[1] : 'unknown';
-    }
-    /**
-     * Get batch size for request type
-     */
-    getBatchSizeForType(type) {
-        if (type.includes('GET'))
-            return 10;
-        if (type.includes('POST'))
-            return 5;
-        if (type.includes('PUT') || type.includes('PATCH'))
-            return 3;
-        if (type.includes('DELETE'))
-            return 3;
-        return 5;
-    }
-    /**
-     * Check if request is rate limited
-     */
-    isRateLimited(url) {
-        const domain = this.extractDomain(url);
-        const lastRequest = this.rateLimiter.get(domain);
-        if (!lastRequest)
-            return false;
-        const timeSinceLastRequest = Date.now() - lastRequest;
-        return timeSinceLastRequest < 100; // 100ms rate limit
-    }
-    /**
-     * Wait for rate limit to clear
-     */
-    async waitForRateLimit(url) {
-        const domain = this.extractDomain(url);
-        const lastRequest = this.rateLimiter.get(domain);
-        if (lastRequest) {
-            const waitTime = 100 - (Date.now() - lastRequest);
-            if (waitTime > 0) {
-                await new Promise(resolve => setTimeout(resolve, waitTime));
-            }
-        }
-        this.rateLimiter.set(domain, Date.now());
-    }
-    /**
-     * Extract domain from URL
-     */
-    extractDomain(url) {
-        try {
-            return new URL(url).hostname;
-        }
-        catch {
-            return 'default';
-        }
-    }
-    /**
-     * Get pooled connection
-     */
-    getPooledConnection(url) {
-        const domain = this.extractDomain(url);
-        return this.connectionPool.get(domain) || {};
-    }
-    /**
-     * Return pooled connection
-     */
-    returnPooledConnection(url, connection) {
-        const domain = this.extractDomain(url);
-        this.connectionPool.set(domain, connection);
-    }
-    /**
-     * Identify batchable requests
-     */
-    identifyBatchableRequests() {
-        // Implementation would analyze request patterns
-        return [];
-    }
-    /**
-     * Predict likely requests based on patterns
-     */
-    predictLikelyRequests(mostAccessed) {
-        // Implementation would use ML or pattern analysis
-        return mostAccessed.slice(0, 5);
-    }
-    /**
-     * Reconstruct request from cache key
-     */
-    reconstructRequestFromCacheKey(cacheKey) {
-        try {
-            const decoded = Buffer.from(cacheKey, 'base64').toString();
-            const [method, url, data, headers] = decoded.split('|');
-            return {
-                id: 'reconstructed',
-                method: method,
-                url,
-                data: JSON.parse(data),
-                headers: JSON.parse(headers),
-                cacheable: true,
-                priority: 1
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Start cleanup timer
-     */
-    startCleanupTimer() {
-        this.cleanupTimer = setInterval(() => {
-            this.cleanupExpiredEntries();
-        }, this.config.cleanup_interval);
-    }
-    /**
-     * Cleanup expired entries
-     */
-    cleanupExpiredEntries() {
-        const now = Date.now();
-        const expiredKeys = [];
-        for (const [key, entry] of this.cache) {
-            if (now - entry.timestamp.getTime() > entry.ttl) {
-                expiredKeys.push(key);
-            }
-        }
-        for (const key of expiredKeys) {
-            this.cache.delete(key);
-        }
-        if (expiredKeys.length > 0) {
-            this.logger.debug(`Cleaned up ${expiredKeys.length} expired cache entries`);
-            this.updateCacheMetrics();
-        }
-    }
-    /**
-     * Load persisted cache
-     */
-    loadPersistedCache() {
-        if (!this.config.persistence_enabled)
-            return;
-        try {
-            const cacheFile = path_1.default.join(process.env.SNOW_FLOW_HOME || path_1.default.join(os_1.default.homedir(), '.snow-flow'), 'cache', 'performance_cache.json');
-            if (fs_1.default.existsSync(cacheFile)) {
-                const cacheData = JSON.parse(fs_1.default.readFileSync(cacheFile, 'utf-8'));
-                for (const [key, entry] of Object.entries(cacheData)) {
-                    this.cache.set(key, {
-                        ...entry,
-                        timestamp: new Date(entry.timestamp),
-                        last_accessed: new Date(entry.last_accessed)
-                    });
-                }
-                this.logger.info(`Loaded ${this.cache.size} entries from persisted cache`);
-            }
-        }
-        catch (error) {
-            this.logger.warn('Failed to load persisted cache:', error);
-        }
-    }
-    /**
-     * Save cache to disk
-     */
-    saveCacheToDisk() {
-        if (!this.config.persistence_enabled)
-            return;
-        try {
-            const cacheDir = path_1.default.join(process.env.SNOW_FLOW_HOME || path_1.default.join(os_1.default.homedir(), '.snow-flow'), 'cache');
-            if (!fs_1.default.existsSync(cacheDir)) {
-                fs_1.default.mkdirSync(cacheDir, { recursive: true });
-            }
-            const cacheFile = path_1.default.join(cacheDir, 'performance_cache.json');
-            const cacheData = Object.fromEntries(this.cache.entries());
-            fs_1.default.writeFileSync(cacheFile, JSON.stringify(cacheData, null, 2));
-            this.logger.info(`Saved ${this.cache.size} entries to persisted cache`);
-        }
-        catch (error) {
-            this.logger.warn('Failed to save cache to disk:', error);
-        }
-    }
-    /**
-     * Clear cache
-     */
-    clearCache(tags) {
-        if (!tags || tags.length === 0) {
-            this.cache.clear();
-            this.logger.info('Cleared all cache entries');
-        }
-        else {
-            const keysToDelete = [];
-            for (const [key, entry] of this.cache) {
-                if (entry.tags.some(tag => tags.includes(tag))) {
-                    keysToDelete.push(key);
-                }
-            }
-            for (const key of keysToDelete) {
-                this.cache.delete(key);
-            }
-            this.logger.info(`Cleared ${keysToDelete.length} cache entries with tags: ${tags.join(', ')}`);
-        }
-        this.updateCacheMetrics();
-    }
-    /**
-     * Destroy optimizer and cleanup
-     */
-    destroy() {
-        if (this.cleanupTimer) {
-            clearInterval(this.cleanupTimer);
-        }
-        this.saveCacheToDisk();
-        this.cache.clear();
-        this.batchQueue.clear();
-        this.rateLimiter.clear();
-        this.connectionPool.clear();
-        this.logger.info('Performance optimizer destroyed');
-    }
-}
-exports.PerformanceOptimizer = PerformanceOptimizer;
-//# sourceMappingURL=performance-optimizer.js.map