neuroglia-python 0.0.23__py3-none-any.whl

neuroglia/eventing/cloud_events/infrastructure/cloud_event_ingestor.py

@@ -0,0 +1,74 @@
+import asyncio
+import inspect
+import logging
+from typing import List, Type
+from neuroglia.core import TypeFinder, ModuleLoader
+from neuroglia.eventing.cloud_events import CloudEvent
+from neuroglia.eventing.cloud_events.infrastructure import CloudEventBus
+from neuroglia.hosting.abstractions import ApplicationBuilderBase, HostedService
+from neuroglia.mediation.mediator import Mediator
+from neuroglia.reactive import AsyncRx
+
+
+class CloudEventIngestionOptions:
+    """Represents the service used to configure how the application should ingest incoming cloud events"""
+
+    type_maps: dict[str, Type] = dict[str, Type]()
+    """ Gets/sets a cloud event type/CLR type mapping of all supported cloud events"""
+
+
+class CloudEventIngestor(HostedService):
+    """Represents the service used to ingest cloud events"""
+
+    def __init__(self, options: CloudEventIngestionOptions, cloud_event_bus: CloudEventBus, mediator: Mediator):
+        self._options = options
+        self._cloud_event_bus = cloud_event_bus
+        self._mediator = mediator
+
+    _options: CloudEventIngestionOptions
+
+    _cloud_event_bus: CloudEventBus
+
+    _mediator: Mediator
+
+    async def start_async(self):
+        AsyncRx.subscribe(self._cloud_event_bus.input_stream, lambda e: asyncio.ensure_future(self._on_cloud_event_async(e)))
+
+    async def _on_cloud_event_async(self, cloud_event: CloudEvent):
+        event_type = self._options.type_maps.get(cloud_event.type, None)
+        if event_type is None:
+            logging.warning(f"Ignored incoming cloud event: the specified type '{cloud_event.type}' is not supported")
+            return
+
+        e: object = None
+        try:
+            e = object.__new__(event_type)
+            e.__dict__ = cloud_event.data
+            e.__cloudevent__source__ = cloud_event.source
+            e.__cloudevent__subject__ = cloud_event.subject
+        except Exception as ex:
+            logging.error(f"An error occured while reading a cloud event of type '{cloud_event.type}': '{ex}'")
+            raise
+        try:
+            await self._mediator.publish_async(e)
+        except Exception as ex:
+            logging.error(f"An error occured while dispatching an incoming cloud event of type '{cloud_event.type}': '{ex}'")
+            raise
+
+    @staticmethod
+    def configure(builder: ApplicationBuilderBase, modules: List[str]) -> ApplicationBuilderBase:
+        """Registers and configures cloud event related services to the specified service collection.
+
+        Args:
+            services (ServiceCollection): the service collection to configure
+            modules (List[str]): a list containing the names of the modules to scan for classes marked with the 'cloudevent' decorator. Marked classes as used to configure the mapping of cloud events consumed by the cloud event ingestor
+        """
+        options: CloudEventIngestionOptions = CloudEventIngestionOptions()
+        for module in [ModuleLoader.load(module_name) for module_name in modules]:
+            for cloud_event_clr_type in TypeFinder.get_types(module, lambda cls: inspect.isclass(cls) and hasattr(cls, "__cloudevent__type__")):
+                cloud_event_type = cloud_event_clr_type.__cloudevent__type__
+                options.type_maps[cloud_event_type] = cloud_event_clr_type
+        builder.services.try_add_singleton(CloudEventBus)
+        builder.services.add_singleton(CloudEventIngestionOptions, singleton=options)
+        builder.services.add_singleton(HostedService, CloudEventIngestor)
+        return builder

neuroglia/eventing/cloud_events/infrastructure/cloud_event_middleware.py

