refactor: use Object.values instead of switch (#139)

Changing way to validate enum values

Author: JavierCane

src/Contexts/Shared/domain/criteria/FilterOperator.ts

@@ -16,22 +16,13 @@ export class FilterOperator extends EnumValueObject<Operator> {
   }
 
   static fromValue(value: string): FilterOperator {
-    switch (value) {
-      case Operator.EQUAL:
-        return new FilterOperator(Operator.EQUAL);
-      case Operator.NOT_EQUAL:
-        return new FilterOperator(Operator.NOT_EQUAL);
-      case Operator.GT:
-        return new FilterOperator(Operator.GT);
-      case Operator.LT:
-        return new FilterOperator(Operator.LT);
-      case Operator.CONTAINS:
-        return new FilterOperator(Operator.CONTAINS);
-      case Operator.NOT_CONTAINS:
-        return new FilterOperator(Operator.NOT_CONTAINS);
-      default:
-        throw new InvalidArgumentError(`The filter operator ${value} is invalid`);
+    for (const operatorValue of Object.values(Operator)) {
+      if (value === operatorValue.toString()) {
+        return new FilterOperator(operatorValue);
+      }
     }
+
+    throw new InvalidArgumentError(`The filter operator ${value} is invalid`);
   }
 
   public isPositive(): boolean {

src/Contexts/Shared/domain/criteria/OrderType.ts

@@ -13,14 +13,13 @@ export class OrderType extends EnumValueObject<OrderTypes> {
   }
 
   static fromValue(value: string): OrderType {
-    switch (value) {
-      case OrderTypes.ASC:
-        return new OrderType(OrderTypes.ASC);
-      case OrderTypes.DESC:
-        return new OrderType(OrderTypes.DESC);
-      default:
-        throw new InvalidArgumentError(`The order type ${value} is invalid`);
+    for (const orderTypeValue of Object.values(OrderTypes)) {
+      if (value === orderTypeValue.toString()) {
+        return new OrderType(orderTypeValue);
+      }
     }
+
+    throw new InvalidArgumentError(`The order type ${value} is invalid`);
   }
 
   public isNone(): boolean {