logging added to scripts, get_db fix, endpoints fixed for fastcrud usage

src/app/api/v1/posts.py

@@ -132,7 +132,7 @@ async def erase_post(
     if db_post is None:
         raise NotFoundException("Post not found")
 
-    await crud_posts.delete(db=db, db_row=db_post, id=id)
+    await crud_posts.delete(db=db, id=id)
 
     return {"message": "Post deleted"}
 

src/app/api/v1/rate_limits.py

@@ -115,5 +115,5 @@ async def erase_rate_limit(
     if db_rate_limit is None:
         raise RateLimitException("Rate Limit not found")
 
-    await crud_rate_limits.delete(db=db, db_row=db_rate_limit, id=db_rate_limit["id"])
+    await crud_rate_limits.delete(db=db, id=db_rate_limit["id"])
     return {"message": "Rate Limit deleted"}

src/app/api/v1/tiers.py

@@ -66,5 +66,5 @@ async def erase_tier(request: Request, name: str, db: Annotated[AsyncSession, De
     if db_tier is None:
         raise NotFoundException("Tier not found")
 
-    await crud_tiers.delete(db=db, db_row=db_tier, name=name)
+    await crud_tiers.delete(db=db, name=name)
     return {"message": "Tier deleted"}

src/app/api/v1/users.py

@@ -115,7 +115,7 @@ async def erase_user(
     if username != current_user["username"]:
         raise ForbiddenException()
 
-    await crud_users.delete(db=db, db_row=db_user, username=username)
+    await crud_users.delete(db=db, username=username)
     await blacklist_token(token=token, db=db)
     return {"message": "User deleted"}
 

src/app/core/db/database.py

@@ -20,7 +20,5 @@ class Base(DeclarativeBase, MappedAsDataclass):
 
 async def async_get_db() -> AsyncSession:
     async_session = local_session
-
     async with async_session() as db:
         yield db
-        await db.commit()

src/scripts/create_first_superuser.py

@@ -1,5 +1,6 @@
 import asyncio
 import uuid
+import logging
 from datetime import UTC, datetime
 
 from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, MetaData, String, Table, insert, select
@@ -10,49 +11,61 @@
 from ..app.core.security import get_password_hash
 from ..app.models.user import User
 
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 
 async def create_first_user(session: AsyncSession) -> None:
-    name = settings.ADMIN_NAME
-    email = settings.ADMIN_EMAIL
-    username = settings.ADMIN_USERNAME
-    hashed_password = get_password_hash(settings.ADMIN_PASSWORD)
+    try:
+        name = settings.ADMIN_NAME
+        email = settings.ADMIN_EMAIL
+        username = settings.ADMIN_USERNAME
+        hashed_password = get_password_hash(settings.ADMIN_PASSWORD)
+
+        query = select(User).filter_by(email=email)
+        result = await session.execute(query)
+        user = result.scalar_one_or_none()
 
-    query = select(User).filter_by(email=email)
-    result = await session.execute(query)
-    user = result.scalar_one_or_none()
+        if user is None:
+            metadata = MetaData()
+            user_table = Table(
+                "user",
+                metadata,
+                Column("id", Integer, primary_key=True, autoincrement=True, nullable=False),
+                Column("name", String(30), nullable=False),
+                Column("username", String(20), nullable=False, unique=True, index=True),
+                Column("email", String(50), nullable=False, unique=True, index=True),
+                Column("hashed_password", String, nullable=False),
+                Column("profile_image_url", String, default="https://profileimageurl.com"),
+                Column("uuid", UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, unique=True),
+                Column("created_at", DateTime(timezone=True), default=lambda: datetime.now(UTC), nullable=False),
+                Column("updated_at", DateTime),
+                Column("deleted_at", DateTime),
+                Column("is_deleted", Boolean, default=False, index=True),
+                Column("is_superuser", Boolean, default=False),
+                Column("tier_id", Integer, ForeignKey("tier.id"), index=True),
+            )
 
-    if user is None:
-        metadata = MetaData()
-        user_table = Table(
-            "user",
-            metadata,
-            Column("id", Integer, primary_key=True, autoincrement=True, nullable=False),
-            Column("name", String(30), nullable=False),
-            Column("username", String(20), nullable=False, unique=True, index=True),
-            Column("email", String(50), nullable=False, unique=True, index=True),
-            Column("hashed_password", String, nullable=False),
-            Column("profile_image_url", String, default="https://profileimageurl.com"),
-            Column("uuid", UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, unique=True),
-            Column("created_at", DateTime(timezone=True), default=lambda: datetime.now(UTC), nullable=False),
-            Column("updated_at", DateTime),
-            Column("deleted_at", DateTime),
-            Column("is_deleted", Boolean, default=False, index=True),
-            Column("is_superuser", Boolean, default=False),
-            Column("tier_id", Integer, ForeignKey("tier.id"), index=True),
-        )
+            data = {
+                "name": name,
+                "email": email,
+                "username": username,
+                "hashed_password": hashed_password,
+                "is_superuser": True,
+            }
 
-        data = {
-            "name": name,
-            "email": email,
-            "username": username,
-            "hashed_password": hashed_password,
-            "is_superuser": True,
-        }
+            stmt = insert(user_table).values(data)
+            async with async_engine.connect() as conn:
+                await conn.execute(stmt)
+                await conn.commit()
 
-        stmt = insert(user_table).values(data)
-        async with async_engine.connect() as conn:
-            await conn.execute(stmt)
-            await conn.commit()
+            logger.info(f"Admin user {username} created successfully.")
+
+        else:
+            logger.info(f"Admin user {username} already exists.")
+
+    except Exception as e:
+        logger.error(f"Error creating admin user: {e}")
 
 
 async def main():

src/scripts/create_first_tier.py

@@ -1,23 +1,34 @@
 import asyncio
+import logging
 
 from sqlalchemy import select
 
 from ..app.core.config import config
 from ..app.core.db.database import AsyncSession, local_session
 from ..app.models.tier import Tier
 
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-async def create_first_tier(session: AsyncSession) -> None:
-    tier_name = config("TIER_NAME", default="free")
-
-    query = select(Tier).where(Tier.name == tier_name)
-    result = await session.execute(query)
-    tier = result.scalar_one_or_none()
 
-    if tier is None:
-        session.add(Tier(name=tier_name))
-
-        await session.commit()
+async def create_first_tier(session: AsyncSession) -> None:
+    try:
+        tier_name = config("TIER_NAME", default="free")
+
+        query = select(Tier).where(Tier.name == tier_name)
+        result = await session.execute(query)
+        tier = result.scalar_one_or_none()
+
+        if tier is None:
+            session.add(Tier(name=tier_name))
+            await session.commit()
+            logger.info(f"Tier '{tier_name}' created successfully.")
+
+        else:
+            logger.info(f"Tier '{tier_name}' already exists.")
+
+    except Exception as e:
+        logger.error(f"Error creating tier: {e}")
 
 
 async def main():