@push.rocks/smartproxy 19.5.4 → 19.5.5

package/dist_ts/core/utils/async-utils.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Async utility functions for SmartProxy
+ * Provides non-blocking alternatives to synchronous operations
+ */
+/**
+ * Delays execution for the specified number of milliseconds
+ * Non-blocking alternative to busy wait loops
+ * @param ms - Number of milliseconds to delay
+ * @returns Promise that resolves after the delay
+ */
+export declare function delay(ms: number): Promise<void>;
+/**
+ * Retry an async operation with exponential backoff
+ * @param fn - The async function to retry
+ * @param options - Retry options
+ * @returns The result of the function or throws the last error
+ */
+export declare function retryWithBackoff<T>(fn: () => Promise<T>, options?: {
+    maxAttempts?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    factor?: number;
+    onRetry?: (attempt: number, error: Error) => void;
+}): Promise<T>;
+/**
+ * Execute an async operation with a timeout
+ * @param fn - The async function to execute
+ * @param timeoutMs - Timeout in milliseconds
+ * @param timeoutError - Optional custom timeout error
+ * @returns The result of the function or throws timeout error
+ */
+export declare function withTimeout<T>(fn: () => Promise<T>, timeoutMs: number, timeoutError?: Error): Promise<T>;
+/**
+ * Run multiple async operations in parallel with a concurrency limit
+ * @param items - Array of items to process
+ * @param fn - Async function to run for each item
+ * @param concurrency - Maximum number of concurrent operations
+ * @returns Array of results in the same order as input
+ */
+export declare function parallelLimit<T, R>(items: T[], fn: (item: T, index: number) => Promise<R>, concurrency: number): Promise<R[]>;
+/**
+ * Debounce an async function
+ * @param fn - The async function to debounce
+ * @param delayMs - Delay in milliseconds
+ * @returns Debounced function with cancel method
+ */
+export declare function debounceAsync<T extends (...args: any[]) => Promise<any>>(fn: T, delayMs: number): T & {
+    cancel: () => void;
+};
+/**
+ * Create a mutex for ensuring exclusive access to a resource
+ */
+export declare class AsyncMutex {
+    private queue;
+    private locked;
+    acquire(): Promise<() => void>;
+    private release;
+    runExclusive<T>(fn: () => Promise<T>): Promise<T>;
+}
+/**
+ * Circuit breaker for protecting against cascading failures
+ */
+export declare class CircuitBreaker {
+    private options;
+    private failureCount;
+    private lastFailureTime;
+    private state;
+    constructor(options: {
+        failureThreshold: number;
+        resetTimeout: number;
+        onStateChange?: (state: 'closed' | 'open' | 'half-open') => void;
+    });
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+    private onSuccess;
+    private onFailure;
+    private setState;
+    isOpen(): boolean;
+    getState(): 'closed' | 'open' | 'half-open';
+    recordSuccess(): void;
+    recordFailure(): void;
+}

package/dist_ts/core/utils/async-utils.js

