Stop Django v5.2 Migration Errors in 10 Minutes Using AI Debugging

# migration_debugger.py - Put this in your Django project root
import os
import django
from django.core.management import execute_from_command_line
from django.db import connection
import json

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'your_project.settings')
django.setup()

def analyze_migration_conflicts():
    """Generate comprehensive migration conflict report for AI analysis"""
    
    report = {
        "django_version": django.get_version(),
        "database_engine": connection.vendor,
        "pending_migrations": [],
        "model_constraints": {},
        "data_samples": {},
        "error_context": {}
    }
    
    # Get pending migrations
    from django.db.migrations.executor import MigrationExecutor
    executor = MigrationExecutor(connection)
    plan = executor.migration_plan(executor.loader.graph.leaf_nodes())
    
    for migration, backwards in plan:
        report["pending_migrations"].append({
            "app": migration.app_label,
            "name": migration.name,
            "operations": [str(op) for op in migration.operations]
        })
    
    # Analyze current constraints
    with connection.cursor() as cursor:
        # PostgreSQL specific - adapt for other databases
        cursor.execute("""
            SELECT conname, contype, pg_get_constraintdef(oid)
            FROM pg_constraint 
            WHERE contype IN ('u', 'f', 'p')
        """)
        
        constraints = cursor.fetchall()
        report["model_constraints"] = {
            name: {"type": ctype, "definition": definition}
            for name, ctype, definition in constraints
        }
    
    return report

if __name__ == "__main__":
    report = analyze_migration_conflicts()
    with open("migration_analysis.json", "w") as f:
        json.dump(report, f, indent=2)
    print("Migration analysis saved to migration_analysis.json")

# settings.py - Add this to your Django settings
import logging

# Enhanced migration logging
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'detailed': {
            'format': '{levelname} {asctime} {module} {process:d} {thread:d} {message}',
            'style': '{',
        },
    },
    'handlers': {
        'migration_file': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',
            'filename': 'migration_debug.log',
            'formatter': 'detailed',
        },
    },
    'loggers': {
        'django.db.migrations': {
            'handlers': ['migration_file'],
            'level': 'DEBUG',
            'propagate': True,
        },
        'django.db.backends': {
            'handlers': ['migration_file'],
            'level': 'DEBUG',
            'propagate': True,
        },
    },
}

# Custom migration error context
MIGRATION_DEBUG_MODE = True

# Run migration with enhanced logging
python manage.py migrate --verbosity=2 2>&1 | tee migration_error_full.log

# If migration fails, you'll have complete context in both files:
# - migration_debug.log (Django internals)
# - migration_error_full.log (Full command output)

# AI Debugging Prompt Template - Copy this exact format

I'm debugging a Django v5.2 migration error. Here's the complete context:

## Error Details
[Paste your full error from migration_error_full.log]

## Migration Analysis  
[Attach your migration_analysis.json file]

## Specific Questions
1. What exact constraint is causing the conflict?
2. Which rows in my database violate this constraint?
3. What's the safest way to fix the data before re-running migration?
4. Is this a known Django 5.2 issue with a documented workaround?

## My Environment
- Django: 5.2.1
- Database: PostgreSQL 15
- Python: 3.11
- Previous Django version: 4.2

## What I Need
- Exact SQL commands to identify problematic data
- Step-by-step fix that preserves existing data
- Prevention strategy for future similar migrations

Please analyze the constraint conflict and provide executable solutions.

# safe_migration_fix.py - AI-guided safe execution
import os
import django
from django.db import transaction, connection
import json
from datetime import datetime

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'your_project.settings')
django.setup()

class SafeMigrationFixer:
    def __init__(self):
        self.backup_data = {}
        self.operations_log = []
    
    def backup_affected_rows(self, table_name, where_clause):
        """Backup rows that will be modified"""
        with connection.cursor() as cursor:
            cursor.execute(f"SELECT * FROM {table_name} WHERE {where_clause}")
            columns = [desc[0] for desc in cursor.description]
            rows = cursor.fetchall()
            
            self.backup_data[table_name] = {
                'columns': columns,
                'rows': [dict(zip(columns, row)) for row in rows],
                'timestamp': datetime.now().isoformat()
            }
            
        print(f"Backed up {len(rows)} rows from {table_name}")
    
    def execute_fix_with_rollback(self, fix_sql, description):
        """Execute AI-recommended fix with automatic rollback on error"""
        try:
            with transaction.atomic():
                print(f"Executing: {description}")
                
                # Create savepoint before each operation
                savepoint = transaction.savepoint()
                
                with connection.cursor() as cursor:
                    if isinstance(fix_sql, list):
                        for sql in fix_sql:
                            print(f"  Running: {sql}")
                            cursor.execute(sql)
                    else:
                        print(f"  Running: {fix_sql}")
                        cursor.execute(fix_sql)
                
                # Verify the fix worked
                self.verify_fix()
                
                print(f"✅ Successfully executed: {description}")
                self.operations_log.append({
                    'operation': description,
                    'sql': fix_sql,
                    'timestamp': datetime.now().isoformat(),
                    'status': 'success'
                })
                
        except Exception as e:
            print(f"❌ Error in {description}: {str(e)}")
            transaction.savepoint_rollback(savepoint)
            self.operations_log.append({
                'operation': description,
                'sql': fix_sql,
                'error': str(e),
                'timestamp': datetime.now().isoformat(),
                'status': 'rolled_back'
            })
            raise
    
    def verify_fix(self):
        """Run verification queries to ensure fix is working"""
        # Add your specific verification logic here
        with connection.cursor() as cursor:
            # Example: Check for constraint violations
            cursor.execute("SELECT COUNT(*) FROM your_table WHERE constraint_violated")
            if cursor.fetchone()[0] > 0:
                raise Exception("Fix didn't resolve constraint violations")
    
    def save_operation_log(self):
        """Save operation log for audit trail"""
        log_data = {
            'backup_data': self.backup_data,
            'operations': self.operations_log,
            'timestamp': datetime.now().isoformat()
        }
        
        filename = f"migration_fix_log_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
        with open(filename, 'w') as f:
            json.dump(log_data, f, indent=2, default=str)
        print(f"Operation log saved to {filename}")

