feat: implement authentication system, add quiz history support, and update API endpoints for material and tutor interactions

auth/routes.py

@@ -0,0 +1,76 @@
+import uuid
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import Optional
+
+from src.store import create_user, get_user_by_email
+
+router = APIRouter(prefix="/api/auth", tags=["Auth"])
+
+
+class LoginRequest(BaseModel):
+    email: str
+    password: str
+
+
+class SignupRequest(BaseModel):
+    name: str
+    email: str
+    password: str
+
+
+class GoogleAuthRequest(BaseModel):
+    token: str
+    name: Optional[str] = None
+    email: Optional[str] = None
+
+
+@router.post("/login")
+async def login(body: LoginRequest):
+    user = get_user_by_email(body.email)
+    if not user or user.get("password") != body.password:
+        raise HTTPException(401, "Invalid email or password")
+    token = str(uuid.uuid4())
+    return {
+        "token": token,
+        "user": {
+            "id": user["id"],
+            "name": user["name"],
+            "email": user["email"],
+        },
+    }
+
+
+@router.post("/signup")
+async def signup(body: SignupRequest):
+    try:
+        user = create_user(body.name, body.email, body.password)
+    except ValueError as e:
+        raise HTTPException(400, str(e))
+    token = str(uuid.uuid4())
+    return {
+        "token": token,
+        "user": {
+            "id": user["id"],
+            "name": user["name"],
+            "email": user["email"],
+        },
+    }
+
+
+@router.post("/google")
+async def google_auth(body: GoogleAuthRequest):
+    email = body.email or f"google_{uuid.uuid4().hex[:8]}@google.com"
+    name = body.name or "Google User"
+    user = get_user_by_email(email)
+    if not user:
+        user = create_user(name, email, "")
+    token = str(uuid.uuid4())
+    return {
+        "token": token,
+        "user": {
+            "id": user["id"],
+            "name": user["name"],
+            "email": user["email"],
+        },
+    }

dependencies.py

@@ -5,21 +5,32 @@ from typing import Any, Optional
 from src.database import get_supabase
 
 DEV_USER_ID = "00000000-0000-0000-0000-000000000001"
+DEV_USER = {"id": DEV_USER_ID, "email": "dev@studymate.ai", "name": "Dev User"}
 
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token", auto_error=False)
 
 
 async def get_current_user(
-    token: str = Depends(oauth2_scheme),
+    token: Optional[str] = Depends(oauth2_scheme),
     x_user_id: Optional[str] = Header(None),
+    x_user_name: Optional[str] = Header(None),
+    x_user_email: Optional[str] = Header(None),
 ) -> Any:
     client = get_supabase()
+
+    # Dev mode: no Supabase configured
     if client is None:
         if x_user_id:
-            return {"id": x_user_id}
-        raise HTTPException(
-            status.HTTP_500_INTERNAL_SERVER_ERROR, "Supabase not configured"
-        )
+            return {
+                "id": x_user_id,
+                "name": x_user_name or "User",
+                "email": x_user_email or f"user{x_user_id}@studymate.ai",
+            }
+        return DEV_USER
+
+    # Real Supabase auth
+    if not token:
+        raise HTTPException(status.HTTP_401_UNAUTHORIZED, "Not authenticated")
     try:
         response = client.auth.get_user(token)
     except Exception:

main.py

@@ -1,11 +1,13 @@
 from contextlib import asynccontextmanager
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import RedirectResponse
 
 from src.materials.routes import router as materials_router
 from src.summary_generator.routes import router as summary_router
 from src.rag.routes import router as tutor_router
 from src.quiz_generator.routes import router as quiz_router
+from src.auth.routes import router as auth_router
 from src.config import settings
 
 
