neuroglia-python 0.7.2__tar.gz → 0.7.3__tar.gz

{neuroglia_python-0.7.2 → neuroglia_python-0.7.3}/PKG-INFO

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

{neuroglia_python-0.7.2 → neuroglia_python-0.7.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "neuroglia-python"
-version = "0.7.2"
+version = "0.7.3"
 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.7.2 → neuroglia_python-0.7.3}/src/neuroglia/__init__.py

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

{neuroglia_python-0.7.2 → neuroglia_python-0.7.3}/src/neuroglia/data/infrastructure/mongo/motor_query.py

@@ -33,7 +33,7 @@ See Also:
 
 import ast
 from ast import NodeVisitor, expr
-from typing import Any, Generic, List, Optional
+from typing import TYPE_CHECKING, Any, Generic, List, Optional
 
 import pymongo
 from motor.motor_asyncio import AsyncIOMotorCollection, AsyncIOMotorCursor
@@ -43,6 +43,9 @@ from neuroglia.expressions.javascript_expression_translator import (
     JavaScriptExpressionTranslator,
 )
 
+if TYPE_CHECKING:
+    from neuroglia.serialization import JsonSerializer
+
 
 class MotorQuery(Generic[T], Queryable[T]):
     """
@@ -71,6 +74,62 @@ class MotorQuery(Generic[T], Queryable[T]):
         """
         super().__init__(query_provider, expression)
 
+    async def to_list_async(self) -> list[T]:
+        """
+        Asynchronously execute the query and return results as a list.
+
+        This is the async equivalent of to_list() for Motor queries.
+
+        Returns:
+            List of entities matching the query
+
+        Example:
+            ```python
+            products = await repo.query_async() \\
+                .where(lambda p: p.price > 10) \\
+                .order_by(lambda p: p.name) \\
+                .to_list_async()
+            ```
+        """
+        # Get the provider and ensure it's a MotorQueryProvider
+        provider = self.provider
+        if not isinstance(provider, MotorQueryProvider):
+            raise TypeError("MotorQuery requires a MotorQueryProvider")
+
+        # Execute the query asynchronously
+        return await provider.execute_async(self.expression, List)
+
+    async def first_or_default_async(self, predicate=None) -> Optional[T]:
+        """
+        Asynchronously get the first element matching the predicate, or None.
+
+        Args:
+            predicate: Optional filter predicate
+
+        Returns:
+            First matching entity or None
+
+        Example:
+            ```python
+            product = await repo.query_async() \\
+                .where(lambda p: p.id == "prod123") \\
+                .first_or_default_async()
+            ```
+        """
+        # Get the provider and ensure it's a MotorQueryProvider
+        provider = self.provider
+        if not isinstance(provider, MotorQueryProvider):
+            raise TypeError("MotorQuery requires a MotorQueryProvider")
+
+        # If predicate provided, apply it as a where clause
+        query = self
+        if predicate is not None:
+            query = self.where(predicate)
+
+        # Execute and get list, then return first or None
+        results = await provider.execute_async(query.expression, List)
+        return results[0] if results else None
+
 
 class MotorQueryBuilder(NodeVisitor):
     """
@@ -228,25 +287,28 @@ class MotorQueryProvider(QueryProvider):
     Attributes:
         _collection: Motor async collection to query
         _entity_type: Type of entities in the collection
+        _serializer: JSON serializer for entity conversion
 
     Example:
         ```python
-        provider = MotorQueryProvider(motor_collection, Product)
+        provider = MotorQueryProvider(motor_collection, Product, serializer)
         query = provider.create_query(Product, expression)
         results = await provider.execute_async(expression, List[Product])
         ```
     """
 
-    def __init__(self, collection: AsyncIOMotorCollection, entity_type: type):
+    def __init__(self, collection: AsyncIOMotorCollection, entity_type: type, serializer: "JsonSerializer"):
         """
         Initialize the Motor query provider.
 
         Args:
             collection: Motor async collection
             entity_type: Type of entities being queried
+            serializer: JSON serializer for entity conversion
         """
         self._collection = collection
         self._entity_type = entity_type
