Implemented enum parsing for exchange oracle

Author: 0xVoronov

packages/apps/fortune/exchange-oracle/server/src/app.module.ts

@@ -15,13 +15,18 @@ import { CronJobModule } from './modules/cron-job/cron-job.module';
 import { HealthModule } from './modules/health/health.module';
 import { EnvConfigModule } from './common/config/config.module';
 import { ScheduleModule } from '@nestjs/schedule';
+import { TransformEnumInterceptor } from './common/interceptors/transform-enum.interceptor';
 
 @Module({
   providers: [
     {
       provide: APP_INTERCEPTOR,
       useClass: SnakeCaseInterceptor,
     },
+    {
+      provide: APP_INTERCEPTOR,
+      useClass: TransformEnumInterceptor,
+    },
     JwtHttpStrategy,
   ],
   imports: [

packages/apps/fortune/exchange-oracle/server/src/common/enums/job.ts

@@ -1,7 +1,7 @@
 export enum JobStatus {
-  ACTIVE = 'ACTIVE',
-  COMPLETED = 'COMPLETED',
-  CANCELED = 'CANCELED',
+  ACTIVE = 'active',
+  COMPLETED = 'completed',
+  CANCELED = 'canceled',
 }
 
 export enum JobSortField {
@@ -22,12 +22,12 @@ export enum JobFieldName {
 }
 
 export enum AssignmentStatus {
-  ACTIVE = 'ACTIVE',
-  VALIDATION = 'VALIDATION',
-  COMPLETED = 'COMPLETED',
-  EXPIRED = 'EXPIRED',
-  CANCELED = 'CANCELED',
-  REJECTED = 'REJECTED',
+  ACTIVE = 'active',
+  VALIDATION = 'validation',
+  COMPLETED = 'completed',
+  EXPIRED = 'expired',
+  CANCELED = 'canceled',
+  REJECTED = 'rejected',
 }
 
 export enum AssignmentSortField {
@@ -40,5 +40,5 @@ export enum AssignmentSortField {
 }
 
 export enum JobType {
-  FORTUNE = 'FORTUNE',
-}
+  FORTUNE = 'fortune',
+}

packages/apps/fortune/exchange-oracle/server/src/common/enums/role.ts

@@ -6,6 +6,6 @@ export enum AuthSignatureRole {
 }
 
 export enum Role {
-  Worker = 'WORKER',
-  HumanApp = 'HUMAN_APP',
+  Worker = 'worker',
+  HumanApp = 'human_app',
 }

packages/apps/fortune/exchange-oracle/server/src/common/enums/webhook.ts

@@ -8,7 +8,7 @@ export enum EventType {
 }
 
 export enum WebhookStatus {
-  PENDING = 'PENDING',
-  COMPLETED = 'COMPLETED',
-  FAILED = 'FAILED',
+  PENDING = 'pending',
+  COMPLETED = 'completed',
+  FAILED = 'failed',
 }

packages/apps/fortune/exchange-oracle/server/src/common/interceptors/transform-enum.interceptor.spec.ts

@@ -0,0 +1,164 @@
+import { TransformEnumInterceptor } from './transform-enum.interceptor';
+import {
+  ExecutionContext,
+  CallHandler,
+  BadRequestException,
+} from '@nestjs/common';
+import { of } from 'rxjs';
+import { IsNumber, IsString, Min } from 'class-validator';
+import { JobType } from '../../common/enums/job';
+import { ApiProperty } from '@nestjs/swagger';
+import { IsEnumCaseInsensitive } from '../utils/enums';
+
+export class MockDto {
+  @ApiProperty({
+    enum: JobType,
+  })
+  @IsEnumCaseInsensitive(JobType)
+  public jobType: JobType;
+
+  @ApiProperty()
+  @IsNumber()
+  @Min(0.5)
+  public amount: number;
+
+  @ApiProperty()
+  @IsString()
+  public address: string;
+}
+
+describe('TransformEnumInterceptor', () => {
+  let interceptor: TransformEnumInterceptor;
+  let executionContext: ExecutionContext;
+  let callHandler: CallHandler;
+
+  beforeEach(() => {
+    interceptor = new TransformEnumInterceptor();
+
+    // Mocking ExecutionContext and CallHandler
+    executionContext = {
+      switchToHttp: jest.fn().mockReturnValue({
+        getRequest: jest.fn().mockReturnValue({
+          body: {
+            jobType: 'FORTUNE',
+            amount: 5,
+            address: '0xCf88b3f1992458C2f5a229573c768D0E9F70C44e',
+          },
+        }),
+      }),
+      getHandler: jest.fn().mockReturnValue({
+        name: 'create', // Assume the handler is named 'create'
+      }),
+      getClass: jest.fn().mockReturnValue({
+        prototype: {},
+      }),
+    } as unknown as ExecutionContext;
+
+    callHandler = {
+      handle: jest.fn().mockReturnValue(of({})),
+    };
+
+    // Mock Reflect.getMetadata to return DTO and Enum types
+    Reflect.getMetadata = jest.fn((metadataKey, target, propertyKey) => {
+      // Mock design:paramtypes to return MockDto as the parameter type
+      if (metadataKey === 'design:paramtypes') {
+        return [MockDto];
+      }
+
+      // Mock custom:enum to return the corresponding enum for each property
+      if (metadataKey === 'custom:enum' && propertyKey === 'jobType') {
+        return JobType;
+      }
+      return undefined; // For non-enum properties, return undefined
+    }) as any;
+  });
+
+  it('should transform enum values to lowercase', async () => {
+    // Run the interceptor
+    await interceptor.intercept(executionContext, callHandler).toPromise();
+
+    // Access the modified request body
+    const request = executionContext.switchToHttp().getRequest();
+
+    // Expectations
+    expect(request.body.jobType).toBe('fortune'); // Should be transformed to lowercase
+    expect(request.body).toEqual({
+      jobType: 'fortune',
+      amount: 5,
+      address: '0xCf88b3f1992458C2f5a229573c768D0E9F70C44e',
+    });
+    expect(callHandler.handle).toBeCalled(); // Ensure the handler is called
+  });
+
+  it('should throw an error if the value is not a valid enum', async () => {
+    // Modify the request body to have an invalid enum value for jobType
+    executionContext.switchToHttp = jest.fn().mockReturnValue({
+      getRequest: jest.fn().mockReturnValue({
+        body: {
+          jobType: 'invalidEnum', // Invalid enum value for jobType
+          amount: 5,
+          address: '0xCf88b3f1992458C2f5a229573c768D0E9F70C44e',
+        },
+      }),
+    });
+
+    try {
+      // Run the interceptor
+      await interceptor.intercept(executionContext, callHandler).toPromise();
+    } catch (err) {
+      // Expect an error to be thrown
+      expect(err).toBeInstanceOf(BadRequestException);
+      expect(err.response.statusCode).toBe(400);
+      expect(err.response.message).toContain('Validation failed');
+    }
+  });
+
+  it('should not transform non-enum properties', async () => {
+    // Run the interceptor with a non-enum property (amount and address)
+    await interceptor.intercept(executionContext, callHandler).toPromise();
+
+    // Access the modified request body
+    const request = executionContext.switchToHttp().getRequest();
+
+    // Expectations
+    expect(request.body.amount).toBe(5); // Non-enum property should remain unchanged
+    expect(request.body.address).toBe(
+      '0xCf88b3f1992458C2f5a229573c768D0E9F70C44e',
+    ); // Non-enum string should remain unchanged
+    expect(callHandler.handle).toBeCalled();
+  });
+
+  it('should handle nested objects with enums', async () => {
+    // Modify the request body to have a nested object with enum value
+    executionContext.switchToHttp = jest.fn().mockReturnValue({
+      getRequest: jest.fn().mockReturnValue({
+        body: {
+          transaction: {
+            jobType: 'FORTUNE',
+            address: '0xCf88b3f1992458C2f5a229573c768D0E9F70C44e',
+          },
+          amount: 5,
+          address: '0xCf88b3f1992458C2f5a229573c768D0E9F70C44e',
+        },
+      }),
+    });
+
+    // Run the interceptor
+    await interceptor.intercept(executionContext, callHandler).toPromise();
+
+    // Access the modified request body
+    const request = executionContext.switchToHttp().getRequest();
+
+    // Expectations
+    expect(request.body.transaction.jobType).toBe('fortune');
+    expect(request.body).toEqual({
+      transaction: {
+        jobType: 'fortune',
+        address: '0xCf88b3f1992458C2f5a229573c768D0E9F70C44e',
+      },
+      amount: 5,
+      address: '0xCf88b3f1992458C2f5a229573c768D0E9F70C44e',
+    });
+    expect(callHandler.handle).toHaveBeenCalled();
+  });
+});

packages/apps/fortune/exchange-oracle/server/src/common/interceptors/transform-enum.interceptor.ts

@@ -0,0 +1,105 @@
+import {
+  Injectable,
+  NestInterceptor,
+  ExecutionContext,
+  CallHandler,
+  BadRequestException,
+} from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { plainToInstance, ClassConstructor } from 'class-transformer';
+import { validateSync } from 'class-validator';
+import 'reflect-metadata';
+
+@Injectable()
+export class TransformEnumInterceptor implements NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const request = context.switchToHttp().getRequest();
+    const body = request.body;
+
+    // Retrieve the class of the controller's DTO (if applicable)
+    const targetClass = this.getTargetClass(context);
+
+    if (targetClass && body) {
+      request.body = this.transformEnums(body, targetClass);
+    }
+
+    return next.handle().pipe(map((data) => data));
+  }
+
+  private getTargetClass(
+    context: ExecutionContext,
+  ): ClassConstructor<any> | null {
+    const handler = context.getHandler();
+    const controller = context.getClass();
+
+    // Get the parameter types of the route handler
+    const routeArgs = Reflect.getMetadata(
+      'design:paramtypes',
+      controller.prototype,
+      handler.name,
+    );
+
+    // Return the first parameter's constructor if the handler has a class (DTO)
+    return routeArgs && routeArgs.length > 0
+      ? (routeArgs[0] as ClassConstructor<any>)
+      : null;
+  }
+
+  private transformEnums(body: any, targetClass: ClassConstructor<any>): any {
+    // Convert the body to an instance of the target class
+    let transformedInstance = plainToInstance(targetClass, body);
+
+    // Transform the enums before validation
+    transformedInstance = this.lowercaseEnumProperties(
+      body,
+      transformedInstance,
+      targetClass,
+    );
+
+    // Validate the transformed body
+    const validationErrors = validateSync(transformedInstance);
+    if (validationErrors.length > 0) {
+      throw new BadRequestException('Validation failed');
+    }
+
+    return body;
+  }
+
+  private lowercaseEnumProperties(
+    body: any,
+    instance: any,
+    targetClass: ClassConstructor<any>,
+  ): any {
+    for (const property in body) {
+      if (body.hasOwnProperty(property)) {
+        const instanceValue = instance[property];
+
+        // Retrieve enum metadata if available
+        const enumType = Reflect.getMetadata(
+          'custom:enum',
+          targetClass.prototype,
+          property,
+        );
+
+        if (enumType && typeof instanceValue === 'string') {
+          // Check if it's an enum and convert to lowercase
+          if (Object.values(enumType).includes(instanceValue.toLowerCase())) {
+            body[property] = instanceValue.toLowerCase();
+          }
+        } else if (
+          typeof body[property] === 'object' &&
+          !Array.isArray(body[property])
+        ) {
+          // Recursively handle nested objects
+          this.lowercaseEnumProperties(
+            body[property],
+            instance[property],
+            targetClass,
+          );
+        }
+      }
+    }
+    return body;
+  }
+}

packages/apps/fortune/exchange-oracle/server/src/common/pagination/pagination.dto.ts

@@ -9,6 +9,7 @@ import {
 } from 'class-validator';
 import { Type } from 'class-transformer';
 import { SortDirection } from '../enums/collection';
+import { IsEnumCaseInsensitive } from '../utils/enums';
 
 export class PageDto<T> {
   @ApiProperty()
@@ -66,7 +67,7 @@ export abstract class PageOptionsDto {
   pageSize?: number = 5;
 
   @ApiPropertyOptional({ enum: SortDirection, default: SortDirection.ASC })
-  @IsEnum(SortDirection)
+  @IsEnumCaseInsensitive(SortDirection)
   @IsOptional()
   sort?: SortDirection = SortDirection.ASC;