supa-seed/dist/features/generation/data-generation-pattern-manager.d.ts

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

/**
 * Data Generation Pattern Manager for Epic 7: Configuration Extensibility Framework
 * Manages advanced data generation patterns and domain-specific configurations
 */
import { ExtendedSeedConfig } from '../../core/types/config-types';
export interface DataGenerationPattern {
    id: string;
    name: string;
    description: string;
    domain: string;
    pattern: {
        type: 'sequential' | 'random' | 'weighted' | 'realistic' | 'custom';
        parameters: Record<string, any>;
    };
    vocabulary: string[];
    templates: Record<string, string>;
    constraints: Array<{
        field: string;
        type: 'length' | 'format' | 'range' | 'unique' | 'custom';
        value: any;
        message?: string;
    }>;
}
export interface DomainVocabulary {
    domain: string;
    categories: Record<string, string[]>;
    templates: Record<string, string>;
    relationships: Record<string, number>;
    businessRules: Record<string, any>;
}
export interface ConsistencyRule {
    id: string;
    tables: string[];
    rule: string;
    validator?: string;
    fixer?: string;
    severity: 'error' | 'warning' | 'info';
    autoFix: boolean;
}
export interface ReferentialIntegrityConfig {
    enforceStrict: boolean;
    allowOrphans: boolean;
    cleanupStrategy: 'cascade' | 'nullify' | 'preserve';
    cascadeLevels: number;
    checkConstraints: boolean;
}
export declare class DataGenerationPatternManager {
    private patterns;
    private vocabularies;
    private consistencyRules;
    constructor();
    /**
     * Generate data according to configured patterns
     */
    generateDataWithPatterns(config: ExtendedSeedConfig, table: string, count: number, context?: Record<string, any>): any[];
    /**
     * Apply consistency rules to generated data
     */
    applyConsistencyRules(data: Record<string, any[]>, config: ExtendedSeedConfig): {
        data: Record<string, any[]>;
        violations: Array<{
            rule: string;
            severity: string;
            message: string;
            affectedTables: string[];
            autoFixed: boolean;
        }>;
    };
    /**
     * Enforce referential integrity
     */
    enforceReferentialIntegrity(data: Record<string, any[]>, config: ExtendedSeedConfig): {
        data: Record<string, any[]>;
        orphansRemoved: number;
        referencesFixed: number;
    };
    /**
     * Validate generated data patterns
     */
    validateGeneratedPatterns(data: Record<string, any[]>, config: ExtendedSeedConfig): {
        valid: boolean;
        errors: string[];
        warnings: string[];
        patternMetrics: Record<string, any>;
    };
    /**
     * Get available patterns for a domain
     */
    getAvailablePatterns(domain?: string): DataGenerationPattern[];
    /**
     * Get domain vocabulary
     */
    getDomainVocabulary(domain: string): DomainVocabulary | undefined;
    /**
     * Create custom pattern
     */
    createCustomPattern(pattern: DataGenerationPattern): void;
    /**
     * Private helper methods
     */
    private initializeDefaultPatterns;
    private initializeDomainVocabularies;
    private initializeConsistencyRules;
    private getDomainConfig;
    private tableMatchesDomain;
    private getPatternForTable;
    private getDefaultPattern;
    private generateBasicData;
    private generateSequentialData;
    private generateRandomData;
    private generateWeightedData;
    private generateRealisticData;
    private generateCustomData;
    private generateRecordFromPattern;
    private processTemplate;
    private checkConsistencyRule;
    private applyConsistencyFixes;
    private buildForeignKeyMap;
    private validateAndFixReferences;
    private analyzeDomainPatterns;
    private validateConsistencyRules;
    private validateReferentialIntegrity;
}
//# sourceMappingURL=data-generation-pattern-manager.d.ts.map