tempest-fastapi-sdk 0.77.0__tar.gz → 0.78.0__tar.gz

{tempest_fastapi_sdk-0.77.0 → tempest_fastapi_sdk-0.78.0}/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to **tempest-fastapi-sdk** are listed below.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.78.0] — 2026-06-27
+
+### Added
+
+- **`BaseService.update` (and `BaseController.update`).** The service
+  skeleton now ships a generic update method: fetch by primary key, copy
+  the fields present in the payload (`data.to_dict()`, which drops unset
+  and ``None`` values) onto the instance, persist via
+  ``repository.update`` and return the mapped response. Because unset
+  fields are skipped, the same method serves full (PUT) and partial
+  (PATCH) updates. ``BaseController.update`` forwards to it, matching the
+  existing pass-through layer. Override either when an update needs
+  orchestration.
+
 ## [0.77.0] — 2026-06-27
 
 ### Added

{tempest_fastapi_sdk-0.77.0 → tempest_fastapi_sdk-0.78.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tempest-fastapi-sdk
-Version: 0.77.0
+Version: 0.78.0
 Summary: Shared FastAPI building blocks: base schemas, ORM model, async repository, exceptions, pagination and settings — the conventions used across Tempest projects.
 Project-URL: Homepage, https://github.com/mauriciobenjamin700/tempest-fastapi-sdk
 Project-URL: Repository, https://github.com/mauriciobenjamin700/tempest-fastapi-sdk
@@ -714,7 +714,7 @@ The highlighted block (under the divider comment) is what you typically add per
 
 The service is where business rules live. It calls one or more repositories and never touches HTTP or SQLAlchemy types directly.
 
-Inherit from `BaseService[RepositoryT, ResponseT]`. Doing so gives you `get_by_id`, `get_or_none`, `list`, `paginate`, `count`, `exists` and `delete` for free — every one is already wired to `repository.map_to_response` (sync or async). Override only the methods that need domain logic; add new ones for use cases the base doesn't cover (signup, password reset, etc.):
+Inherit from `BaseService[RepositoryT, ResponseT]`. Doing so gives you `get_by_id`, `get_or_none`, `list`, `paginate`, `count`, `exists`, `update` and `delete` for free — every one is already wired to `repository.map_to_response` (sync or async). Override only the methods that need domain logic; add new ones for use cases the base doesn't cover (signup, password reset, etc.):
 
 ```python
 # src/services/user.py
@@ -811,7 +811,7 @@ class UserService(BaseService[UserRepository, UserResponseSchema]):
 
 Even when there's no orchestration to do, `controllers/` exists as a **thin pass-through** so the import graph stays uniform across services. The day a use case needs to coordinate two services (or fan out to a queue), the controller is already there.
 
-Inherit from `BaseController[ServiceT, ResponseT]`. The base forwards `get_by_id`, `list`, `paginate`, `count` and `delete` to the service for you — you only declare methods that add cross-service coordination or that don't exist on the service (custom use cases like `signup`):
+Inherit from `BaseController[ServiceT, ResponseT]`. The base forwards `get_by_id`, `list`, `paginate`, `count`, `update` and `delete` to the service for you — you only declare methods that add cross-service coordination or that don't exist on the service (custom use cases like `signup`):
 
 ```python
 # src/controllers/user.py
@@ -2136,6 +2136,7 @@ What you inherit by subclassing `BaseService[RepositoryT, ResponseT]`:
 | `paginate(filters=None, order_by=None, page=1, page_size=20, ascending=True)` | `dict` with mapped `items` + `total`/`page`/`size`/`pages`. | Offset pagination via `repository.paginate`. |
 | `count(filters=None)` | `int` | Pass-through to `repository.count`. |
 | `exists(filters)` | `bool` | Pass-through to `repository.exists`. |
+| `update(id, data)` | `ResponseT` | Fetch by id, copy the fields present in `data` (a `BaseSchema`) onto the row, persist, map. `to_dict()` drops unset/`None`, so it serves PUT and PATCH alike. |
 | `delete(id)` | `None` | Hard delete via `repository.delete`. |
 
 `map_to_response` is `await`-ed when it returns a coroutine, so async mappers work transparently — no method override needed.
@@ -2148,6 +2149,7 @@ What you inherit by subclassing `BaseController[ServiceT, ResponseT]`:
 | `list(filters, order_by, ascending)` | `service.list` | Same. |
 | `paginate(filters, order_by, page, page_size, ascending)` | `service.paginate` | Same. |
 | `count(filters)` | `service.count` | Same. |
+| `update(id, data)` | `service.update` | Same. |
 | `delete(id)` | `service.delete` | Same. |
 
 When a use case needs domain rules, override the inherited method in the service. When a use case needs to coordinate more than one service, override the inherited method (or add a new one) in the controller. The router never grows — it only depends on the controller.

{tempest_fastapi_sdk-0.77.0 → tempest_fastapi_sdk-0.78.0}/README.md

@@ -611,7 +611,7 @@ The highlighted block (under the divider comment) is what you typically add per
 
 The service is where business rules live. It calls one or more repositories and never touches HTTP or SQLAlchemy types directly.
 
-Inherit from `BaseService[RepositoryT, ResponseT]`. Doing so gives you `get_by_id`, `get_or_none`, `list`, `paginate`, `count`, `exists` and `delete` for free — every one is already wired to `repository.map_to_response` (sync or async). Override only the methods that need domain logic; add new ones for use cases the base doesn't cover (signup, password reset, etc.):
+Inherit from `BaseService[RepositoryT, ResponseT]`. Doing so gives you `get_by_id`, `get_or_none`, `list`, `paginate`, `count`, `exists`, `update` and `delete` for free — every one is already wired to `repository.map_to_response` (sync or async). Override only the methods that need domain logic; add new ones for use cases the base doesn't cover (signup, password reset, etc.):
 
 ```python
 # src/services/user.py
@@ -708,7 +708,7 @@ class UserService(BaseService[UserRepository, UserResponseSchema]):
 
 Even when there's no orchestration to do, `controllers/` exists as a **thin pass-through** so the import graph stays uniform across services. The day a use case needs to coordinate two services (or fan out to a queue), the controller is already there.
 
-Inherit from `BaseController[ServiceT, ResponseT]`. The base forwards `get_by_id`, `list`, `paginate`, `count` and `delete` to the service for you — you only declare methods that add cross-service coordination or that don't exist on the service (custom use cases like `signup`):
+Inherit from `BaseController[ServiceT, ResponseT]`. The base forwards `get_by_id`, `list`, `paginate`, `count`, `update` and `delete` to the service for you — you only declare methods that add cross-service coordination or that don't exist on the service (custom use cases like `signup`):
 
 ```python
 # src/controllers/user.py
@@ -2033,6 +2033,7 @@ What you inherit by subclassing `BaseService[RepositoryT, ResponseT]`:
 | `paginate(filters=None, order_by=None, page=1, page_size=20, ascending=True)` | `dict` with mapped `items` + `total`/`page`/`size`/`pages`. | Offset pagination via `repository.paginate`. |
 | `count(filters=None)` | `int` | Pass-through to `repository.count`. |
 | `exists(filters)` | `bool` | Pass-through to `repository.exists`. |
+| `update(id, data)` | `ResponseT` | Fetch by id, copy the fields present in `data` (a `BaseSchema`) onto the row, persist, map. `to_dict()` drops unset/`None`, so it serves PUT and PATCH alike. |
 | `delete(id)` | `None` | Hard delete via `repository.delete`. |
 
 `map_to_response` is `await`-ed when it returns a coroutine, so async mappers work transparently — no method override needed.
@@ -2045,6 +2046,7 @@ What you inherit by subclassing `BaseController[ServiceT, ResponseT]`:
 | `list(filters, order_by, ascending)` | `service.list` | Same. |
 | `paginate(filters, order_by, page, page_size, ascending)` | `service.paginate` | Same. |
 | `count(filters)` | `service.count` | Same. |
+| `update(id, data)` | `service.update` | Same. |
 | `delete(id)` | `service.delete` | Same. |
 
 When a use case needs domain rules, override the inherited method in the service. When a use case needs to coordinate more than one service, override the inherited method (or add a new one) in the controller. The router never grows — it only depends on the controller.

{tempest_fastapi_sdk-0.77.0 → tempest_fastapi_sdk-0.78.0}/docs/architecture.en.md

@@ -147,6 +147,7 @@ What you inherit by subclassing `BaseService[RepositoryT, ResponseT]`:
 | `paginate(filters=None, order_by=None, page=1, page_size=20, ascending=True)` | `dict` with mapped `items` + `total`/`page`/`page_size`/`pages`. | Offset pagination via `repository.paginate`. |
 | `count(filters=None)` | `int` | Pass-through to `repository.count`. |
 | `exists(filters)` | `bool` | Pass-through to `repository.exists`. |
+| `update(id, data)` | `ResponseT` | Fetch by id, copy the fields present in `data` (a `BaseSchema`) onto the row, persist, map. `to_dict()` drops unset/`None`, so it serves PUT and PATCH. |
 | `delete(id)` | `None` | Hard delete via `repository.delete`. |
 
 `map_to_response` is `await`-ed when it returns a coroutine, so async mappers work transparently — no method override needed.
@@ -159,6 +160,7 @@ What you inherit by subclassing `BaseController[ServiceT, ResponseT]`:
 | `list(filters, order_by, ascending)` | `service.list` | Same. |
 | `paginate(filters, order_by, page, page_size, ascending)` | `service.paginate` | Same. |
 | `count(filters)` | `service.count` | Same. |
+| `update(id, data)` | `service.update` | Same. |
 | `delete(id)` | `service.delete` | Same. |
 
 When a use case needs domain rules, override the inherited method in the service. When a use case needs to coordinate more than one service, override the inherited method (or add a new one) in the controller. The router never grows — it only depends on the controller.

{tempest_fastapi_sdk-0.77.0 → tempest_fastapi_sdk-0.78.0}/docs/architecture.md

@@ -147,6 +147,7 @@ O que você herda ao subclassear `BaseService[RepositoryT, ResponseT]`:
 | `paginate(filters=None, order_by=None, page=1, page_size=20, ascending=True)` | `dict` com `items` mapeados + `total`/`page`/`page_size`/`pages`. | Paginação por offset via `repository.paginate`. |
 | `count(filters=None)` | `int` | Pass-through para `repository.count`. |
 | `exists(filters)` | `bool` | Pass-through para `repository.exists`. |
+| `update(id, data)` | `ResponseT` | Busca por id, copia os campos presentes em `data` (um `BaseSchema`) na instância, persiste e mapeia. `to_dict()` descarta unset/`None`, então serve PUT e PATCH. |
 | `delete(id)` | `None` | Hard delete via `repository.delete`. |
 
 `map_to_response` é aguardado com `await` quando retorna uma coroutine, então mappers async funcionam de forma transparente — sem precisar sobrescrever o método.
@@ -159,6 +160,7 @@ O que você herda ao subclassear `BaseController[ServiceT, ResponseT]`:
 | `list(filters, order_by, ascending)` | `service.list` | Igual. |
 | `paginate(filters, order_by, page, page_size, ascending)` | `service.paginate` | Igual. |
 | `count(filters)` | `service.count` | Igual. |
+| `update(id, data)` | `service.update` | Igual. |
 | `delete(id)` | `service.delete` | Igual. |
 
 Quando um caso de uso precisa de regras de domínio, sobrescreva o método herdado no service. Quando um caso de uso precisa coordenar mais de um service, sobrescreva o método herdado (ou adicione um novo) no controller. O router nunca cresce — ele só depende do controller.

{tempest_fastapi_sdk-0.77.0 → tempest_fastapi_sdk-0.78.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tempest-fastapi-sdk"
-version = "0.77.0"
+version = "0.78.0"
 description = "Shared FastAPI building blocks: base schemas, ORM model, async repository, exceptions, pagination and settings — the conventions used across Tempest projects."
 readme = "README.md"
 requires-python = ">=3.11"

{tempest_fastapi_sdk-0.77.0 → tempest_fastapi_sdk-0.78.0}/tempest_fastapi_sdk/__init__.py

@@ -342,7 +342,7 @@ from tempest_fastapi_sdk.websockets import (
     make_websocket_router,
 )
 
-__version__: str = "0.77.0"
+__version__: str = "0.78.0"
 
 __all__: list[str] = [
     "BASE_COLUMN_ORDER",

{tempest_fastapi_sdk-0.77.0 → tempest_fastapi_sdk-0.78.0}/tempest_fastapi_sdk/controllers/base.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from typing import Any, Generic, TypeVar, cast
 from uuid import UUID
 
+from tempest_fastapi_sdk.schemas.base import BaseSchema
 from tempest_fastapi_sdk.services.base import BaseService
 
 ServiceT = TypeVar("ServiceT", bound=BaseService[Any, Any])
@@ -112,6 +113,18 @@ class BaseController(Generic[ServiceT, ResponseT]):
         """
         return await self.service.count(filters)
 
+    async def update(self, id: UUID, data: BaseSchema) -> ResponseT:
+        """Pass-through to :meth:`BaseService.update`.
+
+        Args:
+            id (UUID): The primary key of the record to update.
+            data (BaseSchema): The update payload (unset fields skipped).
+
+        Returns:
+            ResponseT: The mapped, updated response.
+        """
+        return cast("ResponseT", await self.service.update(id, data))
+
     async def delete(self, id: UUID) -> None:
         """Pass-through to :meth:`BaseService.delete`.
 

{tempest_fastapi_sdk-0.77.0 → tempest_fastapi_sdk-0.78.0}/tempest_fastapi_sdk/services/base.py

@@ -7,6 +7,7 @@ from typing import Any, Generic, TypeVar
 from uuid import UUID
 
 from tempest_fastapi_sdk.db.repository import BaseRepository
+from tempest_fastapi_sdk.schemas.base import BaseSchema
 
 RepositoryT = TypeVar("RepositoryT", bound=BaseRepository[Any])
 ResponseT = TypeVar("ResponseT")
@@ -168,6 +169,39 @@ class BaseService(Generic[RepositoryT, ResponseT]):
         """
         return await self.repository.exists(filters)
 
+    async def update(self, id: UUID, data: BaseSchema) -> ResponseT:
+        """Apply a partial update to a record and map it to a response.
+
+        Fetches the row by primary key, copies the fields present in
+        ``data`` onto the instance, persists, and returns the mapped
+        response. Because :meth:`BaseSchema.to_dict` drops unset and
+        ``None`` fields, only the values the caller actually supplied are
+        applied — so the same method serves both full (PUT) and partial
+        (PATCH) updates.
+
+        Override this in a concrete service when an update needs
+        orchestration (cross-repository writes, domain rules, side
+        effects); leave it untouched for plain field copies.
+
+        Args:
+            id (UUID): The primary key of the record to update.
+            data (BaseSchema): The update payload. Fields left unset (or
+                ``None``) are not applied.
+
+        Returns:
+            ResponseT: The mapped, updated response.
+
+        Raises:
+            AppException: ``repository.not_found_exception`` when no
+                record with ``id`` exists.
+            ConflictException: On integrity violations while persisting.
+        """
+        instance = await self.repository.get_by_id(id)
+        for field, value in data.to_dict().items():
+            setattr(instance, field, value)
+        updated = await self.repository.update(instance)
+        return await self._map_to_response(updated)
+
     async def delete(self, id: UUID) -> None:
         """Delete a row by primary key.
 

{tempest_fastapi_sdk-0.77.0 → tempest_fastapi_sdk-0.78.0}/tests/controllers/test_base.py

@@ -12,6 +12,7 @@ from tempest_fastapi_sdk import (
     BaseModel,
     BaseRepository,
     BaseResponseSchema,
+    BaseSchema,
     BaseService,
     NotFoundException,
 )
@@ -27,6 +28,10 @@ class GadgetResponse(BaseResponseSchema):
     name: str
 
 
+class GadgetUpdate(BaseSchema):
+    name: str | None = None
+
+
 class GadgetRepository(BaseRepository[Gadget]):
     def __init__(self, session: AsyncSession) -> None:
         super().__init__(session, model=Gadget)
@@ -81,6 +86,11 @@ class TestBaseController:
         await controller.service.repository.add(Gadget(name="single"))
         assert await controller.count() == 1
 
+    async def test_update_passes_through(self, controller: GadgetController) -> None:
+        created = await controller.service.repository.add(Gadget(name="before"))
+        result = await controller.update(created.id, GadgetUpdate(name="after"))
+        assert result.name == "after"
+
     async def test_delete_passes_through(self, controller: GadgetController) -> None:
         created = await controller.service.repository.add(Gadget(name="gone"))
         await controller.delete(created.id)

{tempest_fastapi_sdk-0.77.0 → tempest_fastapi_sdk-0.78.0}/tests/services/test_base.py

@@ -12,6 +12,7 @@ from tempest_fastapi_sdk import (
     BaseModel,
     BaseRepository,
     BaseResponseSchema,
+    BaseSchema,
     BaseService,
     NotFoundException,
 )
@@ -21,10 +22,17 @@ class Widget(BaseModel):
     __tablename__ = "widget_for_service_test"
 
     name: Mapped[str] = mapped_column(String(64), nullable=False, unique=True)
+    description: Mapped[str | None] = mapped_column(String(128), nullable=True)
 
 
 class WidgetResponse(BaseResponseSchema):
     name: str
+    description: str | None = None
+
+
+class WidgetUpdate(BaseSchema):
+    name: str | None = None
+    description: str | None = None
 
 
 class WidgetRepository(BaseRepository[Widget]):
@@ -38,6 +46,7 @@ class WidgetRepository(BaseRepository[Widget]):
             created_at=instance.created_at,
             updated_at=instance.updated_at,
             name=instance.name,
+            description=instance.description,
         )
 
 
@@ -98,6 +107,31 @@ class TestBaseService:
         assert await service.exists({"name": "here"})
         assert not await service.exists({"name": "absent"})
 
+    async def test_update_applies_fields(self, service: WidgetService) -> None:
+        created = await service.repository.add(
+            Widget(name="old", description="d0"),
+        )
+        result = await service.update(
+            created.id, WidgetUpdate(name="new", description="d1")
+        )
+        assert isinstance(result, WidgetResponse)
+        assert (result.name, result.description) == ("new", "d1")
+
+    async def test_update_is_partial(self, service: WidgetService) -> None:
+        """Unset fields are left untouched (PATCH semantics)."""
+        created = await service.repository.add(
+            Widget(name="keep", description="keep-me"),
+        )
+        result = await service.update(created.id, WidgetUpdate(name="renamed"))
+        assert result.name == "renamed"
+        assert result.description == "keep-me"
+
+    async def test_update_missing_raises_not_found(
+        self, service: WidgetService
+    ) -> None:
+        with pytest.raises(NotFoundException):
+            await service.update(uuid4(), WidgetUpdate(name="x"))
+
     async def test_delete(self, service: WidgetService) -> None:
         created = await service.repository.add(Widget(name="bye"))
         await service.delete(created.id)
@@ -116,6 +150,7 @@ class AsyncWidgetRepository(BaseRepository[Widget]):
             created_at=instance.created_at,
             updated_at=instance.updated_at,
             name=instance.name,
+            description=instance.description,
         )
 
 

{tempest_fastapi_sdk-0.77.0 → tempest_fastapi_sdk-0.78.0}/uv.lock

@@ -2822,7 +2822,7 @@ wheels = [
 
 [[package]]
 name = "tempest-fastapi-sdk"
-version = "0.77.0"
+version = "0.78.0"
 source = { editable = "." }
 dependencies = [
     { name = "alembic" },