elastic criteria converter in backoffice

Author: alemarcha

src/Contexts/Backoffice/Courses/infrastructure/persistence/ElasticBackofficeCourseRepository.ts

@@ -18,7 +18,7 @@ export class ElasticBackofficeCourseRepository
     return this.persist(course);
   }
 
-  matching(criteria: Criteria): Promise<BackofficeCourse[]> {
+  async matching(criteria: Criteria): Promise<BackofficeCourse[]> {
     return this.searchByCriteria(criteria, BackofficeCourse.fromPrimitives);
   }
 }

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

@@ -1,3 +1,4 @@
+import { EnumValueObject } from '../value-object/EnumValueObject';
 import { InvalidArgumentError } from '../value-object/InvalidArgumentError';
 
 export enum FilterOperators {
@@ -9,12 +10,9 @@ export enum FilterOperators {
   NOT_CONTAINS = 'NOT_CONTAINS'
 }
 
-export class FilterOperator {
-  readonly value: string;
-
-  constructor(value: string) {
-    this.value = value;
-    this.ensureIsBetweenAcceptedValues(value);
+export class FilterOperator extends EnumValueObject<FilterOperators> {
+  constructor(value: FilterOperators) {
+    super(value, Object.values(FilterOperators));
   }
 
   static fromValue(value: string): FilterOperator {
@@ -32,24 +30,15 @@ export class FilterOperator {
       case FilterOperators.NOT_CONTAINS:
         return new FilterOperator(FilterOperators.NOT_CONTAINS);
       default:
-        return new FilterOperator(value);
+        throw new InvalidArgumentError(`The filter operator ${value} is invalid`);
     }
   }
 
   public isPositive(): boolean {
     return this.value !== FilterOperators.NOT_EQUAL && this.value !== FilterOperators.NOT_CONTAINS;
   }
 
-  private ensureIsBetweenAcceptedValues(value: string): void {
-    const allOperators: string[] = Object.values(FilterOperators);
-    const operatorsIncludeValue = allOperators.includes(value);
-
-    if (!operatorsIncludeValue) {
-      this.throwExceptionForInvalidValue(value);
-    }
-  }
-
-  private throwExceptionForInvalidValue(value: string): void {
+  protected throwErrorForInvalidValue(value: FilterOperators): void {
     throw new InvalidArgumentError(`The filter operator ${value} is invalid`);
   }
 }

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

@@ -31,6 +31,6 @@ export class Order {
   }
 
   public hasOrder() {
-    return this.orderType.isNone();
+    return !this.orderType.isNone();
   }
 }

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

@@ -1,3 +1,4 @@
+import { EnumValueObject } from '../value-object/EnumValueObject';
 import { InvalidArgumentError } from '../value-object/InvalidArgumentError';
 
 export enum OrderTypes {
@@ -6,12 +7,9 @@ export enum OrderTypes {
   NONE = 'none'
 }
 
-export class OrderType {
-  readonly value: string;
-
-  constructor(type: string) {
-    this.value = type;
-    this.ensureIsBetweenAcceptedValues(type);
+export class OrderType extends EnumValueObject<OrderTypes> {
+  constructor(value: OrderTypes) {
+    super(value, Object.values(OrderTypes));
   }
 
   static fromValue(value: string): OrderType {
@@ -21,7 +19,7 @@ export class OrderType {
       case OrderTypes.DESC:
         return new OrderType(OrderTypes.DESC);
       default:
-        return new OrderType(value);
+        throw new InvalidArgumentError(`The order type ${value} is invalid`);
     }
   }
 
@@ -33,16 +31,7 @@ export class OrderType {
     return this.value === OrderTypes.ASC;
   }
 
-  private ensureIsBetweenAcceptedValues(value: string): void {
-    const allOperators: string[] = Object.values(OrderTypes);
-    const operatorsIncludeValue = allOperators.includes(value);
-
-    if (!operatorsIncludeValue) {
-      this.throwExceptionForInvalidValue(value);
-    }
-  }
-
-  private throwExceptionForInvalidValue(value: string): void {
+  protected throwErrorForInvalidValue(value: OrderTypes): void {
     throw new InvalidArgumentError(`The order type ${value} is invalid`);
   }
 }

src/Contexts/Shared/domain/value-object/EnumValueObject.ts

@@ -0,0 +1,16 @@
+export abstract class EnumValueObject<T> {
+  readonly value: T;
+
+  constructor(value: T, public readonly validValues: T[]) {
+    this.value = value;
+    this.checkValueIsValid(value);
+  }
+
+  public checkValueIsValid(value: T): void {
+    if (!this.validValues.includes(value)) {
+      this.throwErrorForInvalidValue(value);
+    }
+  }
+
+  protected abstract throwErrorForInvalidValue(value: T): void;
+}

src/Contexts/Shared/infrastructure/persistence/elasticsearch/ElasticCriteriaConverter.ts

@@ -0,0 +1,90 @@
+import { Bodybuilder } from 'bodybuilder';
+import { Criteria } from '../../../domain/criteria/Criteria';
+import { Filter } from '../../../domain/criteria/Filter';
+import { FilterOperators } from '../../../domain/criteria/FilterOperator';
+import { Filters } from '../../../domain/criteria/Filters';
+
+export enum TypeQueryEnum {
+  TERMS = 'terms',
+  MATCH = 'match',
+  MATCH_ALL = 'match_all',
+  RANGE = 'range'
+}
+
+type QueryObject = { type: TypeQueryEnum; field: string; value: string | object };
+
+interface FunctionTransformer<T, K> {
+  (value: T): K;
+}
+
+export class ElasticCriteriaConverter {
+  private queryTransformers: Map<FilterOperators, FunctionTransformer<Filter, QueryObject>>;
+
+  constructor() {
+    this.queryTransformers = new Map<FilterOperators, FunctionTransformer<Filter, QueryObject>>([
+      [FilterOperators.EQUAL, this.termsQuery],
+      [FilterOperators.NOT_EQUAL, this.termsQuery],
+      [FilterOperators.GT, this.greaterThanQuery],
+      [FilterOperators.LT, this.lowerThanQuery],
+      [FilterOperators.CONTAINS, this.matchQuery],
+      [FilterOperators.NOT_CONTAINS, this.matchQuery]
+    ]);
+  }
+
+  public convert(criteria: Criteria): Bodybuilder {
+    let body = bodybuilder();
+
+    body.from(criteria.offset || 0);
+    body.size(criteria.limit || 1000);
+
+    if (criteria.order.hasOrder()) {
+      body.sort(criteria.order.orderBy.value, criteria.order.orderType.value);
+    }
+
+    if (criteria.hasFilters()) {
+      body = this.generateQuery(body, criteria.filters);
+    }
+
+    return body;
+  }
+
+  protected generateQuery(body: Bodybuilder, filters: Filters): Bodybuilder {
+    filters.filters.map(filter => {
+      const { type, value, field } = this.queryForFilter(filter);
+
+      if (filter.operator.isPositive()) {
+        body.query(type, field, value);
+      } else {
+        body.notQuery(type, field, value);
+      }
+    });
+
+    return body;
+  }
+
+  private queryForFilter(filter: Filter): QueryObject {
+    const functionToApply = this.queryTransformers.get(filter.operator.value);
+
+    if (!functionToApply) {
+      throw Error(`Unexpected operator value ${filter.operator.value}`);
+    }
+
+    return functionToApply(filter);
+  }
+
+  private termsQuery(filter: Filter): QueryObject {
+    return { type: TypeQueryEnum.TERMS, field: filter.field.value, value: filter.value.value };
+  }
+
+  private greaterThanQuery(filter: Filter): QueryObject {
+    return { type: TypeQueryEnum.RANGE, field: filter.field.value, value: { gt: filter.value.value } };
+  }
+
+  private lowerThanQuery(filter: Filter): QueryObject {
+    return { type: TypeQueryEnum.RANGE, field: filter.field.value, value: { lt: filter.value.value } };
+  }
+
+  private matchQuery(filter: Filter): QueryObject {
+    return { type: TypeQueryEnum.MATCH, field: filter.field.value, value: filter.value.value };
+  }
+}

src/Contexts/Shared/infrastructure/persistence/elasticsearch/ElasticRepository.ts

@@ -1,14 +1,19 @@
 import { Client as ElasticClient } from '@elastic/elasticsearch';
 import { ResponseError } from '@elastic/elasticsearch/lib/errors';
+import bodybuilder, { Bodybuilder } from 'bodybuilder';
 import httpStatus from 'http-status';
 import { AggregateRoot } from '../../../domain/AggregateRoot';
 import { Criteria } from '../../../domain/criteria/Criteria';
-import bodybuilder, { Bodybuilder } from 'bodybuilder';
+import { ElasticCriteriaConverter, TypeQueryEnum } from './ElasticCriteriaConverter';
 
 type Hit = { _source: any };
 
 export abstract class ElasticRepository<T extends AggregateRoot> {
-  constructor(private _client: Promise<ElasticClient>) {}
+  private criteriaConverter: ElasticCriteriaConverter;
+
+  constructor(private _client: Promise<ElasticClient>) {
+    this.criteriaConverter = new ElasticCriteriaConverter();
+  }
 
   protected abstract moduleName(): string;
 
@@ -17,15 +22,14 @@ export abstract class ElasticRepository<T extends AggregateRoot> {
   }
 
   protected async searchAllInElastic(unserializer: (data: any) => T): Promise<T[]> {
-    const body = bodybuilder().query('match_all');
-    body.build();
+    const body = bodybuilder().query(TypeQueryEnum.MATCH_ALL);
+
     return this.searchInElasticWithSourceBuilder(unserializer, body);
   }
 
   protected async searchByCriteria(criteria: Criteria, unserializer: (data: any) => T): Promise<T[]> {
-    // TODO elastic search converter from Criteria
-    const body = bodybuilder().query('match_all');
-    body.build();
+    const body = this.criteriaConverter.convert(criteria);
+
     return this.searchInElasticWithSourceBuilder(unserializer, body);
   }
 
@@ -35,7 +39,7 @@ export abstract class ElasticRepository<T extends AggregateRoot> {
     try {
       const response = await client.search({
         index: this.moduleName(),
-        body
+        body: body.build()
       });
 
       return response.body.hits.hits.map((hit: Hit) => unserializer({ ...hit._source }));

tests/Contexts/Backoffice/Courses/application/SearchByCriteria/SearchCoursesByCriteriaQueryHandler.test.ts

@@ -33,12 +33,10 @@ describe('SearchAllCourses QueryHandler', () => {
     const filters: Array<Map<string, string>> = new Array(filterName, filterDuration);
 
     const query = new SearchCoursesByCriteriaQuery(filters);
-
     const response = await handler.handle(query);
 
-    repository.assertMatchingHasBeenCalledWith();
-
     const expected = SearchCoursesByCriteriaResponseMother.create(courses);
+    repository.assertMatchingHasBeenCalledWith();
     expect(expected).toEqual(response);
   });
 
@@ -60,17 +58,14 @@ describe('SearchAllCourses QueryHandler', () => {
     ]);
 
     const filters: Array<Map<string, string>> = new Array(filterName, filterDuration);
-
     const orderBy = 'name';
     const orderType = OrderTypes.ASC;
 
     const query = new SearchCoursesByCriteriaQuery(filters, orderBy, orderType, 10, 1);
-
     const response = await handler.handle(query);
 
-    repository.assertMatchingHasBeenCalledWith();
-
     const expected = SearchCoursesByCriteriaResponseMother.create(courses);
+    repository.assertMatchingHasBeenCalledWith();
     expect(expected).toEqual(response);
   });
 });

tests/Contexts/Backoffice/Courses/domain/BackofficeCourseCriteriaMother.ts

@@ -0,0 +1,22 @@
+import { Criteria } from '../../../../../src/Contexts/Shared/domain/criteria/Criteria';
+import { Filter } from '../../../../../src/Contexts/Shared/domain/criteria/Filter';
+import { FilterField } from '../../../../../src/Contexts/Shared/domain/criteria/FilterField';
+import { FilterOperator, FilterOperators } from '../../../../../src/Contexts/Shared/domain/criteria/FilterOperator';
+import { Filters } from '../../../../../src/Contexts/Shared/domain/criteria/Filters';
+import { FilterValue } from '../../../../../src/Contexts/Shared/domain/criteria/FilterValue';
+import { Order } from '../../../../../src/Contexts/Shared/domain/criteria/Order';
+
+export class BackofficeCourseCriteriaMother {
+  static nameAndDurationContains(name: string, duration: string): Criteria {
+    const filterFieldName = new FilterField('name');
+    const filterFieldDuration = new FilterField('duration');
+    const filterOperator = new FilterOperator(FilterOperators.CONTAINS);
+    const valueName = new FilterValue(name);
+    const valueDuration = new FilterValue(duration);
+
+    const nameFilter = new Filter(filterFieldName, filterOperator, valueName);
+    const durationFilter = new Filter(filterFieldDuration, filterOperator, valueDuration);
+
+    return new Criteria(new Filters([nameFilter, durationFilter]), Order.asc('name'));
+  }
+}

tests/Contexts/Backoffice/Courses/domain/BackofficeCourseMother.ts

@@ -15,6 +15,14 @@ export class BackofficeCourseMother {
     return new BackofficeCourse(id, name, duration);
   }
 
+  static withNameAndDuration(name: string, duration: string): BackofficeCourse {
+    return this.create(
+      BackofficeCourseIdMother.random(),
+      BackofficeCourseNameMother.create(name),
+      BackofficeCourseDurationMother.create(duration)
+    );
+  }
+
   static random(): BackofficeCourse {
     return this.create(
       BackofficeCourseIdMother.random(),