fix: fix users endpoints

app/api/routers/user.py

@@ -3,7 +3,7 @@ from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.engine.postgresdb import get_db_session
-from app.schema.index import UserCreate, User as UserSchema
+from app.schema.index import UserCreate, User as UserSchema, UserResponse, UserUpdate
 from app.model.user import User as UserModel
 
 
@@ -13,7 +13,7 @@ logger = logging.getLogger(__name__)
 
 @r.post(
     "/",
-    response_model=UserSchema,
+    response_model=UserResponse,
     responses={
         200: {"description": "New user created"},
         400: {"description": "Bad request"},
@@ -23,63 +23,67 @@ logger = logging.getLogger(__name__)
 )
 async def create_user(user: UserCreate, db: AsyncSession = Depends(get_db_session)):
     try:
-        logger.info(f"Checking if user exists: {user.dict()}")
         db_user = await UserModel.get(db, email=user.email)
         if db_user and not db_user.is_deleted:
             raise HTTPException(status_code=409, detail="User already exists")
 
-        logger.info(f"Creating user: {user.dict()}")
-        db_user = await UserModel.create(db, **user.dict())
-        return db_user
+        await UserModel.create(db, **user.dict())
+        user = await UserModel.get(db, email=user.email)
+        return user
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
 
 @r.get(
-    "/{user_id}",
-    response_model=UserSchema,
+    "/{email}",
+    response_model=UserResponse,
     responses={
         200: {"description": "User found"},
         404: {"description": "User not found"},
         500: {"description": "Internal server error"},
     },
 )
-async def get_user(user_id: int, db: AsyncSession = Depends(get_db_session)):
-    user = await UserModel.get(db, id=user_id)
+async def get_user(email: str, db: AsyncSession = Depends(get_db_session)):
+    user = await UserModel.get(db, email=email)
     if not user:
         raise HTTPException(status_code=404, detail="User not found")
     return user
 
 
 @r.put(
-    "/{user_id}",
-    response_model=UserSchema,
+    "/{email}",
+    response_model=UserResponse,
     responses={
         200: {"description": "User updated"},
         404: {"description": "User not found"},
         500: {"description": "Internal server error"},
     },
 )
-async def update_user(user_id: int, user_payload: UserCreate, db: AsyncSession = Depends(get_db_session)):
-    user = await UserModel.get(db, id=user_id)
-    if not user:
-        raise HTTPException(status_code=404, detail="User not found")
-    user = await UserModel.update(db, id=user_id, **user_payload.dict())
-    return user
+async def update_user(email: str, user_payload: UserUpdate, db: AsyncSession = Depends(get_db_session)):
+    try:
+        user = await UserModel.get(db, email=email)
+        if not user:
+            raise HTTPException(status_code=404, detail="User not found")
+        await UserModel.update(db, id=user.id, **user_payload.dict())
+        user = await UserModel.get(db, email=email)
+        return user
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
 
 
 @r.delete(
-    "/{user_id}",
-    response_model=UserSchema,
+    "/{email}",
+    response_model=UserResponse,
     responses={
         200: {"description": "User deleted"},
         404: {"description": "User not found"},
         500: {"description": "Internal server error"},
     },
 )
-async def delete_user(user_id: int, db: AsyncSession = Depends(get_db_session)):
-    user = await UserModel.get(db, id=user_id)
+async def delete_user(email: str, db: AsyncSession = Depends(get_db_session)):
+    user = await UserModel.get(db, email=email)
     if not user:
         raise HTTPException(status_code=404, detail="User not found")
-    user = await UserModel.delete(db, id=user_id)
+    await UserModel.delete(db, email=email)
+    user = await UserModel.get(db, email=email)
     return user

app/model/base.py

@@ -1,10 +1,15 @@
 from datetime import datetime, timezone
-from sqlalchemy import Column, DateTime, Integer
+from sqlalchemy import DateTime
+from sqlalchemy.orm import Mapped, mapped_column
 
 from app.engine.postgresdb import Base
 
 
 class BaseModel:
-    id = Column(Integer, primary_key=True, index=True)
-    created_at = Column(DateTime, default=datetime.now(timezone.utc))
-    updated_at = Column(DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
+    id: Mapped[int] = mapped_column(primary_key=True, index=True, autoincrement=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=datetime.now(timezone.utc))
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        default=datetime.now(timezone.utc),
+        onupdate=datetime.now(timezone.utc),
+    )

app/model/user.py

@@ -1,3 +1,4 @@
+import logging
 from sqlalchemy.orm import relationship, Mapped, mapped_column
 from sqlalchemy.sql import expression as sql
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -5,6 +6,8 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from app.model.base import BaseModel
 from app.engine.postgresdb import Base
 
+logger = logging.getLogger(__name__)
+
 
 class User(Base, BaseModel):
     __tablename__ = "users"
@@ -18,47 +21,40 @@ class User(Base, BaseModel):
 
     @classmethod
     async def create(cls: "type[User]", db: AsyncSession, **kwargs) -> "User":
-        query = sql.insert(cls).values(**kwargs).returning(cls.id)
-        users = await db.execute(query)
+        logging.info(f"Creating user: {kwargs}")
+        query = sql.insert(cls).values(**kwargs)
+        users = await db.scalars(query)
+        user = users.first()
+        logging.info(f"User created: {users.first()}")
         await db.commit()
-        return users.first()
+        return user
 
     @classmethod
     async def update(cls: "type[User]", db: AsyncSession, id: int, **kwargs) -> "User":
-        query = (
-            sql.update(cls)
-            .where(cls.id == id)
-            .values(**kwargs)
-            .execution_options(synchronize_session="fetch")
-            .returning(cls.id)
-        )
-        users = await db.execute(query)
+        query = sql.update(cls).where(cls.id == id).values(**kwargs).execution_options(synchronize_session="fetch")
+        users = await db.scalars(query)
+        user = users.first()
         await db.commit()
-        return users.first()
-
-    @classmethod
-    async def get(cls: "type[User]", db: AsyncSession, id: int) -> "User":
-        query = sql.select(cls).where(cls.id == id)
-        users = await db.execute(query)
-        (user,) = users.first()
         return user
 
     @classmethod
     async def get(cls: "type[User]", db: AsyncSession, email: str) -> "User":
+        logging.info(f"Getting user: {email}")
         query = sql.select(cls).where(cls.email == email)
-        users = await db.execute(query)
-        (user,) = users.first()
-        return user
+        logging.info(f"Query: {query}")
+        users = await db.scalars(query)
+        logging.info(f"Users: {users}")
+        return users.first()
 
     @classmethod
-    async def delete(cls: "type[User]", db: AsyncSession, id: int) -> "User":
+    async def delete(cls: "type[User]", db: AsyncSession, email: str) -> "User":
         query = (
             sql.update(cls)
-            .where(cls.id == id)
+            .where(cls.email == email)
             .values(is_deleted=True)
             .execution_options(synchronize_session="fetch")
-            .returning(cls.id)
         )
-        users = await db.execute(query)
+        users = await db.scalars(query)
+        user = users.first()
         await db.commit()
-        return users.first()
+        return user

app/schema/base.py

@@ -2,7 +2,11 @@ from datetime import datetime
 from pydantic import BaseModel
 
 
-class BaseModel(BaseModel):
+class PydanticBaseModel(BaseModel):
+    pass
+
+
+class BaseModel(PydanticBaseModel):
     id: int
     created_at: datetime
     updated_at: datetime

app/schema/index.py

@@ -1,8 +1,8 @@
 from enum import Enum
 from datetime import datetime
-from typing import List
+from typing import List, Optional
 
-from app.schema.base import BaseModel
+from app.schema.base import BaseModel, PydanticBaseModel
 
 
 class TransactionType(str, Enum):
@@ -10,12 +10,25 @@ class TransactionType(str, Enum):
     EXPENSE = "expense"
 
 
-class UserCreate(BaseModel):
+class UserCreate(PydanticBaseModel):
     name: str
     email: str
     hashed_password: str
 
 
+class UserUpdate(PydanticBaseModel):
+    name: str
+    email: str
+    hashed_password: str
+
+
+class UserResponse(PydanticBaseModel):
+    id: int
+    name: str
+    email: str
+    is_deleted: bool
+
+
 class User(BaseModel):
     name: str
     email: str

migration/versions/7ea44cbc5b1f_default_timezone.py

@@ -0,0 +1,69 @@
+"""default_timezone
+
+Revision ID: 7ea44cbc5b1f
+Revises: 8feaedca36f9
+Create Date: 2024-06-02 14:36:01.552518
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = "7ea44cbc5b1f"
+down_revision: Union[str, None] = "8feaedca36f9"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column(
+        "transactions",
+        "created_at",
+        existing_type=postgresql.TIMESTAMP(),
+        type_=sa.DateTime(timezone=True),
+        nullable=False,
+    )
+    op.alter_column(
+        "transactions",
+        "updated_at",
+        existing_type=postgresql.TIMESTAMP(),
+        type_=sa.DateTime(timezone=True),
+        nullable=False,
+    )
+    op.alter_column(
+        "users", "created_at", existing_type=postgresql.TIMESTAMP(), type_=sa.DateTime(timezone=True), nullable=False
+    )
+    op.alter_column(
+        "users", "updated_at", existing_type=postgresql.TIMESTAMP(), type_=sa.DateTime(timezone=True), nullable=False
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column(
+        "users", "updated_at", existing_type=sa.DateTime(timezone=True), type_=postgresql.TIMESTAMP(), nullable=True
+    )
+    op.alter_column(
+        "users", "created_at", existing_type=sa.DateTime(timezone=True), type_=postgresql.TIMESTAMP(), nullable=True
+    )
+    op.alter_column(
+        "transactions",
+        "updated_at",
+        existing_type=sa.DateTime(timezone=True),
+        type_=postgresql.TIMESTAMP(),
+        nullable=True,
+    )
+    op.alter_column(
+        "transactions",
+        "created_at",
+        existing_type=sa.DateTime(timezone=True),
+        type_=postgresql.TIMESTAMP(),
+        nullable=True,
+    )
+    # ### end Alembic commands ###