@kenniy/godeye-data-contracts/dist/repositories/enhanced-mongoose-aggregate.repository.d.ts

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

/**
 * BLAZING FAST Enhanced MongoDB Aggregation Repository
 *
 * Next-generation MongoDB aggregation with:
 * - Adaptive query planning and strategy selection
 * - Memory-efficient streaming for large datasets
 * - Intelligent $facet and $lookup optimization
 * - Smart caching with automatic invalidation
 * - Performance monitoring and auto-tuning
 * - Parallel aggregation processing
 */
import { Model, Document } from "mongoose";
import { MongooseAggregateRepository } from "../repositories/mongoose-aggregate.repository";
import { EnhancedQueryConfig, EnhancedPaginatedResult, AggregationStrategy } from "../utils/enhanced-aggregation.utils";
import { PaginationDto } from "../repositories/base-aggregate.repository";
export declare abstract class EnhancedMongooseRepository<T extends Document> extends MongooseAggregateRepository<T> {
    protected readonly model: Model<T>;
    constructor(model: Model<T>);
    /**
     * Execute enhanced complex query with adaptive optimization
     */
    enhancedComplexQuery(config: EnhancedQueryConfig): Promise<EnhancedPaginatedResult<any>>;
    /**
     * Memory-optimized strategy for small datasets (<1K records)
     * Uses simple aggregation pipeline with minimal overhead
     */
    private executeMemoryOptimized;
    /**
     * Hybrid strategy for medium datasets (1K-100K records)
     * Combines memory and disk operations with selective optimization
     */
    private executeHybrid;
    /**
     * Streaming strategy for large datasets (100K-1M records)
     * Uses aggregation cursor with chunked processing
     */
    private executeStreaming;
    /**
     * Distributed strategy for very large datasets (>1M records)
     * Uses map-reduce patterns and chunked parallel processing
     */
    private executeDistributed;
    /**
     * Execute multiple joins in parallel using Promise.all
     */
    private executeParallelJoins;
    /**
     * Build optimized aggregation pipeline based on strategy
     */
    protected buildOptimizedPipeline(config: EnhancedQueryConfig, strategy: AggregationStrategy): any[];
    /**
     * Build filter stages with optimization for different strategies
     */
    protected buildFilterStages(config: EnhancedQueryConfig): any[];
    /**
     * Add pagination using $facet for parallel data + count execution
     */
    private addPaginationToPipeline;
    /**
     * Select optimal index based on query conditions
     */
    private selectOptimalIndex;
    /**
     * Estimate result size for strategy selection
     */
    protected estimateResultSize(config: EnhancedQueryConfig): Promise<number>;
    /**
     * Format results into enhanced paginated structure
     */
    protected formatEnhancedResult(items: any[], total: number, pagination?: PaginationDto): EnhancedPaginatedResult<any>;
    protected buildLookupStage(join: any): any;
    private buildOptimizedLookupStage;
    private buildGroupStages;
    private buildIndexOptimizedStages;
    private convertSortFormat;
    private groupJoinsForParallelExecution;
    private createJoinMergeProjection;
    private selectPartitionField;
    private createDataPartitions;
    private processPartition;
}