instant-python 0.20.0__py3-none-any.whl

instant_python/templates/boilerplate/README.md

@@ -0,0 +1,8 @@
+# {{ general.slug }}
+
+> [!NOTE]
+> This project was generated using [Instant Python](https://github.com/dimanu-py/instant-python), a fast, easy and reliable project generator for Python projects.
+
+## Description
+
+{{ general.description }}

instant_python/templates/boilerplate/SECURITY.md

@@ -0,0 +1,43 @@
+# Security Policy
+
+Thank you for helping keep **{{ general.slug }}** package and its users safe.
+We take security issues seriously and appreciate responsible disclosures.
+
+## Reporting a Vulnerability
+
+> [!NOTE]
+> **Please do NOT open public issues for security reports.**
+> Use one of the private channels below so we can coordinate a safe disclosure.
+
+| Channel                      | How it works                                                                                                                  |
+| ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| **GitHub Security Advisory** | 1. Navigate to the repository's **“Security → Advisories”** tab<br>2. Click **“Report a vulnerability”** and fill in the form |
+
+Include the following, if possible:
+
+1. A **concise description** of the issue and its impact.
+2. **Reproduction steps** or a proof-of-concept script.
+3. Any **mitigation** ideas you've identified.
+
+## Our Disclosure Process
+
+1. **Acknowledge** report within 24–48 hours.
+2. **Triage & validate** the issue; request additional info if needed.
+3. **Fix & prepare**: develop a patch and regression tests.
+4. **Coordinate release**:
+    - Agree on a disclosure date with the reporter (usually ≤ 30 days).
+    - Publish a CVE (if applicable) and a new PyPI release.
+    - Post a security advisory and update CHANGELOG.
+5. **Credit** the reporter (optional & with consent).
+
+## Responsible Disclosure
+
+We kindly ask you to:
+
+- Allow us reasonable time to remediate before any public disclosure.
+- Avoid violating user privacy, destroying data, or disrupting production services while researching.
+- Test only on your own instances or in minimal, isolated cases.
+
+We are committed to keeping this project and its users safe and will strive to resolve all legitimate reports swiftly and transparently.
+
+_Thank you for keeping the **{{ general.slug }}** package community secure!_

instant_python/templates/boilerplate/event_bus/domain_event.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, asdict
+
+
+@dataclass(frozen=True, kw_only=True)
+class DomainEvent(ABC):
+    id: str
+
+    @classmethod
+    @abstractmethod
+    def name(cls) -> str:
+        raise NotImplementedError
+
+    def to_dict(self) -> dict:
+        return asdict(self)

instant_python/templates/boilerplate/event_bus/domain_event_json_deserializer.py

@@ -0,0 +1,25 @@
+import json
+
+from {{ general.source_name }}{{ "shared.domain.event.domain_event" | resolve_import_path(template.name) }} import DomainEvent
+from {{ general.source_name }}{{ "shared.domain.event.domain_event_subscriber" | resolve_import_path(template.name) }} import (
+    DomainEventSubscriber,
+)
+from {{ general.source_name }}{{ "shared.domain.event.domain_event_type_not_found_errorr" | resolve_import_path(template.name) }} import (
+    DomainEventTypeNotFoundError,
+)
+
+
+class DomainEventJsonDeserializer:
+    _events_mapping: dict[str, type[DomainEvent]]
+
+    def __init__(self, subscriber: DomainEventSubscriber[DomainEvent]) -> None:
+        self._events_mapping = {event.name(): event for event in subscriber.subscribed_to()}
+
+    def deserialize(self, body: bytes) -> DomainEvent:
+        content = json.loads(body)
+        event_class = self._events_mapping.get(content["data"]["type"])
+
+        if not event_class:
+            raise DomainEventTypeNotFoundError(content["data"]["type"])
+
+        return event_class(**content["data"]["attributes"])

instant_python/templates/boilerplate/event_bus/domain_event_json_serializer.py

@@ -0,0 +1,16 @@
+import json
+
+from {{ general.source_name }}{{ "shared.domain.event.domain_event" | resolve_import_path(template.name) }} import DomainEvent
+
+
+class DomainEventJsonSerializer:
+    @staticmethod
+    def serialize(event: DomainEvent) -> str:
+        body = {
+            "data": {
+                "id": event.id,
+                "type": event.name(),
+                "attributes": event.to_dict(),
+            }
+        }
+        return json.dumps(body)

instant_python/templates/boilerplate/event_bus/domain_event_subscriber.py

@@ -0,0 +1,33 @@
+{% if python_version in ["3.12", "3.13"] %}
+from abc import ABC, abstractmethod
+
+from {{ general.source_name }}{{ "shared.domain.event.domain_event" | resolve_import_path(template.name) }} import DomainEvent
+
+
+class DomainEventSubscriber[EventType: DomainEvent](ABC):
+    @staticmethod
+    @abstractmethod
+    def subscribed_to() -> list[type[EventType]]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def on(self, event: EventType) -> None:
+        raise NotImplementedError
+{% else %}
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+from {{ general.source_name }}{{ "shared.domain.event.domain_event" | resolve_import_path(template.name) }} import DomainEvent
+
+EventType = TypeVar("EventType", bound=DomainEvent)
+
+class DomainEventSubscriber(Generic[EventType], ABC):
+    @staticmethod
+    @abstractmethod
+    def subscribed_to() -> list[type[EventType]]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def on(self, event: EventType) -> None:
+        raise NotImplementedError
+{% endif %}

instant_python/templates/boilerplate/event_bus/event_aggregate.py

@@ -0,0 +1,19 @@
+from sindripy.value_objects import Aggregate
+from {{ general.source_name }}{{ "shared.domain.event.domain_event" | resolve_import_path(template.name) }} import DomainEvent
+
+
+class EventAggregate(Aggregate):
+    _domain_events: list[DomainEvent]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._domain_events = []
+
+    def record(self, event: DomainEvent) -> None:
+        self._domain_events.append(event)
+
+    def pull_domain_events(self) -> list[DomainEvent]:
+        recorded_domain_events = self._domain_events
+        self._domain_events = []
+
+        return recorded_domain_events

instant_python/templates/boilerplate/event_bus/event_bus.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from {{ general.source_name }}{{ "shared.domain.event.domain_event" | resolve_import_path(template.name) }} import DomainEvent
+
+
+class EventBus(ABC):
+    @abstractmethod
+    async def publish(self, events: list[DomainEvent]) -> None:
+        raise NotImplementedError

instant_python/templates/boilerplate/event_bus/exchange_type.py

@@ -0,0 +1,14 @@
+{% if general.python_version in ["3.13", "3.12", "3.11"] %}
+from enum import StrEnum
+
+
+class ExchangeType(StrEnum):
+{% else %}
+from enum import Enum
+
+
+class ExchangeType(str, Enum):
+{% endif %}
+    TOPIC = "topic"
+    DIRECT = "direct"
+    FANOUT = "fanout"

instant_python/templates/boilerplate/event_bus/mock_event_bus.py

@@ -0,0 +1,16 @@
+from unittest.mock import AsyncMock
+
+from {{ general.source_name }}{{ "shared.domain.event.domain_event" | resolve_import_path(template.name) }} import DomainEvent
+from {{ general.source_name }}{{ "shared.domain.event.event_bus" | resolve_import_path(template.name) }} import EventBus
+
+
+class MockEventBus(EventBus):
+    def __init__(self) -> None:
+        self._mock_publish = AsyncMock()
+
+    async def publish(self, events: list[DomainEvent]) -> None:
+        await self._mock_publish(events)
+
+    def should_have_published(self, event: DomainEvent) -> None:
+        self._mock_publish.assert_awaited_once_with([event])
+        self._mock_publish.reset_mock()

instant_python/templates/boilerplate/event_bus/rabbit_mq_configurer.py

@@ -0,0 +1,45 @@
+from {{ general.source_name }}{{ "shared.domain.event.domain_event" | resolve_import_path(template.name) }} import DomainEvent
+from {{ general.source_name }}{{ "shared.domain.event.domain_event_subscriber" | resolve_import_path(template.name) }} import (
+    DomainEventSubscriber,
+)
+from {{ general.source_name }}{{ "shared.infra.event.rabbit_mq.rabbit_mq_connection" | resolve_import_path(template.name) }} import (
+    RabbitMqConnection,
+)
+from {{ general.source_name }}{{ "shared.infra.event.rabbit_mq.rabbit_mq_queue_formatter" | resolve_import_path(template.name) }} import (
+    RabbitMqQueueFormatter,
+)
+
+
+class RabbitMqConfigurer:
+    _queue_formatter: RabbitMqQueueFormatter
+    _connection: RabbitMqConnection
+
+    def __init__(self, connection: RabbitMqConnection, queue_formatter: RabbitMqQueueFormatter) -> None:
+        self._queue_formatter = queue_formatter
+        self._connection = connection
+
+    def configure(self, exchange_name: str, subscribers: list[DomainEventSubscriber[DomainEvent]]) -> None:
+        self._create_exchange(exchange_name)
+        for subscriber in subscribers:
+            self._create_and_bind_queue(subscriber, exchange_name)
+
+    def _create_exchange(self, exchange_name: str) -> None:
+        self._connection.create_exchange(name=exchange_name)
+
+    def _create_and_bind_queue(self, subscriber: DomainEventSubscriber[DomainEvent], exchange_name: str) -> None:
+        routing_keys = self._get_queues_routing_keys_for(subscriber)
+        queue_name = self._queue_formatter.format(subscriber)
+        self._connection.create_queue(name=queue_name)
+
+        for routing_key in routing_keys:
+            self._connection.bind_queue_to_exchange(
+                queue_name=queue_name,
+                exchange_name=exchange_name,
+                routing_key=routing_key,
+            )
+
+    @staticmethod
+    def _get_queues_routing_keys_for(
+        subscriber: DomainEventSubscriber[DomainEvent],
+    ) -> list[str]:
+        return [event.name() for event in subscriber.subscribed_to()]

instant_python/templates/boilerplate/event_bus/rabbit_mq_connection.py

@@ -0,0 +1,71 @@
+from typing import Callable
+
+import pika
+from pika.adapters.blocking_connection import BlockingChannel
+
+from {{ general.source_name }}{{ "shared.domain.event.exchange_type" | resolve_import_path(template.name) }} import ExchangeType
+from {{ general.source_name }}{{ "shared.domain.errors.rabbit_mq_connection_not_established_error" | resolve_import_path(template.name) }} import (
+    RabbitMqConnectionNotEstablishedError,
+)
+from {{ general.source_name }}{{ "shared.infra.event.rabbit_mq.rabbit_mq_settings" | resolve_import_path(template.name) }} import (
+    RabbitMqSettings,
+)
+
+
+class RabbitMqConnection:
+    _channel: BlockingChannel | None
+    _connection: pika.BlockingConnection | None
+    _connection_settings: RabbitMqSettings
+
+    def __init__(self, connection_settings: RabbitMqSettings) -> None:
+        self._connection_settings = connection_settings
+        self._connection = None
+        self._channel = None
+        self.open_connection()
+
+    def open_connection(self) -> None:
+        credentials = pika.PlainCredentials(
+            username=self._connection_settings.user,
+            password=self._connection_settings.password,
+        )
+        self._connection = pika.BlockingConnection(
+            parameters=pika.ConnectionParameters(host=self._connection_settings.host, credentials=credentials)
+        )
+        self._channel = self._connection.channel()
+
+    def _ensure_channel_exists(self) -> None:
+        if self._channel is None:
+            raise RabbitMqConnectionNotEstablishedError
+
+    def create_exchange(self, name: str) -> None:
+        self._ensure_channel_exists()
+        self._channel.exchange_declare(exchange=name, exchange_type=ExchangeType.TOPIC)  # type: ignore
+
+    def publish(self, content: str, exchange: str, routing_key: str) -> None:
+        self._ensure_channel_exists()
+        self._channel.basic_publish(  # type: ignore
+            exchange=exchange,
+            routing_key=routing_key,
+            body=content,
+            properties=pika.BasicProperties(delivery_mode=pika.DeliveryMode.Persistent),
+        )
+
+    def bind_queue_to_exchange(self, queue_name: str, exchange_name: str, routing_key: str) -> None:
+        self._ensure_channel_exists()
+        self._channel.queue_bind(  # type: ignore
+            exchange=exchange_name, queue=queue_name, routing_key=routing_key
+        )
+
+    def create_queue(self, name: str) -> None:
+        self._ensure_channel_exists()
+        self._channel.queue_declare(queue=name, durable=True)  # type: ignore
+
+    def consume(self, queue_name: str, callback: Callable) -> None:
+        self._ensure_channel_exists()
+        self._channel.basic_consume(  # type: ignore
+            queue=queue_name, on_message_callback=callback, auto_ack=False
+        )
+        self._channel.start_consuming()  # type: ignore
+
+    def close_connection(self) -> None:
+        self._channel.close()  # type: ignore

instant_python/templates/boilerplate/event_bus/rabbit_mq_consumer.py

@@ -0,0 +1,56 @@
+from pika.adapters.blocking_connection import BlockingChannel
+from pika.spec import Basic, BasicProperties
+
+from {{ general.source_name }}{{ "shared.domain.event.domain_event" | resolve_import_path(template.name) }} import DomainEvent
+from {{ general.source_name }}{{ "shared.domain.event.domain_event_subscriber" | resolve_import_path(template.name) }} import (
+    DomainEventSubscriber,
+)
+from {{ general.source_name }}{{ "shared.infra.event.domain_event_json_deserializer" | resolve_import_path(template.name) }} import (
+    DomainEventJsonDeserializer,
+)
+from {{ general.source_name }}{{ "shared.infra.event.rabbit_mq.rabbit_mq_connection" | resolve_import_path(template.name) }} import (
+    RabbitMqConnection,
+)
+from {{ general.source_name }}{{ "shared.infra.event.rabbit_mq.rabbit_mq_queue_formatter" | resolve_import_path(template.name) }} import (
+    RabbitMqQueueFormatter,
+)
+
+
+class RabbitMqConsumer:
+    _queue_formatter: RabbitMqQueueFormatter
+    _subscriber: DomainEventSubscriber[DomainEvent]
+    _client: RabbitMqConnection
+
+    def __init__(
+        self,
+        client: RabbitMqConnection,
+        subscriber: DomainEventSubscriber[DomainEvent],
+        queue_formatter: RabbitMqQueueFormatter,
+    ) -> None:
+        self._queue_formatter = queue_formatter
+        self._subscriber = subscriber
+        self._client = client
+        self._event_deserializer = DomainEventJsonDeserializer(subscriber=subscriber)
+
+    def _on_call(
+        self,
+        channel: BlockingChannel,
+        method: Basic.Deliver,
+        properties: BasicProperties,
+        body: bytes,
+    ) -> None:
+        event = self._deserialize_event(body)
+        self._subscriber.on(event)
+        channel.basic_ack(delivery_tag=method.delivery_tag)
+
+    def start_consuming(self) -> None:
+        self._client.consume(
+            queue_name=self._queue_formatter.format(self._subscriber),
+            callback=self._on_call,
+        )
+
+    def stop_consuming(self) -> None:
+        self._client.close_connection()
+
+    def _deserialize_event(self, body: bytes) -> DomainEvent:
+        return self._event_deserializer.deserialize(body)

instant_python/templates/boilerplate/event_bus/rabbit_mq_event_bus.py

@@ -0,0 +1,26 @@
+from {{ general.source_name }}{{ "shared.domain.event.domain_event" | resolve_import_path(template.name) }} import DomainEvent
+from {{ general.source_name }}{{ "shared.domain.event.event_bus" | resolve_import_path(template.name) }} import EventBus
+from {{ general.source_name }}{{ "shared.infra.event.domain_event_json_serializer" | resolve_import_path(template.name) }} import (
+    DomainEventJsonSerializer,
+)
+from {{ general.source_name }}{{ "shared.infra.event.rabbit_mq.rabbit_mq_connection" | resolve_import_path(template.name) }} import (
+    RabbitMqConnection,
+)
+
+
+class RabbitMqEventBus(EventBus):
+    def __init__(self, client: RabbitMqConnection, exchange_name: str) -> None:
+        self._client = client
+        self._exchange_name = exchange_name
+        self._event_serializer = DomainEventJsonSerializer()
+
+    def publish(self, events: list[DomainEvent]) -> None:
+        for event in events:
+            self._client.publish(
+                content=self._serialize_event(event),
+                exchange=self._exchange_name,
+                routing_key=event.name(),
+            )
+
+    def _serialize_event(self, event: DomainEvent) -> str:
+        return self._event_serializer.serialize(event)

instant_python/templates/boilerplate/event_bus/rabbit_mq_queue_formatter.py

@@ -0,0 +1,21 @@
+import re
+
+from {{ general.source_name }}{{ "shared.domain.event.domain_event" | resolve_import_path(template.name) }} import DomainEvent
+from {{ general.source_name }}{{ "shared.domain.event.domain_event_subscriber" | resolve_import_path(template.name) }} import (
+    DomainEventSubscriber,
+)
+
+
+class RabbitMqQueueFormatter:
+    _bounded_context: str
+    CAMEL_CASE_TO_SNAKE_CASE_PATTERN = r"(?<!^)(?=[A-Z])"
+
+    def __init__(self, bounded_context: str) -> None:
+        self._bounded_context = bounded_context
+
+    def format(self, subscriber: DomainEventSubscriber[DomainEvent]) -> str:
+        unformatted_subscriber_name = subscriber.__class__.__name__
+        formatted_subscriber_name = re.sub(
+            self.CAMEL_CASE_TO_SNAKE_CASE_PATTERN, "_", unformatted_subscriber_name
+        ).lower()
+        return f"{self._bounded_context}.{formatted_subscriber_name}"

instant_python/templates/boilerplate/event_bus/rabbit_mq_settings.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+
+@dataclass(kw_only=True)
+class RabbitMqSettings:
+    user: str
+    password: str
+    host: str

instant_python/templates/boilerplate/exceptions/base_error.py

@@ -0,0 +1,13 @@
+from abc import ABC
+
+
+class BaseError(Exception, ABC):
+	"""Base class for all controlled errors in the application."""
+
+	def __init__(self, message: str) -> None:
+		self._message = message
+		super().__init__(self._message)
+
+	@property
+	def message(self) -> str:
+		return self._message

instant_python/templates/boilerplate/exceptions/domain_error.py

@@ -0,0 +1,6 @@
+from {{ general.source_name }}{{ "shared.domain.errors.base_error" | resolve_import_path(template.name) }} import BaseError
+
+
+class DomainError(BaseError):
+    ...
+

instant_python/templates/boilerplate/exceptions/domain_event_type_not_found_error.py

@@ -0,0 +1,6 @@
+from {{ general.source_name }}{{ "shared.domain.errors.domain_error" | resolve_import_path(template.name) }} import DomainError
+
+
+class DomainEventTypeNotFoundError(DomainError):
+	def __init__(self, name: str) -> None:
+		super().__init__(message=f"Event type {name} not found among subscriber.")

instant_python/templates/boilerplate/exceptions/rabbit_mq_connection_not_established_error.py

@@ -0,0 +1,7 @@
+from {{ general.source_name }}{{ "shared.domain.errors.domain_error" | resolve_import_path(template.name) }} import DomainError
+
+
+
+class RabbitMqConnectionNotEstablishedError(DomainError):
+    def __init__(self) -> None:
+        super().__init__(message="RabbitMQ connection not established.")

instant_python/templates/boilerplate/exceptions/required_value_error.py

@@ -0,0 +1,6 @@
+from {{ general.source_name }}{{ "shared.domain.errors.domain_error" | resolve_import_path(template.name) }} import DomainError
+
+
+class RequiredValueError(DomainError):
+    def __init__(self) -> None:
+        super().__init__(message="Value is required, can't be None")

instant_python/templates/boilerplate/fastapi/application.py

@@ -0,0 +1,74 @@
+from fastapi import FastAPI
+{% if "logger" in template.built_in_features %}
+from fastapi.errors import RequestValidationError
+{% endif %}
+{% if "value_objects" in template.built_in_features %}
+from sindripy.value_objects import SindriValidationError
+{% endif %}
+{% if template.name == template_types.STANDARD %}
+{% if "logger" in template.built_in_features %}
+from {{ general.source_name }}.api.handlers.error_handlers import (
+	unexpected_exception_handler,
+	domain_error_handler,
+	validation_error_handler,
+    {% if "value_objects" in template.built_in_features %}sindri_validation_error_handler,{% endif %}
+)
+{% else %}
+from {{ general.source_name }}.api.handlers.error_handlers import (
+	unexpected_exception_handler,
+	domain_error_handler,
+    {% if "value_objects" in template.built_in_features %}sindri_validation_error_handler,{% endif %}
+)
+{% endif %}
+{% else %}
+{% if "logger" in template.built_in_features %}
+from {{ general.source_name }}.delivery.api.handlers.error_handlers import (
+	unexpected_exception_handler,
+	domain_error_handler,
+	validation_error_handler,
+    {% if "value_objects" in template.built_in_features %}sindri_validation_error_handler,{% endif %}
+)
+{% else %}
+from {{ general.source_name }}.delivery.api.handlers.error_handlers import (
+	unexpected_exception_handler,
+	domain_error_handler,
+    {% if "value_objects" in template.built_in_features %}sindri_validation_error_handler,{% endif %}
+)
+{% endif %}
+{% endif %}
+
+{% if ["async_alembic"] | is_in(template.built_in_features) %}
+{% if template.name == template_types.STANDARD %}
+from {{ general.source_name }}.api.lifespan import lifespan
+{% else %}
+from {{ general.source_name }}.delivery.api.lifespan import lifespan
+{% endif %}
+{% endif %}
+from {{ general.source_name }}{{ "shared.domain.errors.domain_error" | resolve_import_path(template.name) }} import DomainError
+{% if "logger" in template.built_in_features %}
+from {{ general.source_name }}{{ "shared.infra.logger.file_logger" | resolve_import_path(template.name) }} import create_file_logger
+{% if template.name == template_types.STANDARD %}
+from {{ general.source_name }}.api.middleare.fast_api_log_middleware import FastapiLogMiddleware
+{% else %}
+from {{ general.source_name }}.delivery.api.middleare.fast_api_log_middleware import FastapiLogMiddleware
+{% endif %}
+{% endif %}
+
+
+{% if ["async_alembic"] | is_in(template.built_in_features) %}
+app = FastAPI(lifespan=lifespan)
+{% else %}
+app = FastAPI()
+{% endif %}
+
+{% if "logger" in template.built_in_features %}
+logger = create_file_logger(name="{{ general.slug }}")
+
+app.add_middleware(FastapiLogMiddleware, logger=logger)
+app.add_exception_handler(RequestValidationError, validation_error_handler)
+{% endif %}
+{% if "value_objects" in template.built_in_features %}
+app.add_exception_handler(SindriValidationError, sindri_validation_error_handler)
+{% endif %}
+app.add_exception_handler(Exception, unexpected_exception_handler)
+app.add_exception_handler(DomainError, domain_error_handler)

instant_python/templates/boilerplate/fastapi/error_handlers.py

@@ -0,0 +1,88 @@
+from fastapi import Request
+from fastapi.responses import JSONResponse
+{% if "logger" in template.built_in_features %}
+from fastapi.errors import RequestValidationError
+from fastapi.exception_handlers import request_validation_exception_handler
+from {{ general.source_name }}{{ "shared.infra.logger.file_logger" | resolve_import_path(template.name) }} import create_file_logger
+{% endif %}
+from {{ general.source_name }}{{ "shared.infra.http.error_response" | resolve_import_path(template.name) }} import InternalServerError, UnprocessableEntityError
+from {{ general.source_name }}{{ "shared.domain.errors.domain_error" | resolve_import_path(template.name) }} import DomainError
+{% if "value_objects" in template.built_in_features %}
+from sindripy.value_objects import SindriValidationError
+{% endif %}
+
+{% if "logger" in template.built_in_features %}
+logger = create_file_logger(name="{{ general.slug }}")
+
+async def unexpected_exception_handler(request: Request, exc: Exception) -> JSONResponse:
+	logger.error(
+		message=f"error - {request.url.path}",
+		details={
+			"error": {
+				"message": str(exc),
+			},
+			"method": request.method,
+			"source": request.url.path,
+		},
+	)
+	return InternalServerError().as_json()
+
+
+async def domain_error_handler(request: Request, exc: DomainError) -> JSONResponse:
+	logger.error(
+		message=f"error - {request.url.path}",
+		details={
+			"error": {"message": exc.message},
+			"method": request.method,
+			"source": request.url.path,
+		},
+	)
+	return UnprocessableEntityError().as_json()
+
+
+async def validation_error_handler(
+		request: Request,
+		exc: RequestValidationError,
+) -> JSONResponse:
+	logger.error(
+		message=f"error - {request.url.path}",
+		details={
+			"error": {"message": str(exc)},
+			"method": request.method,
+			"source": request.url.path,
+		},
+	)
+	return await request_validation_exception_handler(request, exc)
+
+{% if "value_objects" in template.built_in_features %}
+async def sindri_validation_error_handler(
+        request: Request,
+        exc: SindriValidationError,
+) -> JSONResponse:
+    logger.error(
+        message=f"error - {request.url.path}",
+        details={
+            "error": {"message": str(exc)},
+            "method": request.method,
+            "source": request.url.path,
+        },
+    )
+    return UnprocessableEntityError().as_json()
+{% endif %}
+{% else %}
+async def unexpected_exception_handler(_: Request, __: Exception) -> JSONResponse:
+	return InternalServerError().as_json()
+
+
+async def domain_error_handler(_: Request, __: DomainError) -> JSONResponse:
+	return UnprocessableEntityError().as_json()
+
+
+{% if "value_objects" in template.built_in_features %}
+async def sindri_validation_error_handler(
+        _: Request,
+        __: SindriValidationError,
+) -> JSONResponse:
+    return UnprocessableEntityError().as_json()
+{% endif %}
+{% endif %}