feat: performance improvements and maintenance tasks

Author: m0wer

backend/app/cli.py

@@ -1,7 +1,19 @@
 import typer
 from sqlmodel import create_engine, SQLModel
 import os
-from app.tasks import fetch_all_feeds, remove_old_embeddings
+from app.tasks import (
+    fetch_all_feeds,
+    remove_old_embeddings,
+    freeze_dormant_users,
+    cleanup_old_articles,
+    cleanup_orphan_user_article_links,
+    cleanup_orphan_user_feed_links,
+    cleanup_inactive_users,
+    vacuum_database,
+    get_database_stats,
+    run_full_maintenance,
+    unfreeze_user,
+)
 from app.models.article import Article
 from app.models.feed import Feed
 from app.models.user import User
@@ -14,19 +26,100 @@
     connect_args={"check_same_thread": False},
 )
 
-cli = typer.Typer()
+cli = typer.Typer(help="RSS Filter maintenance CLI")
 
 
 @cli.command()
-def fetch_feeds():
-    """Enqueue task to fetch all feeds."""
+def fetch_feeds() -> None:
+    """Fetch all feeds for active (non-frozen) users."""
     fetch_all_feeds()
+    typer.echo("Feed fetch tasks enqueued")
+
+
+@cli.command()
+def clean_embeddings() -> None:
+    """Remove embeddings from old articles to save space."""
+    count = remove_old_embeddings()
+    typer.echo(f"Removed embeddings from {count} articles")
+
+
+@cli.command()
+def freeze_users(days: int = 90) -> None:
+    """Freeze users who have been inactive for specified days."""
+    os.environ["DORMANT_THRESHOLD_DAYS"] = str(days)
+    count = freeze_dormant_users()
+    typer.echo(f"Froze {count} dormant users (inactive >{days} days)")
+
+
+@cli.command()
+def unfreeze(user_id: str) -> None:
+    """Manually unfreeze a specific user."""
+    if unfreeze_user(user_id):
+        typer.echo(f"User {user_id} unfrozen successfully")
+    else:
+        typer.echo(f"User {user_id} was not frozen or does not exist")
+
+
+@cli.command()
+def clean_articles(days: int = 180) -> None:
+    """Delete old unread articles to free up space."""
+    count = cleanup_old_articles(days)
+    typer.echo(f"Deleted {count} old unread articles (>{days} days)")
+
+
+@cli.command()
+def clean_orphans() -> None:
+    """Remove orphan user-article and user-feed links."""
+    article_links = cleanup_orphan_user_article_links()
+    feed_links = cleanup_orphan_user_feed_links()
+    typer.echo(
+        f"Deleted {article_links} orphan article links, {feed_links} orphan feed links"
+    )
+
+
+@cli.command()
+def clean_users(days: int = 365) -> None:
+    """Delete inactive users with no feeds or articles."""
+    count = cleanup_inactive_users(days)
+    typer.echo(f"Deleted {count} inactive users (>{days} days, no feeds/articles)")
+
+
+@cli.command()
+def vacuum() -> None:
+    """Run VACUUM and ANALYZE on the database."""
+    vacuum_database()
+    typer.echo("Database vacuumed and analyzed")
+
+
+@cli.command()
+def stats() -> None:
+    """Show database statistics."""
+    stats = get_database_stats()
+    typer.echo("\nDatabase Statistics:")
+    typer.echo("-" * 40)
+    typer.echo(f"Users: {stats['users']['total']}")
+    typer.echo(f"  - Active (30d): {stats['users']['active_30d']}")
+    typer.echo(f"  - Frozen: {stats['users']['frozen']}")
+    typer.echo(f"Feeds: {stats['feeds']['total']}")
+    typer.echo(f"Articles: {stats['articles']['total']}")
+    typer.echo(f"  - With embeddings: {stats['articles']['with_embeddings']}")
+    typer.echo(f"User-Article Links: {stats['links']['user_article']}")
+    typer.echo(f"User-Feed Links: {stats['links']['user_feed']}")
 
 
 @cli.command()
-def clean_embeddings():
-    """Enqueue task to remove old embeddings."""
-    remove_old_embeddings()
+def maintenance() -> None:
+    """Run full maintenance cycle (freeze, clean, vacuum)."""
+    typer.echo("Starting full maintenance cycle...")
+    results = run_full_maintenance()
+    typer.echo("\nMaintenance Results:")
+    typer.echo("-" * 40)
+    typer.echo(f"Frozen users: {results['frozen_users']}")
+    typer.echo(f"Removed embeddings: {results['removed_embeddings']}")
+    typer.echo(f"Deleted articles: {results['deleted_articles']}")
+    typer.echo(f"Orphan article links: {results['orphan_article_links']}")
+    typer.echo(f"Orphan feed links: {results['orphan_feed_links']}")
+    typer.echo("Database vacuumed: Yes")
 
 
 if __name__ == "__main__":

backend/app/models/user.py

@@ -15,6 +15,8 @@ class User(SQLModel, table=True):
     )
     clusters: str | None = Field(default=None, repr=False)
     clusters_updated_at: datetime | None = Field(default=None, repr=False)
+    is_frozen: bool = Field(default=False, index=True)
+    frozen_at: datetime | None = Field(default=None, repr=False)
 
     articles: list["Article"] = Relationship(  # type: ignore  # noqa: F821
         back_populates="users", link_model=UserArticleLink

backend/app/routers/feed.py

@@ -6,6 +6,7 @@
 from fastapi import APIRouter, Response, Depends
 from sqlmodel import Session, select
 from loguru import logger
+from app.models.article import Article
 from app.models.feed import (
     Feed,
     generate_feed,
@@ -20,9 +21,7 @@
 from fastapi import HTTPException
 from fastapi import BackgroundTasks
 
-# from fastapi_cache.coder import PickleCoder
-# from fastapi_cache.decorator import cache
-from sqlalchemy.orm.exc import NoResultFound
+from sqlalchemy.exc import NoResultFound
 
 router = APIRouter(
     tags=["feed"],
@@ -40,11 +39,15 @@ async def get_feed(
     feed_url: HttpUrl,
     background_tasks: BackgroundTasks,
     engine=Depends(get_engine),
-) -> str:
+) -> Response:
     with Session(engine, autoflush=False) as session:
-        # User handling (same as before)
         try:
             user: User = session.exec(select(User).where(User.id == user_id)).one()
+            user.last_request = datetime.now(timezone.utc)
+            if user.is_frozen:
+                user.is_frozen = False
+                user.frozen_at = None
+                logger.info(f"Auto-unfroze user {user_id} due to feed request")
         except NoResultFound:
             logger.info(f"User {user_id} not found in database, creating new user")
             user = User(id=user_id)
@@ -104,7 +107,14 @@ async def get_feed(
                     break
             session.refresh(feed)
 
-        articles = feed.articles[-30:]
+        articles = list(
+            session.exec(
+                select(Article)
+                .where(Article.feed_id == feed.id)
+                .order_by(Article.pub_date.desc())  # type: ignore[union-attr]
+                .limit(30)
+            ).all()
+        )
 
         if user.clusters:
             filtered_articles = filter_articles(