feat(settings): add settings management endpoints for saving and clearing data

- Implemented a POST endpoint to save settings, allowing users to store configuration values.
- Added a DELETE endpoint to clear specific data types from the database.
- Introduced a manual cleanup endpoint to remove old records based on retention policies.
- Enhanced the database size retrieval functionality for better monitoring.
- Updated the settings page to display database size and provide a manual cleanup option.

Author: halilibrahimd27

schema-monitor/api/routes.py

@@ -1080,6 +1080,130 @@ async def test_alert_channel(request: Request, channel_name: str) -> dict[str, A
     }
 
 
+# === Settings Yönetimi ===
+
+@router.post("/api/settings")
+async def save_settings(request: Request) -> dict[str, Any]:
+    """Ayarları kaydet.
+
+    Args:
+        request: HTTP isteği
+
+    Returns:
+        Kayıt sonucu
+    """
+    storage = request.app.state.storage
+    if storage is None:
+        raise HTTPException(status_code=503, detail="Storage backend hazır değil")
+
+    body = await request.json()
+    saved_keys: list[str] = []
+
+    for key, value in body.items():
+        await storage.save_setting(key, str(value))
+        saved_keys.append(key)
+
+    logger.info(f"Ayarlar kaydedildi: {saved_keys}")
+
+    return {"saved_keys": saved_keys, "message": "Ayarlar başarıyla kaydedildi"}
+
+
+@router.delete("/api/settings/clear/{data_type}")
+async def clear_data(request: Request, data_type: str) -> dict[str, Any]:
+    """Veritabanı verilerini temizle.
+
+    Args:
+        request: HTTP isteği
+        data_type: Silinecek veri tipi (changes, snapshots, all)
+
+    Returns:
+        Silme sonucu
+    """
+    storage = request.app.state.storage
+    if storage is None:
+        raise HTTPException(status_code=503, detail="Storage backend hazır değil")
+
+    valid_types = {"changes", "snapshots", "all"}
+    if data_type not in valid_types:
+        raise HTTPException(status_code=400, detail=f"Geçersiz veri tipi: {data_type}")
+
+    deleted: dict[str, int] = {}
+
+    if data_type == "changes":
+        deleted["changes"] = await storage.clear_table("changes")
+    elif data_type == "snapshots":
+        deleted["snapshots"] = await storage.clear_table("snapshots")
+    elif data_type == "all":
+        deleted["changes"] = await storage.clear_table("changes")
+        deleted["snapshots"] = await storage.clear_table("snapshots")
+        deleted["endpoints"] = await storage.clear_table("endpoints")
+        deleted["providers"] = await storage.clear_table("providers")
+        deleted["credentials"] = await storage.clear_table("credentials")
+
+    # Boş alanları geri kazan
+    await storage.vacuum()
+
+    total = sum(deleted.values())
+    logger.info(f"Veri temizliği ({data_type}): toplam {total} kayıt silindi")
+
+    return {"data_type": data_type, "deleted": deleted, "message": f"{total} kayıt silindi"}
+
+
+@router.post("/api/settings/cleanup")
+async def run_cleanup(request: Request) -> dict[str, Any]:
+    """Manuel retention temizliği çalıştır.
+
+    Settings'teki max_changes_retained ve max_snapshots_per_endpoint
+    değerlerine göre eski verileri temizler.
+
+    Args:
+        request: HTTP isteği
+
+    Returns:
+        Temizlik sonucu
+    """
+    storage = request.app.state.storage
+    if storage is None:
+        raise HTTPException(status_code=503, detail="Storage backend hazır değil")
+
+    # Retention ayarlarını oku
+    max_changes = int(await storage.get_setting("max_changes_retained", "1000"))
+    max_snapshots = int(await storage.get_setting("max_snapshots_per_endpoint", "50"))
+
+    deleted_changes = await storage.cleanup_old_changes(max_changes)
+    deleted_snapshots = await storage.cleanup_old_snapshots(max_snapshots)
+
+    # Silinen varsa VACUUM yap
+    if deleted_changes > 0 or deleted_snapshots > 0:
+        await storage.vacuum()
+
+    db_size = await storage.get_db_size_bytes()
+
+    return {
+        "deleted_changes": deleted_changes,
+        "deleted_snapshots": deleted_snapshots,
+        "db_size_bytes": db_size,
+        "db_size_human": _format_bytes(db_size),
+        "message": f"Temizlik tamamlandı: {deleted_changes} change, {deleted_snapshots} snapshot silindi",
+    }
+
+
+def _format_bytes(size: int) -> str:
+    """Byte değerini okunabilir formata dönüştür.
+
+    Args:
+        size: Byte cinsinden boyut
+
+    Returns:
+        Okunabilir boyut string'i (örn: '2.4 MB')
+    """
+    for unit in ("B", "KB", "MB", "GB"):
+        if size < 1024:
+            return f"{size:.1f} {unit}" if size >= 10 else f"{size:.2f} {unit}"
+        size /= 1024
+    return f"{size:.1f} TB"
+
+
 # === Metrics ===
 
 @router.get("/metrics")

