fix: latest deploymnent

auth.py

@@ -21,20 +21,30 @@ ALGORITHM  = "HS256"
 TOKEN_TTL_MINUTES = 60 * 24   # 24 hours — long enough to avoid friction
 
 
-def create_access_token(user_id: str) -> str:
+def create_access_token(user_id) -> str:
     """
     Create a signed JWT for the given user ID.
 
+    Accepts either:
+      - a plain string user UUID  (new style: create_access_token(user_id))
+      - a dict with a "sub" key   (old style: create_access_token({"sub": user_id}))
+
     The token contains:
       sub  — user UUID (primary claim, used by get_current_user)
       iat  — issued-at timestamp
       exp  — expiry timestamp
     """
+    # Support both calling conventions without breaking either
+    if isinstance(user_id, dict):
+        sub = str(user_id.get("sub", ""))
+    else:
+        sub = str(user_id)
+
     now    = datetime.now(timezone.utc)
     expire = now + timedelta(minutes=TOKEN_TTL_MINUTES)
 
     payload = {
-        "sub": str(user_id),
+        "sub": sub,
         "iat": now,
         "exp": expire,
     }

db.py

@@ -259,3 +259,192 @@ def get_scan_task(task_id: str, user_id: str) -> dict | None:
     except Exception as e:
         logger.error(f"get_scan_task({task_id}): {e}")
         return None
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  BACKWARDS-COMPATIBILITY LAYER
+#  app.py was written against the old DB module which had different function
+#  names and additional helpers.  All aliases and stubs live here so neither
+#  app.py nor the new db.py needs to change structure.
+# ══════════════════════════════════════════════════════════════════════════════
+
+# ── Name aliases (old name → new function) ────────────────────────────────────
+def fetch_user_by_id(user_id: str) -> dict | None:
+    return get_user_by_id(user_id)
+
+def fetch_user_by_email(email: str) -> dict | None:
+    return get_user_by_email(email)
+
+def user_email_exists(email: str) -> bool:
+    return email_exists(email)
+
+def insert_user(data: dict) -> bool:
+    """Insert a user row from a raw dict (old-style call)."""
+    try:
+        # Prefer explicit fields; fall back gracefully if columns differ
+        _db.table("users").insert(data).execute()
+        return True
+    except Exception as e:
+        logger.error(f"insert_user: {e}")
+        return False
+
+def fetch_scan_task(task_id: str, user_id: str | None = None) -> dict | None:
+    """Fetch a scan task.  user_id is optional for backwards compat."""
+    try:
+        q = _db.table("scan_tasks").select("*").eq("id", task_id)
+        if user_id:
+            q = q.eq("user_id", user_id)
+        return _one(q.limit(1).execute())
+    except Exception as e:
+        logger.error(f"fetch_scan_task({task_id}): {e}")
+        return None
+
+def insert_scan_task(data: dict) -> bool:
+    """Insert a scan task row from a raw dict (old-style call)."""
+    try:
+        _db.table("scan_tasks").insert(data).execute()
+        return True
+    except Exception as e:
+        logger.error(f"insert_scan_task: {e}")
+        return False
+
+# ── Org helpers ───────────────────────────────────────────────────────────────
+
+def insert_org(data: dict) -> bool:
+    """Insert an organisation row. No-op if organisations table doesn't exist."""
+    try:
+        _db.table("organisations").insert(data).execute()
+        return True
+    except Exception as e:
+        logger.warning(f"insert_org (non-fatal): {e}")
+        return False  # non-fatal — org_id still stored on user row
+
+def fetch_org_by_id(org_id: str) -> dict | None:
+    try:
+        return _one(_db.table("organisations").select("*").eq("id", org_id).limit(1).execute())
+    except Exception as e:
+        logger.warning(f"fetch_org_by_id({org_id}): {e}")
+        return None
+
+def fetch_org_members(org_id: str) -> list:
+    try:
+        res = _db.table("users").select("id, email, is_pro, created_at").eq("org_id", org_id).execute()
+        return res.data or []
+    except Exception as e:
+        logger.error(f"fetch_org_members({org_id}): {e}")
+        return []
+
+# ── Scan history helpers ──────────────────────────────────────────────────────
+
+def insert_scan_history(data: dict) -> bool:
+    """Persist a scan result into the scans table using old field names."""
+    try:
+        # Map old field names to new schema
+        row = {
+            "user_id":       data.get("user_id"),
+            "source":        data.get("input_text", "")[:120] or "code_paste",
+            "risk_level":    data.get("risk", "LOW"),
+            "total_secrets": data.get("findings_count", 0),
+            "result_json":   {
+                "explanation":    data.get("explanation", ""),
+                "fixes":          data.get("fixes", []),
+                "score":          data.get("score", 0),
+                "findings_count": data.get("findings_count", 0),
+            },
+        }
+        # Include id if provided
+        if data.get("id"):
+            row["id"] = data["id"]
+        _db.table("scans").insert(row).execute()
+        return True
+    except Exception as e:
+        logger.error(f"insert_scan_history: {e}")
+        return False
+
+def fetch_scan_history(user_id: str, limit: int = 20) -> list:
+    return list_scans(user_id, limit=limit)
+
+# ── Usage tracking (best-effort — graceful if table absent) ──────────────────
+
+def fetch_usage_today(user_id: str, today: str) -> dict | None:
+    """Fetch today's usage record.  Returns None if table not present."""
+    try:
+        return _one(
+            _db.table("usage_tracking")
+            .select("*")
+            .eq("user_id", user_id)
+            .eq("date", today)
+            .limit(1)
+            .execute()
+        )
+    except Exception:
+        return None  # table may not exist — caller handles None
+
+def upsert_usage(user_id: str, org_id: str, today: str, count: int) -> None:
+    """Update daily usage counter.  Best-effort — never raises."""
+    try:
+        existing = fetch_usage_today(user_id, today)
+        if existing:
+            _db.table("usage_tracking").update({"request_count": count}).eq("user_id", user_id).eq("date", today).execute()
+        else:
+            _db.table("usage_tracking").insert({"user_id": user_id, "org_id": org_id, "date": today, "request_count": count}).execute()
+    except Exception as e:
+        logger.debug(f"upsert_usage (non-fatal): {e}")
+
+def fetch_usage_history(user_id: str, limit: int = 30) -> list:
+    try:
+        res = (
+            _db.table("usage_tracking")
+            .select("date, request_count")
+            .eq("user_id", user_id)
+            .order("date", desc=True)
+            .limit(limit)
+            .execute()
+        )
+        return res.data or []
+    except Exception:
+        return []
+
+# ── Dashboard aggregation ─────────────────────────────────────────────────────
+
+def fetch_dashboard_data(user_id: str, org_id: str | None, plan: str) -> dict:
+    """Return usage series, history, and team for the dashboard endpoint."""
+    usage   = fetch_usage_history(user_id, limit=30)
+    history = fetch_scan_history(user_id, limit=10)
+    team    = fetch_org_members(org_id) if org_id else []
+    return {"usage": usage, "history": history, "team": team}
+
+# ── CVE cache (in-memory — no DB table needed) ────────────────────────────────
+
+_cve_cache: dict = {}
+
+def fetch_cve_cache(query: str) -> dict | None:
+    return _cve_cache.get(query.lower())
+
+def store_cve_cache(query: str, data: dict) -> None:
+    # Keep cache bounded — evict oldest entry when over 200 items
+    if len(_cve_cache) >= 200:
+        oldest = next(iter(_cve_cache))
+        del _cve_cache[oldest]
+    _cve_cache[query.lower()] = data
+
+# ── Audit log (best-effort — graceful if table absent) ───────────────────────
+
+def write_audit_log(user_id: str, action: str, **kwargs) -> None:
+    """Write an audit log entry.  Completely non-fatal — never raises."""
+    try:
+        row = {
+            "user_id":    user_id,
+            "action":     action,
+            "created_at": __import__("datetime").datetime.utcnow().isoformat(),
+        }
+        row.update({k: str(v)[:500] if v else None for k, v in kwargs.items()})
+        _db.table("audit_logs").insert(row).execute()
+    except Exception as e:
+        logger.debug(f"write_audit_log (non-fatal): {e}")
+
+# ── Cache invalidation stub ───────────────────────────────────────────────────
+
+def cache_invalidate(key: str) -> None:
+    """No-op stub — in-memory caches invalidate themselves via TTL."""
+    pass

tasks.py

@@ -89,3 +89,9 @@ def run_repo_scan(task_id: str, repo_url: str, user_id: str, is_pro: bool) -> No
     finally:
         if clone_dir:
             shutil.rmtree(clone_dir, ignore_errors=True)
+
+
+# ── Backwards-compatibility alias ─────────────────────────────────────────────
+# app.py imports `run_scan` (old name). The function was renamed to
+# run_repo_scan but the alias keeps the import working without touching app.py.
+run_scan = run_repo_scan