@@ -0,0 +1,39 @@
+import logging
+from fastapi import FastAPI, Request, Response
+from neuroglia.dependency_injection.service_provider import ServiceProviderBase
+from neuroglia.eventing.cloud_events.cloud_event import CloudEvent
+from neuroglia.eventing.cloud_events.infrastructure import CloudEventBus
+from neuroglia.serialization.json import JsonSerializer
+from starlette.middleware.base import BaseHTTPMiddleware
+
+
+class CloudEventMiddleware(BaseHTTPMiddleware):
+    ''' Represents the HTTP middleware used to handle incoming cloud events '''
+
+    def __init__(self, app, service_provider: ServiceProviderBase):
+        super().__init__(app)
+        self.service_provider = service_provider
+        self.serializer = self.service_provider.get_required_service(JsonSerializer)
+        self.cloud_event_bus = self.service_provider.get_required_service(CloudEventBus)
+
+    service_provider: ServiceProviderBase
+    ''' Gets the current service provider '''
+
+    cloud_event_bus: CloudEventBus
+    ''' Gets the service used to stream the application's incoming and outgoing cloud events '''
+
+    serializer: JsonSerializer
+    ''' Gets the service used to serialize/deserialize values to/from JSON '''
+
+    async def dispatch(self, request: Request, call_next):
+        content_type = request.headers.get('content-type', None)
+        if content_type is None or not content_type.startswith('application/cloudevents+json'):
+            return await call_next(request)
+        try:
+            attributes = self.serializer.deserialize(await request.body(), dict)
+            cloud_event = CloudEvent(**attributes)
+            self.cloud_event_bus.input_stream.on_next(cloud_event)
+        except Exception as ex:
+            logging.error(f"An error occured while processing an incoming cloud event: {ex}")
+            return Response(content=str(ex), status_code=500)
+        return Response(status_code=202)

neuroglia/eventing/cloud_events/infrastructure/cloud_event_publisher.py

@@ -0,0 +1,103 @@
+import asyncio
+import httpx
+import logging
+
+from dataclasses import dataclass
+from urllib.parse import urlparse
+from rx.core.typing import Disposable
+
+from neuroglia.eventing.cloud_events.cloud_event import CloudEvent
+from neuroglia.eventing.cloud_events.infrastructure.cloud_event_bus import CloudEventBus
+from neuroglia.hosting.abstractions import ApplicationBuilderBase, HostedService
+from neuroglia.reactive.rx_async import AsyncRx
+from neuroglia.serialization.json import JsonSerializer
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class CloudEventPublishingOptions:
+    ''' Represents the service used to configure the way Cloud Events should be published by the application '''
+
+    sink_uri: str
+    ''' Gets the URI to publish cloud events to '''
+
+    source: str
+    ''' Gets the value of the 'source' context attribute for all cloud events produced by the application '''
+
+    type_prefix: str = "io.openbank"
+    ''' Gets the prefix value of the 'type' context attribute for all cloud events produced by the application '''
+
+    retry_attempts: int = 5
+    ''' Gets/sets the maximum amount of retries before giving up '''
+
+    retry_delay: float = 1
+    ''' Gets/sets the delay, in seconds, to wait after each retry attempt. Configured value is multiplied by the amount of retries that have been performed '''
+
+
+class CloudEventPublisher(HostedService):
+    ''' Represents the service used to publish the application's outgoing cloud events '''
+
+    def __init__(self, options: CloudEventPublishingOptions, cloud_event_bus: CloudEventBus, json_serializer: JsonSerializer):
+        self._options = options
+        self._cloud_event_bus = cloud_event_bus
+        self._json_serializer: JsonSerializer = json_serializer
+
+    _options: CloudEventPublishingOptions
+    ''' Gets the current CloudEventPublishingOptions '''
+
+    _cloud_event_bus: CloudEventBus
+    ''' Gets the service used to manage the cloud events produced and consumed by the application '''
+
+    _json_serializer: JsonSerializer
+
+    _subscription: Disposable
+
+    async def start_async(self):
+        # ERROR:root:An exception occured while publishing an event of type 'PersonRegisteredDomainEventV1': asyncio.run() cannot be called from a running event loop
+        # /tmp/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_trace_dispatch_regular.py:326: RuntimeWarning: coroutine 'CloudEventPublisher.on_publish_cloud_event_async' was never awaited
+        # self._subscription = AsyncRx.subscribe(self._cloud_event_bus.output_stream, lambda e: asyncio.run(self.on_publish_cloud_event_async(e)))
+        self._subscription = AsyncRx.subscribe(self._cloud_event_bus.output_stream, lambda e: asyncio.create_task(self.on_publish_cloud_event_async(e)))
+        # await self._subscription
+
+    async def stop_async(self):
+        self._subscription.dispose()
+
+    async def on_publish_cloud_event_async(self, e: CloudEvent):
+        uri = urlparse(self._options.sink_uri)
+        published = False
+        for retries in range(self._options.retry_attempts):
+            try:
+                url = uri.geturl()
+                headers = {
+                    "Content-Type": "application/cloudevents+json"
+                }
+                response = None
+                with httpx.Client() as client:
+                    response = client.post(url=url, headers=headers, content=self._json_serializer.serialize(e))
+                    response.raise_for_status()
+                    if response is not None and 200 <= response.status_code < 300:
+                        log.debug(f"Published cloudevent: {e.type}")
+                        published = True
+                        break
+
+            except httpx.HTTPError as ex:
+                log.error(f"HTTP error occurred: {ex}")
+            except Exception as ex:
+                log.warning(f"An error occured while publishing the cloud event with id '{e.id}' [attempt {retries}/{self._options.retry_attempts}]: {ex}")
+            await asyncio.sleep(self._options.retry_delay * retries)
+        if not published:
+            raise Exception(f"Failed to publish cloud events to the specified sink '{self._options.sink_uri}' after '{self._options.retry_attempts}' attempts")
+
+    @staticmethod
+    def configure(builder: ApplicationBuilderBase) -> ApplicationBuilderBase:
+        ''' Registers and configures a cloud event publisher to the specified service collection.
+
+            Args:
+                services (ServiceCollection): the service collection to configure
+        '''
+        options = CloudEventPublishingOptions(builder.settings.cloud_event_sink, builder.settings.cloud_event_source, builder.settings.cloud_event_type_prefix, builder.settings.cloud_event_retry_attempts, builder.settings.cloud_event_retry_delay)
+        builder.services.try_add_singleton(CloudEventBus)
+        builder.services.add_singleton(CloudEventPublishingOptions, singleton=options)
+        builder.services.add_singleton(HostedService, CloudEventPublisher)
+        return builder

