Fixed OpenApi for multiple Module Routers

Author: eadwinCode

ellar/openapi/builder.py

@@ -117,15 +117,19 @@ def _get_openapi_route_document_models(self, app: App) -> t.List[OpenAPIRoute]:
         openapi_route_models: t.List = []
         reflector = app.injector.get(Reflector)
         for route in app.routes:
-            if isinstance(route, Mount) and len(route.routes) > 0:
+            if (
+                isinstance(route, ModuleMount)
+                and len(route.routes) > 0
+                and route.include_in_schema
+            ):
                 openapi: t.Dict = dict()
                 guards = app.get_guards()
+
                 openapi_route_models.append(
                     OpenAPIMountDocumentation(
                         mount=route, global_guards=guards, **openapi
                     )
                 )
-                continue
             elif (
                 isinstance(route, (RouteOperation, ControllerRouteOperation))
                 and route.include_in_schema
@@ -203,11 +207,10 @@ def build_document(self, app: App) -> OpenAPI:
         if definitions:
             components["schemas"] = {k: definitions[k] for k in sorted(definitions)}
 
-        for mount in mounts:
-            if isinstance(mount, ModuleMount):
-                data = mount.get_tag()
-                if data and mount.include_in_schema:
-                    self._build.setdefault("tags", []).append(data)
+        for route_model in openapi_route_models:
+            if isinstance(route_model, OpenAPIMountDocumentation):
+                data = route_model.get_tag()
+                self._build.setdefault("tags", []).append(data)
         if components:
             self._build.setdefault("components", {}).update(components)
         return OpenAPI(**self._build)

ellar/openapi/module.py

@@ -54,7 +54,7 @@ def setup_swagger_doc(
         title: str = "Ellar Swagger Doc",
         swagger_js_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@3/swagger-ui-bundle.js",
         swagger_css_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@3/swagger-ui.css",
-        swagger_favicon_url: str = "https://fastapi.tiangolo.com/img/favicon.png",
+        swagger_favicon_url: str = "https://eadwincode.github.io/ellar/img/Icon.svg",
     ) -> None:
         self._setup_docs(
             template_name="swagger",
@@ -72,7 +72,7 @@ def setup_redocs(
         path: str = "redoc",
         title: str = "Ellar Redoc",
         redoc_js_url: str = "https://cdn.jsdelivr.net/npm/redoc@next/bundles/redoc.standalone.js",
-        redoc_favicon_url: str = "https://fastapi.tiangolo.com/img/favicon.png",
+        redoc_favicon_url: str = "https://eadwincode.github.io/ellar/img/Icon.svg",
         with_google_fonts: bool = True,
     ) -> None:
         self._setup_docs(

ellar/openapi/route_doc_models.py

@@ -5,19 +5,13 @@
 from pydantic import BaseModel
 from pydantic.fields import ModelField, Undefined
 from pydantic.schema import field_schema
-from starlette.convertors import (
-    FloatConvertor,
-    IntegerConvertor,
-    PathConvertor,
-    StringConvertor,
-    UUIDConvertor,
-)
 from starlette.routing import Mount, compile_path
 from starlette.status import HTTP_422_UNPROCESSABLE_ENTITY
 
-from ellar.compatible import cached_property
+from ellar.compatible import AttributeDict, cached_property
 from ellar.constants import GUARDS_KEY, METHODS_WITH_BODY, OPENAPI_KEY, REF_PREFIX
 from ellar.core.guard import BaseAuthGuard
+from ellar.core.params.args import EndpointArgsModel
 from ellar.core.params.params import Body, Param
 from ellar.core.params.resolvers import (
     BodyParameterResolver,
@@ -33,15 +27,6 @@
     from ellar.core.guard import GuardCanActivate
 
 
-CONVERTOR_TYPES = {
-    StringConvertor: dict(title="title", type="string"),
-    PathConvertor: dict(title="title", type="string"),
-    IntegerConvertor: dict(title="title", type="integer"),
-    FloatConvertor: dict(title="title", type="number"),
-    UUIDConvertor: dict(title="title", type="string", format="uuid"),
-}
-
-
 class OpenAPIRoute(ABC):
     @abstractmethod
     def get_route_models(self) -> t.List[t.Union[ModelField, RouteParameterModelField]]:
@@ -70,29 +55,24 @@ def __init__(
             t.Union[t.Type["GuardCanActivate"], "GuardCanActivate"]
         ] = None,
     ) -> None:
-        self.tag = tag
-        self.description = description
-        self.external_doc_description = external_doc_description
-        self.external_doc_url = external_doc_url
+        meta = mount.get_meta() if isinstance(mount, ModuleMount) else AttributeDict()
+        self.tag = tag or meta.tag  # type: ignore
+        self.description = description or meta.description  # type: ignore
+        self.external_doc_description = (
+            external_doc_description or meta.external_doc_description  # type: ignore
+        )
+        self.external_doc_url = external_doc_url or meta.external_doc_url  # type: ignore
         self.mount = mount
         self.path_regex, self.path_format, self.param_convertors = compile_path(
             self.mount.path
         )
-        self.global_route_parameters = []
+        # if there is some convertor on ModuleMount Object, then we need to convert it to ModelField
+        self.global_route_parameters: t.List[ModelField] = [
+            EndpointArgsModel.get_convertor_model_field(name, convertor)
+            for name, convertor in self.param_convertors.items()
+        ]
         self.global_guards = global_guards or []
 
-        if self.param_convertors:
-            for name, converter in self.param_convertors.items():
-                schema = CONVERTOR_TYPES[converter.__class__]
-                schema.update(title=name)
-                parameter = {
-                    "name": name,
-                    "in": "path",
-                    "required": True,
-                    "schema": schema,
-                }
-                self.global_route_parameters.append(parameter)
-
         self._routes: t.List["OpenAPIRouteDocumentation"] = self._build_routes()
 
     def get_tag(self) -> t.Dict:
@@ -116,11 +96,13 @@ def _build_routes(self) -> t.List["OpenAPIRouteDocumentation"]:
             if isinstance(route, RouteOperation) and route.include_in_schema:
                 openapi = reflector.get(OPENAPI_KEY, route.endpoint) or dict()
                 guards = reflector.get(GUARDS_KEY, route.endpoint)
-                self._routes.append(
+
+                _routes.append(
                     OpenAPIRouteDocumentation(
                         route=route,
                         global_route_parameters=self.global_route_parameters,
                         guards=guards or self.global_guards,
+                        tags=[self.tag],
                         **openapi,
                     )
                 )
@@ -150,17 +132,12 @@ def get_openapi_path(
             else self.path_format
         )
         for openapi_route in self._routes:
-            path, _security_schemes = openapi_route.get_child_openapi_path(
-                model_name_map=model_name_map
+            openapi_route.get_openapi_path(
+                model_name_map=model_name_map,
+                paths=paths,
+                security_schemes=security_schemes,
+                path_prefix=path_prefix,
             )
-            if path:
-                route_path = (
-                    normalize_path(f"{path_prefix}/{openapi_route.route.path_format}")
-                    if path_prefix
-                    else openapi_route.route.path_format
-                )
-                paths.setdefault(route_path, {}).update(path)
-            security_schemes.update(_security_schemes)
 
 
 class OpenAPIRouteDocumentation(OpenAPIRoute):
@@ -173,7 +150,7 @@ def __init__(
         description: t.Optional[str] = None,
         tags: t.Optional[t.List[str]] = None,
         deprecated: t.Optional[bool] = None,
-        global_route_parameters: t.List[t.Dict] = None,
+        global_route_parameters: t.List[ModelField] = None,
         guards: t.List[t.Union["GuardCanActivate", t.Type["GuardCanActivate"]]] = None,
     ) -> None:
         self.operation_id = operation_id
@@ -198,7 +175,11 @@ def _openapi_models(self) -> t.List[t.Union[ModelField, RouteParameterModelField
 
     @cached_property
     def input_fields(self) -> t.List[ModelField]:
-        _models: t.List[ModelField] = []
+        omitted_path_parameter_fields = (
+            self.route.endpoint_parameter_model.get_omitted_prefix()
+        )
+        _models: t.List[ModelField] = self.global_route_parameters
+
         for item in self.route.endpoint_parameter_model.get_all_models():
             if isinstance(item, BodyParameterResolver):
                 continue
@@ -210,6 +191,12 @@ def input_fields(self) -> t.List[ModelField]:
             if isinstance(item, RouteParameterResolver):
                 _models.append(item.model_field)
 
+        already_existing_parameter_names = [model.name for model in _models]
+        for omitted_path_parameter_field in omitted_path_parameter_fields:
+            if omitted_path_parameter_field.name in already_existing_parameter_names:
+                continue
+            _models.append(omitted_path_parameter_field)
+
         return _models
 
     @cached_property
@@ -282,7 +269,7 @@ def get_openapi_operation_parameters(
             if field_info.deprecated:
                 parameter["deprecated"] = field_info.deprecated
             parameters.append(parameter)
-        return parameters + self.global_route_parameters
+        return parameters
 
     def get_openapi_operation_request_body(
         self,
@@ -345,14 +332,10 @@ def _get_openapi_path_object(
             operation_responses = operation.setdefault("responses", {})
             for status, response_model in self.route.response_model.models.items():
                 operation_responses_status = operation_responses.setdefault(status, {})
-                operation_responses_status["description"] = getattr(
-                    response_model, "description", ""
-                )
+                operation_responses_status["description"] = response_model.description
 
                 content = operation_responses_status.setdefault("content", {})
-                media_type = content.setdefault(
-                    getattr(response_model, "media_type", "text/plain"), {}
-                )
+                media_type = content.setdefault(response_model.media_type, {})
                 media_type.setdefault("schema", {"type": "string"})
 
                 model_field = response_model.get_model_field()