first commit

app/users/models.py

@@ -0,0 +1,41 @@
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from sqlalchemy import Boolean, DateTime, String, func
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.database.base import Base
+
+if TYPE_CHECKING:
+    from app.auth.models import EmailVerificationToken, PasswordResetToken
+    from app.chats.models import ChatMember
+    from app.messages.models import Message
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id: Mapped[int] = mapped_column(primary_key=True, index=True)
+    username: Mapped[str] = mapped_column(String(50), unique=True, index=True)
+    email: Mapped[str] = mapped_column(String(255), unique=True, index=True)
+    password_hash: Mapped[str] = mapped_column(String(255))
+    avatar_url: Mapped[str | None] = mapped_column(String(512), nullable=True)
+    email_verified: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False, index=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), nullable=False)
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+
+    memberships: Mapped[list["ChatMember"]] = relationship(back_populates="user", cascade="all, delete-orphan")
+    sent_messages: Mapped[list["Message"]] = relationship(back_populates="sender")
+    email_verification_tokens: Mapped[list["EmailVerificationToken"]] = relationship(
+        back_populates="user",
+        cascade="all, delete-orphan",
+    )
+    password_reset_tokens: Mapped[list["PasswordResetToken"]] = relationship(
+        back_populates="user",
+        cascade="all, delete-orphan",
+    )

app/users/repository.py

@@ -0,0 +1,26 @@
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.users.models import User
+
+
+async def create_user(db: AsyncSession, *, email: str, username: str, password_hash: str) -> User:
+    user = User(email=email, username=username, password_hash=password_hash, email_verified=False)
+    db.add(user)
+    await db.flush()
+    return user
+
+
+async def get_user_by_id(db: AsyncSession, user_id: int) -> User | None:
+    result = await db.execute(select(User).where(User.id == user_id))
+    return result.scalar_one_or_none()
+
+
+async def get_user_by_email(db: AsyncSession, email: str) -> User | None:
+    result = await db.execute(select(User).where(User.email == email))
+    return result.scalar_one_or_none()
+
+
+async def get_user_by_username(db: AsyncSession, username: str) -> User | None:
+    result = await db.execute(select(User).where(User.username == username))
+    return result.scalar_one_or_none()

app/users/router.py

@@ -0,0 +1,43 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.auth.service import get_current_user
+from app.database.session import get_db
+from app.users.models import User
+from app.users.schemas import UserProfileUpdate, UserRead
+from app.users.service import get_user_by_id, get_user_by_username, update_user_profile
+
+router = APIRouter(prefix="/users", tags=["users"])
+
+
+@router.get("/me", response_model=UserRead)
+async def read_me(current_user: User = Depends(get_current_user)) -> UserRead:
+    return current_user
+
+
+@router.get("/{user_id}", response_model=UserRead)
+async def read_user(user_id: int, db: AsyncSession = Depends(get_db), _current_user: User = Depends(get_current_user)) -> UserRead:
+    user = await get_user_by_id(db, user_id)
+    if not user:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found")
+    return user
+
+
+@router.put("/profile", response_model=UserRead)
+async def update_profile(
+    payload: UserProfileUpdate,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> UserRead:
+    if payload.username and payload.username != current_user.username:
+        username_owner = await get_user_by_username(db, payload.username)
+        if username_owner:
+            raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Username already taken")
+
+    updated = await update_user_profile(
+        db,
+        current_user,
+        username=payload.username,
+        avatar_url=payload.avatar_url,
+    )
+    return updated

app/users/schemas.py

@@ -0,0 +1,27 @@
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict, EmailStr, Field
+
+
+class UserBase(BaseModel):
+    username: str = Field(min_length=3, max_length=50)
+    email: EmailStr
+
+
+class UserCreate(UserBase):
+    password: str = Field(min_length=8, max_length=128)
+
+
+class UserRead(UserBase):
+    model_config = ConfigDict(from_attributes=True)
+
+    id: int
+    avatar_url: str | None = None
+    email_verified: bool
+    created_at: datetime
+    updated_at: datetime
+
+
+class UserProfileUpdate(BaseModel):
+    username: str | None = Field(default=None, min_length=3, max_length=50)
+    avatar_url: str | None = Field(default=None, max_length=512)

app/users/service.py

@@ -0,0 +1,32 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.users import repository
+from app.users.models import User
+
+
+async def get_user_by_id(db: AsyncSession, user_id: int) -> User | None:
+    return await repository.get_user_by_id(db, user_id)
+
+
+async def get_user_by_email(db: AsyncSession, email: str) -> User | None:
+    return await repository.get_user_by_email(db, email)
+
+
+async def get_user_by_username(db: AsyncSession, username: str) -> User | None:
+    return await repository.get_user_by_username(db, username)
+
+
+async def update_user_profile(
+    db: AsyncSession,
+    user: User,
+    *,
+    username: str | None = None,
+    avatar_url: str | None = None,
+) -> User:
+    if username is not None:
+        user.username = username
+    if avatar_url is not None:
+        user.avatar_url = avatar_url
+    await db.commit()
+    await db.refresh(user)
+    return user