rationalise schemas

Author: nhsd-david-wass

lambdas/supplier-allocator/src/handler/allocate-handler.ts

@@ -17,10 +17,6 @@ function resolveSupplierForVariant(
   deps: Deps,
 ): SupplierSpec {
   deps.logger.info({ variantId }, "Resolving supplier for letter variant");
-  deps.logger.info(
-    { variantMap: deps.env.VARIANT_MAP },
-    "Current variant to supplier mapping",
-  );
   return deps.env.VARIANT_MAP[variantId];
 }
 
@@ -53,13 +49,17 @@ export default function createSupplierAllocatorHandler(deps: Deps): SQSHandler {
         deps.logger.info({
           description: "Extracted letter event",
           messageId: record.messageId,
-          event: letterEvent,
         });
 
         validateType(letterEvent);
 
         const supplierSpec = getSupplier(letterEvent as PreparedEvents, deps);
 
+        deps.logger.info({
+          description: "Resolved supplier spec",
+          supplierSpec,
+        });
+
         // Send to allocated letters queue
         const queueUrl = process.env.UPSERT_LETTERS_QUEUE_URL;
         if (!queueUrl) {
@@ -70,10 +70,6 @@ export default function createSupplierAllocatorHandler(deps: Deps): SQSHandler {
           letterEvent,
           supplierSpec,
         };
-        deps.logger.info(
-          { msg: queueMessage, url: queueUrl },
-          "Prepared message for upsert letter queue",
-        );
 
         deps.logger.info(
           { msg: queueMessage, url: queueUrl },

lambdas/upsert-letter/src/handler/__tests__/upsert-handler.test.ts

@@ -283,12 +283,8 @@ describe("createUpsertLetterHandler", () => {
   test("unknown supplier has metric emitted with 'unknown' supplier dimension", async () => {
     const letterEvent = createSupplierStatusChangeEventWithoutSupplier();
 
-    const message = {
-      letterEvent,
-      supplierSpec: undefined,
-    };
     const evt: SQSEvent = createSQSEvent([
-      createSqsRecord("unknown-supplier", JSON.stringify(message)),
+      createSqsRecord("unknown-supplier", JSON.stringify(letterEvent)),
     ]);
 
     await createUpsertLetterHandler(mockedDeps)(evt, {} as any, {} as any);

lambdas/upsert-letter/src/handler/upsert-handler.ts

@@ -24,17 +24,16 @@ const SupplierSpecSchema = z.object({
   specId: z.string().min(1),
 });
 
-const LetterEventUnionSchema = z.discriminatedUnion("type", [
+const PreparedEventUnionSchema = z.discriminatedUnion("type", [
   $LetterRequestPreparedEventV2,
   $LetterRequestPreparedEvent,
-  $LetterEvent,
 ]);
 
 const QueueMessageSchema = z.union([
   $LetterEvent,
   z.object({
-    letterEvent: LetterEventUnionSchema,
-    supplierSpec: SupplierSpecSchema.optional(),
+    letterEvent: PreparedEventUnionSchema,
+    supplierSpec: SupplierSpecSchema,
   }),
 ]);
 
@@ -190,13 +189,9 @@ export default function createUpsertLetterHandler(deps: Deps): SQSHandler {
             message: record.body,
           });
           const queueMessage = JSON.parse(record.body);
-          deps.logger.info({
-            description: "Parsed message body",
-            messageId: record.messageId,
-            queueMessage,
-          });
 
           const result = QueueMessageSchema.safeParse(queueMessage);
+
           if (!result.success) {
             throw new Error(
               `Message did not match expected schema: ${JSON.stringify(
@@ -218,7 +213,7 @@ export default function createUpsertLetterHandler(deps: Deps): SQSHandler {
           deps.logger.info({
             description: "Extracted letter event",
             messageId: record.messageId,
-            event: letterEvent,
+            type: letterEvent,
             supplier: supplierSpec,
           });
 
@@ -228,11 +223,6 @@ export default function createUpsertLetterHandler(deps: Deps): SQSHandler {
               : supplierSpec.supplierId;
 
           const operation = getOperationFromType(letterEvent.type);
-          deps.logger.info({
-            description: "Determined operation from event type",
-            messageId: record.messageId,
-            operation: operation.name,
-          });
 
           await runUpsert(
             operation,