CCM-11228: Add logging functionality and update letter repository methods

Author: m-houston

internal/datastore/package.json

@@ -2,6 +2,7 @@
   "dependencies": {
     "@aws-sdk/client-dynamodb": "^3.858.0",
     "@aws-sdk/lib-dynamodb": "^3.858.0",
+    "pino": "^9.7.0",
     "zod": "^4.0.14"
   },
   "devDependencies": {

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

@@ -1,32 +1,43 @@
 import { createTables, DBContext, deleteTables, setupDynamoDBContainer } from './db';
 import { LetterRepository } from '../letter-repository';
 import { Letter } from '../types';
+import { Logger } from 'pino';
+import { createTestLogger, LogStream } from './logs';
 
 function createLetter(supplierId: string, letterId: string, status: Letter['status'] = 'PENDING'): Letter {
   return {
-    supplierId: supplierId,
     id: letterId,
+    supplierId: supplierId,
+    specificationId: 'specification1',
+    groupId: 'group1',
     url: `s3://bucket/${letterId}.pdf`,
     status: status,
     createdAt: new Date().toISOString(),
     updatedAt: new Date().toISOString()
   };
 }
 
+// Database tests can take longer, especially with setup and teardown
 jest.setTimeout(30000);
 
 describe('LetterRepository', () => {
 
   let db: DBContext;
   let letterRepository: LetterRepository;
+  let logStream: LogStream;
+  let logger: Logger;
 
   beforeAll(async () => {
     db = await setupDynamoDBContainer();
   });
 
   beforeEach(async () => {
     await createTables(db);
-    letterRepository = new LetterRepository(db.docClient, db.config);
+    (
+      { logStream, logger } = createTestLogger()
+    );
+
+    letterRepository = new LetterRepository(db.docClient, logger, db.config);
   });
 
   afterEach(async () => {
@@ -124,11 +135,12 @@ describe('LetterRepository', () => {
     expect(firstPage.letters[0].id).toBe('letter001');
     expect(firstPage.letters[49].id).toBe('letter050');
 
-    const secondPage = await letterRepository.getLettersByStatus('supplier1', 'PENDING', firstPage.lastEvaluatedKey);
+    const secondPage = await letterRepository.getLettersByStatus('supplier1', 'PENDING', {
+      exclusiveStartKey: firstPage.lastEvaluatedKey
+    });
     expect(secondPage.letters).toHaveLength(49);
     expect(secondPage.lastEvaluatedKey).toBeUndefined(); // No more pages
     expect(secondPage.letters[0].id).toBe('letter051');
     expect(secondPage.letters[48].id).toBe('letter099');
   });
-
 });

internal/datastore/src/__test__/logs.ts

@@ -0,0 +1,19 @@
+import pino from 'pino';
+import { Writable } from 'stream';
+
+export class LogStream extends Writable {
+  logs: string[] = [];
+
+  _write(chunk: any, _encoding: string, callback: () => void) {
+    this.logs.push(chunk.toString());
+    callback();
+  }
+}
+
+export function createTestLogger() {
+  let logStream = new LogStream();
+  return {
+    logStream: logStream,
+    logger: pino(logStream)
+  };
+}

internal/datastore/src/letter-repository.ts

@@ -6,10 +6,21 @@ import {
   UpdateCommand,
   UpdateCommandOutput
 } from '@aws-sdk/lib-dynamodb';
-import { Letter, LetterDB, LetterDBSchema, LetterSchema } from './types';
+import { Letter, LetterDB, LetterSchema } from './types';
+import { Logger } from 'pino';
+
+export type PagingOptions = Partial<{
+  exclusiveStartKey: Record<string, any>,
+  pageSize: number
+}>
+
+const defaultPagingOptions = {
+  pageSize: 50
+};
 
 export class LetterRepository {
   constructor(readonly ddbClient: DynamoDBDocumentClient,
+              readonly log: Logger,
               readonly config: { lettersTableName: string }) {
   }
 
@@ -42,10 +53,13 @@ export class LetterRepository {
     return LetterSchema.parse(result.Item);
   }
 
-  async getLettersByStatus(supplierId: string, status: Letter['status'], exclusiveStartKey?: Record<string, any>, pageSize: number = 50): Promise<{
+  async getLettersByStatus(supplierId: string, status: Letter['status'], options?: PagingOptions): Promise<{
     letters: Letter[],
     lastEvaluatedKey?: Record<string, any>
   }> {
+
+    const extendedOptions = { ...defaultPagingOptions, ...options };
+
     const result = await this.ddbClient.send(new QueryCommand({
       TableName: this.config.lettersTableName,
       IndexName: 'supplierStatus-index',
@@ -55,21 +69,28 @@ export class LetterRepository {
           AttributeValueList: [`${supplierId}#${status}`]
         }
       },
-      Limit: pageSize,
-      ExclusiveStartKey: exclusiveStartKey
+      Limit: extendedOptions.pageSize,
+      ExclusiveStartKey: extendedOptions.exclusiveStartKey
     }));
 
     if (!result.Items) {
       throw new Error(`No letters found for supplier ${supplierId} with status ${status}`);
     }
     return {
-      letters: result.Items.map(item => LetterSchema.parse(item)),
+      letters: result.Items.map(item => LetterSchema.safeParse(item))
+        .filter((result) => {
+          if (!result.success) {
+            this.log.warn(`Invalid letter data: ${result.error}`);
+          }
+          return result.success;
+        })
+        .map(result => result.data),
       lastEvaluatedKey: result.LastEvaluatedKey
     }
   }
 
   async updateLetterStatus(supplierId: string, letterId: string, status: Letter['status']): Promise<Letter> {
-    console.debug(`Updating letter ${letterId} to status ${status}`);
+    this.log.debug(`Updating letter ${letterId} to status ${status}`);
     let result: UpdateCommandOutput;
     try {
       result = await this.ddbClient.send(new UpdateCommand({
@@ -100,7 +121,7 @@ export class LetterRepository {
     if (!result.Attributes) {
       throw new Error(`Letter with id ${letterId} not found for supplier ${supplierId}`);
     }
-    console.debug(`Updated letter ${letterId} to status ${status}`);
+    this.log.debug(`Updated letter ${letterId} to status ${status}`);
     return LetterSchema.parse(result.Attributes);
   }
 }

internal/datastore/src/types.ts

@@ -11,23 +11,23 @@ export const SupplierSchema = z.object({
 }).describe('Supplier');
 
 export type Supplier = z.infer<typeof SupplierSchema>;
-export type SupplierId = Supplier['id'];
 
 export const LetterStatus = z.enum([
   'PENDING', 'ACCEPTED', 'DISPATCHED', 'FAILED',
   'REJECTED', 'DELIVERED', 'CANCELLED']);
 
 export const LetterSchema = z.object({
-  supplierId: idRef(SupplierSchema),
   id: z.string(),
+  supplierId: idRef(SupplierSchema),
+  specificationId: z.string(),
+  groupId: z.string(),
   url: z.url(),
   status: LetterStatus,
   createdAt: z.string(),
   updatedAt: z.string(),
 }).describe('Letter');
 
 export type Letter = z.infer<typeof LetterSchema>;
-export type LetterId = Letter['id'];
 
 export const LetterDBSchema = LetterSchema.extend({
   supplierStatus: z.string().describe('Secondary index PK'),