Code refactor and more testing

Author: eadwinCode

ellar/core/factory.py

@@ -3,7 +3,7 @@
 from pathlib import Path
 from uuid import uuid4
 
-from starlette.routing import BaseRoute, Host, Mount
+from starlette.routing import Host, Mount
 
 from ellar.constants import MODULE_METADATA, MODULE_WATERMARK
 from ellar.core import Config
@@ -66,7 +66,7 @@ def _build_modules(
         app_module: t.Type[t.Union[ModuleBase, t.Any]],
         config: Config,
         injector: EllarInjector,
-    ) -> t.List[BaseRoute]:
+    ) -> None:
         """
         builds application module and registers them to EllarInjector
         :param app_module: Root App Module
@@ -80,7 +80,6 @@ def _build_modules(
 
         app_module_config = ModuleSetup(app_module)
         module_dependency = cls.get_all_modules(app_module_config)
-        routes = []
 
         for module_config in reversed(module_dependency):
             if injector.get_module(module_config.module):  # pragma: no cover
@@ -92,7 +91,6 @@ def _build_modules(
 
             if not isinstance(module_ref, ModuleSetup):
                 module_ref.run_module_register_services()
-                routes.extend(module_ref.routes)
 
             injector.add_module(module_ref)
 
@@ -106,8 +104,6 @@ def _build_modules(
             module_ref.run_module_register_services()
 
             injector.add_module(module_ref)
-            routes.extend(module_ref.routes)
-        return routes
 
     @classmethod
     def _create_app(
@@ -138,15 +134,14 @@ def _get_config_kwargs() -> t.Dict:
         injector.container.register_instance(config, concrete_type=Config)
         CoreServiceRegistration(injector, config).register_all()
 
-        routes = cls._build_modules(app_module=module, injector=injector, config=config)
+        cls._build_modules(app_module=module, injector=injector, config=config)
 
         shutdown_event = config.ON_REQUEST_STARTUP
         startup_event = config.ON_REQUEST_SHUTDOWN
 
         app = App(
             config=config,
             injector=injector,
-            routes=routes,
             on_shutdown_event_handlers=shutdown_event if shutdown_event else None,
             on_startup_event_handlers=startup_event if startup_event else None,
             lifespan=config.DEFAULT_LIFESPAN_HANDLER,

ellar/core/main.py

@@ -40,7 +40,6 @@ def __init__(
         self,
         config: Config,
         injector: EllarInjector,
-        routes: t.List[BaseRoute],
         on_startup_event_handlers: t.Optional[t.Sequence[EventHandler]] = None,
         on_shutdown_event_handlers: t.Optional[t.Sequence[EventHandler]] = None,
         lifespan: t.Optional[t.Callable[["App"], t.AsyncContextManager]] = None,
@@ -83,7 +82,7 @@ def __init__(
             lifespan or self.config.DEFAULT_LIFESPAN_HANDLER
         )
         self.router = ApplicationRouter(
-            routes=self._get_module_routes(routes),
+            routes=self._get_module_routes(),
             redirect_slashes=self.config.REDIRECT_SLASHES,
             on_startup=[self.on_startup.async_run]
             if self.config.DEFAULT_LIFESPAN_HANDLER is None
@@ -116,8 +115,8 @@ async def _statics_func_wrapper(
 
         return _statics_func_wrapper
 
-    def _get_module_routes(self, routes: t.List[BaseRoute]) -> t.List[BaseRoute]:
-        _routes: t.List[BaseRoute] = list(routes)
+    def _get_module_routes(self) -> t.List[BaseRoute]:
+        _routes: t.List[BaseRoute] = list()
         if self.has_static_files:
             self._static_app = self.create_static_app()
             _routes.append(
@@ -128,9 +127,8 @@ def _get_module_routes(self, routes: t.List[BaseRoute]) -> t.List[BaseRoute]:
                 )
             )
 
-        # for _, module_ref in self._injector.get_modules().items():
-        #     _routes.extend(module_ref.routes)
-        #     module_ref.run_module_register_services()
+        for _, module_ref in self._injector.get_modules().items():
+            _routes.extend(module_ref.routes)
 
         return _routes
 

ellar/core/modules/config.py

@@ -13,6 +13,7 @@
 from .ref import ModuleRefBase, create_module_ref_factor
 
 if t.TYPE_CHECKING:  # pragma: no cover
+    from ellar.commands import EllarTyper
     from ellar.core import ControllerBase
 
 
@@ -28,10 +29,15 @@ class DynamicModule:
     controllers: t.Sequence[
         t.Union[t.Type["ControllerBase"], t.Type]
     ] = dataclasses.field(default_factory=lambda: tuple())
+
     routers: t.Sequence[t.Union[BaseRoute]] = dataclasses.field(
         default_factory=lambda: tuple()
     )
 
+    commands: t.Sequence[t.Union[t.Callable, "EllarTyper"]] = dataclasses.field(
+        default_factory=lambda: tuple()
+    )
+
     def __post_init__(self) -> None:
         if not isinstance(self.module, type) or not issubclass(self.module, ModuleBase):
             raise Exception(f"{self.module.__name__} is not a valid Module")
@@ -40,11 +46,13 @@ def __post_init__(self) -> None:
             controllers=list(self.controllers),
             routers=list(self.routers),
             providers=list(self.providers),
+            commands=list(self.commands),
         )
         for key in [
             MODULE_METADATA.CONTROLLERS,
             MODULE_METADATA.ROUTERS,
             MODULE_METADATA.PROVIDERS,
+            MODULE_METADATA.COMMANDS,
         ]:
             value = kwargs[key]
             if value:
@@ -55,17 +63,18 @@ def __post_init__(self) -> None:
 @dataclasses.dataclass
 class ModuleSetup:
     """
-    ModuleSetup is a way to configure a module after the application has started.
+    ModuleSetup is a way to configure a module based on its dependencies.
     This is necessary for Module that requires some services available to configure them.
     For example:
 
+     @Module()
      class MyModule(ModuleBase, IModuleSetup):
         @classmethod
         def setup(cls, param1: Any, param2: Any, foo: str) -> DynamicModule:
-            return DynamicModule(module, provider=[], controllers=[], routers=[])
+            return DynamicModule(cls, providers=[], controllers=[], routers=[])
 
 
-    def module_a_configuration_factory(module: t.Type[MyModule], config: Config, foo: Foo):
+    def module_a_configuration_factory(module: Type[MyModule], config: Config, foo: Foo):
         return module.setup(param1=config.param1, param2=config.param2, foo=foo.foo)
 
 

ellar/di/service_config.py

@@ -33,7 +33,7 @@ def __init__(
         base_type: t.Union[t.Type[T], t.Type],
         *,
         use_value: T = None,
-        use_class: t.Union[t.Type[T], t.Any] = None
+        use_class: t.Union[t.Type[T], t.Any] = None,
     ):
         if use_value and use_class:
             raise DIImproperConfiguration(
@@ -55,6 +55,12 @@ def register(self, container: "Container") -> None:
             container.register_singleton(
                 base_type=self.base_type, concrete_type=self.use_value
             )
+        elif not isinstance(self.base_type, type):
+            raise DIImproperConfiguration(
+                f"couldn't determine provider setup for {self.base_type}. "
+                f"Please use `ProviderConfig` or `register_services` function in a "
+                f"Module to configure the provider"
+            )
         else:
             container.register(base_type=self.base_type, scope=scope)