+        self._serializer = serializer
 
     def create_query(self, element_type: type, expression: expr) -> Queryable:
         """
@@ -308,9 +370,29 @@ class MotorQueryProvider(QueryProvider):
             is_list_type = query_type.__origin__ in (list, List)
 
         if is_list_type:
-            # Return list of documents
-            return [doc async for doc in cursor]
+            # Return list of deserialized entities
+            documents = [doc async for doc in cursor]
+            return [self._deserialize_entity(doc) for doc in documents]
         else:
-            # Return single document
+            # Return single deserialized entity
             results = await cursor.to_list(length=1)
-            return results[0] if results else None
+            return self._deserialize_entity(results[0]) if results else None
+
+    def _deserialize_entity(self, doc: dict) -> Any:
+        """
+        Deserialize a MongoDB document to an entity instance.
+
+        Args:
+            doc: MongoDB document dictionary
+
+        Returns:
+            Deserialized entity instance
+        """
+        # Remove MongoDB's _id field
+        doc.pop("_id", None)
+
+        # Serialize dict back to JSON for deserialization
+        json_str = self._serializer.serialize_to_text(doc)
+
+        # Deserialize using the entity type
+        return self._serializer.deserialize_from_text(json_str, self._entity_type)

{neuroglia_python-0.7.2 → neuroglia_python-0.7.3}/src/neuroglia/data/infrastructure/mongo/motor_repository.py

@@ -552,7 +552,7 @@ class MotorRepository(Generic[TEntity, TKey], QueryableRepository[TEntity, TKey]
         if entity_type is None:
             raise TypeError("Cannot create query: entity type not set. Pass entity_type to constructor.")
 
-        return MotorQuery[TEntity](MotorQueryProvider(self.collection, entity_type))
+        return MotorQuery[TEntity](MotorQueryProvider(self.collection, entity_type, self._serializer))
 
     async def get_all_async(self) -> list[TEntity]:
         """

{neuroglia_python-0.7.2 → neuroglia_python-0.7.3}/src/neuroglia/hosting/configuration/data_access_layer.py

@@ -252,24 +252,54 @@ class DataAccessLayer:
                 ValueError: If consumer_group not specified in settings
                 ValueError: If neither repository_setup nor database_name is provided
             """
+            # Configure read model reconciliation
+            self._configure_reconciliation(builder)
+
+            # If custom setup provided, use it (backwards compatible)
+            if repository_setup is not None:
+                return self._configure_with_custom_setup(builder, modules, repository_setup)
+
+            # Otherwise use simplified configuration with database_name
+            return self._configure_with_database_name(builder, modules)
+
+        def _configure_reconciliation(self, builder: ApplicationBuilderBase) -> None:
+            """Configure read model reconciliation services
+
+            Args:
+                builder: The application builder
+
+            Raises:
+                ValueError: If consumer_group not specified in settings
+            """
             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
+        def _configure_with_custom_setup(
+            self,
+            builder: ApplicationBuilderBase,
+            modules: list[str],
+            repository_setup: Callable[[ApplicationBuilderBase, type, type], None],
+        ) -> ApplicationBuilderBase:
+            """Configure repositories using custom setup function (backwards compatible pattern)
 
