migrate codebase to fastcrud 0.19.0

Author: igorbenav

pyproject.toml

@@ -28,7 +28,7 @@ dependencies = [
     "arq>=0.25.0",
     "bcrypt>=4.1.1",
     "psycopg2-binary>=2.9.9",
-    "fastcrud>=0.15.5",
+    "fastcrud>=0.19.0",
     "crudadmin>=0.4.2",
     "gunicorn>=23.0.0",
     "ruff>=0.11.13",

src/app/api/dependencies.py

@@ -23,7 +23,7 @@
 
 async def get_current_user(
     token: Annotated[str, Depends(oauth2_scheme)], db: Annotated[AsyncSession, Depends(async_get_db)]
-) -> dict[str, Any] | None:
+) -> dict[str, Any]:
     token_data = await verify_token(token, TokenType.ACCESS, db)
     if token_data is None:
         raise UnauthorizedException("User not authenticated.")
@@ -34,10 +34,7 @@ async def get_current_user(
         user = await crud_users.get(db=db, username=token_data.username_or_email, is_deleted=False)
 
     if user:
-        if hasattr(user, 'model_dump'):
-            return user.model_dump()
-        else:
-            return user
+        return user
 
     raise UnauthorizedException("User not authenticated.")
 

src/app/api/v1/posts.py

@@ -1,4 +1,5 @@
 from typing import Annotated, Any, cast
+
 from fastapi import APIRouter, Depends, Request
 from fastcrud import PaginatedListResponse, compute_offset, paginated_response
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -22,28 +23,30 @@ async def write_post(
     post: PostCreate,
     current_user: Annotated[dict, Depends(get_current_user)],
     db: Annotated[AsyncSession, Depends(async_get_db)],
-) -> PostRead:
-    db_user = await crud_users.get(
-        db=db, username=username, is_deleted=False, schema_to_select=UserRead, return_as_model=True
-    )
+) -> dict[str, Any]:
+    db_user = await crud_users.get(db=db, username=username, is_deleted=False, schema_to_select=UserRead)
     if db_user is None:
         raise NotFoundException("User not found")
 
-    db_user = cast(UserRead, db_user)
-    if current_user["id"] != db_user.id:
+    db_user = cast(dict[str, Any], db_user)
+
+    if current_user["id"] != db_user["id"]:
         raise ForbiddenException()
 
     post_internal_dict = post.model_dump()
-    post_internal_dict["created_by_user_id"] = db_user.id
+    post_internal_dict["created_by_user_id"] = db_user["id"]
 
     post_internal = PostCreateInternal(**post_internal_dict)
     created_post = await crud_posts.create(db=db, object=post_internal)
 
-    post_read = await crud_posts.get(db=db, id=created_post.id, schema_to_select=PostRead)
+    if created_post is None:
+        raise NotFoundException("Failed to create post")
+
+    post_read = await crud_posts.get(db=db, id=created_post["id"], schema_to_select=PostRead)
     if post_read is None:
         raise NotFoundException("Created post not found")
 
-    return cast(PostRead, post_read)
+    return cast(dict[str, Any], post_read)
 
 
 @router.get("/{username}/posts", response_model=PaginatedListResponse[PostRead])
@@ -59,22 +62,16 @@ async def read_posts(
     page: int = 1,
     items_per_page: int = 10,
 ) -> dict:
-    db_user = await crud_users.get(
-        db=db, 
-        username=username, 
-        is_deleted=False, 
-        schema_to_select=UserRead,
-        return_as_model=True
-    )
+    db_user = await crud_users.get(db=db, username=username, is_deleted=False, schema_to_select=UserRead)
     if not db_user:
         raise NotFoundException("User not found")
 
-    db_user = cast(UserRead, db_user)
+    db_user = cast(dict[str, Any], db_user)
     posts_data = await crud_posts.get_multi(
         db=db,
         offset=compute_offset(page, items_per_page),
         limit=items_per_page,
-        created_by_user_id=db_user.id,
+        created_by_user_id=db_user["id"],
         is_deleted=False,
     )
 