neuroglia/expressions/javascript_expression_translator.py

@@ -0,0 +1,147 @@
+import ast
+from ast import And, Attribute, BoolOp, Call, Compare, Constant, Eq, Gt, GtE, In, Is, IsNot, Lambda, Lt, LtE, Name, Not, NotEq, NotIn, Or, Subscript, USub, UnaryOp, arg, boolop, cmpop, expr
+import importlib
+from typing import Dict, List, Type
+
+
+class JavaScriptExpressionTranslator:
+    ''' Represents a service used to translate ast expressions into JavaScript expressions'''
+
+    def translate(self, expression: expr) -> str:
+        ''' Translates the specified expression into a new JavaScript expression '''
+        if isinstance(expression, arg): return self._translate_arg(expression)
+        elif isinstance(expression, Attribute): return self._translate_attribute(expression)
+        elif isinstance(expression, BoolOp): return self._translate_bool_op(expression)
+        elif isinstance(expression, Call):  return self._translate_call(expression)
+        elif isinstance(expression, Compare): return self._translate_compare(expression)
+        elif isinstance(expression, Constant): return self._translate_constant(expression)
+        elif isinstance(expression, Lambda): return self._translate_lambda(expression)
+        elif isinstance(expression, Name): return self._translate_name(expression)
+        elif isinstance(expression, Subscript): return self._translate_subscript(expression)
+        elif isinstance(expression, UnaryOp): return self._translate_unary_op(expression)
+        elif isinstance(expression, ast.List): return self._translate_list(expression)
+        else: raise Exception(f"The specified expression type '{type(expression)}' is not supported in this context")
+
+    def _translate_arg(self, expression: arg) -> str: 
+        return expression.arg
+
+    def _translate_attribute(self, expression: Attribute) -> str:
+        attribute_name : str = None
+        attribute_path_parts = list[str]()
+        if isinstance(expression.value, Constant):
+            return self.translate(Constant(getattr(expression.value.value, expression.attr)))
+        else:
+            try: 
+                attribute_name = expression.value.id
+                attribute_path_parts.append(expression.attr)
+            except:
+                while True:
+                    try:
+                        attribute_name = expression.value.id
+                        break
+                    except:
+                        attribute_path_part = self.translate(expression.value)
+                        attribute_path_parts.append(attribute_path_part)
+                        expression = expression.value
+            #if scope.get_all_arguments().get(attribute_name) is None: return self._evaluate(expression) #todo
+            attribute_path_parts.reverse()
+            attribute_full_name = f"this.{'.'.join(attribute_path_parts)}"
+            return attribute_full_name
+
+    def _translate_bool_op(self, expression: BoolOp) -> str:
+        operator = self._translate_boolop(expression.op)
+        parameters = [ self.translate(parameter) for parameter in expression.values ]
+        return f' {operator} '.join(parameters)        
+
+    def _translate_call(self, expression: Call) -> str:
+        function_name = getattr(expression.func, 'id', None)
+        function_body : str
+        function_args : List[str]
+        if function_name is None:
+            function_name = expression.func.attr
+            function_body = self.translate(expression.func.value)
+            function_args = [self.translate(arg) for arg in expression.args]
+        else:
+            function_body = self.translate(expression.args[0])
+            function_args = [self.translate(arg) for arg in expression.args[1:]]
+        if function_name == 'count': return f"{function_body}.length"
+        elif function_name == 'len': return f"{function_body}.length"
+        elif function_name == 'lower': return f"{function_body}.toLowerCase()"
+        elif function_name == 'startswith': return f"{function_body}.startsWith({function_args[0]})"
+        elif function_name == 'endswith': return f"{function_body}.endsWith({function_args[0]})"
+        elif function_name == 'index': return f"{function_body}.indexOf({', '.join(function_args)})"
+        elif function_name == 'upper': return f"{function_body}.toUpperCase()"
+        elif function_name == 'split': return f"{function_body}.split({', '.join(function_args)})"
+        else: raise Exception(f"The specified function '{function_name}' is not supported in this context")
+    
+    def _translate_compare(self, expression: Compare) -> str:
+        left = self.translate(expression.left)        
+        right = self.translate(expression.comparators[0])
+        operator = self._translate_cmpop(expression.ops[0])
+        if operator == 'in': return f"{right}.includes({left})"
+        elif operator == 'not in': return f"!{right}.includes({left})"
+        else: return f"{left} {operator} {right}"
+
+    def _translate_constant(self, expression: Constant) -> str:
+        if expression.value is None: return 'null'
+        if isinstance(expression.value, str): return f"'{expression.value}'"
+        else: return str(expression.value)
+        
+    def _translate_lambda(self, expression: Lambda) -> str:
+        body = self.translate(expression.body)
+        return body
+    
+    def _translate_list(self, expression: ast.List) -> str:
+        return f"[ {', '.join([self.translate(expression) for expression in expression.elts])} ]"
+
+    def _translate_name(self, expression: Name) -> str:
+        return "this"
+    
+    def _translate_subscript(self, expression: Subscript) -> str:
+        source = self.translate(expression.value)
+        slice = self.translate(expression.slice)
+        slice_index : int = None
+        try: slice_index = int(slice)
+        except: pass
+        if slice_index is not None and slice_index < 0: return f"{source}.slice({slice})"
+        else: return f"{source}[{slice}]"
+    
+    def _translate_unary_op(self, expression: UnaryOp) -> str:
+        operand = self.translate(expression.operand)
+        if isinstance(expression.op, Not): return f"!({operand})"
+        elif isinstance(expression.op, USub): return f"-{operand}"
+        else: raise Exception(f"The specified unary operator '{type(expression.op).__name__}' is not supported in this context")
+
+    def _get_lambda_arguments(self, expression: Lambda) -> Dict[str, Type]:
+        argument_name = expression.args.args[0].arg
+        argument_type_qualified_name = expression.args.args[0].annotation.id
+        module_name, _, type_name = argument_type_qualified_name.rpartition('.')
+        module = importlib.import_module(module_name)
+        argument_type = getattr(module, type_name)
+        return { argument_name: argument_type }
+
+    def _translate_boolop(self, operator : boolop) -> str:
+        switch = {
+            And: '&&',
+            Or: '||'
+        }
+        result = switch.get(type(operator))
+        if result is None: raise Exception(f"The specified bool operator '{type(operator).__name__}' is not supported")
+        return result
+
+    def _translate_cmpop(self, operator : cmpop) -> str:
+        switch = {
+            Eq: '===',
+            NotEq: '!==',
+            Lt: '<',
+            LtE: '<=',
+            Gt: '>',
+            GtE: '>=',
+            In: 'in',
+            NotIn: 'not in',  # todo: 'not in' is not directly translatable to JavaScript
+            Is: '===',
+            IsNot: '!==',
+        }
+        result = switch.get(type(operator))
+        if result is None: raise Exception(f"The specified comparison operator '{type(operator).__name__}' is not supported")
+        return result