-            # Otherwise use simplified configuration with database_name
-            return self._configure_with_database_name(builder, modules)
+            Args:
+                builder: The application builder
+                modules: List of module names to scan for queryable types
+                repository_setup: Custom function to setup repositories
+
+            Returns:
+                The configured builder
+            """
+            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
 
         def _configure_with_database_name(
             self,
@@ -291,148 +321,260 @@ class DataAccessLayer:
             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.")
 
+            # Configure based on repository type
+            if self._repository_type == "mongo":
+                return self._configure_mongo_repositories(builder, modules)
+            elif self._repository_type == "motor":
+                return self._configure_motor_repositories(builder, modules)
+
+            return builder
+
+        def _configure_mongo_repositories(
+            self,
+            builder: ApplicationBuilderBase,
+            modules: list[str],
+        ) -> ApplicationBuilderBase:
+            """Configure synchronous MongoRepository instances
+
+            Args:
+                builder: The application builder
+                modules: List of module names to scan for queryable types
+
+            Returns:
+                The configured builder
+
+            Raises:
+                ValueError: If mongo connection string is missing
+            """
+            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
 
-            # Configure based on repository type
-            if self._repository_type == "mongo":
-                # Synchronous MongoRepository configuration
-                from pymongo import MongoClient
+            # 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")
 
-                from neuroglia.data.infrastructure.mongo.mongo_repository import (
-                    MongoRepository,
-                    MongoRepositoryOptions,
-                )
+            # Register MongoClient singleton (shared across all repositories)
+            builder.services.try_add_singleton(MongoClient, singleton=MongoClient(connection_string))
 
-                # 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")
+            # 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
 
-                # Register MongoClient singleton (shared across all repositories)
-                builder.services.try_add_singleton(MongoClient, singleton=MongoClient(connection_string))
+                    # 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
+                    )
 
-                # 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
+                    # Register repository
+                    builder.services.try_add_singleton(
+                        Repository[queryable_type, key_type],  # type: ignore
+                        MongoRepository[queryable_type, key_type],  # type: ignore
+                    )
 
-                        # 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 queryable repository alias
+                    def make_queryable_factory(qt, kt):
+                        def queryable_factory(provider: ServiceProvider):
+                            return provider.get_required_service(Repository[qt, kt])  # type: ignore
 
-                        # Register repository
-                        builder.services.try_add_singleton(
-                            Repository[queryable_type, key_type],  # type: ignore
-                            MongoRepository[queryable_type, key_type],  # type: ignore
-                        )
+                        return queryable_factory
 
-                        # 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
+                    builder.services.try_add_singleton(
+                        QueryableRepository[queryable_type, key_type],  # type: ignore
+                        implementation_factory=make_queryable_factory(queryable_type, key_type),
+                    )
 
-                            return queryable_factory
+                    # 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
 
-                        builder.services.try_add_singleton(
-                            QueryableRepository[queryable_type, key_type],  # type: ignore
-                            implementation_factory=make_queryable_factory(queryable_type, key_type),
-                        )
+            return builder
+
+        def _configure_motor_repositories(
+            self,
+            builder: ApplicationBuilderBase,
+            modules: list[str],
+        ) -> ApplicationBuilderBase:
+            """Configure async MotorRepository instances
 
-                        # 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
+            Args:
+                builder: The application builder
+                modules: List of module names to scan for queryable types
 
-            elif self._repository_type == "motor":
-                # Async MotorRepository configuration with queryable support
-                from motor.motor_asyncio import AsyncIOMotorClient
+            Returns:
+                The configured builder
 