schema-monitor/api/views.py

@@ -10,6 +10,22 @@
 
 logger = logging.getLogger(__name__)
 
+
+def _format_bytes(size: int) -> str:
+    """Byte değerini okunabilir formata dönüştür.
+
+    Args:
+        size: Byte cinsinden boyut
+
+    Returns:
+        Okunabilir boyut string'i (örn: '2.4 MB')
+    """
+    for unit in ("B", "KB", "MB", "GB"):
+        if size < 1024:
+            return f"{size:.1f} {unit}" if size >= 10 else f"{size:.2f} {unit}"
+        size /= 1024
+    return f"{size:.1f} TB"
+
 view_router = APIRouter()
 
 # Templates dizini — app.py'de mount edilecek
@@ -299,6 +315,11 @@ async def settings_page(request: Request) -> HTMLResponse:
         for key, value in table_counts.items():
             settings_data[key] = str(value)
 
+        # DB dosya boyutunu ekle
+        db_size_bytes = await storage.get_db_size_bytes()
+        settings_data["db_size_bytes"] = str(db_size_bytes)
+        settings_data["db_size_human"] = _format_bytes(db_size_bytes)
+
     return templates.TemplateResponse(
         "settings.html",
         {

schema-monitor/core/store/base.py

@@ -115,3 +115,58 @@ async def acknowledge_change(self, change_id: int) -> bool:
             Başarılıysa True
         """
         ...
+
+    @abstractmethod
+    async def cleanup_old_snapshots(self, max_per_endpoint: int) -> int:
+        """Her endpoint için eski snapshot'ları temizle.
+
+        Her endpoint'te en fazla max_per_endpoint kadar snapshot bırakır,
+        geri kalanını (en eski olanları) siler.
+
+        Args:
+            max_per_endpoint: Endpoint başına saklanacak max snapshot sayısı
+
+        Returns:
+            Silinen snapshot sayısı
+        """
+        ...
+
+    @abstractmethod
+    async def cleanup_old_changes(self, max_total: int) -> int:
+        """Eski değişiklik kayıtlarını temizle.
+
+        Toplam max_total kadar kayıt bırakır, en eskileri siler.
+
+        Args:
+            max_total: Saklanacak max toplam değişiklik sayısı
+
+        Returns:
+            Silinen değişiklik sayısı
+        """
+        ...
+
+    @abstractmethod
+    async def get_db_size_bytes(self) -> int:
+        """Veritabanı dosya boyutunu byte cinsinden döndür.
+
+        Returns:
+            Dosya boyutu (byte)
+        """
+        ...
+
+    @abstractmethod
+    async def clear_table(self, table_name: str) -> int:
+        """Belirtilen tablonun tüm kayıtlarını sil.
+
+        Args:
+            table_name: Silinecek tablo adı
+
+        Returns:
+            Silinen kayıt sayısı
+        """
+        ...
+
+    @abstractmethod
+    async def vacuum(self) -> None:
+        """Veritabanı dosyasını sıkıştır (boş alanları geri kazan)."""
+        ...

schema-monitor/core/store/sqlite_store.py

@@ -818,6 +818,153 @@ async def get_table_counts(self) -> dict[str, int]:
 
         return counts
 
+    # === Retention / Cleanup ===
+
+    async def cleanup_old_snapshots(self, max_per_endpoint: int) -> int:
+        """Her endpoint için eski snapshot'ları temizle.
+
+        Her endpoint'te en fazla max_per_endpoint kadar snapshot bırakır,
+        geri kalanını (en eski olanları) siler.
+
+        Args:
+            max_per_endpoint: Endpoint başına saklanacak max snapshot sayısı
+
+        Returns:
+            Silinen snapshot sayısı
+        """
+        conn = self._get_connection()
+
+        # Her provider/endpoint çifti için en yeni max_per_endpoint kadarını bırak
+        cursor = conn.execute(
+            "SELECT DISTINCT provider, endpoint FROM snapshots"
+        )
+        pairs = [(row["provider"], row["endpoint"]) for row in cursor.fetchall()]
+
+        total_deleted = 0
+        for provider, endpoint in pairs:
+            # En yeni max_per_endpoint id'sini bul (eşik)
+            threshold_cursor = conn.execute(
+                """SELECT id FROM snapshots
+                   WHERE provider = ? AND endpoint = ?
+                   ORDER BY version DESC
+                   LIMIT 1 OFFSET ?""",
+                (provider, endpoint, max_per_endpoint - 1),
+            )
+            threshold_row = threshold_cursor.fetchone()
+
+            if threshold_row is None:
+                # Bu endpoint'te max_per_endpoint'ten az snapshot var
+                continue
+
+            # Eşiğin altındaki eski kayıtları sil
+            delete_cursor = conn.execute(
+                """DELETE FROM snapshots
+                   WHERE provider = ? AND endpoint = ? AND id < ?""",
+                (provider, endpoint, threshold_row["id"]),
+            )
+            total_deleted += delete_cursor.rowcount
+
+        if total_deleted > 0:
+            conn.commit()
+            logger.info(f"Eski snapshot temizliği: {total_deleted} kayıt silindi")
+
+        return total_deleted
+
+    async def cleanup_old_changes(self, max_total: int) -> int:
+        """Eski değişiklik kayıtlarını temizle.
+
+        Toplam max_total kadar kayıt bırakır, en eskileri siler.
+
+        Args:
+            max_total: Saklanacak max toplam değişiklik sayısı
+
+        Returns:
+            Silinen değişiklik sayısı
+        """
+        conn = self._get_connection()
+
+        # Mevcut toplam sayı
+        cursor = conn.execute("SELECT COUNT(*) as cnt FROM changes")
+        total = cursor.fetchone()["cnt"]
+
+        if total <= max_total:
+            return 0
+
+        # En yeni max_total kaydın id eşiğini bul
+        threshold_cursor = conn.execute(
+            """SELECT id FROM changes
+               ORDER BY detected_at DESC
+               LIMIT 1 OFFSET ?""",
+            (max_total - 1,),
+        )
+        threshold_row = threshold_cursor.fetchone()
+
+        if threshold_row is None:
+            return 0
+
+        # Eşiğin altındaki eski kayıtları sil
+        delete_cursor = conn.execute(
+            "DELETE FROM changes WHERE id < ?",
+            (threshold_row["id"],),
+        )
+        deleted = delete_cursor.rowcount
+        conn.commit()
+
+        if deleted > 0:
+            logger.info(f"Eski değişiklik temizliği: {deleted} kayıt silindi")
+
+        return deleted
+
+    async def get_db_size_bytes(self) -> int:
+        """Veritabanı dosya boyutunu byte cinsinden döndür.
+
+        Returns:
+            Dosya boyutu (byte)
+        """
+        db_path = Path(self._db_path)
+        if not db_path.exists():
+            return 0
+
+        total = db_path.stat().st_size
+
+        # WAL ve SHM dosyalarını da hesaba kat
+        wal_path = db_path.with_suffix(".db-wal")
+        shm_path = db_path.with_suffix(".db-shm")
+        if wal_path.exists():
+            total += wal_path.stat().st_size
+        if shm_path.exists():
+            total += shm_path.stat().st_size
+
+        return total
+
+    async def clear_table(self, table_name: str) -> int:
+        """Belirtilen tablonun tüm kayıtlarını sil.
+
+        Args:
+            table_name: Silinecek tablo adı
+
+        Returns:
+            Silinen kayıt sayısı
+        """
+        # Güvenlik: sadece bilinen tabloları sil
+        allowed_tables = {"snapshots", "changes", "providers", "endpoints", "credentials", "alert_configs"}
+        if table_name not in allowed_tables:
+            logger.warning(f"Bilinmeyen tablo temizleme isteği reddedildi: {table_name}")
+            return 0
+
+        conn = self._get_connection()
+        cursor = conn.execute(f"DELETE FROM {table_name}")  # noqa: S608
+        conn.commit()
+        deleted = cursor.rowcount
+        logger.info(f"Tablo temizlendi: {table_name} ({deleted} kayıt)")
+        return deleted
+
+    async def vacuum(self) -> None:
+        """Veritabanı dosyasını sıkıştır (boş alanları geri kazan)."""
+        conn = self._get_connection()
+        conn.execute("VACUUM")
+        logger.info("Veritabanı VACUUM tamamlandı")
+
     # === İstatistikler ===
 
     async def get_stats(self) -> dict[str, Any]: