gmail-mcp-server/dist/utils/performance-optimization.d.ts

Gmail MCP Server with on-demand authentication for SIYA/Claude Desktop. Complete Gmail integration with multi-user support and OAuth2 security.

/**
 * Performance Optimization Module
 * Implements caching, batch operations, connection pooling, and memory management
 */
import { EmailMessage } from './gmail-operations.js';
export interface CacheConfig {
    maxSize: number;
    ttlMs: number;
    enablePersistence: boolean;
    compressionLevel: number;
}
export interface BatchConfig {
    maxBatchSize: number;
    batchTimeoutMs: number;
    concurrentBatches: number;
    retryAttempts: number;
}
export interface ConnectionPoolConfig {
    maxConnections: number;
    idleTimeoutMs: number;
    connectionTimeoutMs: number;
    keepAliveMs: number;
}
export interface PerformanceMetrics {
    cacheHitRate: number;
    avgResponseTime: number;
    memoryUsage: number;
    activeConnections: number;
    batchSuccessRate: number;
    apiCallsReduced: number;
}
/**
 * High-Performance Email Cache System
 * LRU cache with compression and persistence options
 */
export declare class EmailCacheManager {
    private cache;
    private accessOrder;
    private config;
    private currentSize;
    private hits;
    private misses;
    private compressionWorker?;
    constructor(config?: Partial<CacheConfig>);
    get<T>(key: string): Promise<T | null>;
    set<T>(key: string, data: T, options?: {
        compress?: boolean;
        priority?: 'high' | 'normal' | 'low';
    }): Promise<void>;
    delete(key: string): boolean;
    clear(): void;
    getStats(): {
        hitRate: number;
        size: number;
        memoryUsage: number;
    };
    static emailKey(messageId: string): string;
    static searchKey(criteria: any): string;
    static threadKey(threadId: string): string;
    static attachmentKey(messageId: string, attachmentId: string): string;
    private updateAccessOrder;
    private evictLRU;
    private calculateSize;
    private compress;
    private decompress;
    private cleanup;
}
/**
 * Batch Operation Manager
 * Efficiently handles bulk email operations
 */
export declare class BatchOperationManager {
    private config;
    private pendingOperations;
    private batchTimers;
    private activeBatches;
    private metrics;
    constructor(config?: Partial<BatchConfig>);
    addToBatch<T>(operationType: string, operation: T, executor: (operations: T[]) => Promise<any[]>): Promise<any>;
    private setBatchTimer;
    private executeBatch;
    getBatchStats(): {
        totalOperations: number;
        batchedOperations: number;
        batchEfficiency: number;
        successRate: number;
    };
    shutdown(): Promise<void>;
}
/**
 * Connection Pool Manager
 * Manages Gmail API connection pooling and optimization
 */
export declare class ConnectionPoolManager {
    private config;
    private activeConnections;
    private idleConnections;
    private connectionPromises;
    private metrics;
    constructor(config?: Partial<ConnectionPoolConfig>);
    getConnection(connectionId?: string): Promise<any>;
    releaseConnection(connectionId: string | undefined, connection: any): void;
    closeConnection(connectionId?: string): void;
    private createConnection;
    private waitForAvailableConnection;
    private cleanupIdleConnections;
    private updateAvgConnectionTime;
    getConnectionStats(): {
        activeConnections: number;
        idleConnections: number;
        connectionsCreated: number;
        connectionsReused: number;
        reuseRate: number;
        avgConnectionTime: number;
    };
    shutdown(): Promise<void>;
}
/**
 * Memory Management and Streaming
 * Handles large result sets efficiently
 */
export declare class MemoryManager {
    private memoryThreshold;
    private streamingThreshold;
    private currentMemoryUsage;
    processLargeResultSet<T>(data: T[], processor: (chunk: T[]) => Promise<void>, chunkSize?: number): Promise<void>;
    createAsyncIterator<T>(data: T[], chunkSize?: number): AsyncIterableIterator<T[]>;
    private shouldTriggerGC;
    private triggerGarbageCollection;
    getMemoryStats(): {
        heapUsed: number;
        heapTotal: number;
        external: number;
    };
}
/**
 * Performance Optimization Manager
 * Orchestrates all performance features
 */
export declare class PerformanceOptimizationManager {
    private cache;
    private batchManager;
    private connectionPool;
    private memoryManager;
    private startTime;
    constructor(cacheConfig?: Partial<CacheConfig>, batchConfig?: Partial<BatchConfig>, connectionConfig?: Partial<ConnectionPoolConfig>);
    getCachedEmail(messageId: string, fetcher: () => Promise<EmailMessage>): Promise<EmailMessage>;
    getCachedSearchResults(criteria: any, searcher: () => Promise<any>): Promise<any>;
    batchEmailOperation<T>(operationType: string, operation: T, executor: (operations: T[]) => Promise<any[]>): Promise<any>;
    getOptimizedConnection(connectionId?: string): Promise<any>;
    releaseOptimizedConnection(connectionId: string | undefined, connection: any): void;
    processLargeEmailSet<T>(emails: T[], processor: (chunk: T[]) => Promise<void>, chunkSize?: number): Promise<void>;
    createEmailIterator<T>(emails: T[], chunkSize?: number): AsyncIterableIterator<T[]>;
    getPerformanceMetrics(): PerformanceMetrics;
    shutdown(): Promise<void>;
}
//# sourceMappingURL=performance-optimization.d.ts.map