CCM-11600: supplier repository and table

masl2 · masl2 · commit 92991439d721 · 2025-10-30T15:08:05.000Z
diff --git a/infrastructure/terraform/components/api/ddb_table_suppliers.tf b/infrastructure/terraform/components/api/ddb_table_suppliers.tf
@@ -0,0 +1,34 @@
+resource "aws_dynamodb_table" "suppliers" {
+  name         = "${local.csi}-suppliers"
+  billing_mode = "PAY_PER_REQUEST"
+
+  hash_key  = "id"
+  range_key = "apimId"
+
+  ttl {
+    attribute_name = "ttl"
+    enabled        = false
+  }
+
+  global_secondary_index {
+    name            = "supplier-apim-index"
+    hash_key        = "apimId"
+    projection_type = "ALL"
+  }
+
+  attribute {
+    name = "id"
+    type = "S"
+  }
+
+  attribute {
+    name = "apimId"
+    type = "S"
+  }
+
+  point_in_time_recovery {
+    enabled = true
+  }
+
+  tags = var.default_tags
+}
diff --git a/internal/datastore/src/__test__/db.ts b/internal/datastore/src/__test__/db.ts
@@ -31,6 +31,7 @@ export async function setupDynamoDBContainer() {
     endpoint,
     lettersTableName: 'letters',
     miTableName: 'management-info',
+    suppliersTableName: 'suppliers',
     lettersTtlHours: 1,
     miTtlHours: 1
   };
@@ -94,6 +95,29 @@ const createMITableCommand = new CreateTableCommand({
     ]
   });
 
