@msugiura/rawsql-prisma/dist/src/StaticAnalysisOrchestrator.d.ts

Prisma integration for rawsql-ts - Dynamic SQL generation with type safety and hierarchical JSON serialization

/**
 * Unified Static Analysis Orchestrator
 *
 * Provides a single entry point for comprehensive static analysis of SQL files,
 * JSON mappings, and domain model compatibility validation.
 *
 * This orchestrator combines:
 * - SQL Static Analysis (schema validation, syntax checking)
 * - Domain Model Compatibility (JSON mapping vs TypeScript interface validation)
 *
 * Usage:
 * ```typescript
 * const orchestrator = new StaticAnalysisOrchestrator(options);
 * const report = await orchestrator.runFullAnalysis();
 * ```
 */
import { SqlStaticAnalysisReport } from './SqlStaticAnalyzer';
export interface StaticAnalysisOptions {
    /** Base directory for the project (typically where package.json is) */
    baseDir: string;
    /** Directory containing SQL and JSON mapping files */
    mappingDir: string;
    /** Prisma client instance (optional - will create if not provided) */
    prismaClient?: any;
    /** Schema name for Prisma resolution (default: 'public') */
    defaultSchema?: string;
    /** String field protection severity level (default: 'error') */
    stringFieldProtectionLevel?: 'error' | 'warning' | 'off';
    /** Enable debug logging */
    debug?: boolean;
}
export interface StringFieldValidationIssue {
    fieldName: string;
    columnName: string;
    entityName: string;
    filePath: string;
    hasStringType: boolean;
    severity: 'warning' | 'error';
    recommendation: string;
}
export interface StringFieldValidationReport {
    totalMappingFiles: number;
    totalStringFields: number;
    protectedFields: number;
    unprotectedFields: number;
    issues: StringFieldValidationIssue[];
    summary: string;
}
export interface ComprehensiveAnalysisReport {
    sqlAnalysis: SqlStaticAnalysisReport;
    domainModelAnalysis: {
        totalMappingFiles: number;
        validCompatibility: number;
        invalidCompatibility: number;
        results: Record<string, any>;
        summary: string;
    };
    stringFieldValidation: StringFieldValidationReport;
    overall: {
        allPassed: boolean;
        totalIssues: number;
        summary: string;
    };
    timestamp: string;
    /** Generate concise per-file summary */
    getConciseFileSummary?: () => string[];
}
export declare class StaticAnalysisOrchestrator {
    private options;
    private sqlAnalyzer?;
    private domainModelTester?;
    private schemaResolver?;
    private ownsPrismaClient;
    private lastDomainModelResults?;
    private lastStringFieldValidation?;
    private lastSqlReport?;
    constructor(options: StaticAnalysisOptions);
    /**
     * Initialize all analysis components
     */
    initialize(): Promise<void>;
    /**
     * Run comprehensive static analysis covering both SQL and domain model aspects
     */
    runFullAnalysis(): Promise<ComprehensiveAnalysisReport>;
    /**
     * Run only SQL static analysis
     */
    runSqlAnalysis(): Promise<SqlStaticAnalysisReport>;
    /**
     * Run only domain model compatibility analysis
     */
    runDomainModelAnalysis(): Promise<Record<string, any>>;
    /**
     * Validate a specific SQL file
     */
    validateSpecificSqlFile(filename: string): Promise<import("./SqlStaticAnalyzer").SqlValidationResult>;
    /**
     * Validate a specific JSON mapping file for domain model compatibility
     */
    validateSpecificMappingFile(filename: string): Promise<{
        isValid: boolean;
        errors: string[];
        details: null;
    } | {
        isValid: boolean;
        errors: string[];
        details: {
            missingProperties: string[];
            extraProperties: string[];
            typeConflicts: {
                property: string;
                expected: string;
                actual: string;
            }[];
        };
    }>;
    /**
     * Clean up resources
     */
    cleanup(): Promise<void>;
    /**
     * Process domain model results into standardized format
     */
    private processDomainModelResults;
    /**
     * Generate overall analysis summary
     */ private generateOverallSummary;
    /**
     * Generate markdown-style concise file summary
     * Format:
     * ## SQL_filename
     * - SQL Static Syntax Check: ✅ Passed
     * - SQL to JSON Query Convert Check: ✅ Passed
     * - JSON to Model Structure Check: ✅ Passed
     */
    generateMarkdownFileSummary(): string[];
    /**
     * Find schema.prisma file path starting from baseDir
     * This method searches common locations to support both terminal and VS Code test execution
     */
    private findSchemaPath; /**
     * Validate string field protection in unified JSON mappings
     */
    validateStringFields(): Promise<StringFieldValidationReport>;
}
/**
 * Convenience function for running full static analysis
 */
export declare function runComprehensiveStaticAnalysis(options: StaticAnalysisOptions): Promise<ComprehensiveAnalysisReport>;
/**
 * Convenience function for running only SQL analysis
 */
export declare function runSqlStaticAnalysis(options: StaticAnalysisOptions): Promise<SqlStaticAnalysisReport>;
/**
 * Convenience function for running only domain model analysis
 */
export declare function runDomainModelAnalysis(options: StaticAnalysisOptions): Promise<Record<string, any>>;