CCM-12613: use new types and validators

Author: Ian-Hodges

lambdas/pdm-uploader-lambda/jest.config.ts

@@ -2,14 +2,4 @@ import { baseJestConfig } from '../../jest.config.base';
 
 const config = baseJestConfig;
 
-config.coveragePathIgnorePatterns = ['/__tests__/', 'cli.ts'];
-config.coverageThreshold = {
-  global: {
-    branches: 90,
-    functions: 100,
-    lines: 90,
-    statements: -10,
-  },
-};
-
 export default config;

lambdas/pdm-uploader-lambda/package.json

@@ -2,6 +2,7 @@
   "dependencies": {
     "@aws-sdk/lib-dynamodb": "^3.908.0",
     "axios": "^1.13.2",
+    "digital-letters-events": "^0.0.1",
     "utils": "^0.0.1",
     "zod": "^4.1.12"
   },

lambdas/pdm-uploader-lambda/src/__tests__/apis/sqs-trigger-lambda.test.ts

@@ -14,12 +14,10 @@ const createValidSQSEvent = (overrides?: Partial<SQSEvent>): SQSEvent => ({
       messageId: 'msg-1',
       body: JSON.stringify({
         detail: {
-          profileversion: '1.0.0',
-          profilepublished: '2025-10',
           id: 'a449d419-e683-4ab4-9291-a0451b5cef8e',
           specversion: '1.0',
           source:
-            '/nhs/england/notify/production/primary/data-plane/digital-letters',
+            '/nhs/england/notify/production/primary/data-plane/digitalletters/mesh',
           subject:
             'customer/920fca11-596a-4eca-9c47-99f624614658/recipient/769acdd4-6a47-496f-999f-76a6fd2c3959',
           type: 'uk.nhs.notify.digital.letters.mesh.inbox.message.downloaded.v1',
@@ -30,11 +28,9 @@ const createValidSQSEvent = (overrides?: Partial<SQSEvent>): SQSEvent => ({
             '00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01',
           datacontenttype: 'application/json',
           dataschema:
-            'https://notify.nhs.uk/cloudevents/schemas/digital-letters/2025-10/digital-letter-base-data.schema.json',
-          dataschemaversion: '1.0',
+            'https://notify.nhs.uk/cloudevents/schemas/digital-letters/2025-10-draft/data/digital-letters-mesh-inbox-message-downloaded-data.schema.json',
           severitytext: 'INFO',
           data: {
-            'digital-letter-id': 'eb4c9442-6f74-437d-8548-76697868c807',
             messageReference: 'test-message-reference',
             senderId: 'test-sender-id',
             messageUri: 's3://bucket/key',
@@ -101,6 +97,7 @@ describe('sqs-trigger-lambda', () => {
             id: '3a2e9238-11f9-41ed-98e4-e519eafb1167',
           }),
         ]),
+        expect.anything(),
       );
       expect(mockLogger.info).toHaveBeenCalledWith(
         expect.objectContaining({
@@ -163,6 +160,7 @@ describe('sqs-trigger-lambda', () => {
             type: 'uk.nhs.notify.digital.letters.pdm.resource.submission.rejected.v1',
           }),
         ]),
+        expect.anything(),
       );
       expect(mockLogger.info).toHaveBeenCalledWith(
         expect.objectContaining({
@@ -217,6 +215,45 @@ describe('sqs-trigger-lambda', () => {
         }),
       );
     });
+
+    it('should handle unhandled promise rejection in processing', async () => {
+      // It's an unlikely scenario due to the try/catch in processRecord, but added for 100% coverage.
+      // Mock logger.error to throw an error, which will cause processRecord to reject
+      const loggerErrorSpy = jest.spyOn(mockLogger, 'error');
+      let callCount = 0;
+      loggerErrorSpy.mockImplementation((() => {
+        callCount += 1;
+        if (callCount === 1) {
+          // First call from processRecord's catch block - throw to cause rejection
+          throw new Error('Logger error causing unhandled rejection');
+        }
+        return mockLogger;
+      }) as any);
+
+      mockUploadToPdm.send.mockRejectedValue(new Error('Upload error'));
+      const handler = createHandler({
+        uploadToPdm: mockUploadToPdm,
+        eventPublisher: mockEventPublisher,
+        logger: mockLogger,
+      });
+      const sqsEvent = createValidSQSEvent();
+
+      const result = await handler(sqsEvent);
+
+      expect(result.batchItemFailures).toEqual([]);
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        expect.objectContaining({
+          err: expect.any(Error),
+        }),
+      );
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        expect.objectContaining({
+          retrieved: 1,
+          sent: 0,
+          failed: 1,
+        }),
+      );
+    });
   });
 
   describe('event publishing', () => {

lambdas/pdm-uploader-lambda/src/__tests__/app/upload-to-pdm.test.ts

@@ -1,6 +1,7 @@
-import { Logger, TtlItemEvent, getS3ObjectFromUri } from 'utils';
 import { UploadToPdm } from 'app/upload-to-pdm';
+import { MESHInboxMessageDownloaded } from 'digital-letters-events';
 import { IPdmClient } from 'infra/pdm-api-client';
+import { Logger, getS3ObjectFromUri } from 'utils';
 
 jest.mock('utils', () => ({
   ...jest.requireActual('utils'),
@@ -12,9 +13,7 @@ describe('UploadToPdm', () => {
   let mockLogger: jest.Mocked<Logger>;
   let uploadToPdm: UploadToPdm;
 
-  const mockEvent: TtlItemEvent = {
-    profileversion: '1.0.0',
-    profilepublished: '2025-10',
+  const mockEvent: MESHInboxMessageDownloaded = {
     id: 'test-event-id',
     specversion: '1.0',
     source: '/nhs/england/notify/production/primary/data-plane/digital-letters',
@@ -27,11 +26,9 @@ describe('UploadToPdm', () => {
     traceparent: '00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01',
     datacontenttype: 'application/json',
     dataschema:
-      'https://notify.nhs.uk/cloudevents/schemas/digital-letters/2025-10/digital-letter-base-data.schema.json',
-    dataschemaversion: '1.0',
+      'https://notify.nhs.uk/cloudevents/schemas/digital-letters/2025-10-draft/data/digital-letters-mesh-inbox-message-downloaded-data.schema.json',
     severitytext: 'INFO',
     data: {
-      'digital-letter-id': 'test-letter-id',
       messageReference: 'test-message-reference',
       senderId: 'test-sender-id',
       messageUri: 's3://bucket/key',

lambdas/pdm-uploader-lambda/src/apis/sqs-trigger-lambda.ts

@@ -9,17 +9,15 @@ import type {
   UploadToPdmOutcome,
   UploadToPdmResult,
 } from 'app/upload-to-pdm';
-import {
-  $TtlItemBusEvent,
-  EventPublisher,
-  Logger,
-  PdmResourceRejectedEvent,
-  PdmResourceSubmittedEvent,
-} from 'utils';
+import messageDownloadedValidator from 'digital-letters-events/MESHInboxMessageDownloaded.js';
+import pdmResourceSubmittedValidator from 'digital-letters-events/PDMResourceSubmitted.js';
+import pdmResourceSubmissionRejectedValidator from 'digital-letters-events/PDMResourceSubmissionRejected.js';
+import { MESHInboxMessageDownloaded } from 'digital-letters-events';
+import { EventPublisher, Logger } from 'utils';
 
 interface ProcessingResult {
   result: UploadToPdmResult;
-  item?: PdmResourceSubmittedEvent | PdmResourceRejectedEvent;
+  item?: MESHInboxMessageDownloaded;
 }
 
 interface CreateHandlerDependencies {
@@ -35,29 +33,29 @@ async function processRecord(
   batchItemFailures: SQSBatchItemFailure[],
 ): Promise<ProcessingResult> {
   try {
-    const {
-      data: item,
-      error: parseError,
-      success: parseSuccess,
-    } = $TtlItemBusEvent.safeParse(JSON.parse(body));
+    const sqsEventBody = JSON.parse(body);
+    const sqsEventDetail = sqsEventBody.detail;
 
-    if (!parseSuccess) {
+    const isEventValid = messageDownloadedValidator(sqsEventDetail);
+    if (!isEventValid) {
       logger.error({
-        err: parseError,
+        err: messageDownloadedValidator.errors,
         description: 'Error parsing queue entry',
       });
       batchItemFailures.push({ itemIdentifier: messageId });
-      return { result: { outcome: 'failed' } };
+      return { result: { outcome: 'failed' }, item: sqsEventDetail };
     }
 
-    const result = await uploadToPdm.send(item.detail);
+    const messageDownloadedEvent: MESHInboxMessageDownloaded = sqsEventDetail;
+
+    const result = await uploadToPdm.send(messageDownloadedEvent);
 
     if (result.outcome === 'failed') {
       batchItemFailures.push({ itemIdentifier: messageId });
-      return { result: { outcome: 'failed' }, item: item.detail };
+      return { result: { outcome: 'failed' }, item: sqsEventDetail };
     }
 
-    return { result, item: item.detail };
+    return { result, item: sqsEventDetail };
   } catch (error) {
     logger.error({
       err: error,
@@ -68,44 +66,41 @@ async function processRecord(
   }
 }
 
+interface CategorizedResults {
+  processed: Record<UploadToPdmOutcome | 'retrieved', number>;
+  successfulItems: { event: MESHInboxMessageDownloaded; resourceId: string }[];
+  failedItems: MESHInboxMessageDownloaded[];
+}
+
 function categorizeResults(
   results: PromiseSettledResult<ProcessingResult>[],
-  successfulEvents: PdmResourceSubmittedEvent[],
-  failedEvents: PdmResourceRejectedEvent[],
   logger: Logger,
-): Record<UploadToPdmOutcome | 'retrieved', number> {
+): CategorizedResults {
   const processed: Record<UploadToPdmOutcome | 'retrieved', number> = {
     retrieved: results.length,
     sent: 0,
     failed: 0,
   };
 
+  const successfulItems: {
+    event: MESHInboxMessageDownloaded;
+    resourceId: string;
+  }[] = [];
+  const failedItems: MESHInboxMessageDownloaded[] = [];
+
   for (const result of results) {
     if (result.status === 'fulfilled') {
       const { item, result: itemResult } = result.value;
       processed[itemResult.outcome] += 1;
 
       if (item) {
         if (itemResult.outcome === 'sent' && itemResult.resourceId) {
-          successfulEvents.push({
-            ...item,
-            data: {
-              'digital-letter-id': item.data['digital-letter-id'],
-              messageReference: item.data.messageReference,
-              senderId: item.data.senderId,
-              resourceId: itemResult.resourceId,
-              retryCount: 0,
-            },
+          successfulItems.push({
+            event: item,
+            resourceId: itemResult.resourceId,
           });
         } else {
-          failedEvents.push({
-            ...item,
-            data: {
-              'digital-letter-id': item.data['digital-letter-id'],
-              messageReference: item.data.messageReference,
-              senderId: item.data.senderId,
-            },
-          });
+          failedItems.push(item);
         }
       }
     } else {
@@ -114,71 +109,89 @@ function categorizeResults(
     }
   }
 
-  return processed;
+  return { processed, successfulItems, failedItems };
 }
 
 async function publishSuccessfulEvents(
-  successfulEvents: PdmResourceSubmittedEvent[],
+  successfulItems: { event: MESHInboxMessageDownloaded; resourceId: string }[],
   eventPublisher: EventPublisher,
   logger: Logger,
 ): Promise<void> {
-  if (successfulEvents.length === 0) return;
+  if (successfulItems.length === 0) return;
 
   try {
     const submittedFailedEvents = await eventPublisher.sendEvents(
-      successfulEvents.map((event) => ({
+      successfulItems.map(({ event, resourceId }) => ({
         ...event,
         id: randomUUID(),
         time: new Date().toISOString(),
         recordedtime: new Date().toISOString(),
         type: 'uk.nhs.notify.digital.letters.pdm.resource.submitted.v1',
+        dataschema:
+          'https://notify.nhs.uk/cloudevents/schemas/digital-letters/2025-10-draft/data/digital-letters-pdm-resource-submitted-data.schema.json',
+        source: event.source.replace(/\/mesh$/, '/pdm'),
+        data: {
+          messageReference: event.data.messageReference,
+          senderId: event.data.senderId,
+          resourceId,
+          retryCount: -1, // Setting to -1 until this field is removed from pdm.resource.submitted.
+        },
       })),
+      pdmResourceSubmittedValidator,
     );
     if (submittedFailedEvents.length > 0) {
       logger.warn({
         description: 'Some successful events failed to publish',
         failedCount: submittedFailedEvents.length,
-        totalAttempted: successfulEvents.length,
+        totalAttempted: successfulItems.length,
       });
     }
   } catch (error) {
     logger.warn({
       err: error,
       description: 'Failed to send successful events to EventBridge',
-      eventCount: successfulEvents.length,
+      eventCount: successfulItems.length,
     });
   }
 }
 
 async function publishFailedEvents(
-  failedEvents: PdmResourceRejectedEvent[],
+  failedItems: MESHInboxMessageDownloaded[],
   eventPublisher: EventPublisher,
   logger: Logger,
 ): Promise<void> {
-  if (failedEvents.length === 0) return;
+  if (failedItems.length === 0) return;
 
   try {
     const rejectedFailedEvents = await eventPublisher.sendEvents(
-      failedEvents.map((event) => ({
+      failedItems.map((event) => ({
         ...event,
         id: randomUUID(),
         time: new Date().toISOString(),
         recordedtime: new Date().toISOString(),
         type: 'uk.nhs.notify.digital.letters.pdm.resource.submission.rejected.v1',
+        dataschema:
+          'https://notify.nhs.uk/cloudevents/schemas/digital-letters/2025-10-draft/data/digital-letters-pdm-resource-submission-rejected-data.schema.json',
+        source: event.source.replace(/\/mesh$/, '/pdm'),
+        data: {
+          messageReference: event.data.messageReference,
+          senderId: event.data.senderId,
+        },
       })),
+      pdmResourceSubmissionRejectedValidator,
     );
     if (rejectedFailedEvents.length > 0) {
       logger.warn({
         description: 'Some failed events failed to publish',
         failedCount: rejectedFailedEvents.length,
-        totalAttempted: failedEvents.length,
+        totalAttempted: failedItems.length,
       });
     }
   } catch (error) {
     logger.warn({
       err: error,
       description: 'Failed to send failed events to EventBridge',
-      eventCount: failedEvents.length,
+      eventCount: failedItems.length,
     });
   }
 }
@@ -190,23 +203,19 @@ export const createHandler = ({
 }: CreateHandlerDependencies) =>
   async function handler(sqsEvent: SQSEvent): Promise<SQSBatchResponse> {
     const batchItemFailures: SQSBatchItemFailure[] = [];
-    const successfulEvents: PdmResourceSubmittedEvent[] = [];
-    const failedEvents: PdmResourceRejectedEvent[] = [];
 
     const promises = sqsEvent.Records.map((record) =>
       processRecord(record, uploadToPdm, logger, batchItemFailures),
     );
 
     const results = await Promise.allSettled(promises);
-    const processed = categorizeResults(
+    const { failedItems, processed, successfulItems } = categorizeResults(
       results,
-      successfulEvents,
-      failedEvents,
       logger,
     );
 
-    await publishSuccessfulEvents(successfulEvents, eventPublisher, logger);
-    await publishFailedEvents(failedEvents, eventPublisher, logger);
+    await publishSuccessfulEvents(successfulItems, eventPublisher, logger);
+    await publishFailedEvents(failedItems, eventPublisher, logger);
 
     logger.info({
       description: 'Processed SQS Event.',