SQLLite Changes

auth_service/app/auth.py

@@ -0,0 +1,40 @@
+from datetime import datetime, timedelta
+from jose import JWTError, jwt
+from fastapi import HTTPException, status, Depends
+from fastapi.security import OAuth2PasswordBearer
+from sqlalchemy.ext.asyncio import AsyncSession
+from . import schemas, database, models
+from sqlalchemy import select
+
+SECRET_KEY = "a866319fb3f839e693191763019cf0dd3d78473d4d3d06d99afb3ef0b14bd0d5"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+def create_access_token(data: dict):
+    to_encode = data.copy()
+    expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+async def get_current_user(token: str = Depends(oauth2_scheme), db: AsyncSession = Depends(database.get_db)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+    stmt = select(models.User).where(models.User.username == username)
+    result = await db.execute(stmt)
+    user = result.scalars().first()
+    if user is None:
+        raise credentials_exception
+    return user

auth_service/app/database.py

@@ -0,0 +1,38 @@
+import logging
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker, declarative_base
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+DATABASE_URL = "sqlite+aiosqlite:///./auth.db"
+
+engine = create_async_engine(
+    DATABASE_URL,
+    echo=False,
+    future=True
+)
+
+AsyncSessionLocal = sessionmaker(
+    engine,
+    class_=AsyncSession,
+    expire_on_commit=False
+)
+
+Base = declarative_base()
+
+async def init_db():
+    from .models import Base
+    logger.info("Initializing SQLite database at data/auth.db")
+    try:
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+        logger.info("Database initialized successfully")
+    except Exception as e:
+        logger.error(f"Failed to initialize database: {str(e)}")
+        raise
+
+async def get_db():
+    async with AsyncSessionLocal() as session:
+        yield session

auth_service/app/main.py

@@ -1,5 +1,14 @@
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.security import OAuth2PasswordRequestForm
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from . import schemas, database, models, auth
+from passlib.context import CryptContext
 
+from . import schemas, database, models, auth
+
+# 🔑 IMPORTANT: root_path="/auth" (for NGINX + HF Spaces)
 app = FastAPI(
     title="Auth Service",
     root_path="/auth",
@@ -7,6 +16,25 @@ app = FastAPI(
     openapi_url="/openapi.json"
 )
 
+# Enable CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins; adjust as needed
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+@app.on_event("startup")
+async def startup():
+    await database.init_db()
+
+async def get_db():
+    async with database.AsyncSessionLocal() as session:
+        yield session
+
 @app.get("/")
 def root():
     return {
@@ -27,3 +55,66 @@ def hello(name: str):
         "service": "auth",
         "hello": name
     }
+
+@app.post("/users/", response_model=schemas.User)
+async def create_user(user: schemas.UserCreate, db: AsyncSession = Depends(get_db)):
+    stmt = select(models.User).where(models.User.username == user.username)
+    result = await db.execute(stmt)
+    if result.scalars().first():
+        raise HTTPException(status_code=400, detail="Username already exists")
+    hashed_password = pwd_context.hash(user.password)
+    db_user = models.User(username=user.username, hashed_password=hashed_password)
+    db.add(db_user)
+    await db.commit()
+    await db.refresh(db_user)
+    return db_user
+
+@app.get("/users/", response_model=list[schemas.User])
+async def get_users(db: AsyncSession = Depends(get_db), current_user: schemas.User = Depends(auth.get_current_user)):
+    stmt = select(models.User)
+    result = await db.execute(stmt)
+    return result.scalars().all()
+
+@app.get("/users/{username}", response_model=schemas.User)
+async def get_user(username: str, db: AsyncSession = Depends(get_db), current_user: schemas.User = Depends(auth.get_current_user)):
+    stmt = select(models.User).where(models.User.username == username)
+    result = await db.execute(stmt)
+    user = result.scalars().first()
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    return user
+
+@app.put("/users/{username}", response_model=schemas.User)
+async def update_user(username: str, user_update: schemas.UserCreate, db: AsyncSession = Depends(get_db), current_user: schemas.User = Depends(auth.get_current_user)):
+    stmt = select(models.User).where(models.User.username == username)
+    result = await db.execute(stmt)
+    db_user = result.scalars().first()
+    if not db_user:
+        raise HTTPException(status_code=404, detail="User not found")
+    db_user.hashed_password = pwd_context.hash(user_update.password)
+    await db.commit()
+    await db.refresh(db_user)
+    return db_user
+
+@app.delete("/users/{username}", status_code=204)
+async def delete_user(username: str, db: AsyncSession = Depends(get_db), current_user: schemas.User = Depends(auth.get_current_user)):
+    stmt = select(models.User).where(models.User.username == username)
+    result = await db.execute(stmt)
+    db_user = result.scalars().first()
+    if not db_user:
+        raise HTTPException(status_code=404, detail="User not found")
+    await db.delete(db_user)
+    await db.commit()
+    return {
+        "message": "User deleted."
+    }
+
+@app.post("/token", response_model=schemas.Token)
+async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends(), db: AsyncSession = Depends(get_db)):
+    stmt = select(models.User).where(models.User.username == form_data.username)
+    result = await db.execute(stmt)
+    user = result.scalars().first()
+    if not user or not pwd_context.verify(form_data.password, user.hashed_password):
+        raise HTTPException(status_code=401, detail="Incorrect username or password")
+    access_token = auth.create_access_token(data={"sub": user.username})
+    return {"access_token": access_token, "token_type": "bearer"}

auth_service/app/models.py

@@ -0,0 +1,10 @@
+from sqlalchemy import Column, Integer, String
+from sqlalchemy.ext.declarative import declarative_base
+
+Base = declarative_base()
+
+class User(Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String, unique=True, index=True)
+    hashed_password = Column(String)

auth_service/app/schemas.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+
+class UserCreate(BaseModel):
+    username: str
+    password: str
+
+class User(BaseModel):
+    id: int
+    username: str
+
+    class Config:
+        from_attributes = True
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str

requirements.txt

@@ -1,2 +1,11 @@
 fastapi
-uvicorn[standard]
+uvicorn[standard]
+pydantic
+sqlalchemy
+asyncio
+aiosqlite
+python-jose
+cryptography
+python-multipart
+passlib==1.7.4
+bcrypt==3.2.2