neuroglia/hosting/abstractions.py

@@ -0,0 +1,141 @@
+import asyncio
+from abc import ABC, abstractmethod
+from contextlib import asynccontextmanager, contextmanager
+from typing import Callable, cast, List
+from neuroglia.dependency_injection.service_provider import ServiceCollection, ServiceProviderBase, ServiceScopeBase
+from pydantic_settings import BaseSettings
+
+
+class HostBase(ABC):
+    ''' Defines the fundamentals of an program's abstraction '''
+
+    services: ServiceProviderBase
+
+    @abstractmethod
+    async def start_async(self):
+        ''' Starts the program '''
+        raise NotImplementedError()
+
+    @abstractmethod
+    async def stop_async(self):
+        ''' Attempts to gracefully stop the program '''
+        raise NotImplementedError()
+
+    def run(self):
+        ''' Runs the program '''
+        try:
+            asyncio.get_running_loop()
+            asyncio.ensure_future(self.start_async())
+        except RuntimeError:
+            asyncio.run(self.start_async())
+
+    @abstractmethod
+    def dispose(self):
+        ''' Disposes of the program's resources '''
+        raise NotImplementedError()
+
+
+class HostedService:
+    ''' Defines the fundamentals of a service managed by the host '''
+
+    async def start_async(self):
+        ''' Starts the service '''
+        pass
+
+    async def stop_async(self):
+        ''' Attempts to gracefully stop the service '''
+        pass
+
+
+class HostApplicationLifetime:
+    ''' Represents a service used to manage (and notify about) the application's lifetime events '''
+
+    on_application_started: List[Callable[[], None]] = list[Callable[[], None]]()
+    ''' Gets a list containing the callbacks, if any, to invoke when the application has started '''
+
+    on_application_stopping: List[Callable[[], None]] = list[Callable[[], None]]()
+    ''' Gets a list containing the callbacks, if any, to invoke when the application is stopping '''
+
+    on_application_stopped: List[Callable[[], None]] = list[Callable[[], None]]()
+    ''' Gets a list containing the callbacks, if any, to invoke when the application has been stopped '''
+
+    def stop_application(self):
+        ''' Stops the application '''
+
+    @asynccontextmanager
+    async def _run_async(self, app: HostBase):
+        await asyncio.gather(*[handler() for handler in self.on_application_started])
+        yield
+        await asyncio.gather(*[handler() for handler in self.on_application_stopping])
+        await app.stop_async()
+        await asyncio.gather(*[handler() for handler in self.on_application_stopped])
+
+
+class Host(HostBase):
+    ''' Represents the default implementation of the HostBase class '''
+
+    def __init__(self, services: ServiceProviderBase):
+        self.services = services
+
+    async def start_async(self):
+        hosted_services = [cast(HostedService, service) for service in self.services.get_services(HostedService)]
+        start_tasks = [hosted_service.start_async() for hosted_service in hosted_services]
+        await asyncio.gather(*start_tasks)
+
+    async def stop_async(self):
+        hosted_services = [cast(HostedService, service) for service in self.services.get_services(HostedService)]
+        stop_tasks = [hosted_service.stop_async() for hosted_service in hosted_services]
+        await asyncio.gather(*stop_tasks)
+
+    def dispose(self):
+        if isinstance(self.services, ServiceScopeBase):
+            self.services.dispose()
+
+
+class ApplicationSettings(BaseSettings):
+
+    consumer_group: str
+
+    connection_strings: dict[str, str] = dict[str, str]()
+
+    cloud_event_sink: str
+
+    cloud_event_source: str
+
+    cloud_event_type_prefix: str
+
+    cloud_event_retry_attempts: int = 5
+
+    cloud_event_retry_delay: float = 1
+
+
+class ApplicationBuilderBase:
+    ''' Defines the fundamentals of a service used to build applications '''
+
+    def __init__(self):
+        self.services.try_add_singleton(HostApplicationLifetime)
+
+    settings: ApplicationSettings = ApplicationSettings()
+
+    services: ServiceCollection = ServiceCollection()
+
+    @abstractmethod
+    def build(self) -> HostBase:
+        ''' Builds the application's host  '''
+        raise NotImplementedError()
+
+
+class ApplicationBuilder(ApplicationBuilderBase):
+    ''' Represents the default implementation of the ApplicationBuilderBase class '''
+
+    def __init__(self):
+        super().__init__()
+
+    @contextmanager
+    def build(self) -> HostBase:
+        try:
+            service_provider = self.services.build()
+            host = Host(service_provider)
+            yield host
+        finally:
+            host.dispose()

