supa-seed/dist/features/analysis/constraint-validator.d.ts

A constraint-aware, framework-agnostic database seeding framework with deep PostgreSQL business logic discovery and MakerKit integration support

/**
 * Constraint-Aware Validation System
 * Validates operations against actual database constraints before execution
 * Prevents the constraint violations identified in beta testing
 */
import type { createClient } from '@supabase/supabase-js';
import { SchemaIntrospectionResult } from '../../schema/schema-introspector';
type SupabaseClient = ReturnType<typeof createClient>;
export interface ValidationRule {
    id: string;
    name: string;
    description: string;
    table: string;
    column?: string;
    type: 'not_null' | 'unique' | 'foreign_key' | 'check' | 'custom' | 'business_logic';
    severity: 'error' | 'warning' | 'info';
    sqlCheck: string;
    parameters: string[];
    errorMessage: string;
    autoFix?: {
        possible: boolean;
        strategy: 'provide_default' | 'skip_field' | 'modify_value' | 'create_dependency';
        fixValue?: any;
    };
}
export interface ValidationContext {
    operation: 'insert' | 'update' | 'delete';
    table: string;
    data: Record<string, any>;
    userId?: string;
    existingData?: Record<string, any>;
    schemaInfo: SchemaIntrospectionResult;
}
export interface ValidationResult {
    valid: boolean;
    errors: ValidationError[];
    warnings: ValidationWarning[];
    autoFixes: AutoFix[];
    constraintsChecked: number;
    executionTime: number;
}
export interface ValidationError {
    rule: string;
    field?: string;
    message: string;
    severity: 'error' | 'warning';
    constraint: string;
    suggestedFix?: string;
    blockExecution: boolean;
}
export interface ValidationWarning {
    rule: string;
    field?: string;
    message: string;
    impact: 'low' | 'medium' | 'high';
    recommendation: string;
}
export interface AutoFix {
    rule: string;
    field: string;
    originalValue: any;
    fixedValue: any;
    strategy: string;
    applied: boolean;
}
export declare class ConstraintValidator {
    private client;
    private validationRules;
    private schemaInfo;
    constructor(client: SupabaseClient);
    /**
     * Initialize validator with schema information and build validation rules
     */
    initialize(schemaInfo: SchemaIntrospectionResult): Promise<void>;
    /**
     * Validate data against all applicable constraints before operation
     */
    validateOperation(context: ValidationContext): Promise<ValidationResult>;
    /**
     * Apply auto-fixes to data before operation
     */
    applyAutoFixes(data: Record<string, any>, autoFixes: AutoFix[]): Promise<{
        data: Record<string, any>;
        appliedFixes: AutoFix[];
    }>;
    /**
     * Build validation rules from schema constraints
     */
    private buildValidationRules;
    /**
     * Build validation rules from database constraints
     */
    private buildConstraintRules;
    /**
     * Build NOT NULL constraint rules
     */
    private buildNotNullRules;
    /**
     * Build UNIQUE constraint rules
     */
    private buildUniqueRules;
    /**
     * Build FOREIGN KEY constraint rules
     */
    private buildForeignKeyRules;
    /**
     * Build CHECK constraint rules
     */
    private buildCheckConstraintRules;
    /**
     * Build business logic constraint rules
     */
    private buildBusinessLogicRules;
    /**
     * Build pattern-based validation rules
     */
    private buildPatternRules;
    /**
     * Build user table specific rules
     */
    private buildUserTableRules;
    /**
     * Execute a single validation rule
     */
    private executeValidationRule;
    /**
     * Validate NOT NULL constraint
     */
    private validateNotNull;
    /**
     * Validate UNIQUE constraint
     */
    private validateUnique;
    /**
     * Validate FOREIGN KEY constraint
     */
    private validateForeignKey;
    /**
     * Validate CHECK constraint
     */
    private validateCheckConstraint;
    /**
     * Validate business logic constraint
     */
    private validateBusinessLogic;
    /**
     * Validate custom rule
     */
    private validateCustomRule;
    /**
     * Utility methods
     */
    private getDefaultValueForColumn;
    private getTotalRuleCount;
    /**
     * Get validation rules for a specific table
     */
    getTableRules(tableName: string): ValidationRule[];
    /**
     * Get all validation rules
     */
    getAllRules(): Map<string, ValidationRule[]>;
    /**
     * Clear validation cache
     */
    clearCache(): void;
}
export {};
//# sourceMappingURL=constraint-validator.d.ts.map