added new endpoints

Dockerfile

@@ -6,7 +6,7 @@ COPY pyproject.toml pyproject.toml
 
 RUN pip install poetry
 RUN poetry config virtualenvs.create false
-RUN poetry install --no-dev
+RUN poetry install --no-root
 
 COPY . /app
 

alembic/versions/cedcfebfb6ad_add_product_tables.py → alembic/versions/256b8bcd290c_init_schema.py

@@ -1,22 +1,19 @@
-"""Add product tables
+"""init schema
 
-Revision ID: cedcfebfb6ad
-Revises: 40f8af84ecb8
-Create Date: 2023-12-06 22:33:42.993363
+Revision ID: 256b8bcd290c
+Revises: 
+Create Date: 2025-08-25 09:37:06.747222
 
 """
-from typing import (
-    Sequence,
-    Union,
-)
+from typing import Sequence, Union
 
+from alembic import op
 import sqlalchemy as sa
 
-from alembic import op
 
 # revision identifiers, used by Alembic.
-revision: str = 'cedcfebfb6ad'
-down_revision: Union[str, None] = '40f8af84ecb8'
+revision: str = '256b8bcd290c'
+down_revision: Union[str, None] = None
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 

reset_db.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+set -e
+
+echo "Dropping and recreating public schema..."
+docker compose exec -T db psql -U user -d fastapi_shop -c "DROP SCHEMA public CASCADE; CREATE SCHEMA public;"
+
+echo "Stamping Alembic to head..."
+docker compose exec -T web alembic stamp head
+
+echo "Running migrations..."
+docker compose exec -T web alembic upgrade head
+
+echo "✅ Database reset complete!"

src/catalogue/models/pydantic.py

@@ -15,3 +15,11 @@ class ProductModel(BaseModel):
 
     class Config:
         from_attributes = True
+
+class CategoryModel(BaseModel):
+    id: Optional[int]
+    title: str
+    description: Optional[str]
+    image: Optional[str]
+    is_active: bool
+    parent_id: Optional[int]

src/catalogue/repository.py

@@ -1,8 +1,8 @@
 from fastapi import Depends
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from src.catalogue.models.pydantic import ProductModel
-from src.catalogue.models.sqlalchemy import Product
+from src.catalogue.models.pydantic import ProductModel, CategoryModel
+from src.catalogue.models.sqlalchemy import Product, Category
 from src.common.databases.postgres import (
     get_session,
 )
@@ -16,3 +16,11 @@ def __init__(self, session: AsyncSession):
 
 def get_product_repository(session: AsyncSession = Depends(get_session)) -> ProductRepository:
     return ProductRepository(session=session)
+
+class CategoryRepository(BaseSQLAlchemyRepository[Category, CategoryModel]):
+    def __init__(self, session: AsyncSession):
+        super().__init__(model=Category, pydantic_model=CategoryModel, session=session)
+
+
+def get_category_repository(session: AsyncSession = Depends(get_session)) -> CategoryRepository:
+    return CategoryRepository(session=session)

src/catalogue/routes.py

@@ -3,7 +3,11 @@
 
 class CatalogueRoutesPrefixes:
     product: str = '/product'
+    category: str = '/category'
 
 
 class ProductRoutesPrefixes(BaseCrudPrefixes):
     ...
+
+class CategoryRoutesPrefixes(BaseCrudPrefixes):
+    ...

src/catalogue/services.py

@@ -1,9 +1,11 @@
 from fastapi import Depends
 
-from src.catalogue.models.pydantic import ProductModel
+from src.catalogue.models.pydantic import ProductModel, CategoryModel
 from src.catalogue.repository import (
     ProductRepository,
     get_product_repository,
+    CategoryRepository,
+    get_category_repository,
 )
 from src.common.service import BaseService
 
@@ -15,3 +17,12 @@ def __init__(self, repository: ProductRepository):
 
 def get_product_service(repo: ProductRepository = Depends(get_product_repository)) -> ProductService:
     return ProductService(repository=repo)
+
+
+class CategoryService(BaseService[CategoryModel]):
+    def __init__(self, repository: CategoryRepository):
+        super().__init__(repository)
+
+
+def get_category_service(repo: CategoryRepository = Depends(get_category_repository)) -> CategoryService:
+    return CategoryService(repository=repo)

src/catalogue/views.py

@@ -10,19 +10,21 @@
     status,
 )
 
-from src.catalogue.models.pydantic import ProductModel
+from src.catalogue.models.pydantic import ProductModel, CategoryModel
 from src.catalogue.routes import (
     CatalogueRoutesPrefixes,
     ProductRoutesPrefixes,
+    CategoryRoutesPrefixes
 )
 from src.catalogue.services import (
-    get_product_service,
+    get_product_service, get_category_service,
 )
 from src.common.exceptions.base import ObjectDoesNotExistException
 from src.common.schemas.common import ErrorResponse
 
 
 product_router = APIRouter(prefix=CatalogueRoutesPrefixes.product)
+category_router = APIRouter(prefix=CatalogueRoutesPrefixes.category)
 
 
 @product_router.get(
@@ -69,3 +71,41 @@ async def product_detail(
         return ErrorResponse(message=exc.message)
 
     return response
+
+@category_router.get(
+    CategoryRoutesPrefixes.root,
+    status_code=status.HTTP_200_OK,
+    response_model=list[CategoryModel],
+)
+async def category_list(category_service=Depends(get_category_service)) -> list[CategoryModel]:
+
+    """
+    Get list of categories..
+
+    Returns:
+        Response with list of categories...
+    """
+    return await category_service.list()
+
+@category_router.get(
+    CategoryRoutesPrefixes.detail,
+    responses={
+        status.HTTP_200_OK: {'model': CategoryModel},
+        status.HTTP_404_NOT_FOUND: {'model': ErrorResponse},
+    },
+    status_code=status.HTTP_200_OK,
+    response_model=Union[CategoryModel, ErrorResponse],
+)
+async def category_detail(
+        response: Response,
+        pk: int,
+        service: Annotated[get_category_service, Depends()],
+) -> Union[Response, ErrorResponse]:
+    try:
+        response = await service.detail(pk=pk)
+    except ObjectDoesNotExistException as exc:
+        response.status_code = status.HTTP_404_NOT_FOUND
+        return ErrorResponse(message=exc.message)
+
+    return response
+

src/common/repository/sqlalchemy.py

@@ -32,14 +32,14 @@ async def get(self, pk: int) -> PType:
         instance = result.scalar_one_or_none()
         if not instance:
             raise ObjectDoesNotExistException()
-        return self.pydantic_model.from_orm(instance)
+        return self.pydantic_model.model_validate(instance, from_attributes=True)
 
     async def create(self, instance_data: PType) -> PType:
         instance = self.model(**instance_data.model_dump())
         self.session.add(instance)
         await self.session.commit()
         await self.session.refresh(instance)
-        return self.pydantic_model.from_orm(instance)
+        return self.pydantic_model.model_validate(instance, from_attributes=True)
 
     async def update(self, pk: int, update_data: PType) -> PType:
         await self.session.execute(
@@ -56,7 +56,7 @@ async def all(self) -> List[PType]:
         stmt = select(self.model)
         result = await self.session.execute(stmt)
         instances = result.scalars().all()
-        return [self.pydantic_model.model_validate(instance) for instance in instances]
+        return [self.pydantic_model.model_validate(instance, from_attributes=True) for instance in instances]
 
     async def filter(self, **kwargs) -> List[PType]:
         stmt = select(self.model).filter_by(**kwargs)

src/main.py

@@ -3,7 +3,7 @@
 
 from src.admin import register_admin_views
 from src.base_settings import base_settings
-from src.catalogue.views import product_router
+from src.catalogue.views import product_router, category_router
 from src.common.databases.postgres import postgres
 from src.general.views import router as status_router
 from src.routes import BaseRoutesPrefixes
@@ -19,6 +19,12 @@ def include_routes(application: FastAPI) -> None:
         tags=['Catalogue'],
     )
 
+    application.include_router(
+        router=category_router,
+        prefix=BaseRoutesPrefixes.catalogue,
+        tags=['Catalogue'],
+    )
+
 
 def get_application() -> FastAPI:
     application = FastAPI(