@push.rocks/smartproxy 22.4.2 → 23.0.0

package/ts/proxies/http-proxy/function-cache.ts

@@ -1,279 +0,0 @@
-import type { IRouteContext } from '../../core/models/route-context.js';
-import type { ILogger } from './models/types.js';
-
-/**
- * Interface for cached function result
- */
-interface ICachedResult<T> {
-  value: T;
-  expiry: number;
-  hash: string;
-}
-
-/**
- * Function cache for NetworkProxy function-based targets
- * 
- * This cache improves performance for function-based targets by storing
- * the results of function evaluations and reusing them for similar contexts.
- */
-export class FunctionCache {
-  // Cache storage
-  private hostCache: Map<string, ICachedResult<string | string[]>> = new Map();
-  private portCache: Map<string, ICachedResult<number>> = new Map();
-  
-  // Maximum number of entries to store in each cache
-  private maxCacheSize: number;
-  
-  // Default TTL for cache entries in milliseconds (default: 5 seconds)
-  private defaultTtl: number;
-  
-  // Logger
-  private logger: ILogger;
-  
-  // Cleanup interval timer
-  private cleanupInterval: NodeJS.Timeout | null = null;
-  
-  /**
-   * Creates a new function cache
-   * 
-   * @param logger Logger for debug output
-   * @param options Cache options
-   */
-  constructor(
-    logger: ILogger,
-    options: {
-      maxCacheSize?: number;
-      defaultTtl?: number;
-    } = {}
-  ) {
-    this.logger = logger;
-    this.maxCacheSize = options.maxCacheSize || 1000;
-    this.defaultTtl = options.defaultTtl || 5000; // 5 seconds default
-    
-    // Start the cache cleanup timer
-    this.cleanupInterval = setInterval(() => this.cleanupCache(), 30000); // Cleanup every 30 seconds
-    
-    // Make sure the interval doesn't keep the process alive
-    if (this.cleanupInterval.unref) {
-      this.cleanupInterval.unref();
-    }
-  }
-  
-  /**
-   * Compute a hash for a context object
-   * This is used to identify similar contexts for caching
-   * 
-   * @param context The route context to hash
-   * @param functionId Identifier for the function (usually route name or ID)
-   * @returns A string hash
-   */
-  private computeContextHash(context: IRouteContext, functionId: string): string {
-    // Extract relevant properties for the hash
-    const hashBase = {
-      functionId,
-      port: context.port,
-      domain: context.domain,
-      clientIp: context.clientIp,
-      path: context.path,
-      query: context.query,
-      isTls: context.isTls,
-      tlsVersion: context.tlsVersion
-    };
-    
-    // Generate a hash string
-    return JSON.stringify(hashBase);
-  }
-  
-  /**
-   * Get cached host result for a function and context
-   * 
-   * @param context Route context
-   * @param functionId Identifier for the function
-   * @returns Cached host value or undefined if not found
-   */
-  public getCachedHost(context: IRouteContext, functionId: string): string | string[] | undefined {
-    const hash = this.computeContextHash(context, functionId);
-    const cached = this.hostCache.get(hash);
-    
-    // Return if no cached value or expired
-    if (!cached || cached.expiry < Date.now()) {
-      if (cached) {
-        // If expired, remove from cache
-        this.hostCache.delete(hash);
-        this.logger.debug(`Cache miss (expired) for host function: ${functionId}`);
-      } else {
-        this.logger.debug(`Cache miss for host function: ${functionId}`);
-      }
-      return undefined;
-    }
-    
-    this.logger.debug(`Cache hit for host function: ${functionId}`);
-    return cached.value;
-  }
-  
-  /**
-   * Get cached port result for a function and context
-   * 
-   * @param context Route context
-   * @param functionId Identifier for the function
-   * @returns Cached port value or undefined if not found
-   */
-  public getCachedPort(context: IRouteContext, functionId: string): number | undefined {
-    const hash = this.computeContextHash(context, functionId);
-    const cached = this.portCache.get(hash);
-    
-    // Return if no cached value or expired
-    if (!cached || cached.expiry < Date.now()) {
-      if (cached) {
-        // If expired, remove from cache
-        this.portCache.delete(hash);
-        this.logger.debug(`Cache miss (expired) for port function: ${functionId}`);
-      } else {
-        this.logger.debug(`Cache miss for port function: ${functionId}`);
-      }
-      return undefined;
-    }
-    
-    this.logger.debug(`Cache hit for port function: ${functionId}`);
-    return cached.value;
-  }
-  
-  /**
-   * Store a host function result in the cache
-   * 
-   * @param context Route context
-   * @param functionId Identifier for the function
-   * @param value Host value to cache
-   * @param ttl Optional TTL in milliseconds
-   */
-  public cacheHost(
-    context: IRouteContext,
-    functionId: string,
-    value: string | string[],
-    ttl?: number
-  ): void {
-    const hash = this.computeContextHash(context, functionId);
-    const expiry = Date.now() + (ttl || this.defaultTtl);
-    
-    // Check if we need to prune the cache before adding
-    if (this.hostCache.size >= this.maxCacheSize) {
-      this.pruneOldestEntries(this.hostCache);
-    }
-    
-    // Store the result
-    this.hostCache.set(hash, { value, expiry, hash });
-    this.logger.debug(`Cached host function result for: ${functionId}`);
-  }
-  
-  /**
-   * Store a port function result in the cache
-   * 
-   * @param context Route context
-   * @param functionId Identifier for the function
-   * @param value Port value to cache
-   * @param ttl Optional TTL in milliseconds
-   */
-  public cachePort(
-    context: IRouteContext,
-    functionId: string,
-    value: number,
-    ttl?: number
-  ): void {
-    const hash = this.computeContextHash(context, functionId);
-    const expiry = Date.now() + (ttl || this.defaultTtl);
-    
-    // Check if we need to prune the cache before adding
-    if (this.portCache.size >= this.maxCacheSize) {
-      this.pruneOldestEntries(this.portCache);
-    }
-    
-    // Store the result
-    this.portCache.set(hash, { value, expiry, hash });
-    this.logger.debug(`Cached port function result for: ${functionId}`);
-  }
-  
-  /**
-   * Remove expired entries from the cache
-   */
-  private cleanupCache(): void {
-    const now = Date.now();
-    let expiredCount = 0;
-    
-    // Clean up host cache
-    for (const [hash, cached] of this.hostCache.entries()) {
-      if (cached.expiry < now) {
-        this.hostCache.delete(hash);
-        expiredCount++;
-      }
-    }
-    
-    // Clean up port cache
-    for (const [hash, cached] of this.portCache.entries()) {
-      if (cached.expiry < now) {
-        this.portCache.delete(hash);
-        expiredCount++;
-      }
-    }
-    
-    if (expiredCount > 0) {
-      this.logger.debug(`Cleaned up ${expiredCount} expired cache entries`);
-    }
-  }
-  
-  /**
-   * Prune oldest entries from a cache map
-   * Used when the cache exceeds the maximum size
-   * 
-   * @param cache The cache map to prune
-   */
-  private pruneOldestEntries<T>(cache: Map<string, ICachedResult<T>>): void {
-    // Find the oldest entries
-    const now = Date.now();
-    const itemsToRemove = Math.floor(this.maxCacheSize * 0.2); // Remove 20% of the cache
-    
-    // Convert to array for sorting
-    const entries = Array.from(cache.entries());
-    
-    // Sort by expiry (oldest first)
-    entries.sort((a, b) => a[1].expiry - b[1].expiry);
-    
-    // Remove oldest entries
-    const toRemove = entries.slice(0, itemsToRemove);
-    for (const [hash] of toRemove) {
-      cache.delete(hash);
-    }
-    
-    this.logger.debug(`Pruned ${toRemove.length} oldest cache entries`);
-  }
-  
-  /**
-   * Get current cache stats
-   */
-  public getStats(): { hostCacheSize: number; portCacheSize: number } {
-    return {
-      hostCacheSize: this.hostCache.size,
-      portCacheSize: this.portCache.size
-    };
-  }
-  
-  /**
-   * Clear all cached entries
-   */
-  public clearCache(): void {
-    this.hostCache.clear();
-    this.portCache.clear();
-    this.logger.info('Function cache cleared');
-  }
-  
-  /**
-   * Destroy the cache and cleanup resources
-   */
-  public destroy(): void {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-    this.clearCache();
-    this.logger.debug('Function cache destroyed');
-  }
-}

package/ts/proxies/http-proxy/handlers/index.ts

@@ -1,5 +0,0 @@
-/**
- * HTTP handlers for various route types
- */
-
-// Empty - all handlers have been removed