@@ -86,25 +83,20 @@ async def read_posts(
 @cache(key_prefix="{username}_post_cache", resource_id_name="id")
 async def read_post(
     request: Request, username: str, id: int, db: Annotated[AsyncSession, Depends(async_get_db)]
-) -> PostRead:
-    db_user = await crud_users.get(
-        db=db, 
-        username=username, 
-        is_deleted=False, 
-        schema_to_select=UserRead,
-        return_as_model=True
-    )
+) -> dict[str, Any]:
+    db_user = await crud_users.get(db=db, username=username, is_deleted=False, schema_to_select=UserRead)
     if db_user is None:
         raise NotFoundException("User not found")
 
-    db_user = cast(UserRead, db_user)
+    db_user = cast(dict[str, Any], db_user)
+
     db_post = await crud_posts.get(
-        db=db, id=id, created_by_user_id=db_user.id, is_deleted=False, schema_to_select=PostRead
+        db=db, id=id, created_by_user_id=db_user["id"], is_deleted=False, schema_to_select=PostRead
     )
     if db_post is None:
         raise NotFoundException("Post not found")
 
-    return cast(PostRead, db_post)
+    return cast(dict[str, Any], db_post)
 
 
 @router.patch("/{username}/post/{id}")
@@ -117,24 +109,21 @@ async def patch_post(
     current_user: Annotated[dict, Depends(get_current_user)],
     db: Annotated[AsyncSession, Depends(async_get_db)],
 ) -> dict[str, str]:
-    db_user = await crud_users.get(
-        db=db, 
-        username=username, 
-        is_deleted=False, 
-        schema_to_select=UserRead,
-        return_as_model=True
-    )
+    db_user = await crud_users.get(db=db, username=username, is_deleted=False, schema_to_select=UserRead)
     if db_user is None:
         raise NotFoundException("User not found")
 
-    db_user = cast(UserRead, db_user)
-    if current_user["id"] != db_user.id:
+    db_user = cast(dict[str, Any], db_user)
+
+    if current_user["id"] != db_user["id"]:
         raise ForbiddenException()
 
     db_post = await crud_posts.get(db=db, id=id, is_deleted=False, schema_to_select=PostRead)
     if db_post is None:
         raise NotFoundException("Post not found")
 
+    db_post = cast(dict[str, Any], db_post)
+
     await crud_posts.update(db=db, object=values, id=id)
     return {"message": "Post updated"}
 
@@ -148,24 +137,21 @@ async def erase_post(
     current_user: Annotated[dict, Depends(get_current_user)],
     db: Annotated[AsyncSession, Depends(async_get_db)],
 ) -> dict[str, str]:
-    db_user = await crud_users.get(
-        db=db, 
-        username=username, 
-        is_deleted=False, 
-        schema_to_select=UserRead,
-        return_as_model=True
-    )
+    db_user = await crud_users.get(db=db, username=username, is_deleted=False, schema_to_select=UserRead)
     if db_user is None:
         raise NotFoundException("User not found")
 
-    db_user = cast(UserRead, db_user)
-    if current_user["id"] != db_user.id:
+    db_user = cast(dict[str, Any], db_user)
+
+    if current_user["id"] != db_user["id"]:
         raise ForbiddenException()
 
     db_post = await crud_posts.get(db=db, id=id, is_deleted=False, schema_to_select=PostRead)
     if db_post is None:
         raise NotFoundException("Post not found")
 
+    db_post = cast(dict[str, Any], db_post)
+
     await crud_posts.delete(db=db, id=id)
 
     return {"message": "Post deleted"}
