@kenniy/godeye-data-contracts/dist/utils/enhanced-aggregation.utils.d.ts

Enterprise-grade base repository architecture for GOD-EYE microservices with zero overhead and maximum code reuse

/**
 * BLAZING FAST Enhanced Aggregation Algorithms
 *
 * Next-generation aggregation engine with advanced optimization:
 * - Adaptive query planning based on data size
 * - Memory-efficient streaming for large datasets
 * - Intelligent index utilization
 * - Parallel processing for multi-step aggregations
 * - Query result caching with smart invalidation
 * - Performance analytics and auto-tuning
 */
import { ComplexQueryConfig, PaginatedResult } from '../repositories/base-aggregate.repository';
export declare enum AggregationStrategy {
    /** Small datasets (<1K records) - Memory-based processing */
    MEMORY_OPTIMIZED = "memory_optimized",
    /** Medium datasets (1K-100K records) - Hybrid approach */
    HYBRID = "hybrid",
    /** Large datasets (>100K records) - Streaming + chunked processing */
    STREAMING = "streaming",
    /** Very large datasets (>1M records) - Distributed processing */
    DISTRIBUTED = "distributed"
}
export declare enum QueryOptimizationLevel {
    /** Basic optimization - Standard indexes */
    BASIC = "basic",
    /** Advanced optimization - Compound indexes + query hints */
    ADVANCED = "advanced",
    /** Enterprise optimization - Partitioning + materialized views */
    ENTERPRISE = "enterprise"
}
export declare enum AggregationStepType {
    /** Standard filtering operation */
    FILTER = "FILTER",
    /** Standard join operation */
    JOIN = "JOIN",
    /** Standard aggregation operation */
    AGGREGATE = "AGGREGATE",
    /** Standard sorting operation */
    SORT = "SORT",
    /** Streaming-based filtering */
    STREAM_FILTER = "STREAM_FILTER",
    /** Chunked join operation for large datasets */
    CHUNK_JOIN = "CHUNK_JOIN",
    /** Streaming aggregation for memory efficiency */
    STREAMING_AGGREGATE = "STREAMING_AGGREGATE",
    /** Merge sort for streaming results */
    MERGE_SORT = "MERGE_SORT",
    /** Data partitioning for distributed processing */
    PARTITION = "PARTITION",
    /** Distributed filtering across partitions */
    DISTRIBUTED_FILTER = "DISTRIBUTED_FILTER",
    /** Map-reduce style join operation */
    MAP_REDUCE_JOIN = "MAP_REDUCE_JOIN",
    /** Distributed aggregation across partitions */
    DISTRIBUTED_AGGREGATE = "DISTRIBUTED_AGGREGATE",
    /** Merge results from distributed operations */
    MERGE_RESULTS = "MERGE_RESULTS"
}
export interface EnhancedQueryConfig extends ComplexQueryConfig {
    /** Strategy override (auto-detected if not specified) */
    strategy?: AggregationStrategy;
    /** Optimization level */
    optimization?: QueryOptimizationLevel;
    /** Enable query result caching */
    enableCaching?: boolean;
    /** Cache TTL in seconds (default: 300) */
    cacheTTL?: number;
    /** Maximum memory usage in MB (default: 512) */
    maxMemoryMB?: number;
    /** Enable parallel processing for multi-step aggregations */
    enableParallel?: boolean;
    /** Query timeout in milliseconds (default: 30000) */
    timeoutMs?: number;
    /** Enable performance metrics collection */
    enableMetrics?: boolean;
    /** Index hints for query optimization */
    indexHints?: string[];
    /** Chunk size for streaming aggregations (default: 1000) */
    chunkSize?: number;
}
export interface QueryMetrics {
    executionTimeMs: number;
    memoryUsedMB: number;
    cpuUsagePercent: number;
    cacheHit: boolean;
    strategy: AggregationStrategy;
    indexesUsed: string[];
    totalRows: number;
    processedChunks?: number;
    parallelOperations?: number;
    optimizationLevel: QueryOptimizationLevel;
}
export interface EnhancedPaginatedResult<T> extends PaginatedResult<T> {
    /** Performance metadata */
    metrics: QueryMetrics;
    /** Query suggestions for optimization */
    suggestions?: string[];
    /** Cache information */
    cacheInfo?: {
        hit: boolean;
        key: string;
        ttl: number;
    };
}
export declare class AdaptiveQueryPlanner {
    /**
     * Analyze query and dataset to determine optimal strategy
     */
    static determineStrategy(config: EnhancedQueryConfig, estimatedRows: number): AggregationStrategy;
    /**
     * Generate optimized query plan based on strategy
     */
    static createQueryPlan(config: EnhancedQueryConfig, strategy: AggregationStrategy): QueryPlan;
    private static generateQuerySteps;
    private static suggestIndexes;
    private static calculateMemoryLimits;
    private static determineParallelization;
}
interface QueryPlan {
    strategy: AggregationStrategy;
    steps: QueryStep[];
    indexHints: string[];
    memoryLimits: MemoryLimits;
    parallelization: ParallelConfig;
}
interface QueryStep {
    type: AggregationStepType;
    priority: number;
    parallel: boolean;
    estimatedTimeMs?: number;
    memoryRequiredMB?: number;
}
interface MemoryLimits {
    totalMB: number;
    bufferMB: number;
    cacheMB: number;
    workingMB: number;
}
interface ParallelConfig {
    enabled: boolean;
    maxWorkers: number;
    chunkSize?: number;
}
export declare class SmartCache {
    private static cache;
    private static readonly DEFAULT_TTL;
    static generateCacheKey(config: EnhancedQueryConfig): string;
    static get<T>(key: string): Promise<T | null>;
    static set<T>(key: string, data: T, ttlSeconds?: number): void;
    static invalidate(pattern: string): void;
    private static hashObject;
    private static estimateSize;
    private static evictIfNeeded;
}
export declare class PerformanceMonitor {
    static startQuery(queryId: string): QuerySession;
    static endQuery(session: QuerySession, result: any): QueryMetrics;
    static analyzePerformance(metrics: QueryMetrics): string[];
}
interface QuerySession {
    queryId: string;
    startTime: number;
    startCpu: NodeJS.CpuUsage;
    startMemory: NodeJS.MemoryUsage;
}
export {};