neuroglia/hosting/configuration/data_access_layer.py

@@ -0,0 +1,50 @@
+import inspect
+from typing import Callable, List, Type
+from neuroglia.core import TypeFinder, ModuleLoader
+from neuroglia.data.abstractions import AggregateRoot
+from neuroglia.data.infrastructure.event_sourcing.read_model_reconciliator import ReadModelConciliationOptions, ReadModelReconciliator
+from neuroglia.hosting.abstractions import ApplicationBuilderBase, HostedService
+from neuroglia.mediation.mediator import RequestHandler
+from neuroglia.data.queries.generic import GetByIdQueryHandler, ListQueryHandler
+
+
+class DataAccessLayer:
+
+    class WriteModel:
+        ''' Represents an helper class used to configure an application's Write Model DAL '''
+
+        def configure(builder: ApplicationBuilderBase, modules: List[str], repository_setup: Callable[[ApplicationBuilderBase, Type, Type], None]) -> ApplicationBuilderBase:
+            ''' Configures the application's Write Model DAL, scaning for aggregate root types within the specified modules
+
+                Args:
+                    builder (ApplicationBuilderBase): the application builder to configure
+                    modules (List[str]): a list containing the names of the modules to scan for aggregate root types
+                    repository_setup (Callable[[ApplicationBuilderBase, Type, Type], None]): a function used to setup the repository for the specified entity and key types
+            '''
+            for module in [ModuleLoader.load(module_name) for module_name in modules]:
+                for aggregate_type in TypeFinder.get_types(module, lambda cls: inspect.isclass(cls) and issubclass(cls, AggregateRoot) and not cls == AggregateRoot):
+                    key_type = str  # todo: reflect from DTO base type
+                    repository_setup(builder, aggregate_type, key_type)
+
+    class ReadModel:
+        ''' Represents an helper class used to configure an application's Read Model DAL '''
+
+        @staticmethod
+        def configure(builder: ApplicationBuilderBase, modules: List[str], repository_setup: Callable[[ApplicationBuilderBase, Type, Type], None]) -> ApplicationBuilderBase:
+            ''' Configures the application's Read Model DAL, scaning for types marked with the 'queryable' decorator within the specified modules
+
+                Args:
+                    builder (ApplicationBuilderBase): the application builder to configure
+                    modules (List[str]): a list containing the names of the modules to scan for types decorated with 'queryable'
+                    repository_setup (Callable[[ApplicationBuilderBase, Type, Type], None]): a function used to setup the repository for the specified entity and key types
+            '''
+            consumer_group = builder.settings.consumer_group
+            builder.services.add_singleton(ReadModelConciliationOptions, singleton=ReadModelConciliationOptions(consumer_group))
+            builder.services.add_singleton(HostedService, ReadModelReconciliator)
+            for module in [ModuleLoader.load(module_name) for module_name in modules]:
+                for queryable_type in TypeFinder.get_types(module, lambda cls: inspect.isclass(cls) and hasattr(cls, "__queryable__")):
+                    key_type = str  # todo: reflect from DTO base type
+                    repository_setup(builder, queryable_type, key_type)
+                    builder.services.add_transient(RequestHandler, GetByIdQueryHandler[queryable_type, key_type])
+                    builder.services.add_transient(RequestHandler, ListQueryHandler[queryable_type, key_type])
+            return builder