@@ -176,19 +162,17 @@ async def erase_post(
 async def erase_db_post(
     request: Request, username: str, id: int, db: Annotated[AsyncSession, Depends(async_get_db)]
 ) -> dict[str, str]:
-    db_user = await crud_users.get(
-        db=db, 
-        username=username, 
-        is_deleted=False, 
-        schema_to_select=UserRead,
-        return_as_model=True
-    )
+    db_user = await crud_users.get(db=db, username=username, is_deleted=False, schema_to_select=UserRead)
     if db_user is None:
         raise NotFoundException("User not found")
 
+    db_user = cast(dict[str, Any], db_user)
+
     db_post = await crud_posts.get(db=db, id=id, is_deleted=False, schema_to_select=PostRead)
     if db_post is None:
         raise NotFoundException("Post not found")
 
+    db_post = cast(dict[str, Any], db_post)
+
     await crud_posts.db_delete(db=db, id=id)
-    return {"message": "Post deleted from the database"}
+    return {"message": "Post deleted from the database"}

src/app/api/v1/rate_limits.py

@@ -18,14 +18,16 @@
 @router.post("/tier/{tier_name}/rate_limit", dependencies=[Depends(get_current_superuser)], status_code=201)
 async def write_rate_limit(
     request: Request, tier_name: str, rate_limit: RateLimitCreate, db: Annotated[AsyncSession, Depends(async_get_db)]
-) -> RateLimitRead:
+) -> dict[str, Any]:
     db_tier = await crud_tiers.get(db=db, name=tier_name, schema_to_select=TierRead)
     if not db_tier:
         raise NotFoundException("Tier not found")
 
-    db_tier = cast(TierRead, db_tier)
+    db_tier = cast(dict[str, Any], db_tier)
+
+    db_tier = cast(dict[str, Any], db_tier)
     rate_limit_internal_dict = rate_limit.model_dump()
-    rate_limit_internal_dict["tier_id"] = db_tier.id
+    rate_limit_internal_dict["tier_id"] = db_tier["id"]
 
     db_rate_limit = await crud_rate_limits.exists(db=db, name=rate_limit_internal_dict["name"])
     if db_rate_limit:
