address PR comments

Author: Vlasis-Perdikidis

lambdas/api-handler/src/handlers/post-letters.ts

@@ -5,6 +5,7 @@ import { ApiErrorDetail } from "../contracts/errors";
 import {
   PostLettersRequest,
   PostLettersRequestSchema,
+  UpdateLetterCommand,
 } from "../contracts/letters";
 import ValidationError from "../errors/validation-error";
 import { processError } from "../mappers/error-mapper";
@@ -22,7 +23,7 @@ function duplicateIdsExist(postLettersRequest: PostLettersRequest) {
 /**
  * emits metrics of successful letter updates, including the supplier and grouped by status
  */
-async function emitMetics(
+function emitMetics(
   metrics: MetricsLogger,
   supplierId: string,
   statusesMapping: Map<string, number>,
@@ -36,6 +37,14 @@ async function emitMetics(
   }
 }
 
+function populateStatusesMap(updateLetterCommands: UpdateLetterCommand[]) {
+  const statusMap = new Map<string, number>();
+  for (const command of updateLetterCommands) {
+    statusMap.set(command.status, (statusMap.get(command.status) || 0) + 1);
+  }
+  return statusMap;
+}
+
 export default function createPostLettersHandler(
   deps: Deps,
 ): APIGatewayProxyHandler {
@@ -95,14 +104,18 @@ export default function createPostLettersHandler(
           );
         }
 
-        const statusesMapping = new Map<string, number>();
+        const updateLetterCommands: UpdateLetterCommand[] = mapToUpdateCommands(
+          postLettersRequest,
+          supplierId,
+        );
+        const statusesMapping = populateStatusesMap(updateLetterCommands);
         await enqueueLetterUpdateRequests(
-          mapToUpdateCommands(postLettersRequest, supplierId, statusesMapping),
+          updateLetterCommands,
           commonIds.value.correlationId,
           deps,
         );
 
-        await emitMetics(metrics, supplierId, statusesMapping);
+        emitMetics(metrics, supplierId, statusesMapping);
         return {
           statusCode: 202,
           body: "",

lambdas/api-handler/src/mappers/letter-mapper.ts

@@ -58,24 +58,14 @@ export function mapToUpdateCommand(
 export function mapToUpdateCommands(
   request: PostLettersRequest,
   supplierId: string,
-  statusesMapping?: Map<string, number>,
 ): UpdateLetterCommand[] {
-  return request.data.map((letterToUpdate: PostLettersRequestResource) => {
-    const letterCommand = {
-      id: letterToUpdate.id,
-      supplierId,
-      status: LetterStatus.parse(letterToUpdate.attributes.status),
-      reasonCode: letterToUpdate.attributes.reasonCode,
-      reasonText: letterToUpdate.attributes.reasonText,
-    };
-    if (statusesMapping) {
-      statusesMapping.set(
-        letterCommand.status,
-        (statusesMapping.get(letterCommand.status) || 0) + 1,
-      );
-    }
-    return letterCommand;
-  });
+  return request.data.map((letterToUpdate: PostLettersRequestResource) => ({
+    id: letterToUpdate.id,
+    supplierId,
+    status: LetterStatus.parse(letterToUpdate.attributes.status),
+    reasonCode: letterToUpdate.attributes.reasonCode,
+    reasonText: letterToUpdate.attributes.reasonText,
+  }));
 }
 
 // ---------------------------------------------

lambdas/letter-updates-transformer/src/letter-updates-transformer.ts

@@ -14,6 +14,7 @@ import { MetricsLogger, Unit, metricScope } from "aws-embedded-metrics";
 import mapLetterToCloudEvent from "./mappers/letter-mapper";
 import { Deps } from "./deps";
 import { LetterForEventPub, LetterSchemaForEventPub } from "./types";
+import { string } from "zod";
 
 // SNS PublishBatchCommand supports up to 10 messages per batch
 const BATCH_SIZE = 10;
@@ -39,7 +40,9 @@ export default function createHandler(deps: Deps): Handler<KinesisStreamEvent> {
           mapLetterToCloudEvent(element, deps.env.EVENT_SOURCE),
         );
 
-      const eventTypeCount = new Map<string, number>();
+      const eventTypeCount: Map<string, number> =
+        populateEventTypeMap(cloudEvents);
+      // const eventTypeCount = new Map<string, number>();
       for (const batch of generateBatches(cloudEvents)) {
         deps.logger.info({
           description: "Publishing batch",
@@ -49,22 +52,26 @@ export default function createHandler(deps: Deps): Handler<KinesisStreamEvent> {
         await deps.snsClient.send(
           new PublishBatchCommand({
             TopicArn: deps.env.EVENTPUB_SNS_TOPIC_ARN,
-            PublishBatchRequestEntries: batch.map((element, index) => {
-              eventTypeCount.set(
-                element.type,
-                (eventTypeCount.get(element.type) || 0) + 1,
-              );
-              return buildMessage(element, index);
-            }),
+            PublishBatchRequestEntries: batch.map((element, index) =>
+              buildMessage(element, index),
+            ),
           }),
         );
       }
-      await emitMetrics(metrics, eventTypeCount);
+      emitMetrics(metrics, eventTypeCount);
     };
   });
 }
 
-async function emitMetrics(
+function populateEventTypeMap(cloudEvents: LetterEvent[]) {
+  const evtMap = new Map<string, number>();
+  for (const event of cloudEvents) {
+    evtMap.set(event.type, (evtMap.get(event.type) || 0) + 1);
+  }
+  return evtMap;
+}
+
+function emitMetrics(
   metrics: MetricsLogger,
   eventTypeCount: Map<string, number>,
 ) {

lambdas/mi-updates-transformer/src/mi-updates-transformer.ts

@@ -50,7 +50,7 @@ function extractMIData(record: DynamoDBRecord): MI {
   return MISchema.parse(unmarshall(newImage as any));
 }
 
-async function emitMetrics(
+function emitMetrics(
   metrics: MetricsLogger,
   eventTypeCount: Map<string, number>,
 ) {
@@ -92,7 +92,7 @@ export default function createHandler(deps: Deps): Handler<KinesisStreamEvent> {
           }),
         );
       }
-      await emitMetrics(metrics, eventTypeCount);
+      emitMetrics(metrics, eventTypeCount);
     };
   });
 }