get rest of dbdata

Author: nhsd-david-wass

infrastructure/terraform/components/api/ddb_table_supplier_configuration.tf

@@ -24,6 +24,11 @@ resource "aws_dynamodb_table" "supplier-configuration" {
     name = "entityType"
     type = "S"
   }
+
+  attribute {
+    name = "volumeGroup"
+    type = "S"
+  }
   // The type-index GSI allows us to query for all supplier configurations of a given type (e.g. all letter supplier configurations)
   global_secondary_index {
     name            = "EntityTypeIndex"
@@ -32,6 +37,13 @@ resource "aws_dynamodb_table" "supplier-configuration" {
     projection_type = "ALL"
   }
 
+  global_secondary_index {
+    name            = "volumeGroupIndex"
+    hash_key        = "PK"
+    range_key       = "volumeGroup"
+    projection_type = "ALL"
+  }
+
   point_in_time_recovery {
     enabled = true
   }

internal/datastore/src/supplier-config-repository.ts

@@ -1,6 +1,17 @@
-import { DynamoDBDocumentClient, GetCommand } from "@aws-sdk/lib-dynamodb";
+import {
+  DynamoDBDocumentClient,
+  GetCommand,
+  QueryCommand,
+} from "@aws-sdk/lib-dynamodb";
 import { Logger } from "pino";
-import { $LetterVariant, LetterVariant } from "./SupplierConfigDomain";
+import {
+  $LetterVariant,
+  LetterVariant,
+  $VolumeGroup,
+  VolumeGroup,
+  $SupplierAllocation,
+  SupplierAllocation,
+} from "./SupplierConfigDomain";
 
 export type SupplierConfigRepositoryConfig = {
   supplierConfigTableName: string;
@@ -25,4 +36,39 @@ export class SupplierConfigRepository {
     }
     return $LetterVariant.parse(result.Item);
   }
+
+  async getVolumeGroup(groupId: string): Promise<VolumeGroup> {
+    const result = await this.ddbClient.send(
+      new GetCommand({
+        TableName: this.config.supplierConfigTableName,
+        Key: { PK: "VOLUME_GROUP", SK: groupId },
+      }),
+    );
+    if (!result.Item) {
+      throw new Error(`Volume group with id ${groupId} not found`);
+    }
+    return $VolumeGroup.parse(result.Item);
+  }
+
+  async getSupplierAllocationsForVolumeGroup(
+    groupId: string,
+  ): Promise<SupplierAllocation[]> {
+    const result = await this.ddbClient.send(
+      new QueryCommand({
+        TableName: this.config.supplierConfigTableName,
+        IndexName: "VolumeGroupIndex",
+        KeyConditionExpression: "PK = :pk AND volumeGroup = :groupId",
+        ExpressionAttributeValues: {
+          ":pk": "SUPPLIER_ALLOCATIONS",
+          ":groupId": groupId,
+        },
+      }),
+    );
+    if (!result.Item) {
+      throw new Error(
+        `Supplier allocations for volume group with id ${groupId} not found`,
+      );
+    }
+    return $SupplierAllocation.array().parse(result.Item.items);
+  }
 }

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

@@ -1,7 +1,11 @@
 import { SQSBatchItemFailure, SQSEvent, SQSHandler } from "aws-lambda";
 import { SendMessageCommand } from "@aws-sdk/client-sqs";
 import { LetterRequestPreparedEvent } from "@nhsdigital/nhs-notify-event-schemas-letter-rendering-v1";
-import { LetterVariant } from "internal/datastore/src/SupplierConfigDomain";
+import {
+  LetterVariant,
+  SupplierAllocation,
+  VolumeGroup,
+} from "internal/datastore/src/SupplierConfigDomain";
 import { LetterRequestPreparedEventV2 } from "@nhsdigital/nhs-notify-event-schemas-letter-rendering";
 import z from "zod";
 import { Deps } from "../config/deps";
@@ -46,23 +50,90 @@ function validateType(event: unknown) {
   }
 }
 
-async function getVariantDetails(variantId: string, deps: Deps) {
+async function getVariantDetails(
+  variantId: string,
+  deps: Deps,
+): Promise<LetterVariant> {
   deps.logger.info({
     description: "Fetching letter variant details from database",
     variantId,
   });
 
   const variantDetails: LetterVariant =
     await deps.supplierConfigRepo.getLetterVariant(variantId);
+  if (!variantDetails) {
+    throw new Error(`No letter variant found for id: ${variantId}`);
+  }
+
   deps.logger.info({
     description: "Fetched letter variant details",
     variantId,
     variantDetails,
   });
+  return variantDetails;
+}
+
+async function getVolumeGroupDetails(
+  groupId: string,
+  deps: Deps,
+): Promise<VolumeGroup> {
+  deps.logger.info({
+    description: "Fetching volume group details from database",
+    groupId,
+  });
+
+  const groupDetails = await deps.supplierConfigRepo.getVolumeGroup(groupId);
+  if (!groupDetails) {
+    throw new Error(`No volume group found for id: ${groupId}`);
+  }
+
+  deps.logger.info({
+    description: "Fetched volume group details",
+    groupId,
+    groupDetails,
+  });
+  return groupDetails;
+}
+
+async function getSupplierFromConfig(letterEvent: PreparedEvents, deps: Deps) {
+  if (!letterEvent.data.letterVariantId) {
+    throw new Error("letterVariantId is required in event data");
+  }
+  const variantDetails: LetterVariant = await getVariantDetails(
+    letterEvent.data.letterVariantId,
+    deps,
+  );
+  deps.logger.info({
+    description: "Fetched variant details for letter variant",
+    variantDetails,
+  });
+
+  if (!variantDetails.volumeGroupId) {
+    throw new Error(
+      `No volume group id for variantId: ${letterEvent.data.letterVariantId}`,
+    );
+  }
+
+  const volumeGroupDetails: VolumeGroup = await getVolumeGroupDetails(
+    variantDetails.volumeGroupId,
+    deps,
+  );
+  deps.logger.info({
+    description: "Fetched volume group details for letter variant",
+    volumeGroupDetails,
+  });
+
+  const supplierAllocations: SupplierAllocation[] =
+    await deps.supplierConfigRepo.getSupplierAllocationsForVolumeGroup(
+      variantDetails.volumeGroupId,
+    );
+  deps.logger.info({
+    description: "Fetched supplier allocations for volume group",
+    supplierAllocations,
+  });
 }
 
 function getSupplier(letterEvent: PreparedEvents, deps: Deps): SupplierSpec {
-  getVariantDetails(letterEvent.data.letterVariantId, deps);
   return resolveSupplierForVariant(letterEvent.data.letterVariantId, deps);
 }
 
@@ -81,6 +152,8 @@ export default function createSupplierAllocatorHandler(deps: Deps): SQSHandler {
 
         validateType(letterEvent);
 
+        await getSupplierFromConfig(letterEvent as PreparedEvents, deps);
+
         const supplierSpec = getSupplier(letterEvent as PreparedEvents, deps);
 
         deps.logger.info({