style(validation): apply stricter linting

Author: dreamorosi

packages/validation/src/middleware.ts

@@ -105,7 +105,7 @@ import { validate } from './validate.js';
  * @param options.ajv - Optional Ajv instance to use for validation, if not provided a new instance will be created.
  */
 const validator = (options: ValidatorOptions) => {
-  const before: MiddlewareFn = async (request) => {
+  const before: MiddlewareFn = (request) => {
     if (options.inboundSchema) {
       const originalEvent = structuredClone(request.event);
       try {
@@ -125,7 +125,7 @@ const validator = (options: ValidatorOptions) => {
     }
   };
 
-  const after = async (handler: MiddyLikeRequest) => {
+  const after = (handler: MiddyLikeRequest) => {
     if (options.outboundSchema) {
       try {
         handler.response = validate({

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

@@ -21,29 +21,29 @@ const outboundSchema = {
 };
 
 describe('Decorator: validator', () => {
-  it('should validate inbound and outbound successfully', async () => {
+  it('should validate inbound and outbound successfully', () => {
     // Prepare
     class TestClass {
       @validator({ inboundSchema, outboundSchema })
-      async multiply(input: { value: number }): Promise<{ result: number }> {
+      multiply(input: { value: number }): { result: number } {
         return { result: input.value * 2 };
       }
     }
     const instance = new TestClass();
     const input = { value: 5 };
 
     // Act
-    const output = await instance.multiply(input);
+    const output = instance.multiply(input);
 
     // Assess
     expect(output).toEqual({ result: 10 });
   });
 
-  it('should throw error on inbound validation failure', async () => {
+  it('should throw error on inbound validation failure', () => {
     // Prepare
     class TestClass {
       @validator({ inboundSchema, outboundSchema })
-      async multiply(input: { value: number }): Promise<{ result: number }> {
+      multiply(input: { value: number }): { result: number } {
         return { result: input.value * 2 };
       }
     }
@@ -53,76 +53,72 @@ describe('Decorator: validator', () => {
     };
 
     // Act & Assess
-    await expect(instance.multiply(invalidInput)).rejects.toThrow(
-      SchemaValidationError
-    );
+    expect(instance.multiply(invalidInput)).toThrow(SchemaValidationError);
   });
 
-  it('should throw error on outbound validation failure', async () => {
+  it('should throw error on outbound validation failure', () => {
     // Prepare
     class TestClassInvalid {
       @validator({ inboundSchema, outboundSchema })
-      async multiply(_input: { value: number }) {
+      multiply(_input: { value: number }) {
         return { result: 'invalid' };
       }
     }
     const instance = new TestClassInvalid();
 
     // Act & Assess
-    await expect(instance.multiply({ value: 5 })).rejects.toThrow(
-      SchemaValidationError
-    );
+    expect(instance.multiply({ value: 5 })).toThrow(SchemaValidationError);
   });
 
-  it('should no-op when no schemas are provided', async () => {
+  it('should no-op when no schemas are provided', () => {
     // Prepare
     class TestClassNoOp {
       @validator({})
-      async echo(input: unknown): Promise<unknown> {
+      echo(input: unknown): unknown {
         return input;
       }
     }
     const instance = new TestClassNoOp();
     const data = { foo: 'bar' };
 
     // Act
-    const result = await instance.echo(data);
+    const result = instance.echo(data);
 
     // Assess
     expect(result).toEqual(data);
   });
 
-  it('should validate inbound only', async () => {
+  it('should validate inbound only', () => {
     // Prepare
     class TestClassInbound {
       @validator({ inboundSchema })
-      async process(input: { value: number }): Promise<{ data: string }> {
+      process(input: { value: number }): { data: string } {
         return { data: JSON.stringify(input) };
       }
     }
     const instance = new TestClassInbound();
     const input = { value: 10 };
 
     // Act
-    const output = await instance.process(input);
+    const output = instance.process(input);
 
     // Assess
     expect(output).toEqual({ data: JSON.stringify(input) });
   });
 
-  it('should validate outbound only', async () => {
+  it('should validate outbound only', () => {
     // Prepare
     class TestClassOutbound {
       @validator({ outboundSchema })
-      async process(_input: { text: string }): Promise<{ result: number }> {
+      process(_input: { text: string }): { result: number } {
         return { result: 42 };
       }
     }
     const instance = new TestClassOutbound();
     const input = { text: 'hello' };
 
     // Act
-    const output = await instance.process(input);
+    const output = instance.process(input);
 
     // Assess
     expect(output).toEqual({ result: 42 });

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

@@ -22,7 +22,7 @@ const outboundSchema = {
   additionalProperties: false,
 };
 
-const baseHandler = async (event: { inputValue: unknown }) => {
+const baseHandler = (event: { inputValue: unknown }) => {
   return {
     outputValue: event.inputValue,
   };