supa-seed/dist/core/config/config-manager.d.ts

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

import { FlexibleSeedConfig, ConfigProfile, ConfigDetectionResult, ExtendedSeedConfig } from '../types/config-types';
import type { createClient } from '@supabase/supabase-js';
import type { ConstraintHandler } from '../../features/analysis/constraint-types';
import type { SeedingStrategy } from '../../features/integration/strategy-interface';
type SupabaseClient = ReturnType<typeof createClient>;
export interface ConfigManagerOptions {
    enableExtensibility?: boolean;
    enableSchemaEvolution?: boolean;
    customHandlerRegistry?: Map<string, ConstraintHandler>;
    customStrategies?: Map<string, SeedingStrategy>;
}
export declare class ConfigManager {
    private configPath;
    private options;
    private schemaCache;
    private customHandlers;
    private customStrategies;
    private client?;
    constructor(configPath?: string, options?: ConfigManagerOptions);
    /**
     * Detect current database schema and suggest configuration
     */
    detectAndSuggestConfig(client: SupabaseClient, configOverride?: any, supabaseUrl?: string, supabaseKey?: string): Promise<ConfigDetectionResult>;
    /**
     * Create a configuration file with auto-detection
     */
    createConfig(client: SupabaseClient, options?: {
        environment?: 'local' | 'staging' | 'production';
        userCount?: number;
        force?: boolean;
    }): Promise<FlexibleSeedConfig>;
    /**
     * Load configuration from file
     */
    loadConfig(): FlexibleSeedConfig;
    /**
     * Save configuration to file
     */
    saveConfig(config: FlexibleSeedConfig): void;
    /**
     * Validate configuration
     */
    validateConfig(config: FlexibleSeedConfig): FlexibleSeedConfig;
    /**
     * Validate column mappings against actual database schema
     */
    validateColumnMappings(client: SupabaseClient, config: FlexibleSeedConfig): Promise<{
        valid: boolean;
        warnings: string[];
        suggestions: string[];
    }>;
    /**
     * Create multiple environment profiles
     */
    createProfiles(): ConfigProfile[];
    /**
     * Auto-create missing tables based on configuration
     */
    autoCreateTables(client: SupabaseClient, config: FlexibleSeedConfig): Promise<void>;
    /**
     * Print configuration summary
     */
    printConfigSummary(config: FlexibleSeedConfig): void;
    /**
     * Check if a table exists in the database
     */
    private tableExists;
    /**
     * Epic 7 Enhanced Configuration Methods
     */
    /**
     * FR-7.1: Support framework strategy overrides
     */
    detectFrameworkWithOverrides(client: SupabaseClient, config?: ExtendedSeedConfig): Promise<{
        detectedFramework: string;
        overriddenFramework?: string;
        availableStrategies: string[];
        recommendations: string[];
    }>;
    /**
     * FR-7.2: Register custom constraint handler
     */
    registerCustomConstraintHandler(handler: ConstraintHandler): void;
    /**
     * FR-7.2: Apply custom constraint handlers from configuration
     */
    applyCustomConstraintHandlers(config: ExtendedSeedConfig): ConstraintHandler[];
    /**
     * FR-7.3: Schema evolution detection
     */
    detectSchemaEvolution(client: SupabaseClient, config: ExtendedSeedConfig): Promise<{
        hasChanged: boolean;
        changes: Array<{
            type: 'table_added' | 'table_removed' | 'column_added' | 'column_removed' | 'constraint_changed';
            table: string;
            column?: string;
            description: string;
        }>;
        schemaVersion: string;
        migrationRequired: boolean;
        recommendations: string[];
    }>;
    /**
     * FR-7.4: Generate realistic data volume configuration
     */
    generateDataVolumeConfiguration(requirements: {
        environment: 'development' | 'staging' | 'production';
        testingScenarios: string[];
        expectedLoad: 'light' | 'medium' | 'heavy';
        domainType?: string;
        customConstraints?: {
            maxUsers?: number;
            maxSeedingTime?: number;
            maxDatabaseSize?: number;
        };
    }): ExtendedSeedConfig['dataVolumes'];
    /**
     * Calculate data generation metrics for a configuration
     */
    calculateDataGenerationMetrics(config: ExtendedSeedConfig): {
        totalUsers: number;
        totalItems: number;
        totalRelationships: number;
        publicContentCount: number;
        privateContentCount: number;
        draftContentCount: number;
        estimatedDatabaseSize: number;
        estimatedSeedingTime: number;
    };
    /**
     * Get recommended data volume profile for specific use case
     */
    getRecommendedDataVolumeProfile(useCase: 'ci-testing' | 'development' | 'demo' | 'load-testing' | 'production'): import("../../features/generation/data-volume-manager").DataVolumeProfile;
    /**
     * Validate data volume configuration
     */
    validateDataVolumeConfiguration(config: ExtendedSeedConfig['dataVolumes']): {
        valid: boolean;
        errors: string[];
        warnings: string[];
        recommendations: string[];
    };
    /**
     * FR-7.5: Validate custom relationship definitions
     */
    validateCustomRelationships(client: SupabaseClient, relationships: ExtendedSeedConfig['customRelationships']): Promise<{
        valid: boolean;
        errors: string[];
        warnings: string[];
        recommendations: string[];
    }>;
    /**
     * Generate relationship execution plan
     */
    generateRelationshipExecutionPlan(client: SupabaseClient, relationships: ExtendedSeedConfig['customRelationships']): Promise<import("../../schema/custom-relationship-manager").RelationshipGenerationPlan>;
    /**
     * Create relationship generators for data seeding
     */
    createRelationshipGenerators(client: SupabaseClient, relationships: ExtendedSeedConfig['customRelationships']): Map<any, any>;
    /**
     * Apply inheritance rules to generated data
     */
    applyInheritanceRules(client: SupabaseClient, data: Record<string, any[]>, inheritanceRules?: any[]): Record<string, any[]>;
    /**
     * Generate data using configured patterns
     */
    generateDataWithPatterns(config: ExtendedSeedConfig, table: string, count: number, context?: Record<string, any>): any[];
    /**
     * Apply consistency rules to generated data
     */
    applyDataConsistencyRules(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 on generated data
     */
    enforceReferentialIntegrity(data: Record<string, any[]>, config: ExtendedSeedConfig): {
        data: Record<string, any[]>;
        orphansRemoved: number;
        referencesFixed: number;
    };
    /**
     * Validate generated data patterns
     */
    validateGeneratedDataPatterns(data: Record<string, any[]>, config: ExtendedSeedConfig): {
        valid: boolean;
        errors: string[];
        warnings: string[];
        patternMetrics: Record<string, any>;
    };
    /**
     * Get available data generation patterns
     */
    getAvailableDataPatterns(domain?: string): import("../../features/generation/data-generation-pattern-manager").DataGenerationPattern[];
    /**
     * Get domain-specific vocabulary
     */
    getDomainVocabulary(domain: string): import("../../features/generation/data-generation-pattern-manager").DomainVocabulary | undefined;
    /**
     * Create custom data generation pattern
     */
    createCustomDataPattern(pattern: any): void;
    /**
     * Enhanced configuration validation with extensibility support
     */
    validateExtendedConfig(config: ExtendedSeedConfig): {
        valid: boolean;
        errors: string[];
        warnings: string[];
        recommendations: string[];
    };
    /**
     * Helper methods for Epic 7 functionality
     */
    private registerCustomStrategy;
    private createConstraintHandlerFunction;
    private mapChangeType;
}
export {};
//# sourceMappingURL=config-manager.d.ts.map