@@ -25,7 +27,7 @@ app = FastAPI(
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=settings.cors_allowed_origins or ["https://your-frontend-domain.com"],
+    allow_origins=settings.cors_allowed_origins or ["*"],
     allow_credentials=True,
     allow_methods=["GET", "POST"],
     allow_headers=["Authorization", "Content-Type"],
@@ -35,6 +37,12 @@ app.include_router(materials_router)
 app.include_router(summary_router)
 app.include_router(tutor_router)
 app.include_router(quiz_router)
+app.include_router(auth_router)
+
+
+@app.get("/")
+async def root():
+    return RedirectResponse(url="/docs")
 
 
 @app.get("/api/health")

materials/routes.py

@@ -5,7 +5,7 @@ from pydantic import BaseModel
 
 from src.materials.text_utils import text_from_pdf, chunk_text, scrap_website
 from src.rag.rag import store_embeddings
-from src.store import create_material, update_material_status, save_chunks
+from src.store import create_material, update_material_status, save_chunks, list_materials
 from src.dependencies import get_current_user_id, get_current_user
 
 router = APIRouter(prefix="/api/materials", tags=["Materials"])
@@ -38,6 +38,14 @@ class URLInput(BaseModel):
     url: str
 
 
+@router.get("")
+async def get_materials(
+    user_id: str = Depends(get_current_user_id),
+    current_user=Depends(get_current_user),
+):
+    return list_materials(user_id)
+
+
 @router.post("/upload-pdf")
 async def upload_pdf(
     file: UploadFile = File(...),

quiz_generator/routes.py

@@ -3,7 +3,7 @@ from pydantic import BaseModel
 from typing import Optional
 
 from src.quiz_generator.quiz import smart_quiz_generator
-from src.store import get_material, get_chunks, get_summary, save_quiz
+from src.store import get_material, get_chunks, get_summary, save_quiz, get_quizzes
 from src.dependencies import get_current_user_id, get_current_user
 from src.config import settings
 
@@ -24,6 +24,15 @@ class QuizResponse(BaseModel):
     quiz_id: str
 
 
+@router.get("/list")
+async def get_quiz_list(
+    material_id: Optional[str] = None,
+    user_id: str = Depends(get_current_user_id),
+    current_user=Depends(get_current_user),
+):
+    return get_quizzes(material_id=material_id, user_id=user_id)
+
+
 @router.post("/generate", response_model=QuizResponse)
 async def generate_quiz(
     body: QuizRequest,

store.py

@@ -1,33 +1,120 @@
 from typing import Optional
+from datetime import datetime, timezone
 from langchain.memory import ConversationBufferMemory
 from src.database import get_supabase
 
+_in_memory: dict = {
+    "materials": {},
+    "material_chunks": {},
+    "summaries": {},
+    "quizzes": {},
+    "users": {},
+    "next_id": 0,
+}
+
+
+def _get_next_id() -> str:
+    _in_memory["next_id"] += 1
+    return str(_in_memory["next_id"])
+
 
 def _db():
     client = get_supabase()
-    if client is None:
-        raise RuntimeError(
-            "Supabase not configured. Set SUPABASE_URL and SUPABASE_KEY in config.env."
-        )
-    return client
+    if client is not None:
+        return client
+    return None
+
+
+def _table_supabase(table: str):
+    client = _db()
+    if client is not None:
+        return client.table(table)
+
+    class _FakeTable:
+        def __init__(self, name):
+            self.name = name
+
+        def insert(self, data):
+            if isinstance(data, list):
+                for item in data:
+                    item["id"] = item.get("id", _get_next_id())
+                    _in_memory.setdefault(self.name, {})[item["id"]] = item
+                class R:
+                    data = data
+                return R()
+            data["id"] = data.get("id", _get_next_id())
+            _in_memory.setdefault(self.name, {})[data["id"]] = data
+            class R:
+                data = [data]
+            return R()
+
+        def select(self, *args):
+            return self
+
+        def eq(self, field, value):
+            self._eq_field = field
+            self._eq_value = value
+            return self
+
+        def order(self, field):
+            return self
+
+        def maybe_single(self):
+            records = list(_in_memory.get(self.name, {}).values())
+            if hasattr(self, '_eq_field'):
+                records = [r for r in records if r.get(self._eq_field) == self._eq_value]
+            return self._make_response(records[0] if records else None)
+
+        def execute(self):
+            records = list(_in_memory.get(self.name, {}).values())
+            if hasattr(self, '_eq_field'):
+                records = [r for r in records if r.get(self._eq_field) == self._eq_value]
+            if hasattr(self, '_order_field'):
+                records.sort(key=lambda r: r.get(self._order_field, 0))
+            return self._make_response(records)
+
+        def update(self, data):
+            self._update_data = data
+            return self
+
+        def _make_response(self, data):
+            class R:
+                pass
+            r = R()
+            r.data = data if isinstance(data, list) else ([data] if data else [])
+            return r
+
+    return _FakeTable(table)
 
 
 # ── Materials ──────────────────────────────────────────
 
+def list_materials(user_id: str) -> list[dict]:
+    sup = _table_supabase("materials")
+    if sup is not None and not isinstance(sup.execute().__class__.__name__, '_FakeTable'):
+        try:
+            result = sup.select("*").eq("user_id", user_id).order("created_at").execute()
+            return list(reversed(result.data))
+        except Exception:
+            pass
+    records = list(_in_memory.get("materials", {}).values())
+    return list(reversed([r for r in records if r.get("user_id") == user_id]))
+
+
 def create_material(user_id: str, source_type: str, title: str,
                     file_path: Optional[str] = None,
-                    url: Optional[str] = None) -> dict:
-    data = {
-        "user_id": user_id,
-        "source_type": source_type,
-        "title": title,
-        "status": "pending",
-    }
+                    url: Optional[str] = None,
+                    topic: Optional[str] = None) -> dict:
+    now = datetime.now(timezone.utc).isoformat()
+    data = {"user_id": user_id, "source_type": source_type, "title": title, "status": "pending",
+            "created_at": now, "updated_at": now}
     if file_path:
         data["file_path"] = file_path
     if url:
         data["url"] = url
-    result = _db().table("materials").insert(data).execute()
+    if topic:
+        data["topic"] = topic
+    result = _table_supabase("materials").insert(data).execute()
     return result.data[0]
 
 
@@ -36,11 +123,11 @@ def update_material_status(material_id: str, status: str,
     data = {"status": status}
     if error_message:
         data["error_message"] = error_message
-    _db().table("materials").update(data).eq("id", material_id).execute()
+    _table_supabase("materials").update(data).eq("id", material_id).execute()
 
 
 def get_material(material_id: str) -> Optional[dict]:
-    result = _db().table("materials").select("*").eq("id", material_id).execute()
+    result = _table_supabase("materials").select("*").eq("id", material_id).execute()
     return result.data[0] if result.data else None
 
 
@@ -51,13 +138,13 @@ def save_chunks(material_id: str, chunks: list[str]) -> list[str]:
         {"material_id": material_id, "chunk_index": i, "content": c}
         for i, c in enumerate(chunks)
     ]
-    result = _db().table("material_chunks").insert(records).execute()
+    result = _table_supabase("material_chunks").insert(records).execute()
     return [r["id"] for r in result.data]
 
 
 def get_chunks(material_id: str) -> list[dict]:
     result = (
-        _db().table("material_chunks")
+        _table_supabase("material_chunks")
         .select("*")
         .eq("material_id", material_id)
         .order("chunk_index")
@@ -78,12 +165,17 @@ def save_summary(material_id: str, user_id: str, summary: str,
         "time_taken": time_taken,
         "model_name": model_name,
     }
-    _db().table("summaries").upsert(data, on_conflict=["material_id"]).execute()
+    tbl = _table_supabase("summaries")
+    existing = tbl.select("*").eq("material_id", material_id).execute()
+    if existing.data:
+        tbl.update(data).eq("material_id", material_id).execute()
+    else:
+        tbl.insert(data).execute()
 
 
 def get_summary(material_id: str) -> Optional[dict]:
     result = (
-        _db().table("summaries")
+        _table_supabase("summaries")
         .select("*")
         .eq("material_id", material_id)
         .maybe_single()
@@ -109,10 +201,42 @@ def save_quiz(user_id: str, material_id: Optional[str], source_type: str,
     }
     if material_id:
         data["material_id"] = material_id
-    result = _db().table("quizzes").insert(data).execute()
+    result = _table_supabase("quizzes").insert(data).execute()
+    return result.data[0]
+
+
+def get_quizzes(material_id: Optional[str] = None, user_id: Optional[str] = None) -> list[dict]:
+    tbl = _table_supabase("quizzes")
+    result = tbl.select("*").execute()
+    records = result.data
+    if material_id:
+        records = [r for r in records if r.get("material_id") == material_id]
+    if user_id:
+        records = [r for r in records if r.get("user_id") == user_id]
+    return records
+
+
+# ── Users ────────────────────────────────────────────
+
+def create_user(name: str, email: str, password: str) -> dict:
+    existing = get_user_by_email(email)
+    if existing:
+        raise ValueError("Email already registered")
+    data = {"name": name, "email": email, "password": password}
+    result = _table_supabase("users").insert(data).execute()
     return result.data[0]
 
 
+def get_user_by_email(email: str) -> Optional[dict]:
+    result = _table_supabase("users").select("*").eq("email", email).maybe_single().execute()
+    return result.data[0] if result.data else None
+
+
+def get_user_by_id(user_id: str) -> Optional[dict]:
+    result = _table_supabase("users").select("*").eq("id", user_id).maybe_single().execute()
+    return result.data[0] if result.data else None
+
+
 # ── Conversation Memory (in-memory, ephemeral) ─────────
 
 import uuid as _uuid

summary_generator/routes.py

@@ -1,9 +1,10 @@
 import time
 from fastapi import APIRouter, HTTPException, Depends
 from pydantic import BaseModel
+from typing import Optional
 
 from src.summary_generator.summary import summarizer
-from src.store import get_material, get_chunks, save_summary
+from src.store import get_material, get_chunks, save_summary, get_summary as get_stored_summary
 from src.dependencies import get_current_user_id, get_current_user
 from src.config import settings
 
@@ -50,3 +51,15 @@ async def generate_summary(
         return SummarizeResponse(summary=summary, time_taken=elapsed)
     except Exception as e:
         raise HTTPException(500, f"Summarization failed: {e}")
+
+
+@router.get("/{material_id}/summary")
+async def get_material_summary(
+    material_id: str,
+    user_id: str = Depends(get_current_user_id),
+    current_user=Depends(get_current_user),
+):
+    summary = get_stored_summary(material_id)
+    if not summary:
+        raise HTTPException(404, "No summary found for this material")
+    return {"summary": summary["summary"], "time_taken": summary.get("time_taken", 0)}