neuroglia/hosting/web.py

@@ -0,0 +1,87 @@
+from abc import abstractmethod
+import inspect
+from typing import List
+from fastapi import FastAPI, Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+from neuroglia.core.problem_details import ProblemDetails
+from neuroglia.core import ModuleLoader, TypeFinder
+from neuroglia.dependency_injection.service_provider import ServiceCollection, ServiceProviderBase
+from neuroglia.hosting.abstractions import ApplicationBuilderBase, Host, HostApplicationLifetime, HostBase
+from neuroglia.mvc.controller_base import ControllerBase
+from neuroglia.serialization.json import JsonSerializer
+
+
+class WebHostBase(HostBase, FastAPI):
+    ''' Defines the fundamentals of a web application's abstraction '''
+
+    def __init__(self):
+        application_lifetime: HostApplicationLifetime = self.services.get_required_service(HostApplicationLifetime)
+        FastAPI.__init__(self, lifespan=application_lifetime._run_async, docs_url="/api/docs")
+
+    def use_controllers(self):
+        ''' Configures FastAPI routes for registered controller services '''
+        controller: ControllerBase
+        for controller in self.services.get_services(ControllerBase):
+            self.include_router(controller.router, prefix="/api/v1")
+
+
+class WebHost(WebHostBase, Host):
+    ''' Represents the default implementation of the HostBase class '''
+
+    def __init__(self, services: ServiceProviderBase):
+        Host.__init__(self, services)
+        WebHostBase.__init__(self)
+
+
+class WebApplicationBuilderBase(ApplicationBuilderBase):
+    ''' Defines the fundamentals of a service used to build applications '''
+
+    def __init__(self):
+        super().__init__()
+
+    def add_controllers(self, modules: List[str]) -> ServiceCollection:
+        ''' Registers all API controller types, which enables automatic configuration and implicit Dependency Injection of the application's controllers (specialized router class in FastAPI) '''
+        controller_types = []
+        for module in [ModuleLoader.load(module_name) for module_name in modules]:
+            controller_types.extend(TypeFinder.get_types(module, lambda t: inspect.isclass(t) and issubclass(t, ControllerBase) and t != ControllerBase, include_sub_packages=True))
+        for controller_type in set(controller_types):
+            self.services.add_singleton(ControllerBase, controller_type)
+        return self.services
+
+    @abstractmethod
+    def build(self) -> WebHostBase:
+        ''' Builds the application's host  '''
+        raise NotImplementedError()
+
+
+class WebApplicationBuilder(WebApplicationBuilderBase):
+    ''' Represents the default implementation of the ApplicationBuilderBase class '''
+
+    def __init__(self):
+        super().__init__()
+
+    def build(self) -> WebHostBase:
+        return WebHost(self.services.build())
+
+
+class ExceptionHandlingMiddleware(BaseHTTPMiddleware):
+    ''' Represents a Startlette HTTP middleware used to catch and describe exceptions '''
+
+    def __init__(self, app, service_provider: ServiceProviderBase):
+        super().__init__(app)
+        self.service_provider = service_provider
+        self.serializer = self.service_provider.get_required_service(JsonSerializer)
+
+    service_provider: ServiceProviderBase
+    ''' Gets the current service provider '''
+
+    serializer: JsonSerializer
+    ''' Gets the service used to serialize/deserialize values to/from JSON '''
+
+    async def dispatch(self, request: Request, call_next):
+        try:
+            return await call_next(request)
+        except Exception as ex:
+            problem_details = ProblemDetails("Internal Server Error", 500, str(ex), "https://www.w3.org/Protocols/HTTP/HTRESP.html#:~:text=Internal%20Error%20500")
+            response_content = self.serializer.serialize_to_text(problem_details)
+            return Response(response_content, 500, media_type="application/json")

neuroglia/integration/models.py

@@ -0,0 +1,18 @@
+from abc import ABC
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Generic, TypeVar
+
+TKey = TypeVar("TKey")
+''' Represents the generic argument used to specify the type of key to use '''
+
+
+@dataclass
+class IntegrationEvent(Generic[TKey], ABC):
+    ''' Represents the base class inherited by all integration events '''
+
+    created_at: datetime
+    ''' Gets the date and time the integration event has been created at '''
+
+    aggregate_id: TKey
+    ''' Gets the id of the aggregate that has produced the integration event '''