Refactored Request & Response Model + Fixed Resolve API Response issue

src/openg2p_spar_mapper_api/config.py

@@ -22,7 +22,7 @@ class Settings(BaseSettings):
     """
     openapi_version: str = __version__
 
-    db_dbname: str = "mapper-db"
+    db_dbname: str = "openg2p_spar_db"
 
     default_callback_url: Optional[AnyUrl] = None
     default_callback_timeout: int = 10

src/openg2p_spar_mapper_api/controllers/async_mapper_controller.py

@@ -9,12 +9,16 @@
     AsyncResponse,
     Request,
 )
-from openg2p_g2pconnect_common_lib.mapper.schemas.link import (
+from openg2p_g2pconnect_common_lib.mapper.schemas import (
+    LinkRequest,
+    ResolveRequest,
     SingleLinkResponse,
+    SingleResolveResponse,
+    SingleUnlinkResponse,
+    SingleUpdateResponse,
+    UnlinkRequest,
+    UpdateRequest,
 )
-from openg2p_g2pconnect_common_lib.mapper.schemas.resolve import SingleResolveResponse
-from openg2p_g2pconnect_common_lib.mapper.schemas.unlink import SingleUnlinkResponse
-from openg2p_g2pconnect_common_lib.mapper.schemas.update import SingleUpdateResponse
 
 from ..config import Settings
 from ..services import (
@@ -85,113 +89,105 @@ def __init__(self, **kwargs):
             methods=["POST"],
         )
 
-    async def link_async(self, request: Request):
+    async def link_async(self, link_request: LinkRequest):
         correlation_id = str(uuid.uuid4())
         await asyncio.create_task(
-            self.handle_service_and_link_callback(request, correlation_id, "link")
+            self.handle_service_and_link_callback(link_request, correlation_id, "link")
         )
         return AsyncResponseHelper.get_component().construct_success_async_response(
-            request,
+            link_request,
             correlation_id,
         )
 
-    async def update_async(self, request: Request):
-        try:
-            RequestValidation.validate_request(request)
-            RequestValidation.validate_update_async_request_header(request)
-        except RequestValidationException as e:
-            error_response = (
-                AsyncResponseHelper.get_component().construct_error_async_response(
-                    request, e
-                )
-            )
-            return error_response
+    async def update_async(self, update_request: UpdateRequest):
         correlation_id = str(uuid.uuid4())
         await asyncio.create_task(
-            self.handle_service_and_update_callback(request, correlation_id, "update")
+            self.handle_service_and_update_callback(
+                update_request, correlation_id, "update"
+            )
         )
         return AsyncResponseHelper.get_component().construct_success_async_response(
-            request,
+            update_request,
             correlation_id,
         )
 
-    async def resolve_async(self, request: Request):
+    async def resolve_async(self, resolve_request: ResolveRequest):
         correlation_id = str(uuid.uuid4())
-        try:
-            RequestValidation.validate_request(request)
-            RequestValidation.validate_resolve_async_request_header(request)
-        except RequestValidationException as e:
-            error_response = (
-                AsyncResponseHelper.get_component().construct_error_async_response(
-                    request, e
-                )
-            )
-            return error_response
         await asyncio.create_task(
-            self.handle_service_and_resolve_callback(request, correlation_id, "resolve")
+            self.handle_service_and_resolve_callback(
+                resolve_request, correlation_id, "resolve"
+            )
         )
         return AsyncResponseHelper.get_component().construct_success_async_response(
-            request,
+            resolve_request,
             correlation_id,
         )
 
-    async def unlink_async(self, request: Request):
+    async def unlink_async(self, unlink_request: UnlinkRequest):
         correlation_id = str(uuid.uuid4())
         try:
-            RequestValidation.validate_request(request)
-            RequestValidation.validate_unlink_async_request_header(request)
+            RequestValidation.get_component().validate_request(unlink_request)
+            RequestValidation.get_component().validate_unlink_async_request_header(
+                unlink_request
+            )
         except RequestValidationException as e:
             error_response = (
                 AsyncResponseHelper.get_component().construct_error_async_response(
-                    request, e
+                    unlink_request, e
                 )
             )
             return error_response
         await asyncio.create_task(
-            self.handle_service_and_resolve_callback(request, correlation_id, "unlink")
+            self.handle_service_and_resolve_callback(
+                unlink_request, correlation_id, "unlink"
+            )
         )
         return AsyncResponseHelper.get_component().construct_success_async_response(
-            request,
+            unlink_request,
             correlation_id,
         )
 
     async def handle_service_and_link_callback(
-        self, request: Request, correlation_id: str, action: str
+        self, link_request: LinkRequest, correlation_id: str, action: str
     ):
         try:
-            RequestValidation.validate_async_request(request)
-            RequestValidation.validate_link_async_request_header(request)
+            RequestValidation.get_component().validate_async_request(link_request)
+            RequestValidation.get_component().validate_link_async_request_header(
+                link_request
+            )
             single_link_responses: list[
                 SingleLinkResponse
-            ] = await self.action_to_method[action](request)
+            ] = await self.action_to_method[action](link_request)
 
             async_call_back_request: (
                 AsyncCallbackRequest
             ) = AsyncResponseHelper.get_component().construct_success_async_callback_link_request(
-                request, correlation_id, single_link_responses
+                link_request, correlation_id, single_link_responses
             )
             await self.make_callback(
                 async_call_back_request,
-                url=request.header.sender_uri,
+                url=link_request.header.sender_uri,
                 url_suffix=f"/on-{action}",
             )
         except RequestValidationException as e:
             _logger.error(f"Error in handle_service_and_callback: {e}")
-            AsyncResponseHelper.get_component().construct_error_async_callback_request(
-                request, e
+            error_response = AsyncResponseHelper.get_component().construct_error_async_callback_request(
+                link_request, e
+            )
+            await self.make_callback(
+                error_response,
+                url=link_request.header.sender_uri,
+                url_suffix=f"/on-{action}",
             )
-            # await self.make_callback(
-            #     error_response,
-            #     url=request.header.sender_uri,
-            #     url_suffix=f"/on-{action}",
-            # )
 
     async def handle_service_and_update_callback(
         self, request: Request, correlation_id: str, action: str
     ):
         try:
-            RequestValidation.validate_async_request(request)
-            RequestValidation.validate_update_async_request_header(request)
+            RequestValidation.get_component().validate_async_request(request)
+            RequestValidation.get_component().validate_update_async_request_header(
+                request
+            )
             single_update_responses: list[
                 SingleUpdateResponse
             ] = await self.action_to_method[action](request)
@@ -220,8 +216,10 @@ async def handle_service_and_resolve_callback(
         self, request: Request, correlation_id: str, action: str
     ):
         try:
-            RequestValidation.validate_async_request(request)
-            RequestValidation.validate_resolve_async_request_header(request)
+            RequestValidation.get_component().validate_async_request(request)
+            RequestValidation.get_component().validate_resolve_async_request_header(
+                request
+            )
             single_resolve_responses: list[
                 SingleResolveResponse
             ] = await self.action_to_method[action](request)
@@ -250,8 +248,10 @@ async def handle_service_and_unlink_callback(
         self, request: Request, correlation_id: str, action: str
     ):
         try:
-            RequestValidation.validate_async_request(request)
-            RequestValidation.validate_unlink_async_request_header(request)
+            RequestValidation.get_component().validate_async_request(request)
+            RequestValidation.get_component().validate_unlink_async_request_header(
+                request
+            )
             single_unlink_responses: list[
                 SingleUnlinkResponse
             ] = await self.action_to_method[action](request)

src/openg2p_spar_mapper_api/controllers/sync_mapper_controller.py

@@ -1,16 +1,16 @@
 from openg2p_fastapi_common.controller import BaseController
-from openg2p_g2pconnect_common_lib.common.schemas import (
-    Request,
-    SyncResponse,
-)
-from openg2p_g2pconnect_common_lib.mapper.schemas.link import (
+from openg2p_g2pconnect_common_lib.mapper.schemas import (
+    LinkRequest,
+    LinkResponse,
+    ResolveRequest,
+    ResolveResponse,
     SingleLinkResponse,
-)
-from openg2p_g2pconnect_common_lib.mapper.schemas.resolve import (
     SingleResolveResponse,
-)
-from openg2p_g2pconnect_common_lib.mapper.schemas.update import (
     SingleUpdateResponse,
+    UnlinkRequest,
+    UnlinkResponse,
+    UpdateRequest,
+    UpdateResponse,
 )
 
 from ..services import (
@@ -33,110 +33,116 @@ def __init__(self, **kwargs):
         self.router.add_api_route(
             "/link",
             self.link_sync,
-            responses={200: {"model": SyncResponse}},
+            responses={200: {"model": LinkResponse}},
             methods=["POST"],
         )
         self.router.add_api_route(
             "/update",
             self.update_sync,
-            responses={200: {"model": SyncResponse}},
+            responses={200: {"model": UpdateResponse}},
             methods=["POST"],
         )
         self.router.add_api_route(
             "/resolve",
             self.resolve_sync,
-            responses={200: {"model": SyncResponse}},
+            responses={200: {"model": ResolveResponse}},
             methods=["POST"],
         )
         self.router.add_api_route(
             "/unlink",
             self.unlink_sync,
-            responses={200: {"model": SyncResponse}},
+            responses={200: {"model": UnlinkResponse}},
             methods=["POST"],
         )
 
-    async def link_sync(self, request: Request):
+    async def link_sync(self, link_request: LinkRequest):
         try:
-            RequestValidation.validate_request(request)
-            RequestValidation.validate_link_request_header(request)
+            RequestValidation.get_component().validate_request(link_request)
+            RequestValidation.get_component().validate_link_request_header(link_request)
         except RequestValidationException as e:
             error_response = (
                 SyncResponseHelper.get_component().construct_error_sync_response(
-                    request, e
+                    link_request, e
                 )
             )
             return error_response
 
         single_link_responses: list[
             SingleLinkResponse
-        ] = await self.mapper_service.link(request)
+        ] = await self.mapper_service.link(link_request)
         return SyncResponseHelper.get_component().construct_success_sync_link_response(
-            request,
+            link_request,
             single_link_responses,
         )
 
-    async def update_sync(self, request: Request):
+    async def update_sync(self, update_request: UpdateRequest):
         try:
-            RequestValidation.validate_request(request)
-            RequestValidation.validate_update_request_header(request)
+            RequestValidation.get_component().validate_request(update_request)
+            RequestValidation.get_component().validate_update_request_header(
+                update_request
+            )
         except RequestValidationException as e:
             error_response = (
                 SyncResponseHelper.get_component().construct_error_sync_response(
-                    request, e
+                    update_request, e
                 )
             )
             return error_response
 
         single_update_responses: list[
             SingleUpdateResponse
-        ] = await self.mapper_service.update(request)
+        ] = await self.mapper_service.update(update_request)
         return (
             SyncResponseHelper.get_component().construct_success_sync_update_response(
-                request,
+                update_request,
                 single_update_responses,
             )
         )
 
-    async def resolve_sync(self, request: Request):
+    async def resolve_sync(self, resolve_request: ResolveRequest):
         try:
-            RequestValidation.validate_request(request)
-            RequestValidation.validate_resolve_request_header(request)
+            RequestValidation.get_component().validate_request(resolve_request)
+            RequestValidation.get_component().validate_resolve_request_header(
+                resolve_request
+            )
         except RequestValidationException as e:
             error_response = (
                 SyncResponseHelper.get_component().construct_error_sync_response(
-                    request, e
+                    resolve_request, e
                 )
             )
             return error_response
 
         single_resolve_responses: list[
             SingleResolveResponse
-        ] = await self.mapper_service.resolve(request)
+        ] = await self.mapper_service.resolve(resolve_request)
         return (
             SyncResponseHelper.get_component().construct_success_sync_resolve_response(
-                request,
+                resolve_request,
                 single_resolve_responses,
             )
         )
 
-    async def unlink_sync(self, request: Request):
+    async def unlink_sync(self, unlink_request: UnlinkRequest):
         try:
-            RequestValidation.validate_request(request)
-            RequestValidation.validate_unlink_request_header(request)
+            RequestValidation.get_component().validate_request(unlink_request)
+            RequestValidation.get_component().validate_unlink_request_header(
+                unlink_request
+            )
         except RequestValidationException as e:
             error_response = (
                 SyncResponseHelper.get_component().construct_error_sync_response(
-                    request, e
+                    unlink_request, e
                 )
             )
             return error_response
 
         single_unlink_responses: list[
             SingleResolveResponse
-        ] = await self.mapper_service.unlink(request)
+        ] = await self.mapper_service.unlink(unlink_request)
         return (
             SyncResponseHelper.get_component().construct_success_sync_unlink_response(
-                request,
+                unlink_request,
                 single_unlink_responses,
             )
         )