feat(validation): add Middy.js middleware for JSON Schema validation

Author: VatsalGoel3

packages/validation/src/index.ts

@@ -1,3 +1,4 @@
 export { validate } from './validate.js';
 export { SchemaValidationError } from './errors.js';
 export { validator } from './decorator.js';
+export { validationMiddleware } from './middleware.js';

packages/validation/src/middleware.ts

@@ -0,0 +1,42 @@
+import { SchemaValidationError } from './errors.js';
+import type { ValidatorOptions } from './types.js';
+import { validate } from './validate.js';
+
+export function validationMiddleware(options: ValidatorOptions) {
+  if (!options.inboundSchema && !options.outboundSchema) {
+    return {};
+  }
+  return {
+    before: async (handler: { event: unknown }) => {
+      if (options.inboundSchema) {
+        try {
+          handler.event = validate({
+            payload: handler.event,
+            schema: options.inboundSchema,
+            envelope: options.envelope,
+            formats: options.formats,
+            externalRefs: options.externalRefs,
+            ajv: options.ajv,
+          });
+        } catch (error) {
+          throw new SchemaValidationError('Inbound validation failed', error);
+        }
+      }
+    },
+    after: async (handler: { response: unknown }) => {
+      if (options.outboundSchema) {
+        try {
+          handler.response = validate({
+            payload: handler.response,
+            schema: options.outboundSchema,
+            formats: options.formats,
+            externalRefs: options.externalRefs,
+            ajv: options.ajv,
+          });
+        } catch (error) {
+          throw new SchemaValidationError('Outbound validation failed', error);
+        }
+      }
+    },
+  };
+}

packages/validation/tests/unit/middleware.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from 'vitest';
+import { SchemaValidationError } from '../../src/errors.js';
+import { validationMiddleware } from '../../src/middleware.js';
+
+const inboundSchema = {
+  type: 'object',
+  properties: {
+    inputValue: { type: 'number' },
+  },
+  required: ['inputValue'],
+  additionalProperties: false,
+};
+
+const outboundSchema = {
+  type: 'object',
+  properties: {
+    outputValue: { type: 'number' },
+  },
+  required: ['outputValue'],
+  additionalProperties: false,
+};
+
+describe('validatorMiddleware', () => {
+  it('should validate inbound and outbound successfully', async () => {
+    // Prepare
+    const middleware = validationMiddleware({ inboundSchema, outboundSchema });
+    const handler = {
+      event: { inputValue: 10 },
+      response: { outputValue: 20 },
+    };
+    // Act
+    if (middleware.before) {
+      await middleware.before(handler);
+    }
+    if (middleware.after) {
+      await middleware.after(handler);
+    }
+    // Assess
+    expect(handler.event).toEqual({ inputValue: 10 });
+    expect(handler.response).toEqual({ outputValue: 20 });
+  });
+
+  it('should throw error on inbound validation failure', async () => {
+    // Prepare
+    const middleware = validationMiddleware({ inboundSchema });
+    const handler = {
+      event: { inputValue: 'invalid' },
+      response: {},
+    };
+    // Act & Assess
+    await expect(middleware.before?.(handler)).rejects.toThrow(
+      SchemaValidationError
+    );
+  });
+
+  it('should throw error on outbound validation failure', async () => {
+    // Prepare
+    const middleware = validationMiddleware({ outboundSchema });
+    const handler = {
+      event: {},
+      response: { outputValue: 'invalid' },
+    };
+    // Act & Assess
+    await expect(middleware.after?.(handler)).rejects.toThrow(
+      SchemaValidationError
+    );
+  });
+
+  it('should no-op when no schemas are provided', async () => {
+    // Prepare
+    const middleware = validationMiddleware({});
+    const handler = {
+      event: { someKey: 'value' },
+      response: { anotherKey: 'value' },
+    };
+    // Act
+    if (middleware.before) {
+      await middleware.before(handler);
+    }
+    if (middleware.after) {
+      await middleware.after(handler);
+    }
+    // Assess
+    expect(handler.event).toEqual({ someKey: 'value' });
+    expect(handler.response).toEqual({ anotherKey: 'value' });
+  });
+});