@freshguard/freshguard-core 0.11.2

package/dist/query-analyzer.js

@@ -0,0 +1,526 @@
+"use strict";
+/**
+ * Query Complexity Analyzer for FreshGuard Core Phase 2
+ *
+ * Analyzes SQL queries for complexity and security risks, providing
+ * risk scoring and recommendations for safe query execution.
+ *
+ * @license MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultQueryAnalyzer = exports.QueryComplexityAnalyzer = void 0;
+exports.createQueryAnalyzer = createQueryAnalyzer;
+exports.createSecurityAnalyzer = createSecurityAnalyzer;
+exports.createPerformanceAnalyzer = createPerformanceAnalyzer;
+// ==============================================
+// Default Configuration
+// ==============================================
+/**
+ * Default query analyzer configuration
+ */
+const DEFAULT_CONFIG = {
+    maxRiskScore: 70,
+    maxComplexityScore: 80,
+    maxEstimatedCost: 1000000, // 1 million cost units
+    maxResultSetSize: 10000,
+    enablePerformanceAnalysis: true,
+    enableSecurityAnalysis: true,
+    customRiskFactors: []
+};
+/**
+ * Default risk factors for security analysis
+ */
+const DEFAULT_RISK_FACTORS = [
+    {
+        pattern: /union\s+all|union\s+select/i,
+        riskScore: 30,
+        description: 'UNION operations can be expensive and may indicate injection attempts',
+        blocking: false
+    },
+    {
+        pattern: /\bor\s+1\s*=\s*1\b/i,
+        riskScore: 90,
+        description: 'Classic SQL injection pattern detected',
+        blocking: true
+    },
+    {
+        pattern: /\bor\s+\'.*?\'\s*=\s*\'.*?\'/i,
+        riskScore: 85,
+        description: 'Potential SQL injection with string comparison',
+        blocking: true
+    },
+    {
+        pattern: /;\s*drop\s+table/i,
+        riskScore: 100,
+        description: 'SQL injection attempt to drop table',
+        blocking: true
+    },
+    {
+        pattern: /;\s*delete\s+from/i,
+        riskScore: 100,
+        description: 'SQL injection attempt to delete data',
+        blocking: true
+    },
+    {
+        pattern: /select\s+\*\s+from\s+information_schema/i,
+        riskScore: 40,
+        description: 'Information schema access - potentially sensitive',
+        blocking: false
+    },
+    {
+        pattern: /select\s+.*\s+from\s+.*\s+where\s+1\s*=\s*1/i,
+        riskScore: 70,
+        description: 'Suspicious WHERE clause that always evaluates to true',
+        blocking: false
+    },
+    {
+        pattern: /\/\*.*?\*\//,
+        riskScore: 20,
+        description: 'SQL comments detected - review for injection attempts',
+        blocking: false
+    },
+    {
+        pattern: /--.*$/m,
+        riskScore: 25,
+        description: 'SQL line comments detected - review for injection attempts',
+        blocking: false
+    }
+];
+// ==============================================
+// SQL Parser Utilities
+// ==============================================
+/**
+ * Simple SQL parser for query analysis
+ * Note: This is a simplified parser for basic analysis
+ */
+class SimpleSQLParser {
+    /**
+     * Parse basic query structure
+     */
+    static parseQuery(sql) {
+        const normalizedSql = sql.trim().toLowerCase();
+        // Determine query type
+        const queryType = this.getQueryType(normalizedSql);
+        // Count tables (simplified - counts FROM and JOIN clauses)
+        const tableCount = this.countTables(normalizedSql);
+        // Count joins
+        const joinCount = this.countJoins(normalizedSql);
+        // Check for various SQL constructs
+        const hasSubqueries = /\(\s*select\b/.test(normalizedSql);
+        const hasAggregations = /\b(count|sum|avg|max|min|group_concat)\s*\(/.test(normalizedSql);
+        const hasWildcards = /select\s+\*\s+from\b/.test(normalizedSql);
+        const hasWhere = /\bwhere\b/.test(normalizedSql);
+        const hasOrderBy = /\border\s+by\b/.test(normalizedSql);
+        const hasGroupBy = /\bgroup\s+by\b/.test(normalizedSql);
+        const hasHaving = /\bhaving\b/.test(normalizedSql);
+        // Check for LIMIT
+        const limitMatch = normalizedSql.match(/\blimit\s+(\d+)/);
+        const hasLimit = !!limitMatch;
+        const limitValue = limitMatch ? parseInt(limitMatch[1], 10) : undefined;
+        // Estimate result set size (simplified)
+        const estimatedResultSize = this.estimateResultSize(tableCount, hasWhere, hasLimit, limitValue);
+        return {
+            queryType,
+            tableCount,
+            joinCount,
+            hasSubqueries,
+            hasAggregations,
+            hasWildcards,
+            hasLimit,
+            limitValue,
+            hasWhere,
+            hasOrderBy,
+            hasGroupBy,
+            hasHaving,
+            estimatedResultSize
+        };
+    }
+    /**
+     * Get query type from SQL
+     */
+    static getQueryType(sql) {
+        if (sql.startsWith('select'))
+            return 'SELECT';
+        if (sql.startsWith('insert'))
+            return 'INSERT';
+        if (sql.startsWith('update'))
+            return 'UPDATE';
+        if (sql.startsWith('delete'))
+            return 'DELETE';
+        if (sql.startsWith('create'))
+            return 'CREATE';
+        if (sql.startsWith('drop'))
+            return 'DROP';
+        if (sql.startsWith('alter'))
+            return 'ALTER';
+        if (sql.startsWith('show'))
+            return 'SHOW';
+        if (sql.startsWith('describe') || sql.startsWith('desc'))
+            return 'DESCRIBE';
+        return 'UNKNOWN';
+    }
+    /**
+     * Count number of tables in query
+     */
+    static countTables(sql) {
+        // Count FROM clauses
+        const fromMatches = sql.match(/\bfrom\s+[\w\.]+/g) || [];
+        // Count JOIN clauses
+        const joinMatches = sql.match(/\bjoin\s+[\w\.]+/g) || [];
+        return fromMatches.length + joinMatches.length;
+    }
+    /**
+     * Count number of joins
+     */
+    static countJoins(sql) {
+        const joinMatches = sql.match(/\b(inner\s+join|left\s+join|right\s+join|full\s+join|join)\b/g) || [];
+        return joinMatches.length;
+    }
+    /**
+     * Estimate result set size
+     */
+    static estimateResultSize(tableCount, hasWhere, hasLimit, limitValue) {
+        // If LIMIT is specified, use that as max
+        if (hasLimit && limitValue) {
+            return Math.min(limitValue, 10000);
+        }
+        // Base estimate on table count and filtering
+        let estimate = Math.pow(1000, tableCount); // Exponential growth with joins
+        // Reduce estimate if WHERE clause exists (assumes filtering)
+        if (hasWhere) {
+            estimate = Math.floor(estimate * 0.1); // Assume WHERE reduces by 90%
+        }
+        // Cap at reasonable maximum
+        return Math.min(estimate, 100000);
+    }
+}
+// ==============================================
+// Query Complexity Analyzer
+// ==============================================
+/**
+ * Analyzes SQL queries for complexity and security risks
+ */
+class QueryComplexityAnalyzer {
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.riskFactors = [
+            ...DEFAULT_RISK_FACTORS,
+            ...(config.customRiskFactors || [])
+        ];
+    }
+    /**
+     * Analyze a SQL query for complexity and security risks
+     */
+    analyzeQuery(sql, tableMetadata = []) {
+        // Parse query structure
+        const details = SimpleSQLParser.parseQuery(sql);
+        // Calculate scores
+        const complexityScore = this.calculateComplexityScore(details, tableMetadata);
+        const riskScore = this.calculateRiskScore(sql, details);
+        const estimatedCost = this.calculateEstimatedCost(details, tableMetadata);
+        // Generate warnings and recommendations
+        const securityWarnings = this.generateSecurityWarnings(sql, details);
+        const performanceWarnings = this.generatePerformanceWarnings(details, tableMetadata);
+        const recommendations = this.generateRecommendations(details, securityWarnings, performanceWarnings);
+        // Determine if execution should be allowed
+        const allowExecution = this.shouldAllowExecution(sql, riskScore, complexityScore, estimatedCost, details);
+        return {
+            allowExecution,
+            riskScore,
+            complexityScore,
+            estimatedCost,
+            securityWarnings,
+            performanceWarnings,
+            recommendations,
+            details
+        };
+    }
+    /**
+     * Calculate query complexity score (0-100)
+     */
+    calculateComplexityScore(details, tableMetadata) {
+        let score = 0;
+        // Base score by query type
+        switch (details.queryType) {
+            case 'SELECT':
+                score += 5;
+                break;
+            case 'INSERT':
+                score += 15;
+                break;
+            case 'UPDATE':
+                score += 20;
+                break;
+            case 'DELETE':
+                score += 25;
+                break;
+            case 'CREATE':
+                score += 30;
+                break;
+            case 'DROP':
+                score += 50;
+                break;
+            case 'ALTER':
+                score += 40;
+                break;
+            default: score += 10;
+        }
+        // Table complexity
+        score += Math.min(details.tableCount * 10, 30); // Max 30 for tables
+        // Join complexity
+        score += Math.min(details.joinCount * 15, 40); // Max 40 for joins
+        // Subquery complexity
+        if (details.hasSubqueries)
+            score += 20;
+        // Aggregation complexity
+        if (details.hasAggregations)
+            score += 10;
+        // Wildcard penalty (SELECT *)
+        if (details.hasWildcards)
+            score += 15;
+        // Missing WHERE clause on multi-table queries
+        if (details.tableCount > 1 && !details.hasWhere)
+            score += 25;
+        // Large result set penalty
+        if (details.estimatedResultSize > 1000)
+            score += 10;
+        if (details.estimatedResultSize > 10000)
+            score += 20;
+        // No LIMIT on potentially large results
+        if (!details.hasLimit && details.estimatedResultSize > 1000)
+            score += 15;
+        return Math.min(score, 100);
+    }
+    /**
+     * Calculate security risk score (0-100)
+     */
+    calculateRiskScore(sql, details) {
+        let score = 0;
+        if (!this.config.enableSecurityAnalysis) {
+            return 0;
+        }
+        // Check against risk factors
+        for (const factor of this.riskFactors) {
+            if (factor.pattern.test(sql)) {
+                score += factor.riskScore;
+            }
+        }
+        // Additional risk factors based on query structure
+        if (details.queryType !== 'SELECT' && details.queryType !== 'SHOW' && details.queryType !== 'DESCRIBE') {
+            score += 30; // Non-read operations are inherently riskier
+        }
+        // Multiple statements (potential injection)
+        const statementCount = sql.split(';').filter(s => s.trim()).length;
+        if (statementCount > 1) {
+            score += 40;
+        }
+        return Math.min(score, 100);
+    }
+    /**
+     * Calculate estimated execution cost
+     */
+    calculateEstimatedCost(details, tableMetadata) {
+        let cost = 1; // Base cost
+        // Cost based on estimated result size
+        cost += details.estimatedResultSize * 0.1;
+        // Join costs (exponential)
+        if (details.joinCount > 0) {
+            cost *= Math.pow(10, details.joinCount);
+        }
+        // Table scan costs
+        for (let i = 0; i < details.tableCount; i++) {
+            const metadata = tableMetadata[i];
+            if (metadata) {
+                cost += metadata.estimatedRows * 0.01;
+            }
+            else {
+                cost += 10000; // Unknown table - assume large
+            }
+        }
+        // Subquery costs
+        if (details.hasSubqueries) {
+            cost *= 5;
+        }
+        // Aggregation costs
+        if (details.hasAggregations) {
+            cost *= 2;
+        }
+        // Sorting costs
+        if (details.hasOrderBy && !details.hasLimit) {
+            cost *= 3;
+        }
+        return Math.floor(cost);
+    }
+    /**
+     * Generate security warnings
+     */
+    generateSecurityWarnings(sql, details) {
+        const warnings = [];
+        if (!this.config.enableSecurityAnalysis) {
+            return warnings;
+        }
+        // Check risk factors
+        for (const factor of this.riskFactors) {
+            if (factor.pattern.test(sql)) {
+                warnings.push(factor.description);
+            }
+        }
+        // Additional security checks
+        if (details.queryType !== 'SELECT' && details.queryType !== 'SHOW' && details.queryType !== 'DESCRIBE') {
+            warnings.push('Non-read operation detected - ensure proper authorization');
+        }
+        if (sql.includes(';') && sql.split(';').filter(s => s.trim()).length > 1) {
+            warnings.push('Multiple SQL statements detected - potential injection risk');
+        }
+        if (details.hasWildcards && details.tableCount > 0) {
+            warnings.push('SELECT * detected - may expose sensitive columns');
+        }
+        return warnings;
+    }
+    /**
+     * Generate performance warnings
+     */
+    generatePerformanceWarnings(details, tableMetadata) {
+        const warnings = [];
+        if (!this.config.enablePerformanceAnalysis) {
+            return warnings;
+        }
+        // Large result set without LIMIT
+        if (details.estimatedResultSize > 1000 && !details.hasLimit) {
+            warnings.push(`Large result set estimated (${details.estimatedResultSize}) without LIMIT clause`);
+        }
+        // Multiple joins without WHERE
+        if (details.joinCount > 1 && !details.hasWhere) {
+            warnings.push('Multiple JOINs without WHERE clause may produce Cartesian product');
+        }
+        // SELECT * on large tables
+        if (details.hasWildcards && tableMetadata.some(t => t.estimatedRows > 10000)) {
+            warnings.push('SELECT * on large table(s) - consider selecting specific columns');
+        }
+        // ORDER BY without LIMIT on large result
+        if (details.hasOrderBy && !details.hasLimit && details.estimatedResultSize > 1000) {
+            warnings.push('ORDER BY without LIMIT on large result set - consider adding LIMIT');
+        }
+        // Subqueries
+        if (details.hasSubqueries) {
+            warnings.push('Subqueries detected - consider using JOINs for better performance');
+        }
+        return warnings;
+    }
+    /**
+     * Generate optimization recommendations
+     */
+    generateRecommendations(details, securityWarnings, performanceWarnings) {
+        const recommendations = [];
+        // Security recommendations
+        if (securityWarnings.length > 0) {
+            recommendations.push('Review security warnings and validate query source');
+        }
+        if (details.hasWildcards) {
+            recommendations.push('Replace SELECT * with specific column names');
+        }
+        // Performance recommendations
+        if (!details.hasLimit && details.estimatedResultSize > 1000) {
+            recommendations.push('Add LIMIT clause to prevent large result sets');
+        }
+        if (details.joinCount > 0 && !details.hasWhere) {
+            recommendations.push('Add WHERE clause to filter results and improve performance');
+        }
+        if (details.hasOrderBy && details.estimatedResultSize > 1000) {
+            recommendations.push('Consider adding indexes on ORDER BY columns');
+        }
+        if (details.hasSubqueries) {
+            recommendations.push('Consider rewriting subqueries as JOINs');
+        }
+        if (performanceWarnings.length > 2) {
+            recommendations.push('Query complexity is high - consider breaking into smaller queries');
+        }
+        return recommendations;
+    }
+    /**
+     * Determine if query execution should be allowed
+     */
+    shouldAllowExecution(sql, riskScore, complexityScore, estimatedCost, details) {
+        // Check against thresholds
+        if (riskScore > this.config.maxRiskScore) {
+            return false;
+        }
+        if (complexityScore > this.config.maxComplexityScore) {
+            return false;
+        }
+        if (estimatedCost > this.config.maxEstimatedCost) {
+            return false;
+        }
+        if (details.estimatedResultSize > this.config.maxResultSetSize) {
+            return false;
+        }
+        // Check for blocking risk factors
+        for (const factor of this.riskFactors) {
+            if (factor.blocking && factor.pattern.test(sql)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Add custom risk factor
+     */
+    addRiskFactor(factor) {
+        this.riskFactors.push(factor);
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+}
+exports.QueryComplexityAnalyzer = QueryComplexityAnalyzer;
+// ==============================================
+// Factory Functions
+// ==============================================
+/**
+ * Create a query analyzer with default configuration
+ */
+function createQueryAnalyzer(config) {
+    return new QueryComplexityAnalyzer(config);
+}
+/**
+ * Create a strict security analyzer
+ */
+function createSecurityAnalyzer() {
+    return new QueryComplexityAnalyzer({
+        maxRiskScore: 30,
+        maxComplexityScore: 50,
+        maxEstimatedCost: 100000,
+        maxResultSetSize: 1000,
+        enableSecurityAnalysis: true,
+        enablePerformanceAnalysis: false
+    });
+}
+/**
+ * Create a performance-focused analyzer
+ */
+function createPerformanceAnalyzer() {
+    return new QueryComplexityAnalyzer({
+        maxRiskScore: 100, // Allow all from security perspective
+        maxComplexityScore: 60,
+        maxEstimatedCost: 500000,
+        maxResultSetSize: 5000,
+        enableSecurityAnalysis: false,
+        enablePerformanceAnalysis: true
+    });
+}
+// ==============================================
+// Default Analyzer Instance
+// ==============================================
+/**
+ * Default query analyzer instance
+ */
+exports.defaultQueryAnalyzer = createQueryAnalyzer();

package/dist/resilience/circuit-breaker.d.ts

@@ -0,0 +1,94 @@
+import type { StructuredLogger } from '../observability/logger.js';
+import type { MetricsCollector } from '../observability/metrics.js';
+export declare enum CircuitBreakerState {
+    CLOSED = "CLOSED",
+    OPEN = "OPEN",
+    HALF_OPEN = "HALF_OPEN"
+}
+export interface CircuitBreakerConfig {
+    failureThreshold: number;
+    successThreshold: number;
+    recoveryTimeout: number;
+    windowSize: number;
+    errorFilter?: (error: Error) => boolean;
+    name?: string;
+    logger?: StructuredLogger;
+    metrics?: MetricsCollector;
+    enableDetailedLogging?: boolean;
+}
+export interface CircuitBreakerStats {
+    state: CircuitBreakerState;
+    totalCalls: number;
+    successfulCalls: number;
+    failedCalls: number;
+    rejectedCalls: number;
+    lastFailureTime: Date | null;
+    lastSuccessTime: Date | null;
+    nextAttemptTime: Date | null;
+    failureRate: number;
+    uptime: number;
+}
+export type CircuitBreakerResult<T> = {
+    success: true;
+    data: T;
+    executionTime: number;
+} | {
+    success: false;
+    error: CircuitBreakerError;
+    executionTime: number;
+};
+export declare class CircuitBreakerError extends Error {
+    readonly circuitName: string;
+    readonly state: CircuitBreakerState;
+    readonly timestamp: Date;
+    constructor(message: string, circuitName: string, state: CircuitBreakerState);
+}
+export declare class CircuitOpenError extends CircuitBreakerError {
+    readonly nextAttemptTime: Date;
+    constructor(circuitName: string, nextAttemptTime: Date);
+}
+export declare class CircuitBreaker {
+    private state;
+    private failureWindow;
+    private successCount;
+    private totalCalls;
+    private successfulCalls;
+    private failedCalls;
+    private rejectedCalls;
+    private lastFailureTime;
+    private lastSuccessTime;
+    private nextAttemptTime;
+    private readonly config;
+    private readonly logger;
+    private readonly metrics;
+    private readonly enableDetailedLogging;
+    private lastStateChangeTime;
+    constructor(config: CircuitBreakerConfig);
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+    executeWithResult<T>(fn: () => Promise<T>): Promise<CircuitBreakerResult<T>>;
+    private onSuccess;
+    private onFailure;
+    private tripCircuit;
+    private changeState;
+    private recordMetrics;
+    private resetFailureCount;
+    getStats(): CircuitBreakerStats;
+    isCallable(): boolean;
+    reset(): void;
+    trip(): void;
+    getName(): string;
+    getState(): CircuitBreakerState;
+}
+export declare function createDatabaseCircuitBreaker(name: string): CircuitBreaker;
+export declare function createApiCircuitBreaker(name: string): CircuitBreaker;
+export declare class CircuitBreakerRegistry {
+    private readonly circuits;
+    getOrCreate(name: string, config?: CircuitBreakerConfig): CircuitBreaker;
+    getAllCircuits(): Map<string, CircuitBreaker>;
+    getAllStats(): Record<string, CircuitBreakerStats>;
+    resetAll(): void;
+    remove(name: string): boolean;
+    clear(): void;
+}
+export declare const defaultCircuitBreakerRegistry: CircuitBreakerRegistry;
+//# sourceMappingURL=circuit-breaker.d.ts.map

package/dist/resilience/circuit-breaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuit-breaker.d.ts","sourceRoot":"","sources":["../../src/resilience/circuit-breaker.ts"],"names":[],"mappings":"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"}