-                from neuroglia.data.infrastructure.mongo.motor_repository import (
-                    MotorRepository,
-                )
-                from neuroglia.mediation import Mediator
-                from neuroglia.serialization.json import JsonSerializer
+            Raises:
+                ValueError: If mongo connection string is missing
+            """
+            from motor.motor_asyncio import AsyncIOMotorClient
 
-                # 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")
+            # 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 AsyncIOMotorClient singleton (shared across all repositories)
-                builder.services.try_add_singleton(AsyncIOMotorClient, singleton=AsyncIOMotorClient(connection_string))
+            # Register AsyncIOMotorClient singleton (shared across all repositories)
+            builder.services.try_add_singleton(AsyncIOMotorClient, singleton=AsyncIOMotorClient(connection_string))
 
-                # Discover and configure each queryable type (filter by @queryable decorator)
-                for module in [ModuleLoader.load(module_name) for module_name in modules]:
-                    for entity_type in TypeFinder.get_types(module, lambda cls: inspect.isclass(cls) and hasattr(cls, "__queryable__")):
-                        key_type = str  # todo: reflect from DTO base type
+            # Discover and configure each queryable type
+            self._register_motor_queryable_types(builder, modules)
 
-                        # Determine collection name (default to lowercase entity name)
-                        collection_name = entity_type.__name__.lower()
-                        if collection_name.endswith("dto"):
-                            collection_name = collection_name[:-3]
-
-                        # Factory function to create MotorRepository instance
-                        def make_motor_factory(et, kt, cn):
-                            def motor_factory(provider: ServiceProvider):
-                                # Attempt to resolve Mediator optionally (tests may skip registration)
-                                mediator = provider.get_service(Mediator)
-                                if mediator is None:
-                                    mediator = provider.get_required_service(Mediator)
-
-                                return MotorRepository[et, kt](  # type: ignore
-                                    client=provider.get_required_service(AsyncIOMotorClient),
-                                    database_name=self._database_name,
-                                    collection_name=cn,
-                                    serializer=provider.get_required_service(JsonSerializer),
-                                    entity_type=et,
-                                    mediator=mediator,
-                                )
-
-                            return motor_factory
-
-                        # Register MotorRepository (scoped for proper async context per request)
-                        builder.services.try_add_scoped(
-                            MotorRepository[entity_type, key_type],  # type: ignore
-                            implementation_factory=make_motor_factory(entity_type, key_type, collection_name),
-                        )
+            # Register custom repository mappings
+            self._register_custom_repository_mappings(builder)
+
+            return builder
 
-                        # Register Repository interface (handlers expect this)
-                        def make_repository_factory(et, kt):
-                            def repository_factory(provider: ServiceProvider):
-                                return provider.get_required_service(MotorRepository[et, kt])  # type: ignore
+        def _register_motor_queryable_types(
+            self,
+            builder: ApplicationBuilderBase,
+            modules: list[str],
+        ) -> None:
+            """Register MotorRepository for each @queryable decorated type
 
