CCM-15256: PDF Component

Author: ScottFullerton-NHSE

lambdas/print-analyser/src/__tests__/apis/sqs-handler.test.ts

@@ -42,6 +42,15 @@ describe('SQS Handler', () => {
       const testPdf = fivePagePdf();
       mockGetS3ObjectBufferFromUri.mockResolvedValue(testPdf);
 
+      eventPublisher.sendEvents.mockImplementation(
+        async (events, validateFn) => {
+          for (const event of events) {
+            validateFn(event, logger);
+          }
+          return [];
+        },
+      );
+
       const response = await handler(recordEvent([fileSafeEvent]));
 
       expect(mockGetS3ObjectBufferFromUri).toHaveBeenCalledWith(
@@ -206,5 +215,79 @@ describe('SQS Handler', () => {
         batchItemFailures: [{ itemIdentifier: '1' }],
       });
     });
+
+    it('should publish InvalidAttachmentReceived event when PDF parsing fails (non-PDF attachment)', async () => {
+      const testPdfBuffer = Buffer.from('not a valid PDF file');
+      mockGetS3ObjectBufferFromUri.mockResolvedValue(testPdfBuffer);
+
+      eventPublisher.sendEvents.mockImplementation(
+        async (events, validateFn) => {
+          for (const event of events) {
+            validateFn(event, logger);
+          }
+          return [];
+        },
+      );
+
+      const event = recordEvent([fileSafeEvent]);
+
+      const result = await handler(event);
+
+      expect(eventPublisher.sendEvents).toHaveBeenCalledWith(
+        [
+          {
+            ...fileSafeEvent,
+            id: '550e8400-e29b-41d4-a716-446655440001',
+            time: '2023-06-20T12:00:00.250Z',
+            recordedtime: '2023-06-20T12:00:00.250Z',
+            dataschema:
+              'https://notify.nhs.uk/cloudevents/schemas/digital-letters/2025-10-draft/data/digital-letters-print-invalid-attachment-received-data.schema.json',
+            type: 'uk.nhs.notify.digital.letters.print.invalid.attachment.received.v1',
+            source:
+              '/nhs/england/notify/production/primary/digitalletters/print',
+            data: {
+              senderId: fileSafeEvent.data.senderId,
+              messageReference: fileSafeEvent.data.messageReference,
+              reasonCode: 'DL_CLIV_002',
+            },
+          },
+        ],
+        expect.any(Function),
+      );
+
+      expect(logger.warn).toHaveBeenCalledWith({
+        messageReference: fileSafeEvent.data.messageReference,
+        reasonCode: 'DL_CLIV_002',
+        description: 'Failed to analyze PDF - invalid attachment format',
+      });
+
+      expect(logger.info).toHaveBeenCalledWith(
+        '1 of 1 records processed successfully',
+      );
+
+      expect(result).toEqual({ batchItemFailures: [] });
+    });
+
+    it('should throw error for unknown event type during validation', async () => {
+      const testPdf = fivePagePdf();
+      mockGetS3ObjectBufferFromUri.mockResolvedValue(testPdf);
+
+      eventPublisher.sendEvents.mockImplementation(
+        async (events, validateFn) => {
+          const modifiedEvent = {
+            ...events[0],
+            type: 'uk.nhs.notify.unknown.event.type',
+          };
+          validateFn(modifiedEvent, logger);
+          return [];
+        },
+      );
+
+      const event = recordEvent([fileSafeEvent]);
+
+      await expect(handler(event)).rejects.toThrow(
+        'Unknown event type: uk.nhs.notify.unknown.event.type',
+      );
+    });
   });
 });

lambdas/print-analyser/src/apis/sqs-handler.ts

@@ -7,8 +7,10 @@ import { createHash, randomUUID } from 'node:crypto';
 import { PDFDocument } from 'pdf-lib';
 import {
   FileSafe,
+  InvalidAttachmentReceived,
   PDFAnalysed,
   validateFileSafe,
+  validateInvalidAttachmentReceived,
   validatePDFAnalysed,
 } from 'digital-letters-events';
 import { EventPublisher, Logger, getS3ObjectBufferFromUri } from 'utils';