@@ -34,11 +36,14 @@ async def write_rate_limit(
     rate_limit_internal = RateLimitCreateInternal(**rate_limit_internal_dict)
     created_rate_limit = await crud_rate_limits.create(db=db, object=rate_limit_internal)
 
-    rate_limit_read = await crud_rate_limits.get(db=db, id=created_rate_limit.id, schema_to_select=RateLimitRead)
+    if created_rate_limit is None:
+        raise NotFoundException("Failed to create rate limit")
+
+    rate_limit_read = await crud_rate_limits.get(db=db, id=created_rate_limit["id"], schema_to_select=RateLimitRead)
     if rate_limit_read is None:
         raise NotFoundException("Created rate limit not found")
 
-    return cast(RateLimitRead, rate_limit_read)
+    return cast(dict[str, Any], rate_limit_read)
 
 
 @router.get("/tier/{tier_name}/rate_limits", response_model=PaginatedListResponse[RateLimitRead])
@@ -53,12 +58,13 @@ async def read_rate_limits(
     if not db_tier:
         raise NotFoundException("Tier not found")
 
-    db_tier = cast(TierRead, db_tier)
+    db_tier = cast(dict[str, Any], db_tier)
+
     rate_limits_data = await crud_rate_limits.get_multi(
         db=db,
         offset=compute_offset(page, items_per_page),
         limit=items_per_page,
-        tier_id=db_tier.id,
+        tier_id=db_tier["id"],
     )
 
     response: dict[str, Any] = paginated_response(crud_data=rate_limits_data, page=page, items_per_page=items_per_page)
@@ -68,17 +74,18 @@ async def read_rate_limits(
 @router.get("/tier/{tier_name}/rate_limit/{id}", response_model=RateLimitRead)
 async def read_rate_limit(
     request: Request, tier_name: str, id: int, db: Annotated[AsyncSession, Depends(async_get_db)]
-) -> RateLimitRead:
+) -> dict[str, Any]:
     db_tier = await crud_tiers.get(db=db, name=tier_name, schema_to_select=TierRead)
     if not db_tier:
         raise NotFoundException("Tier not found")
 
-    db_tier = cast(TierRead, db_tier)
-    db_rate_limit = await crud_rate_limits.get(db=db, tier_id=db_tier.id, id=id, schema_to_select=RateLimitRead)
+    db_tier = cast(dict[str, Any], db_tier)
+
+    db_rate_limit = await crud_rate_limits.get(db=db, tier_id=db_tier["id"], id=id, schema_to_select=RateLimitRead)
     if db_rate_limit is None:
         raise NotFoundException("Rate Limit not found")
 
-    return cast(RateLimitRead, db_rate_limit)
+    return cast(dict[str, Any], db_rate_limit)
 
 
 @router.patch("/tier/{tier_name}/rate_limit/{id}", dependencies=[Depends(get_current_superuser)])
@@ -93,8 +100,9 @@ async def patch_rate_limit(
     if not db_tier:
         raise NotFoundException("Tier not found")
 
-    db_tier = cast(TierRead, db_tier)
-    db_rate_limit = await crud_rate_limits.get(db=db, tier_id=db_tier.id, id=id, schema_to_select=RateLimitRead)
+    db_tier = cast(dict[str, Any], db_tier)
+
+    db_rate_limit = await crud_rate_limits.get(db=db, tier_id=db_tier["id"], id=id, schema_to_select=RateLimitRead)
     if db_rate_limit is None:
         raise NotFoundException("Rate Limit not found")
 
@@ -110,8 +118,9 @@ async def erase_rate_limit(
     if not db_tier:
         raise NotFoundException("Tier not found")
 
-    db_tier = cast(TierRead, db_tier)
-    db_rate_limit = await crud_rate_limits.get(db=db, tier_id=db_tier.id, id=id, schema_to_select=RateLimitRead)
+    db_tier = cast(dict[str, Any], db_tier)
+
+    db_rate_limit = await crud_rate_limits.get(db=db, tier_id=db_tier["id"], id=id, schema_to_select=RateLimitRead)
     if db_rate_limit is None:
         raise NotFoundException("Rate Limit not found")
 

src/app/api/v1/tiers.py

@@ -16,7 +16,7 @@
 @router.post("/tier", dependencies=[Depends(get_current_superuser)], status_code=201)
 async def write_tier(
     request: Request, tier: TierCreate, db: Annotated[AsyncSession, Depends(async_get_db)]
-) -> TierRead:
+) -> dict[str, Any]:
     tier_internal_dict = tier.model_dump()
     db_tier = await crud_tiers.exists(db=db, name=tier_internal_dict["name"])
     if db_tier:
@@ -25,11 +25,14 @@ async def write_tier(
     tier_internal = TierCreateInternal(**tier_internal_dict)
     created_tier = await crud_tiers.create(db=db, object=tier_internal)
 
-    tier_read = await crud_tiers.get(db=db, id=created_tier.id, schema_to_select=TierRead)
+    if created_tier is None:
+        raise NotFoundException("Failed to create tier")
+
+    tier_read = await crud_tiers.get(db=db, id=created_tier["id"], schema_to_select=TierRead)
     if tier_read is None:
         raise NotFoundException("Created tier not found")
 
-    return cast(TierRead, tier_read)
+    return cast(dict[str, Any], tier_read)
 
 
 @router.get("/tiers", response_model=PaginatedListResponse[TierRead])
@@ -43,12 +46,12 @@ async def read_tiers(
 
 
 @router.get("/tier/{name}", response_model=TierRead)
-async def read_tier(request: Request, name: str, db: Annotated[AsyncSession, Depends(async_get_db)]) -> TierRead:
+async def read_tier(request: Request, name: str, db: Annotated[AsyncSession, Depends(async_get_db)]) -> dict[str, Any]:
     db_tier = await crud_tiers.get(db=db, name=name, schema_to_select=TierRead)
     if db_tier is None:
         raise NotFoundException("Tier not found")
 
-    return cast(TierRead, db_tier)
+    return cast(dict[str, Any], db_tier)
 
 
 @router.patch("/tier/{name}", dependencies=[Depends(get_current_superuser)])