CCM-14616: POF

Author: simonlabarere

lambdas/ttl-create-lambda/src/__tests__/apis/sqs-trigger-lambda.test.ts

@@ -85,7 +85,7 @@ describe('createHandler', () => {
     expect(res.batchItemFailures).toEqual([{ itemIdentifier: 'msg2' }]);
     expect(logger.error).toHaveBeenCalledWith(
       expect.objectContaining({
-        description: expect.stringContaining('parsing ttl queue entry'),
+        description: expect.stringContaining('Error parsing MESHInboxMessageDownloaded event'),
       }),
     );
     expect(logger.info).toHaveBeenCalledWith({

lambdas/ttl-create-lambda/src/apis/sqs-trigger-lambda.ts

@@ -7,11 +7,7 @@ import { randomUUID } from 'node:crypto';
 import type { CreateTtl, CreateTtlOutcome } from 'app/create-ttl';
 import { EventPublisher, Logger } from 'utils';
 import itemEnqueuedValidator from 'digital-letters-events/ItemEnqueued.js';
-import messageDownloadedValidator from 'digital-letters-events/MESHInboxMessageDownloaded.js';
-import {
-  ItemEnqueued,
-  MESHInboxMessageDownloaded,
-} from 'digital-letters-events';
+import { MESHInboxMessageDownloaded, validateMESHInboxMessageDownloaded } from 'digital-letters-events';
 
 interface ProcessingResult {
   result: CreateTtlOutcome;
@@ -36,19 +32,12 @@ export const createHandler = ({
       async ({ body, messageId }): Promise<ProcessingResult> => {
         try {
           const sqsEventBody = JSON.parse(body);
-          const sqsEventDetail = sqsEventBody.detail;
-
-          const isEventValid = messageDownloadedValidator(sqsEventDetail);
-          if (!isEventValid) {
-            logger.error({
-              err: messageDownloadedValidator.errors,
-              description: 'Error parsing ttl queue entry',
-            });
+          const messageDownloadedEvent = validateMESHInboxMessageDownloaded(sqsEventBody.detail, logger);
+
+          if (!messageDownloadedEvent) {
             batchItemFailures.push({ itemIdentifier: messageId });
             return { result: 'failed' };
           }
-          const messageDownloadedEvent: MESHInboxMessageDownloaded =
-            sqsEventDetail;
 
           const result = await createTtl.send(messageDownloadedEvent);
 

src/digital-letters-events/.gitignore

@@ -1,3 +1,4 @@
 validators
 types
 models
+guard-functions

src/digital-letters-events/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './guard-functions';

src/digital-letters-events/package.json

@@ -10,7 +10,7 @@
   },
   "exports": {
     ".": {
-      "types": "./types/index.d.ts"
+      "default": "./index.ts"
     },
     "./*.js": {
       "default": "./validators/*.js",

src/typescript-schema-generator/package.json

@@ -18,7 +18,8 @@
   "name": "typescript-schema-generator",
   "private": true,
   "scripts": {
-    "generate-dependencies": "npm run generate-types && npm run generate-validators",
+    "generate-dependencies": "npm run generate-types && npm run generate-validators && npm run generate-guard-functions",
+    "generate-guard-functions": "tsx src/generate-guard-functions-cli.ts",
     "generate-types": "tsx src/generate-types-cli.ts",
     "generate-validators": "tsx src/generate-validators-cli.ts",
     "lint": "eslint src",

src/typescript-schema-generator/src/generate-guard-functions-cli.ts

@@ -0,0 +1,8 @@
+/* eslint-disable no-console */
+
+import { generateGuardFunctions } from 'generate-guard-functions'
+
+generateGuardFunctions().catch((error) => {
+  console.error('Error generating guard functions:', error);
+  throw error;
+});

src/typescript-schema-generator/src/generate-guard-functions.ts

@@ -0,0 +1,55 @@
+/* eslint-disable no-console */
+import { createOutputDir, writeFile, writeTypesIndex } from 'file-utils';
+import path from 'node:path';
+import { writeFileSync } from 'node:fs';
+import { eventSchemasDir, listEventSchemas, loadSchema } from 'utils';
+
+export async function generateGuardFunctions() {
+  const eventSchemaFilenames = listEventSchemas();
+  const outputDir = createOutputDir('guard-functions');
+  console.log(`Output directory created at ${outputDir}`);
+
+  console.group('Writing guard functions:');
+  const indexLines: string[] = [];
+  for (const eventSchemaFilename of eventSchemaFilenames) {
+    const eventSchemaPath = path.join(eventSchemasDir, eventSchemaFilename);
+    const eventSchema = loadSchema(eventSchemaPath);
+    const typeName = eventSchema.title;
+
+    const validatorVariableName = `event${typeName}Validator`;
+
+    let eventTs = `import ${validatorVariableName} from 'digital-letters-events/${typeName}.js'\n`;
+    eventTs += `import type { ${typeName} } from 'digital-letters-events';\n`;
+    eventTs += `import { Logger } from 'utils';\n\n`;
+
+    eventTs += `export function validate${typeName}(\n`;
+    eventTs += `  event: unknown,\n`;
+    eventTs += `  logger: Logger,\n`;
+    eventTs += `): ${typeName} | null {\n\n`;
+
+    eventTs += `  const eventValidator = event${typeName}Validator as (d: unknown) => d is ${typeName};\n\n`;
+
+    eventTs += `  if (!eventValidator(event)) {\n`;
+    eventTs += `    logger.error({\n`;
+    eventTs += `      err: ${validatorVariableName}.errors,\n`;
+    eventTs += `      description: 'Error parsing ${typeName} event',\n`;
+    eventTs += `    });\n`;
+    eventTs += `    return null;\n`;
+    eventTs += `  }\n\n`;
+
+    eventTs += `  return event;\n`;
+    eventTs += `}\n\n`;
+
+
+    const typeDeclarationName = `${typeName}`;
+    const typeDeclarationFilename = `${typeDeclarationName}.ts`;
+    writeFile(outputDir, typeDeclarationFilename, eventTs);
+    console.log(typeDeclarationFilename);
+
+    indexLines.push(`export * from './${typeDeclarationName}';`);
+  }
+  console.groupEnd();
+
+  writeFileSync(path.join(outputDir, 'index.ts'), `${indexLines.join('\n')}\n`);
+  console.log('index.ts file written');
+}

src/typescript-schema-generator/src/generate-types.ts

@@ -1,6 +1,7 @@
 /* eslint-disable no-console */
 import { createOutputDir, writeFile, writeTypesIndex } from 'file-utils';
 import { compile } from 'json-schema-to-typescript';
+import { writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { eventSchemasDir, listEventSchemas, loadSchema } from 'utils';
 
@@ -21,7 +22,7 @@ export async function generateTypes() {
     });
 
     // Write a .d.ts file named after the schema title or file.
-    const typeDeclarationFilename = `${typeName}.d.ts`;
+    const typeDeclarationFilename = `${typeName}.ts`;
     writeFile(outputDir, typeDeclarationFilename, eventTs);
     console.log(typeDeclarationFilename);
 
@@ -30,6 +31,6 @@ export async function generateTypes() {
   }
   console.groupEnd();
 
-  writeTypesIndex(outputDir, indexLines);
-  console.log('index.d.ts file written');
+  writeFileSync(path.join(outputDir, 'index.ts'), `${indexLines.join('\n')}\n`);
+  console.log('index.ts file written');
 }