refaktorálás javításai

backend/app/tests_internal/diagnostics/compare_schema.py

@@ -1,11 +1,13 @@
 # /opt/docker/dev/service_finder/backend/app/tests_internal/diagnostics/compare_schema.py
 import asyncio
 import sys
+import os
 from sqlalchemy.ext.asyncio import create_async_engine
 from sqlalchemy import inspect
 from app.database import Base
 from app.core.config import settings
 
+# Biztosítjuk az importálást
 try:
     import app.models 
 except ImportError as e:
@@ -13,20 +15,25 @@ except ImportError as e:
     sys.exit(1)
 
 async def compare():
-    """ Diagnosztika minden sémára: identity, data, system. """
+    """ Teljes körű diagnosztika az összes DDD domain sémára. """
     print(f"🔗 Kapcsolódás az adatbázishoz...")
     engine = create_async_engine(str(settings.SQLALCHEMY_DATABASE_URI))
     
     def get_diff(connection):
         inspector = inspect(connection)
-        # Ezeket a sémákat ellenőrizzük
-        schemas = ["identity", "data", "system"]
+        
+        # 1. Dinamikusan kigyűjtjük az összes sémát, amit a modellekben definiáltunk
+        expected_schemas = sorted({t.schema for t in Base.metadata.sorted_tables if t.schema})
         all_db_schemas = inspector.get_schema_names()
         
+        print(f"📋 Ellenőrizendő domainek: {', '.join(expected_schemas)}")
+        
         mismatches = 0
-        for sc in schemas:
+        
+        for sc in expected_schemas:
             if sc not in all_db_schemas:
-                print(f"❌ HIBA: A(z) '{sc}' séma nem létezik!")
+                print(f"\n❌ KRITIKUS HIBA: A(z) '{sc}' séma fizikailag HIÁNYZIK az adatbázisból!")
+                mismatches += 1
                 continue
 
             db_tables = inspector.get_table_names(schema=sc)
@@ -40,27 +47,41 @@ async def compare():
                     print(f"❌ HIÁNYZÓ TÁBLA: {sc}.{mt}")
                     mismatches += 1
                 else:
+                    # Oszlopok ellenőrzése
                     db_cols = {c['name']: c for c in inspector.get_columns(mt, schema=sc)}
-                    # Kikeressük a modellt a metadata-ból
+                    
+                    # SQLAlchemy metadata kulcs keresése (séma.tábla formátum)
                     table_key = f"{sc}.{mt}"
+                    if table_key not in Base.metadata.tables:
+                        # Fallback ha nincs séma előtag a kulcsban (ritka)
+                        table_key = mt
+                        
                     model_cols = Base.metadata.tables[table_key].columns
                     
                     missing_cols = [m.name for m in model_cols if m.name not in db_cols]
                     if missing_cols:
-                        print(f"⚠️  {mt:25} | HIÁNYZÓ OSZLOPOK: {missing_cols}")
+                        print(f"⚠️  {mt:30} | HIÁNYZÓ OSZLOPOK: {missing_cols}")
                         mismatches += 1
                     else:
-                        print(f"✅ {mt:25} | Rendben.")
+                        print(f"✅ {mt:30} | Rendben.")
+                        
         return mismatches
 
     try:
         async with engine.connect() as conn:
             err_count = await conn.run_sync(get_diff)
-            print(f"\n--- Összegzés: {err_count} eltérés található. ---\n")
+            if err_count == 0:
+                print(f"\n✨ GRATULÁLOK! Az adatbázis és a modellek 100%-ban szinkronban vannak. ✨")
+            else:
+                print(f"\n--- ⚠️ Összegzés: {err_count} eltérés található. ---\n")
     except Exception as e:
         print(f"❌ HIBA: {e}")
+        import traceback
+        traceback.print_exc()
     finally:
         await engine.dispose()
 
 if __name__ == "__main__":
-    asyncio.run(compare())
+    asyncio.run(compare())
+
+    # docker compose exec api python -m app.tests_internal.diagnostics.compare_schema