neuroglia-python 0.6.21__tar.gz → 0.6.22__tar.gz

{neuroglia_python-0.6.21 → neuroglia_python-0.6.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuroglia-python
-Version: 0.6.21
+Version: 0.6.22
 Summary: Port from .NET to Python of the Neuroglia Framework
 License: Apache
 License-File: LICENSE

{neuroglia_python-0.6.21 → neuroglia_python-0.6.22}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "neuroglia-python"
-version = "0.6.21"
+version = "0.6.22"
 description = "Port from .NET to Python of the Neuroglia Framework"
 authors = ["Charles d'Avernas <charles.davernas@neuroglia.io>", "Bruno van de Werve <bvandewe@gmail.com>"]
 license = "Apache"

{neuroglia_python-0.6.21 → neuroglia_python-0.6.22}/src/neuroglia/__init__.py

@@ -62,7 +62,7 @@ __all__ = [
 ]
 
 # Framework metadata
-__version__ = "0.6.18"
+__version__ = "0.6.21"
 __author__ = "Neuroglia Team"
 __email__ = "team@neuroglia.io"
 __license__ = "Apache"

{neuroglia_python-0.6.21 → neuroglia_python-0.6.22}/src/neuroglia/hosting/configuration/data_access_layer.py

@@ -144,26 +144,149 @@ class DataAccessLayer:
             return builder
 
     class ReadModel:
-        """Represents an helper class used to configure an application's Read Model DAL"""
+        """Represents a 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:
+        Supports two configuration patterns:
+        1. Simplified: Pass database_name directly to constructor
+        2. Custom: Pass custom repository_setup function to configure()
+
+        Examples:
+            # Simple configuration with database name
+            DataAccessLayer.ReadModel(database_name="myapp").configure(
+                builder, ["integration.models"]
+            )
+
+            # Custom factory (advanced, backwards compatible)
+            def custom_setup(builder_, entity_type, key_type):
+                # Custom configuration logic
+                pass
+            DataAccessLayer.ReadModel().configure(
+                builder, ["integration.models"], custom_setup
+            )
+        """
+
+        def __init__(self, database_name: Optional[str] = None):
+            """Initialize ReadModel configuration
+
+            Args:
+                database_name: Optional database name for MongoDB repositories.
+                              If not provided, custom repository_setup must be used.
+            """
+            self._database_name = database_name
+
+        def configure(
+            self,
+            builder: ApplicationBuilderBase,
+            modules: list[str],
+            repository_setup: Optional[Callable[[ApplicationBuilderBase, type, type], None]] = None,
+        ) -> ApplicationBuilderBase:
             """Configures the application's Read Model DAL, scanning 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
+                repository_setup (Optional[Callable[[ApplicationBuilderBase, Type, Type], None]]):
+                    Optional custom function to setup repositories. If provided, takes precedence over database_name.
+                    If not provided, uses simplified configuration with database_name.
+
+            Returns:
+                ApplicationBuilderBase: The configured builder
+
+            Raises:
+                ValueError: If consumer_group not specified in settings
+                ValueError: If neither repository_setup nor database_name is provided
             """
             consumer_group = builder.settings.consumer_group
             if not consumer_group:
                 raise ValueError("Cannot configure Read Model DAL: consumer group not specified in application settings")
             builder.services.add_singleton(ReadModelConciliationOptions, singleton=ReadModelConciliationOptions(consumer_group))
             builder.services.add_singleton(HostedService, ReadModelReconciliator)
+
+            # If custom setup provided, use it (backwards compatible)
+            if repository_setup is not None:
+                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])  # type: ignore
+                        builder.services.add_transient(RequestHandler, ListQueryHandler[queryable_type, key_type])  # type: ignore
+                return builder
+
+            # Otherwise use simplified configuration with database_name
+            return self._configure_with_database_name(builder, modules)
+
+        def _configure_with_database_name(
+            self,
+            builder: ApplicationBuilderBase,
+            modules: list[str],
+        ) -> ApplicationBuilderBase:
+            """Configure repositories using simplified database_name pattern
+
+            Args:
+                builder: The application builder
+                modules: List of module names to scan for queryable types
+
+            Returns:
+                The configured builder
+
+            Raises:
+                ValueError: If database_name was not provided
+            """
+            if not self._database_name:
+                raise ValueError("Cannot configure Read Model with simplified API: " "database_name not provided. Either pass database_name to ReadModel() " "or use custom repository_setup function.")
+
+            from pymongo import MongoClient
+
+            from neuroglia.data.infrastructure.abstractions import (
+                QueryableRepository,
+                Repository,
+            )
+            from neuroglia.data.infrastructure.mongo.mongo_repository import (
+                MongoRepository,
+                MongoRepositoryOptions,
+            )
+            from neuroglia.dependency_injection import ServiceProvider
+
+            # Get MongoDB connection string
+            connection_string_name = "mongo"
+            connection_string = builder.settings.connection_strings.get(connection_string_name, None)
+            if connection_string is None:
+                raise ValueError(f"Missing '{connection_string_name}' connection string in application settings")
+
+            # Register MongoClient singleton (shared across all repositories)
+            builder.services.try_add_singleton(MongoClient, singleton=MongoClient(connection_string))
+
+            # Discover and configure each queryable type
             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)
+
+                    # Register options for this entity type
+                    builder.services.try_add_singleton(
+                        MongoRepositoryOptions[queryable_type, key_type],  # type: ignore
+                        singleton=MongoRepositoryOptions[queryable_type, key_type](self._database_name),  # type: ignore
+                    )
+
+                    # Register repository
+                    builder.services.try_add_singleton(
+                        Repository[queryable_type, key_type],  # type: ignore
+                        MongoRepository[queryable_type, key_type],  # type: ignore
+                    )
+
+                    # Register queryable repository alias
+                    def make_queryable_factory(qt, kt):
+                        def queryable_factory(provider: ServiceProvider):
+                            return provider.get_required_service(Repository[qt, kt])  # type: ignore
+
+                        return queryable_factory
+
+                    builder.services.try_add_singleton(
+                        QueryableRepository[queryable_type, key_type],  # type: ignore
+                        implementation_factory=make_queryable_factory(queryable_type, key_type),
+                    )
+
+                    # Register query handlers
                     builder.services.add_transient(RequestHandler, GetByIdQueryHandler[queryable_type, key_type])  # type: ignore
                     builder.services.add_transient(RequestHandler, ListQueryHandler[queryable_type, key_type])  # type: ignore
+
             return builder