+const createSupplierTableCommand = new CreateTableCommand({
+    TableName: 'suppliers',
+    BillingMode: 'PAY_PER_REQUEST',
+    KeySchema: [
+      { AttributeName: 'id', KeyType: 'HASH' }  // Partition key
+    ],
+    GlobalSecondaryIndexes: [
+      {
+        IndexName: 'supplier-apim-index',
+        KeySchema: [
+          { AttributeName: 'apimId', KeyType: 'HASH' } // Partition key for GSI
+        ],
+        Projection: {
+          ProjectionType: 'ALL'
+        }
+      }
+    ],
+    AttributeDefinitions: [
+      { AttributeName: 'id', AttributeType: 'S' },
+      { AttributeName: 'apimId', AttributeType: 'S' }
+    ]
+  });
+
 
 export async function createTables(context: DBContext) {
   const { ddbClient } = context;
@@ -102,6 +126,7 @@ export async function createTables(context: DBContext) {
   await ddbClient.send(updateTimeToLiveCommand);
 
   await ddbClient.send(createMITableCommand);
+  await ddbClient.send(createSupplierTableCommand);
 }
 
 
@@ -115,4 +140,8 @@ export async function deleteTables(context: DBContext) {
   await ddbClient.send(new DeleteTableCommand({
     TableName: 'management-info'
   }));
+
+  await ddbClient.send(new DeleteTableCommand({
+    TableName: 'suppliers'
+  }));
 }
diff --git a/internal/datastore/src/__test__/supplier-repository.test.ts b/internal/datastore/src/__test__/supplier-repository.test.ts
@@ -0,0 +1,127 @@
+import { Logger } from "pino";
+import { createTables, DBContext, deleteTables, setupDynamoDBContainer } from "./db";
+import { createTestLogger, LogStream } from "./logs";
+import { SupplierRepository } from "../supplier-repository";
+import { Supplier } from "../types";
+import { v4 as uuidv4 } from 'uuid';
+
+function createSupplier(status: 'ENABLED' | 'DISABLED', apimId = uuidv4()): Omit<Supplier, 'updatedAt'> {
+    return {
+        id: uuidv4(),
+        name: 'Supplier One',
+        apimId,
+        status
+    }
+}
+
+// Database tests can take longer, especially with setup and teardown
+jest.setTimeout(30000);
+
+describe('SupplierRepository', () => {
+    let db: DBContext;
+    let supplierRepository: SupplierRepository;
+    let logStream: LogStream;
+    let logger: Logger;
+
+    beforeAll(async () => {
+        db = await setupDynamoDBContainer();
+    });
+
+    beforeEach(async () => {
+        await createTables(db);
+        (
+            { logStream, logger } = createTestLogger()
+        );
+
+        supplierRepository = new SupplierRepository(db.docClient, logger, db.config);
+    });
+
+    afterEach(async () => {
+        await deleteTables(db);
+        jest.useRealTimers();
+    });
+
+    afterAll(async () => {
+        await db.container.stop();
+    });
+
+    test('creates an enabled supplier with provided values and timestamps', async () => {
+        jest.useFakeTimers();
+        // Month is zero-indexed in JS Date
+        jest.setSystemTime(new Date(2020, 1, 1));
+
+        const supplier = createSupplier('ENABLED');
+
+        const persistedSupplier = await supplierRepository.putSupplier(supplier);
+
+        expect(persistedSupplier).toEqual(expect.objectContaining({
+            ...supplier,
+            updatedAt: '2020-02-01T00:00:00.000Z',
+        }));
+    });
+
+    test('fetches a supplier by its ID', async () => {
+        const supplier = createSupplier('DISABLED')
+        await supplierRepository.putSupplier(supplier);
+
+        const fetched = await supplierRepository.getSupplierById(supplier.id);
+
+        expect(fetched).toEqual(expect.objectContaining({
+            ...supplier
+        }));
+    });
+
+    test('throws an error fetching a supplier that does not exist', async () => {
+        await expect(supplierRepository.getSupplierById('non-existent-id'))
+        .rejects.toThrow('Supplier with id non-existent-id not found');
+    });
+
+    test('overwrites an existing supplier entry', async () => {
+        const supplier = createSupplier('DISABLED');
+
+        const original = await supplierRepository.putSupplier(supplier);
+        expect(original.status).toBe('DISABLED');
+
+        supplier.status = 'ENABLED';
+        const updated = await supplierRepository.putSupplier(supplier);
+        expect(updated.status).toBe('ENABLED');
+    });
+
+    test('rethrows errors from DynamoDB when creating a letter', async () => {
+        const misconfiguredRepository = new SupplierRepository(db.docClient, logger, {
+            ...db.config,
+            suppliersTableName: 'nonexistent-table'
+        });
+        await expect(misconfiguredRepository.putSupplier(createSupplier('ENABLED')))
+        .rejects.toThrow('Cannot do operations on a non-existent table');
+    });
+
+    test('fetches a supplier by apimId', async () => {
+        const supplier = createSupplier('ENABLED');
+
+        await supplierRepository.putSupplier(supplier);
+
+        const fetched = await supplierRepository.getSupplierByApimId(supplier.apimId);
+        expect(fetched).toEqual(expect.objectContaining({
+            ...supplier
+        }));
+    });
+
+    test('throws an error fetching a supplier by apimId that does not exist', async () => {
+        await expect(supplierRepository.getSupplierByApimId('non-existent-apim-id'))
+        .rejects.toThrow('Supplier with apimId non-existent-apim-id not found');
+    });
+
+    test('throws an error fetching a supplier by apimId when multiple exist', async () => {
+        const apimId = 'duplicate-apim-id';
+        const supplier1 = createSupplier('ENABLED', apimId);
+        const supplier2 = createSupplier('DISABLED', apimId);
+
+        await supplierRepository.putSupplier(supplier1);
+        await supplierRepository.putSupplier(supplier2);
+
+        await expect(supplierRepository.getSupplierByApimId(apimId))
+        .rejects.toThrow(`Multiple suppliers found with apimId ${apimId}`);
+    });
+
+});
diff --git a/internal/datastore/src/config.ts b/internal/datastore/src/config.ts
@@ -3,6 +3,7 @@ export type DatastoreConfig = {
   endpoint?: string,
   lettersTableName: string,
   miTableName: string,
+  suppliersTableName: string,
   lettersTtlHours: number,
   miTtlHours: number
 }
diff --git a/internal/datastore/src/supplier-repository.ts b/internal/datastore/src/supplier-repository.ts
@@ -0,0 +1,73 @@
+import {
+  DynamoDBDocumentClient,
+  GetCommand,
+  PutCommand,
+  QueryCommand
+} from '@aws-sdk/lib-dynamodb';
+import { Supplier, SupplierSchema } from './types';
+import { Logger } from 'pino';
+import { v4 as uuidv4 } from 'uuid';
+import z from 'zod';
+
+export type SupplierRepositoryConfig = {
+  suppliersTableName: string
+};
+
+export class SupplierRepository {
+  constructor(readonly ddbClient: DynamoDBDocumentClient,
+    readonly log: Logger,
+    readonly config: SupplierRepositoryConfig) {
+  }
+
+  async putSupplier(supplier: Omit<Supplier, 'updatedAt'>): Promise<Supplier> {
+
+    const now = new Date().toISOString();
+    const supplierDb = {
+      ...supplier,
+      updatedAt: now
+    };
+
+    await this.ddbClient.send(new PutCommand({
+      TableName: this.config.suppliersTableName,
+      Item: supplierDb,
+    }));
+
+    return SupplierSchema.parse(supplierDb);
+  }
+
+  async getSupplierById(supplierId: string): Promise<Supplier> {
+    const result = await this.ddbClient.send(new GetCommand({
+      TableName: this.config.suppliersTableName,
+      Key: {
+        id: supplierId
+      }
+    }));
+
+    if (!result.Item) {
+        throw new Error(`Supplier with id ${supplierId} not found`);
+    }
+
+    return SupplierSchema.parse(result.Item);
+  }
+
+  async getSupplierByApimId(apimId: string): Promise<Supplier> {
+    const result = await this.ddbClient.send(new QueryCommand({
+          TableName: this.config.suppliersTableName,
+          IndexName: 'supplier-apim-index',
+          KeyConditionExpression: 'apimId = :apimId',
+          ExpressionAttributeValues: {
+            ':apimId': apimId
+          },
+        }));
+
+      if(result.Count && result.Count > 1) {
+        throw new Error(`Multiple suppliers found with apimId ${apimId}`);
+      }
+
+      if(result.Count === 0 || !result.Items) {
+        throw new Error(`Supplier with apimId ${apimId} not found`);
+      }
+
+      return SupplierSchema.parse(result.Items[0]);
+  }
+};
diff --git a/internal/datastore/src/types.ts b/internal/datastore/src/types.ts
@@ -1,13 +1,14 @@
 import { z } from 'zod';
 import { idRef } from '@internal/helpers';
 
-export const SupplerStatus = z.enum(['ENABLED', 'DISABLED']);
+export const SupplierStatus = z.enum(['ENABLED', 'DISABLED']);
 
 export const SupplierSchema = z.object({
   id: z.string(),
   name: z.string(),
   apimId: z.string(),
-  status: SupplerStatus
+  status: SupplierStatus,
+  updatedAt: z.string(),
 }).describe('Supplier');
 
 export type Supplier = z.infer<typeof SupplierSchema>;

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@ export type DatastoreConfig = {`
`3`	`3`	`endpoint?: string,`
`4`	`4`	`lettersTableName: string,`
`5`	`5`	`miTableName: string,`
	`6`	`+ suppliersTableName: string,`
`6`	`7`	`lettersTtlHours: number,`
`7`	`8`	`miTtlHours: number`
`8`	`9`	`}`