feat(api): cache /user upstream responses in postgres (24h TTL) (#78)

Author: Androz2091

src/app.py

@@ -8,7 +8,7 @@
 # Import tasks before db so dotenv loads before SQLAlchemy reads POSTGRES_URL.
 import tasks
 from enqueue import enqueue_package
-from db import PackageProcessStatus, SavedPackageData, Session, fetch_package_status, fetch_package_rank
+from db import PackageProcessStatus, SavedPackageData, Session, fetch_package_status, fetch_package_rank, get_cached_discord_user, cache_discord_user
 
 from sqlite import generate_demo_database
 
@@ -291,13 +291,23 @@ def get_avatar(package_id, user_id):
             return make_response('', 401)
 
         session = Session()
-        data = fetch_package_status(package_id, session)
-        session.close()
-
-        if not data:
-            return make_response('', 401)
-        
-        user = fetch_diswho_user(user_id)
+        try:
+            data = fetch_package_status(package_id, session)
+
+            if not data:
+                return make_response('', 401)
+
+            # Hit the upstream only on a cache miss / stale entry. Then
+            # only persist responses that look real — username present
+            # is the cheapest signal that we got past auth/404/5xx and
+            # have something worth handing back to a future caller.
+            user = get_cached_discord_user(user_id, session)
+            if not user:
+                user = fetch_diswho_user(user_id)
+                if user and user.get('username'):
+                    cache_discord_user(user_id, user, session)
+        finally:
+            session.close()
 
         if not user:
             return make_response('', 500)

src/db.py

@@ -1,10 +1,12 @@
 import os
 
-from datetime import datetime
+from datetime import datetime, timedelta
 from sqlalchemy import create_engine, Column, Integer, String, DateTime, Boolean
 from sqlalchemy.orm import declarative_base, sessionmaker
 from sqlalchemy.sql import func, text
 
+import orjson
+
 engine = create_engine(os.getenv('POSTGRES_URL'), pool_recycle=3600, pool_pre_ping=True)
 
 Base = declarative_base()
@@ -18,6 +20,24 @@ class SavedPackageData(Base):
     created_at = Column(DateTime, nullable=False, default=func.now())
     updated_at = Column(DateTime, nullable=False, onupdate=func.now(), default=func.now())
 
+class CachedDiscordUser(Base):
+    """Cache of upstream /user payloads (diswho or Discord bot API).
+
+    Discord usernames + avatars don't move often; the upstream is rate-
+    limited (429s on bursts) so a small Postgres-backed cache absorbs
+    the per-package fan-out and stops us hammering Discord every time
+    a user opens a heavy package.
+    """
+    __tablename__ = 'cached_discord_user'
+
+    user_id = Column(String(255), primary_key=True)
+    payload = Column(String, nullable=False)  # JSON-serialized upstream response
+    cached_at = Column(DateTime, nullable=False, default=func.now())
+
+
+CACHED_DISCORD_USER_TTL_HOURS = 24
+
+
 class PackageProcessStatus(Base):
     __tablename__ = 'package_process_status'
 
@@ -93,6 +113,33 @@ def fetch_package_status(package_id, session):
     status = session.query(PackageProcessStatus).filter_by(package_id=package_id).order_by(PackageProcessStatus.created_at.desc()).first()
     return status
 
+def get_cached_discord_user(user_id, session):
+    """Return the cached upstream user dict, or None if absent or stale."""
+    row = session.query(CachedDiscordUser).filter_by(user_id=user_id).first()
+    if not row:
+        return None
+    if datetime.now() - row.cached_at > timedelta(hours=CACHED_DISCORD_USER_TTL_HOURS):
+        return None
+    return orjson.loads(row.payload)
+
+
+def cache_discord_user(user_id, payload, session):
+    """Upsert a user payload into the cache.
+
+    Caller must only pass valid upstream responses — never None, never
+    error envelopes — so the cache doesn't pin failures and starve
+    legitimate retries.
+    """
+    serialized = orjson.dumps(payload).decode()
+    existing = session.query(CachedDiscordUser).filter_by(user_id=user_id).first()
+    if existing:
+        existing.payload = serialized
+        existing.cached_at = datetime.now()
+    else:
+        session.add(CachedDiscordUser(user_id=user_id, payload=serialized))
+    session.commit()
+
+
 def fetch_pending_packages():
     session = Session()
     # select * from package_process_status pps where step <> 'PROCESSED' and error_message_code is null