CCM-11201 Store MI in DDB

Author: stevebux

internal/datastore/src/__test__/db.ts

@@ -30,6 +30,7 @@ export async function setupDynamoDBContainer() {
     region: 'us-west-2',
     endpoint,
     lettersTableName: 'letters',
+    miTableName: 'management-info',
     ttlHours: 1
   };
 
@@ -44,10 +45,7 @@ export async function setupDynamoDBContainer() {
 
 export type DBContext = Awaited<ReturnType<typeof setupDynamoDBContainer>>;
 
-export async function createTables(context: DBContext) {
-  const { ddbClient } = context;
-
-  await ddbClient.send(new CreateTableCommand({
+const createLetterTableCommand = new CreateTableCommand({
     TableName: 'letters',
     BillingMode: 'PAY_PER_REQUEST',
     KeySchema: [
@@ -72,15 +70,37 @@ export async function createTables(context: DBContext) {
       { AttributeName: 'supplierStatus', AttributeType: 'S' },
       { AttributeName: 'supplierStatusSk', AttributeType: 'S' },
     ]
-  }));
+  });
 
-  await ddbClient.send(new UpdateTimeToLiveCommand({
+const updateTimeToLiveCommand = new UpdateTimeToLiveCommand({
     TableName: 'letters',
     TimeToLiveSpecification: {
       AttributeName: 'ttl',
       Enabled: true
     }
-  }));
+  });
+
+const createMITableCommand = new CreateTableCommand({
+    TableName: 'management-info',
+    BillingMode: 'PAY_PER_REQUEST',
+    KeySchema: [
+      { AttributeName: 'supplierId', KeyType: 'HASH' },  // Partition key
+      { AttributeName: 'id', KeyType: 'RANGE' }         // Sort key
+    ],
+    AttributeDefinitions: [
+      { AttributeName: 'supplierId', AttributeType: 'S' },
+      { AttributeName: 'id', AttributeType: 'S' },
+    ]
+  });
+
+
+export async function createTables(context: DBContext) {
+  const { ddbClient } = context;
+
+  await ddbClient.send(createLetterTableCommand);
+  await ddbClient.send(updateTimeToLiveCommand);
+
+  await ddbClient.send(createMITableCommand);
 }
 
 
@@ -90,4 +110,8 @@ export async function deleteTables(context: DBContext) {
   await ddbClient.send(new DeleteTableCommand({
     TableName: 'letters'
   }));
+
+  await ddbClient.send(new DeleteTableCommand({
+    TableName: 'management-info'
+  }));
 }

internal/datastore/src/__test__/mi-repository.test.ts

@@ -0,0 +1,62 @@
+import { Logger } from "pino";
+import { LetterRepository } from "../letter-repository";
+import { setupDynamoDBContainer, createTables, DBContext, deleteTables } from "./db";
+import { createTestLogger, LogStream } from "./logs";
+import { MIRepository } from "../mi-repository";
+
+describe('MiRepository', () => {
+  let db: DBContext;
+  let miRepository: MIRepository;
+  let logStream: LogStream;
+  let logger: Logger;
+
+
+  beforeAll(async () => {
+    db = await setupDynamoDBContainer();
+  });
+
+  beforeEach(async () => {
+    await createTables(db);
+    (
+      { logStream, logger } = createTestLogger()
+    );
+
+    miRepository = new MIRepository(db.docClient, logger, db.config);
+  });
+
+  afterEach(async () => {
+    await deleteTables(db);
+    jest.useRealTimers();
+  });
+
+  afterAll(async () => {
+    await db.container.stop();
+  });
+
+  describe('putMi', () => {
+
+    it('creates a letter with id and timestamps', async () => {
+
+      jest.useFakeTimers();
+      // Month is zero-indexed in JS Date
+      jest.setSystemTime(new Date(2020, 1, 1));
+      const mi = {
+        specificationId: 'spec1',
+        supplierId: 'supplier1',
+        groupId:'group1',
+        lineItem: 'item1',
+        quantity: 12,
+        stockRemaining: 0
+      };
+
+      const persistedMi = await(miRepository.putMI(mi));
+
+      expect(persistedMi).toEqual(expect.objectContaining({
+        id: expect.any(String),
+        createdAt: '2020-02-01T00:00:00.000Z',
+        updatedAt: '2020-02-01T00:00:00.000Z',
+        ...mi
+      }));
+    });
+  });
+});

internal/datastore/src/config.ts

@@ -2,5 +2,6 @@ export type DatastoreConfig = {
   region: string,
   endpoint?: string,
   lettersTableName: string,
+  miTableName: string,
   ttlHours: number
 }

internal/datastore/src/mi-repository.ts

@@ -0,0 +1,35 @@
+import {
+  DynamoDBDocumentClient,
+  PutCommand
+} from '@aws-sdk/lib-dynamodb';
+import { MI, MISchema } from './types';
+import { Logger } from 'pino';
+import { v4 as uuidv4 } from 'uuid';
+
+export type MIRepositoryConfig = {
+  miTableName: string
+};
+
+export class MIRepository {
+  constructor(readonly ddbClient: DynamoDBDocumentClient,
+    readonly log: Logger,
+    readonly config: MIRepositoryConfig) {
+  }
+
+  async putMI(mi: Omit<MI, 'id' | 'createdAt' | 'updatedAt'>): Promise<MI> {
+    const now = new Date().toISOString();
+    const miDb = {
+      ...mi,
+      id: uuidv4(),
+      createdAt: now,
+      updatedAt: now
+    };
+
+    await this.ddbClient.send(new PutCommand({
+      TableName: this.config.miTableName,
+      Item: miDb
+    }));
+
+    return MISchema.parse(miDb);
+  }
+};

internal/datastore/src/types.ts

@@ -46,16 +46,20 @@ export const LetterSchema = LetterSchemaBase.extend({
 export type Letter = z.infer<typeof LetterSchema>;
 export type LetterBase = z.infer<typeof LetterSchemaBase>;
 
-export const MISchema = z.object({
+export const MISchemaBase = z.object({
   id: z.string(),
-  supplierId: idRef(SupplierSchema),
   specificationId: z.string(),
   groupId: z.string(),
   lineItem: z.string(),
   quantity: z.number(),
-  stockRemaining: z.number(),
+  stockRemaining: z.number()
+});
+
+export const MISchema = MISchemaBase.extend({
+  supplierId: idRef(SupplierSchema),
   createdAt: z.string(),
   updatedAt: z.string()
 }).describe('MI');
 
 export type MI = z.infer<typeof MISchema>;
+export type MIBase = z.infer<typeof MISchemaBase>;