-                            return repository_factory
+            Args:
+                builder: The application builder
+                modules: List of module names to scan for queryable types
+            """
+            from motor.motor_asyncio import AsyncIOMotorClient
 
-                        builder.services.try_add_scoped(
-                            Repository[entity_type, key_type],  # type: ignore
-                            implementation_factory=make_repository_factory(entity_type, key_type),
-                        )
+            from neuroglia.data.infrastructure.abstractions import (
+                QueryableRepository,
+                Repository,
+            )
+            from neuroglia.data.infrastructure.mongo.motor_repository import (
+                MotorRepository,
+            )
+            from neuroglia.dependency_injection import ServiceProvider
+            from neuroglia.mediation import Mediator
+            from neuroglia.serialization.json import JsonSerializer
+
+            for module in [ModuleLoader.load(module_name) for module_name in modules]:
+                for entity_type in TypeFinder.get_types(module, lambda cls: inspect.isclass(cls) and hasattr(cls, "__queryable__")):
+                    key_type = str  # todo: reflect from DTO base type
 
-                        # Register QueryableRepository interface (for queryable support)
-                        def make_queryable_factory(et, kt):
-                            def queryable_factory(provider: ServiceProvider):
-                                return provider.get_required_service(Repository[et, kt])  # type: ignore
+                    # Determine collection name (default to lowercase entity name)
+                    collection_name = entity_type.__name__.lower()
+                    if collection_name.endswith("dto"):
+                        collection_name = collection_name[:-3]
+
+                    # Factory function to create MotorRepository instance
+                    def make_motor_factory(et, kt, cn):
+                        def motor_factory(provider: ServiceProvider):
+                            # Attempt to resolve Mediator optionally (tests may skip registration)
+                            mediator = provider.get_service(Mediator)
+                            if mediator is None:
+                                mediator = provider.get_required_service(Mediator)
+
+                            return MotorRepository[et, kt](  # type: ignore
+                                client=provider.get_required_service(AsyncIOMotorClient),
+                                database_name=self._database_name,
+                                collection_name=cn,
+                                serializer=provider.get_required_service(JsonSerializer),
+                                entity_type=et,
+                                mediator=mediator,
+                            )
 
-                            return queryable_factory
+                        return motor_factory
 
-                        builder.services.try_add_scoped(
-                            QueryableRepository[entity_type, key_type],  # type: ignore
-                            implementation_factory=make_queryable_factory(entity_type, key_type),
-                        )
+                    # Register MotorRepository (scoped for proper async context per request)
+                    builder.services.try_add_scoped(
+                        MotorRepository[entity_type, key_type],  # type: ignore
+                        implementation_factory=make_motor_factory(entity_type, key_type, collection_name),
+                    )
 
-                        # Register query handlers (consistent with mongo)
-                        builder.services.add_transient(RequestHandler, GetByIdQueryHandler[entity_type, key_type])  # type: ignore
-                        builder.services.add_transient(RequestHandler, ListQueryHandler[entity_type, key_type])  # type: ignore
+                    # Register Repository interface (handlers expect this)
+                    def make_repository_factory(et, kt):
+                        def repository_factory(provider: ServiceProvider):
+                            return provider.get_required_service(MotorRepository[et, kt])  # type: ignore
 
-                # Register custom repository mappings
-                for abstract_type, implementation_type in self._repository_mappings.items():
-                    builder.services.add_scoped(abstract_type, implementation_type)
+                        return repository_factory
 
-            return builder
+                    builder.services.try_add_scoped(
+                        Repository[entity_type, key_type],  # type: ignore
+                        implementation_factory=make_repository_factory(entity_type, key_type),
+                    )
+
+                    # Register QueryableRepository interface (for queryable support)
+                    def make_queryable_factory(et, kt):
+                        def queryable_factory(provider: ServiceProvider):
+                            return provider.get_required_service(Repository[et, kt])  # type: ignore
+
+                        return queryable_factory
+
+                    builder.services.try_add_scoped(
+                        QueryableRepository[entity_type, key_type],  # type: ignore
+                        implementation_factory=make_queryable_factory(entity_type, key_type),
+                    )
+
+                    # Register query handlers (consistent with mongo)
+                    builder.services.add_transient(RequestHandler, GetByIdQueryHandler[entity_type, key_type])  # type: ignore
+                    builder.services.add_transient(RequestHandler, ListQueryHandler[entity_type, key_type])  # type: ignore
+
+        def _register_custom_repository_mappings(self, builder: ApplicationBuilderBase) -> None:
+            """Register custom domain repository implementations
+
+            Uses factory functions to properly instantiate custom repositories,
+            avoiding DI auto-construction issues with generic type parameters.
+
+            Args:
+                builder: The application builder
+            """
+            from motor.motor_asyncio import AsyncIOMotorClient
+
+            from neuroglia.dependency_injection import ServiceProvider
+            from neuroglia.mediation import Mediator
+            from neuroglia.serialization.json import JsonSerializer
+
+            for abstract_type, implementation_type in self._repository_mappings.items():
+
+                def make_custom_repo_factory(impl_type):
+                    def custom_repo_factory(provider: ServiceProvider):
+                        # Get entity type from implementation's base classes
+                        entity_type = None
+                        collection_name = None
+
+                        # Extract entity type from MotorRepository[TEntity, TKey] base
+                        for base in getattr(impl_type, "__orig_bases__", []):
+                            if hasattr(base, "__origin__") and base.__origin__.__name__ == "MotorRepository":
+                                if hasattr(base, "__args__") and len(base.__args__) >= 1:
+                                    entity_type = base.__args__[0]
+                                    # Determine collection name
+                                    collection_name = entity_type.__name__.lower()
+                                    if collection_name.endswith("dto"):
+                                        collection_name = collection_name[:-3]
+                                    break
+
+                        if entity_type is None:
+                            raise ValueError(f"Could not determine entity type for {impl_type.__name__}. " f"Ensure it extends MotorRepository[TEntity, TKey]")
+
+                        # Construct repository with proper dependencies
+                        mediator = provider.get_service(Mediator)
+                        if mediator is None:
+                            mediator = provider.get_required_service(Mediator)
+
+                        return impl_type(
+                            client=provider.get_required_service(AsyncIOMotorClient),
+                            database_name=self._database_name,
+                            collection_name=collection_name,
+                            serializer=provider.get_required_service(JsonSerializer),
+                            entity_type=entity_type,
+                            mediator=mediator,
+                        )
+
+                    return custom_repo_factory
+
+                builder.services.add_scoped(abstract_type, implementation_factory=make_custom_repo_factory(implementation_type))