# Example usage based on AI recommendations
if __name__ == "__main__":
    fixer = SafeMigrationFixer()
    
    # Example AI-recommended fix for unique constraint violation
    ai_recommended_fixes = [
        {
            'description': 'Remove duplicate email entries keeping latest',
            'backup_query': 'email IN (SELECT email FROM users GROUP BY email HAVING COUNT(*) > 1)',
            'fix_sql': [
                """DELETE FROM users 
                   WHERE id NOT IN (
                       SELECT MAX(id) FROM users GROUP BY email
                   )"""
            ]
        }
    ]
    
    try:
        for fix in ai_recommended_fixes:
            # Backup affected data first
            fixer.backup_affected_rows('users', fix['backup_query'])
            
            # Execute the fix
            fixer.execute_fix_with_rollback(fix['fix_sql'], fix['description'])
        
        print("✅ All fixes applied successfully. Ready to run migration.")
        
    except Exception as e:
        print(f"❌ Fix failed: {e}")
        print("Data has been rolled back to original state.")
    
    finally:
        fixer.save_operation_log()

# Test migration in safe incremental steps
python manage.py migrate --dry-run --verbosity=2 > migration_plan.txt

# Review the plan with AI first
echo "AI: Review this migration plan for potential issues:"
cat migration_plan.txt

# Run migration with detailed monitoring
python manage.py migrate --verbosity=2 | tee final_migration.log

# post_migration_validator.py - Verify migration success
import os
import django
from django.db import connection
from django.core.management import call_command
import json

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'your_project.settings')
django.setup()

def validate_migration_success():
    """Comprehensive post-migration validation"""
    validation_results = {
        "migration_status": {},
        "data_integrity": {},
        "performance_impact": {},
        "constraint_health": {}
    }
    
    # Check migration status
    from django.db.migrations.executor import MigrationExecutor
    executor = MigrationExecutor(connection)
    plan = executor.migration_plan(executor.loader.graph.leaf_nodes())
    
    validation_results["migration_status"] = {
        "pending_migrations": len(plan),
        "all_applied": len(plan) == 0
    }
    
    # Validate constraints are working
    with connection.cursor() as cursor:
        cursor.execute("""
            SELECT COUNT(*) as total_constraints,
                   SUM(CASE WHEN NOT convalidated THEN 1 ELSE 0 END) as invalid_constraints
            FROM pg_constraint
        """)
        
        result = cursor.fetchone()
        validation_results["constraint_health"] = {
            "total_constraints": result[0],
            "invalid_constraints": result[1],
            "all_valid": result[1] == 0
        }
    
    # Basic data integrity checks
    from django.apps import apps
    for model in apps.get_models():
        try:
            count = model.objects.count()
            validation_results["data_integrity"][model._meta.label] = {
                "record_count": count,
                "accessible": True
            }
        except Exception as e:
            validation_results["data_integrity"][model._meta.label] = {
                "error": str(e),
                "accessible": False
            }
    
    return validation_results

if __name__ == "__main__":
    results = validate_migration_success()
    
    print("🔍 Migration Validation Results:")
    if results["migration_status"]["all_applied"]:
        print("✅ All migrations applied successfully")
    else:
        print(f"⚠️  {results['migration_status']['pending_migrations']} migrations still pending")
    
    if results["constraint_health"]["all_valid"]:
        print("✅ All database constraints are valid")
    else:
        print(f"❌ {results['constraint_health']['invalid_constraints']} invalid constraints found")
    
    print(f"📊 Validated {len(results['data_integrity'])} models")
    
    # Save detailed results
    with open("migration_validation_results.json", "w") as f:
        json.dump(results, f, indent=2, default=str)
    
    print("📄 Full validation report saved to migration_validation_results.json")