code-auditor-mcp/dist/analyzers/universal/UniversalSchemaAnalyzer.d.ts

Multi-language code quality auditor with MCP server - Analyze TypeScript, JavaScript, and Go code for SOLID principles, DRY violations, security patterns, and more

/**
 * Universal Schema Analyzer
 * Works across multiple programming languages using the adapter pattern
 * Analyzes code against database schemas
 */
import { UniversalAnalyzer } from '../../languages/UniversalAnalyzer.js';
import type { Violation } from '../../types.js';
import type { AST, LanguageAdapter } from '../../languages/types.js';
/**
 * Configuration for Schema analyzer
 */
export interface SchemaAnalyzerConfig {
    enableTableUsageTracking?: boolean;
    checkMissingReferences?: boolean;
    checkNamingConventions?: boolean;
    detectUnusedTables?: boolean;
    validateQueryPatterns?: boolean;
    maxQueriesPerFunction?: number;
    requiredSchemas?: string[];
    schemas?: Array<{
        name: string;
        tables: Array<{
            name: string;
            columns: Array<{
                name: string;
                type: string;
            }>;
        }>;
    }>;
    validateJsonSchemas?: boolean;
    jsonSchemaVersion?: 'draft-04' | 'draft-06' | 'draft-07' | '2019-09' | '2020-12';
    allowedJsonTypes?: string[];
    schemaFilePatterns?: string[];
    dataFilePatterns?: string[];
    schemaDataPairs?: Array<{
        schema: string;
        data: string | string[];
    }>;
    strictMode?: boolean;
    allowAdditionalProperties?: boolean;
}
export declare const DEFAULT_SCHEMA_CONFIG: SchemaAnalyzerConfig;
import type { AnalyzerResult } from '../../types.js';
export declare class UniversalSchemaAnalyzer extends UniversalAnalyzer {
    readonly name = "schema";
    readonly description = "Analyzes code against database schemas and validates JSON schemas";
    readonly category = "database";
    private tableReferences;
    private columnReferences;
    /**
     * Override analyze to handle both TypeScript files and JSON files
     */
    analyze(files: string[], config: any): Promise<AnalyzerResult>;
    protected analyzeAST(ast: AST, adapter: LanguageAdapter, config: SchemaAnalyzerConfig, sourceCode: string): Promise<Violation[]>;
    /**
     * Find table references in the code
     */
    private findTableReferences;
    /**
     * Find column references
     */
    private findColumnReferences;
    /**
     * Check naming conventions
     */
    private checkNamingConventions;
    /**
     * Check query patterns
     */
    private checkQueryPatterns;
    /**
     * Check for SQL injection vulnerabilities
     */
    private checkSQLInjection;
    /**
     * Helper methods
     */
    private getQueryType;
    private isSystemTable;
    private countQueries;
    private findNodeByLocation;
    /**
     * Analyze JSON Schema files
     */
    private analyzeJsonSchemas;
    /**
     * Validate a JSON Schema
     */
    private validateJsonSchema;
    /**
     * Recursively validate schema types
     */
    private validateSchemaTypes;
    /**
     * Identify schema files based on patterns
     */
    private identifySchemaFiles;
    /**
     * Identify data files based on patterns
     */
    private identifyDataFiles;
    /**
     * Load a schema from file
     */
    private loadSchema;
    /**
     * Find matching schema for a data file
     */
    private findMatchingSchema;
    /**
     * Validate data against a JSON Schema
     */
    private validateDataAgainstSchema;
    /**
     * Validate data against schema recursively
     */
    private validateAgainstSchema;
}
//# sourceMappingURL=UniversalSchemaAnalyzer.d.ts.map