WIP

Author: nhsd-angel-pastor

lambdas/core-notifier/src/__tests__/app/notify-api-client.test.ts

@@ -5,10 +5,7 @@ import axios, {
   type AxiosResponse,
   type AxiosStatic,
 } from 'axios';
-import {
-  RetryErrorConditionFn,
-  conditionalRetry as _retry,
-} from 'utils';
+import { RetryErrorConditionFn, conditionalRetry as _retry } from 'utils';
 import type { Logger } from 'utils';
 import { mockRequest1, mockResponse } from '__tests__/constants';
 import { IAccessTokenRepository, NotifyClient } from 'app/notify-api-client';

lambdas/core-notifier/src/apis/sqs-handler.ts

@@ -4,24 +4,24 @@ import type {
   SQSEvent,
   SQSRecord,
 } from 'aws-lambda';
-import { Logger } from 'utils';
-// import { SenderManagement } from 'sender-management';
+import { Logger, Sender } from 'utils';
+import { PDMResourceAvailable } from 'digital-letters-events';
 import { mapQueueToRequest } from 'domain/mapper';
 import { parseSqsRecord } from 'app/parse-sqs-message';
 
 import type { NotifyMessageProcessor } from 'app/notify-message-processor';
-import { SenderRepository } from 'sender-management/src/infra/sender-repository/repository';
+import { SenderManagement } from 'sender-management';
 
 export interface SqsHandlerDependencies {
   notifyMessageProcessor: NotifyMessageProcessor;
   logger: Logger;
-  senderRepository: SenderRepository;
+  senderManagement: SenderManagement;
 }
 
 export const createHandler = ({
-  notifyMessageProcessor,
   logger,
-  senderRepository,
+  notifyMessageProcessor,
+  senderManagement,
 }: SqsHandlerDependencies) =>
   async function handler(sqsEvent: SQSEvent): Promise<SQSBatchResponse> {
     const receivedItemCount = sqsEvent.Records.length;
@@ -33,8 +33,15 @@ export const createHandler = ({
     await Promise.all(
       sqsEvent.Records.map(async (sqsRecord: SQSRecord) => {
         try {
-          const incoming = parseSqsRecord(sqsRecord, logger);
-          const request = mapQueueToRequest(incoming, senderRepository);
+          const incoming: PDMResourceAvailable = parseSqsRecord(
+            sqsRecord,
+            logger,
+          );
+          const sender: Sender = senderManagement.getSender(
+            incoming.data.senderId,
+          );
+
+          const request = mapQueueToRequest(incoming, senderManagement);
           await notifyMessageProcessor.process(request);
         } catch (error: any) {
           logger.warn({

lambdas/core-notifier/src/app/notify-api-client.ts

@@ -6,14 +6,9 @@ import type {
   SingleMessageResponse,
 } from 'domain/request';
 import { RequestAlreadyReceivedError } from 'domain/request-already-received-error';
-import {
-  IAccessibleService,
-  RetryConfig,
-  conditionalRetry,
-} from 'utils';
+import { IAccessibleService, RetryConfig, conditionalRetry } from 'utils';
 import type { Logger } from 'utils';
 
-
 export interface IAccessTokenRepository {
   getAccessToken(): Promise<string>;
 }
@@ -29,9 +24,9 @@ export interface INotifyClient {
   ): Promise<SingleMessageResponse>;
 }
 /*
-* Client for sending requests to the NHS Notify API using FHIR API, see
-*  https://digital.nhs.uk/developer/api-catalogue/nhs-notify
-*/
+ * Client for sending requests to the NHS Notify API using FHIR API, see
+ *  https://digital.nhs.uk/developer/api-catalogue/nhs-notify
+ */
 export class NotifyClient implements INotifyClient, IAccessibleService {
   private client: AxiosInstance;
 

lambdas/core-notifier/src/app/notify-message-processor.ts

@@ -10,6 +10,7 @@ type Dependencies = {
 
 export class NotifyMessageProcessor {
   private readonly logger: Logger;
+
   private readonly nhsNotifyClient: NotifyClient;
 
   constructor({ logger, nhsNotifyClient }: Dependencies) {

lambdas/core-notifier/src/app/parse-sqs-message.ts

@@ -1,23 +1,32 @@
 import { SQSRecord } from 'aws-lambda';
 import { Logger } from 'utils';
-import { NudgeCommand } from 'domain/nudge-command';
-import { $NudgeCommand } from 'app/nudge-command-validator';
+import { PDMResourceAvailable } from 'digital-letters-events';
+import { InvalidPdmResourceAvailableEvent } from 'domain/invalid-pdm-resource-available-event';
+import { messageDownloadedValidator } from 'digital-letters-events/PDMResourceAvailable.js';
 
 export const parseSqsRecord = (
   sqsRecord: SQSRecord,
   logger: Logger,
-): NudgeCommand => {
+): PDMResourceAvailable => {
   logger.info('Parsing SQS Record', {
     messageId: sqsRecord.messageId,
   });
+  const sqsEventBody = JSON.parse(sqsRecord.body);
+  const sqsEventDetail = sqsEventBody.detail;
+  const isEventValid = messageDownloadedValidator(sqsEventDetail);
+  if (!isEventValid) {
+    logger.error({
+      err: messageDownloadedValidator.errors,
+      description:
+        'The SQS message does not contain a valid PDMResourceAvailable event',
+      messageId: sqsRecord.messageId,
+    });
+    throw new InvalidPdmResourceAvailableEvent(sqsRecord.messageId);
+  }
 
-  const jsonParsed = JSON.parse(sqsRecord.body) as NudgeCommand;
-  const zodParsed = $NudgeCommand.parse(jsonParsed);
-
-  logger.info('Parsed SQS Record as Nudge Command Event', {
+  logger.info('Parsed valid PDMResourceAvailable Event', {
     messageId: sqsRecord.messageId,
-    sourceEventId: zodParsed.sourceEventId,
   });
 
-  return zodParsed;
+  return sqsEventDetail as PDMResourceAvailable;
 };

lambdas/core-notifier/src/container.ts

@@ -1,20 +1,14 @@
-import {
-  ParameterStoreCache,
-  createGetApimAccessToken,
-  logger,
-} from 'utils';
+import { ParameterStoreCache, createGetApimAccessToken, logger } from 'utils';
 import { NotifyClient } from 'app/notify-api-client';
 import { NotifyMessageProcessor } from 'app/notify-message-processor';
 import type { SqsHandlerDependencies } from 'apis/sqs-handler';
 import { loadConfig } from 'infra/config';
-import { SenderRepository } from 'sender-management/src/infra/sender-repository';
+import { SenderManagement } from '@sender-management';
 
 export async function createContainer(): Promise<SqsHandlerDependencies> {
   const parameterStore = new ParameterStoreCache();
   const config = loadConfig();
-  const senderRepository = new SenderRepository({
-    config,
-    logger,
+  const senderManagement = new SenderManagement({
     parameterStore,
   });
 
@@ -38,8 +32,8 @@ export async function createContainer(): Promise<SqsHandlerDependencies> {
   });
 
   return {
-    notifyMessageProcessor: notifyMessageProcessor,
+    notifyMessageProcessor,
     logger,
-    senderRepository
+    senderManagement,
   };
 }

lambdas/core-notifier/src/domain/invalid-pdm-resource-available-event.ts

@@ -0,0 +1,8 @@
+export class InvalidPdmResourceAvailableEvent extends Error {
+  readonly sqsMessageId: string;
+
+  constructor(sqsMessageId: string) {
+    super('Unable to parse PDMResourceAvailable event from SQS message');
+    this.sqsMessageId = sqsMessageId;
+  }
+}

lambdas/core-notifier/src/domain/mapper.ts

@@ -0,0 +1,34 @@
+import { logger, Sender } from 'utils';
+import { PDMResourceAvailable } from 'digital-letters-events';
+import type { SingleMessageRequest } from 'domain/request';
+
+export function mapQueueToRequest(
+  pdmResourceAvailable: PDMResourceAvailable,
+  sender: Sender,
+): SingleMessageRequest {
+  const data = pdmResourceAvailable.data;
+  const messageReference = data.messageReference;
+
+  logger.info(`Mapping resource available with reference: ${messageReference} for sender: ${sender.senderId}`);
+
+  const request: SingleMessageRequest = {
+    data: {
+      type: 'Message',
+      attributes: {
+        sender.routingConfigId!,
+        messageReference,
+        billingReference,
+        recipient: {
+          nhsNumber: data.nhsNumber,
+        },
+        originator: {
+          odsCode: data.odsCode;
+        },
+        personalisation: {
+          digitalLetterURL: `https://www.nhsapp.service.nhs.uk/digital-letters?letterid=${data.resourceId}`,
+        }
+      },
+    },
+  };
+  return request;
+}

lambdas/core-notifier/src/infra/event-publisher-facade.ts

@@ -0,0 +1,30 @@
+import { EventPublisher, Logger } from 'utils';
+import { MessageRequestSubmitted, MessageRequestRejected, MessageRequestSkipped } from 'digital-letters-events';
+import messageRequestSubmittedValidator from 'digital-letters-events/MessageRequestSubmitted.js';
+import messageRequestRejectedValidator from 'digital-letters-events/MessageRequestRejected.js';
+import messageRequestSkippedValidator from 'digital-letters-events/MessageRequestSkipped.js';
+export class EventPublisherFacade {
+    constructor(private readonly messageRequestSubmittedEventPublisher: EventPublisher,
+        private readonly messageRequestSkippedEventPublisher: EventPublisher,
+        private readonly messageRequestRejectedEventPublisher: EventPublisher,
+        private readonly logger: Logger
+    ){}
+
+    async publishMessageRequestSubmitted(events: [MessageRequestSubmitted]): Promise<void>{
+        this.logger.info(`Publishing ${events.length} MessageRequestSubmitted events`);
+        this.messageRequestSubmittedEventPublisher.sendEvents<MessageRequestSubmitted>(
+            events, messageRequestSubmittedValidator);
+    }
+
+    async publishMessageRequestRejected(events: [MessageRequestRejected]): Promise<void>{
+        this.logger.info(`Publishing ${events.length} MessageRequestRejected events`);
+        this.messageRequestRejectedEventPublisher.sendEvents<MessageRequestRejected>(
+            events, messageRequestRejectedValidator);
+    }
+
+    async publishMessageRequestSkipped(events: [MessageRequestSkipped]): Promise<void>{
+        this.logger.info(`Publishing ${events.length} MessageRequestSkipped events`);
+        this.messageRequestSkippedEventPublisher.sendEvents<MessageRequestSkipped>(
+            events, messageRequestSkippedValidator);
+    }
+}