VED-755: refactor handler

Author: Akol125

lambdas/id_sync/README.md

@@ -28,8 +28,4 @@
 
 - Code is located in the `lambdas/id_sync/src/` directory.
 - Unit tests are in the `lambdas/id_sync/tests/` directory.
-- Use the provided Makefile and Dockerfile for building, testing, and packaging.
-
-## License
-
-This project is maintained by NHS. See [LICENSE](../LICENSE) for details.
+- Use the provided Makefile and Dockerfile for building, testing, and packaging.

lambdas/id_sync/src/id_sync.py

@@ -1,46 +1,53 @@
-from common.clients import logger
-from common.clients import STREAM_NAME
+from typing import Any, Dict
+
+from common.clients import logger, STREAM_NAME
 from common.log_decorator import logging_decorator
 from common.aws_lambda_event import AwsLambdaEvent
 from exceptions.id_sync_exception import IdSyncException
 from record_processor import process_record
-'''
-Lambda function handler for processing SQS events.Lambda for ID Sync. Fired by SQS
-'''
 
+"""
+- Parses the incoming AWS event into `AwsLambdaEvent` and iterate its `records`.
+- Delegate each record to `process_record` and collect `nhs_number` from each result.
+- If any record has status == "error" raise `IdSyncException` with aggregated nhs_numbers.
+- Any unexpected error is wrapped into `IdSyncException(message="Error processing id_sync event")`.
+"""
 
 @logging_decorator(prefix="id_sync", stream_name=STREAM_NAME)
-def handler(event_data, _):
-
+def handler(event_data: Dict[str, Any], _context) -> Dict[str, Any]:
     try:
         logger.info("id_sync handler invoked")
         event = AwsLambdaEvent(event_data)
-        record_count = len(event.records)
-        if record_count > 0:
-            logger.info("id_sync processing event with %d records", record_count)
-            error_count = 0
-            nhs_numbers = []
-            for record in event.records:
-                record_result = process_record(record)
-                nhs_numbers.append(record_result["nhs_number"])
-                if record_result["status"] == "error":
-                    error_count += 1
-            if error_count > 0:
-                raise IdSyncException(message=f"Processed {record_count} records with {error_count} errors",
-                                      nhs_numbers=nhs_numbers)
-
-            else:
-                response = {"status": "success",
-                            "message": f"Successfully processed {record_count} records",
-                            "nhs_numbers": nhs_numbers}
-        else:
-            response = {"status": "success", "message": "No records found in event"}
+        records = event.records
+
+        if not records:
+            return {"status": "success", "message": "No records found in event"}
+
+        logger.info("id_sync processing event with %d records", len(records))
+
+        # Process records in order. Let any unexpected exception bubble to the outer handler
+        # so tests that expect a wrapped IdSyncException keep working.
+        results = [process_record(record) for record in records]
+        nhs_numbers = [result["nhs_number"] for result in results]
+        error_count = sum(1 for result in results if result.get("status") == "error")
+
+        if error_count:
+            raise IdSyncException(message=f"Processed {len(records)} records with {error_count} errors",
+                                  nhs_numbers=nhs_numbers)
+
+        response = {"status": "success",
+                    "message": f"Successfully processed {len(records)} records",
+                    "nhs_numbers": nhs_numbers}
+
         logger.info("id_sync handler completed: %s", response)
         return response
+
     except IdSyncException as e:
+        # Preserve domain exceptions but ensure they're logged
         logger.exception(f"id_sync error: {e.message}")
-        raise e
-    except Exception as e:
+        raise
+    except Exception:
         msg = "Error processing id_sync event"
         logger.exception(msg)
-        raise IdSyncException(message=msg, exception=e)
+        # Raise a domain exception with a predictable message for callers/tests
+        raise IdSyncException(message=msg)

lambdas/id_sync/src/pds_details.py

@@ -48,7 +48,6 @@ def pds_get_patient_id(nhs_number: str) -> str:
 
         return patient_details["identifier"][0]["value"]
 
-    # ✅ Remove the IdSyncException catch since you're just re-raising
     except Exception as e:
         msg = f"Error getting PDS patient ID for {nhs_number}"
         logger.exception(msg)