@simonecoelhosfo/optimizely-mcp-server
Version:
Optimizely MCP Server for AI assistants with integrated CLI tools
154 lines • 4.15 kB
TypeScript
/**
* Query Complexity Firewall - Final Protection Layer
*
* CRITICAL COMPONENT: Last line of defense against query explosions by:
* 1. Scoring query complexity across multiple dimensions
* 2. Implementing circuit breakers for dangerous queries
* 3. Providing intelligent fallback strategies
* 4. Learning from query execution patterns
*
* Created: July 5, 2025
* Purpose: Third line of defense against analytics system failure
*/
export interface QueryComplexity {
joinCount: number;
estimatedRows: number;
aggregationFunctions: string[];
groupByFields: number;
crossEntityCount: number;
jsonPathCount: number;
nestedQueryDepth: number;
complexity: 'simple' | 'moderate' | 'complex' | 'dangerous';
score: number;
riskFactors: string[];
}
export interface ComplexityThresholds {
simple: {
maxScore: number;
maxJoins: number;
maxRows: number;
};
moderate: {
maxScore: number;
maxJoins: number;
maxRows: number;
};
complex: {
maxScore: number;
maxJoins: number;
maxRows: number;
};
dangerous: {
maxScore: number;
maxJoins: number;
maxRows: number;
};
}
export interface QueryFirewallConfig {
enabled: boolean;
thresholds: ComplexityThresholds;
enableFallbacks: boolean;
enableLearning: boolean;
timeoutMs: number;
debugMode: boolean;
}
export interface FallbackStrategy {
name: string;
description: string;
sql: string;
estimatedAccuracy: number;
executionTime: number;
}
/**
* Query Complexity Firewall Implementation
*/
export declare class QueryComplexityFirewall {
private config;
private queryHistory;
private circuitBreaker;
constructor(config?: Partial<QueryFirewallConfig>);
/**
* Analyze query complexity and determine if it should be allowed
*/
analyzeQuery(queryInfo: {
sql: string;
joins: Array<{
fromTable: string;
toTable: string;
joinType: string;
}>;
aggregations: string[];
groupByFields: string[];
crossEntities: string[];
estimatedRows: number;
}): {
complexity: QueryComplexity;
allowed: boolean;
fallback?: FallbackStrategy;
recommendations: string[];
};
/**
* Calculate comprehensive complexity score
*/
private calculateComplexity;
/**
* Check if a JOIN pattern is known to be dangerous
*/
private isDangerousJoinPattern;
/**
* Count JSON path operations in SQL
*/
private countJSONPaths;
/**
* Calculate nested query depth
*/
private calculateNestedQueryDepth;
/**
* Convert score to complexity level
*/
private scoreToComplexityLevel;
/**
* Determine if query should be allowed based on complexity
*/
private isQueryAllowed;
private queryInfo;
/**
* Generate recommendations for query optimization
*/
private generateRecommendations;
/**
* Generate fallback strategy for complex queries
*/
private generateFallbackStrategy;
/**
* Check circuit breaker for query type
*/
private checkCircuitBreaker;
/**
* Record query execution result for learning
*/
recordQueryExecution(complexity: QueryComplexity, success: boolean, executionTimeMs: number, resultCount: number): void;
/**
* Create a pattern key for query learning
*/
private createQueryPattern;
/**
* Create simple complexity for disabled firewall
*/
private createSimpleComplexity;
/**
* Get firewall statistics for monitoring
*/
getStatistics(): {
totalQueries: number;
blockedQueries: number;
complexityDistribution: Record<string, number>;
circuitBreakerStatus: Record<string, boolean>;
averageScore: number;
};
/**
* Update firewall configuration at runtime
*/
updateConfig(updates: Partial<QueryFirewallConfig>): void;
}
//# sourceMappingURL=QueryComplexityFirewall.d.ts.map