@@ -0,0 +1,216 @@
+/**
+ * Async utility functions for SmartProxy
+ * Provides non-blocking alternatives to synchronous operations
+ */
+/**
+ * Delays execution for the specified number of milliseconds
+ * Non-blocking alternative to busy wait loops
+ * @param ms - Number of milliseconds to delay
+ * @returns Promise that resolves after the delay
+ */
+export async function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Retry an async operation with exponential backoff
+ * @param fn - The async function to retry
+ * @param options - Retry options
+ * @returns The result of the function or throws the last error
+ */
+export async function retryWithBackoff(fn, options = {}) {
+    const { maxAttempts = 3, initialDelay = 100, maxDelay = 10000, factor = 2, onRetry } = options;
+    let lastError = null;
+    let currentDelay = initialDelay;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === maxAttempts) {
+                throw error;
+            }
+            if (onRetry) {
+                onRetry(attempt, error);
+            }
+            await delay(currentDelay);
+            currentDelay = Math.min(currentDelay * factor, maxDelay);
+        }
+    }
+    throw lastError || new Error('Retry failed');
+}
+/**
+ * Execute an async operation with a timeout
+ * @param fn - The async function to execute
+ * @param timeoutMs - Timeout in milliseconds
+ * @param timeoutError - Optional custom timeout error
+ * @returns The result of the function or throws timeout error
+ */
+export async function withTimeout(fn, timeoutMs, timeoutError) {
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(timeoutError || new Error(`Operation timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+    });
+    return Promise.race([fn(), timeoutPromise]);
+}
+/**
+ * Run multiple async operations in parallel with a concurrency limit
+ * @param items - Array of items to process
+ * @param fn - Async function to run for each item
+ * @param concurrency - Maximum number of concurrent operations
+ * @returns Array of results in the same order as input
+ */
+export async function parallelLimit(items, fn, concurrency) {
+    const results = new Array(items.length);
+    const executing = new Set();
+    for (let i = 0; i < items.length; i++) {
+        const promise = fn(items[i], i).then(result => {
+            results[i] = result;
+            executing.delete(promise);
+        });
+        executing.add(promise);
+        if (executing.size >= concurrency) {
+            await Promise.race(executing);
+        }
+    }
+    await Promise.all(executing);
+    return results;
+}
+/**
+ * Debounce an async function
+ * @param fn - The async function to debounce
+ * @param delayMs - Delay in milliseconds
+ * @returns Debounced function with cancel method
+ */
+export function debounceAsync(fn, delayMs) {
+    let timeoutId = null;
+    let lastPromise = null;
+    const debounced = ((...args) => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        lastPromise = new Promise((resolve, reject) => {
+            timeoutId = setTimeout(async () => {
+                timeoutId = null;
+                try {
+                    const result = await fn(...args);
+                    resolve(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            }, delayMs);
+        });
+        return lastPromise;
+    });
+    debounced.cancel = () => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+        }
+    };
+    return debounced;
+}
+/**
+ * Create a mutex for ensuring exclusive access to a resource
+ */
+export class AsyncMutex {
+    constructor() {
+        this.queue = [];
+        this.locked = false;
+    }
+    async acquire() {
+        if (!this.locked) {
+            this.locked = true;
+            return () => this.release();
+        }
+        return new Promise(resolve => {
+            this.queue.push(() => {
+                resolve(() => this.release());
+            });
+        });
+    }
+    release() {
+        const next = this.queue.shift();
+        if (next) {
+            next();
+        }
+        else {
+            this.locked = false;
+        }
+    }
+    async runExclusive(fn) {
+        const release = await this.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+        }
+    }
+}
+/**
+ * Circuit breaker for protecting against cascading failures
+ */
+export class CircuitBreaker {
+    constructor(options) {
+        this.options = options;
+        this.failureCount = 0;
+        this.lastFailureTime = 0;
+        this.state = 'closed';
+    }
+    async execute(fn) {
+        if (this.state === 'open') {
+            if (Date.now() - this.lastFailureTime > this.options.resetTimeout) {
+                this.setState('half-open');
+            }
+            else {
+                throw new Error('Circuit breaker is open');
+            }
+        }
+        try {
+            const result = await fn();
+            this.onSuccess();
+            return result;
+        }
+        catch (error) {
+            this.onFailure();
+            throw error;
+        }
+    }
+    onSuccess() {
+        this.failureCount = 0;
+        if (this.state !== 'closed') {
+            this.setState('closed');
+        }
+    }
+    onFailure() {
+        this.failureCount++;
+        this.lastFailureTime = Date.now();
+        if (this.failureCount >= this.options.failureThreshold) {
+            this.setState('open');
+        }
+    }
+    setState(state) {
+        if (this.state !== state) {
+            this.state = state;
+            if (this.options.onStateChange) {
+                this.options.onStateChange(state);
+            }
+        }
+    }
+    isOpen() {
+        return this.state === 'open';
+    }
+    getState() {
+        return this.state;
+    }
+    recordSuccess() {
+        this.onSuccess();
+    }
+    recordFailure() {
+        this.onFailure();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/core/utils/binary-heap.d.ts

@@ -0,0 +1,73 @@
+/**
+ * A binary heap implementation for efficient priority queue operations
+ * Supports O(log n) insert and extract operations
+ */
+export declare class BinaryHeap<T> {
+    private compareFn;
+    private extractKey?;
+    private heap;
+    private keyMap?;
+    constructor(compareFn: (a: T, b: T) => number, extractKey?: (item: T) => string);
+    /**
+     * Get the current size of the heap
+     */
+    get size(): number;
+    /**
+     * Check if the heap is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Peek at the top element without removing it
+     */
+    peek(): T | undefined;
+    /**
+     * Insert a new item into the heap
+     * O(log n) time complexity
+     */
+    insert(item: T): void;
+    /**
+     * Extract the top element from the heap
+     * O(log n) time complexity
+     */
+    extract(): T | undefined;
+    /**
+     * Extract an element that matches the predicate
+     * O(n) time complexity for search, O(log n) for extraction
+     */
+    extractIf(predicate: (item: T) => boolean): T | undefined;
+    /**
+     * Extract an element by its key (if extractKey was provided)
+     * O(log n) time complexity
+     */
+    extractByKey(key: string): T | undefined;
+    /**
+     * Check if a key exists in the heap
+     * O(1) time complexity
+     */
+    hasKey(key: string): boolean;
+    /**
+     * Get all elements as an array (does not modify heap)
+     * O(n) time complexity
+     */
+    toArray(): T[];
+    /**
+     * Clear the heap
+     */
+    clear(): void;
+    /**
+     * Extract element at specific index
+     */
+    private extractAt;
+    /**
+     * Bubble up element at given index to maintain heap property
+     */
+    private bubbleUp;
+    /**
+     * Bubble down element at given index to maintain heap property
+     */
+    private bubbleDown;
+    /**
+     * Swap two elements in the heap
+     */
+    private swap;
+}

package/dist_ts/core/utils/binary-heap.js

@@ -0,0 +1,193 @@
+/**
+ * A binary heap implementation for efficient priority queue operations
+ * Supports O(log n) insert and extract operations
+ */
+export class BinaryHeap {
+    constructor(compareFn, extractKey) {
+        this.compareFn = compareFn;
+        this.extractKey = extractKey;
+        this.heap = [];
+        if (extractKey) {
+            this.keyMap = new Map();
+        }
+    }
+    /**
+     * Get the current size of the heap
+     */
+    get size() {
+        return this.heap.length;
+    }
+    /**
+     * Check if the heap is empty
+     */
+    isEmpty() {
+        return this.heap.length === 0;
+    }
+    /**
+     * Peek at the top element without removing it
+     */
+    peek() {
+        return this.heap[0];
+    }
+    /**
+     * Insert a new item into the heap
+     * O(log n) time complexity
+     */
+    insert(item) {
+        const index = this.heap.length;
+        this.heap.push(item);
+        if (this.keyMap && this.extractKey) {
+            const key = this.extractKey(item);
+            this.keyMap.set(key, index);
+        }
+        this.bubbleUp(index);
+    }
+    /**
+     * Extract the top element from the heap
+     * O(log n) time complexity
+     */
+    extract() {
+        if (this.heap.length === 0)
+            return undefined;
+        if (this.heap.length === 1) {
+            const item = this.heap.pop();
+            if (this.keyMap && this.extractKey) {
+                this.keyMap.delete(this.extractKey(item));
+            }
+            return item;
+        }
+        const result = this.heap[0];
+        const lastItem = this.heap.pop();
+        this.heap[0] = lastItem;
+        if (this.keyMap && this.extractKey) {
+            this.keyMap.delete(this.extractKey(result));
+            this.keyMap.set(this.extractKey(lastItem), 0);
+        }
+        this.bubbleDown(0);
+        return result;
+    }
+    /**
+     * Extract an element that matches the predicate
+     * O(n) time complexity for search, O(log n) for extraction
+     */
+    extractIf(predicate) {
+        const index = this.heap.findIndex(predicate);
+        if (index === -1)
+            return undefined;
+        return this.extractAt(index);
+    }
+    /**
+     * Extract an element by its key (if extractKey was provided)
+     * O(log n) time complexity
+     */
+    extractByKey(key) {
+        if (!this.keyMap || !this.extractKey) {
+            throw new Error('extractKey function must be provided to use key-based extraction');
+        }
+        const index = this.keyMap.get(key);
+        if (index === undefined)
+            return undefined;
+        return this.extractAt(index);
+    }
+    /**
+     * Check if a key exists in the heap
+     * O(1) time complexity
+     */
+    hasKey(key) {
+        if (!this.keyMap)
+            return false;
+        return this.keyMap.has(key);
+    }
+    /**
+     * Get all elements as an array (does not modify heap)
+     * O(n) time complexity
+     */
+    toArray() {
+        return [...this.heap];
+    }
+    /**
+     * Clear the heap
+     */
+    clear() {
+        this.heap = [];
+        if (this.keyMap) {
+            this.keyMap.clear();
+        }
+    }
+    /**
+     * Extract element at specific index
+     */
+    extractAt(index) {
+        const item = this.heap[index];
+        if (this.keyMap && this.extractKey) {
+            this.keyMap.delete(this.extractKey(item));
+        }
+        if (index === this.heap.length - 1) {
+            this.heap.pop();
+            return item;
+        }
+        const lastItem = this.heap.pop();
+        this.heap[index] = lastItem;
+        if (this.keyMap && this.extractKey) {
+            this.keyMap.set(this.extractKey(lastItem), index);
+        }
+        // Try bubbling up first
+        const parentIndex = Math.floor((index - 1) / 2);
+        if (parentIndex >= 0 && this.compareFn(this.heap[index], this.heap[parentIndex]) < 0) {
+            this.bubbleUp(index);
+        }
+        else {
+            this.bubbleDown(index);
+        }
+        return item;
+    }
+    /**
+     * Bubble up element at given index to maintain heap property
+     */
+    bubbleUp(index) {
+        while (index > 0) {
+            const parentIndex = Math.floor((index - 1) / 2);
+            if (this.compareFn(this.heap[index], this.heap[parentIndex]) >= 0) {
+                break;
+            }
+            this.swap(index, parentIndex);
+            index = parentIndex;
+        }
+    }
+    /**
+     * Bubble down element at given index to maintain heap property
+     */
+    bubbleDown(index) {
+        const length = this.heap.length;
+        while (true) {
+            const leftChild = 2 * index + 1;
+            const rightChild = 2 * index + 2;
+            let smallest = index;
+            if (leftChild < length &&
+                this.compareFn(this.heap[leftChild], this.heap[smallest]) < 0) {
+                smallest = leftChild;
+            }
+            if (rightChild < length &&
+                this.compareFn(this.heap[rightChild], this.heap[smallest]) < 0) {
+                smallest = rightChild;
+            }
+            if (smallest === index)
+                break;
+            this.swap(index, smallest);
+            index = smallest;
+        }
+    }
+    /**
+     * Swap two elements in the heap
+     */
+    swap(i, j) {
+        const temp = this.heap[i];
+        this.heap[i] = this.heap[j];
+        this.heap[j] = temp;
+        if (this.keyMap && this.extractKey) {
+            this.keyMap.set(this.extractKey(this.heap[i]), i);
+            this.keyMap.set(this.extractKey(this.heap[j]), j);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/core/utils/enhanced-connection-pool.d.ts

@@ -0,0 +1,110 @@
+import { LifecycleComponent } from './lifecycle-component.js';
+/**
+ * Interface for pooled connection
+ */
+export interface IPooledConnection<T> {
+    id: string;
+    connection: T;
+    createdAt: number;
+    lastUsedAt: number;
+    useCount: number;
+    inUse: boolean;
+    metadata?: any;
+}
+/**
+ * Configuration options for the connection pool
+ */
+export interface IConnectionPoolOptions<T> {
+    minSize?: number;
+    maxSize?: number;
+    acquireTimeout?: number;
+    idleTimeout?: number;
+    maxUseCount?: number;
+    validateOnAcquire?: boolean;
+    validateOnReturn?: boolean;
+    queueTimeout?: number;
+    connectionFactory: () => Promise<T>;
+    connectionValidator?: (connection: T) => Promise<boolean>;
+    connectionDestroyer?: (connection: T) => Promise<void>;
+    onConnectionError?: (error: Error, connection?: T) => void;
+}
+/**
+ * Enhanced connection pool with priority queue, backpressure, and lifecycle management
+ */
+export declare class EnhancedConnectionPool<T> extends LifecycleComponent {
+    private readonly options;
+    private readonly availableConnections;
+    private readonly activeConnections;
+    private readonly waitQueue;
+    private readonly mutex;
+    private readonly eventEmitter;
+    private connectionIdCounter;
+    private requestIdCounter;
+    private isClosing;
+    private metrics;
+    constructor(options: IConnectionPoolOptions<T>);
+    /**
+     * Initialize minimum number of connections
+     */
+    private initializeMinConnections;
+    /**
+     * Start maintenance timer for idle connection cleanup
+     */
+    private startMaintenance;
+    /**
+     * Perform maintenance tasks
+     */
+    private performMaintenance;
+    /**
+     * Acquire a connection from the pool
+     */
+    acquire(priority?: number, timeout?: number): Promise<IPooledConnection<T>>;
+    /**
+     * Try to acquire an available connection
+     */
+    private tryAcquireConnection;
+    /**
+     * Checkout a connection for use
+     */
+    private checkoutConnection;
+    /**
+     * Queue an acquire request
+     */
+    private queueAcquireRequest;
+    /**
+     * Release a connection back to the pool
+     */
+    release(connection: IPooledConnection<T>): Promise<void>;
+    /**
+     * Create a new connection
+     */
+    private createConnection;
+    /**
+     * Destroy a connection
+     */
+    private destroyConnection;
+    /**
+     * Get current pool statistics
+     */
+    getStats(): {
+        connectionsCreated: number;
+        connectionsDestroyed: number;
+        connectionsAcquired: number;
+        connectionsReleased: number;
+        acquireTimeouts: number;
+        validationFailures: number;
+        queueHighWaterMark: number;
+        available: number;
+        active: number;
+        waiting: number;
+        total: number;
+    };
+    /**
+     * Subscribe to pool events
+     */
+    on(event: string, listener: Function): void;
+    /**
+     * Close the pool and cleanup resources
+     */
+    protected onCleanup(): Promise<void>;
+}