@@ -81,6 +83,33 @@ function generateUpdatedEvent(event: FileSafe, pdfInfo: PdfInfo): PDFAnalysed {
   };
 }
 
+function generateInvalidAttachmentEvent(
+  event: FileSafe,
+): InvalidAttachmentReceived {
+  const eventTime = new Date().toISOString();
+
+  const {
+    data: { messageReference, senderId },
+  } = event;
+
+  return {
+    ...event,
+    id: randomUUID(),
+    time: eventTime,
+    recordedtime: eventTime,
+    dataschema:
+      'https://notify.nhs.uk/cloudevents/schemas/digital-letters/2025-10-draft/data/digital-letters-print-invalid-attachment-received-data.schema.json',
+    type: 'uk.nhs.notify.digital.letters.print.invalid.attachment.received.v1',
+    // NOTE: CCM-13892 Generate event digital letters source property from scratch
+    source: '/nhs/england/notify/production/primary/digitalletters/print',
+    data: {
+      senderId,
+      messageReference,
+      reasonCode: 'DL_CLIV_002',
+    },
+  };
+}
+
 async function analysePdf(pdf: Buffer): Promise<PdfInfo> {
   const doc = await PDFDocument.load(pdf);
   const pageCount = doc.getPageCount();
@@ -97,7 +126,7 @@ export const createHandler = ({
     const receivedItemCount = sqsEvent.Records.length;
     const batchItemFailures: SQSBatchItemFailure[] = [];
     const validatedRecords: ValidatedRecord[] = [];
-    const validEvents: PDFAnalysed[] = [];
+    const validEvents: (PDFAnalysed | InvalidAttachmentReceived)[] = [];
 
     logger.info(`Received SQS Event of ${receivedItemCount} record(s)`);
 
@@ -120,16 +149,47 @@ export const createHandler = ({
           const pdfInfo = await analysePdf(pdfBuffer);
           validEvents.push(generateUpdatedEvent(event, pdfInfo));
         } catch (error: any) {
-          logger.warn({
-            err: error.message,
-            description: 'Failed processing message',
-          });
-          batchItemFailures.push({ itemIdentifier: validatedRecord.messageId });
+          const isPdfParsingError =
+            error.message?.includes('PDF') ||
+            error.message?.includes('parse') ||
+            error.message?.includes('Invalid') ||
+            error.name === 'PDFParsingError';
+
+          if (isPdfParsingError) {
+            const invalidAttachmentEvent = generateInvalidAttachmentEvent(
+              validatedRecord.event,
+            );
+            validEvents.push(invalidAttachmentEvent);
+            logger.warn({
+              messageReference: validatedRecord.event.data.messageReference,
+              reasonCode: 'DL_CLIV_002',
+              description: 'Failed to analyze PDF - invalid attachment format',
+            });
+          } else {
+            logger.warn({
+              err: error.message,
+              description: 'Failed processing message',
+            });
+            batchItemFailures.push({
+              itemIdentifier: validatedRecord.messageId,
+            });
+          }
         }
       }),
     );
 
-    await eventPublisher.sendEvents(validEvents, validatePDFAnalysed);
+    await eventPublisher.sendEvents(validEvents, (event) => {
+      if (event.type.includes('pdf.analysed')) {
+        return validatePDFAnalysed(event as PDFAnalysed, logger);
+      }
+      if (event.type.includes('invalid.attachment.received')) {
+        return validateInvalidAttachmentReceived(
+          event as InvalidAttachmentReceived,
+          logger,
+        );
+      }
+      throw new Error(`Unknown event type: ${event.type}`);
+    });
 
     const processedItemCount = receivedItemCount - batchItemFailures.length;
     logger.info(