Search in Elasticsearch by criteria

Author: rgomezcasas

databases/backoffice/courses.json

@@ -3,13 +3,16 @@
     "courses": {
       "properties": {
         "id": {
-          "type": "keyword"
+          "type": "keyword",
+          "index": true
         },
         "name": {
-          "type": "text"
+          "type": "text",
+          "index": true
         },
         "duration": {
-          "type": "text"
+          "type": "text",
+          "index": true
         }
       }
     }

doc/endpoints/backoffice_frontend.http

@@ -0,0 +1,19 @@
+# ELASTIC - Search
+POST localhost:9200/backoffice_courses/_search
+Content-Type: application/json
+
+{
+  "query": {
+    "term": {
+      "name": "Pepe"
+    }
+  }
+}
+
+###
+# ELASTIC - Search
+POST localhost:9200/backoffice_courses/_search
+Content-Type: application/json
+
+###
+

src/Backoffice/Courses/Infrastructure/Persistence/ElasticsearchBackofficeCourseRepository.php

@@ -14,7 +14,7 @@ final class ElasticsearchBackofficeCourseRepository extends ElasticsearchReposit
 {
     protected function aggregateName(): string
     {
-        return 'course';
+        return 'courses';
     }
 
     public function save(BackofficeCourse $course): void
@@ -29,7 +29,7 @@ public function searchAll(): array
 
     public function matching(Criteria $criteria): array
     {
-        return map($this->toCourse(), $this->searchAllInElastic());
+        return map($this->toCourse(), $this->searchByCriteria($criteria));
     }
 
     private function toCourse()

src/Shared/Domain/Criteria/FilterOperator.php

@@ -14,16 +14,25 @@
  */
 final class FilterOperator extends Enum
 {
-    public const EQUAL    = '=';
-    public const GT       = '>';
-    public const LT       = '<';
-    public const CONTAINS = 'CONTAINS';
+    public const EQUAL        = '=';
+    public const NOT_EQUAL    = '!=';
+    public const GT           = '>';
+    public const LT           = '<';
+    public const CONTAINS     = 'CONTAINS';
+    public const NOT_CONTAINS = 'NOT_CONTAINS';
+
+    private static $containing = [self::CONTAINS, self::NOT_CONTAINS];
 
     public static function equal(): self
     {
         return new self('=');
     }
 
+    public function isContaining(): bool
+    {
+        return in_array($this->value(), self::$containing, true);
+    }
+
     protected function throwExceptionForInvalidValue($value): void
     {
         throw new InvalidArgumentException(sprintf('The filter <%s> is invalid', $value));

src/Shared/Infrastructure/Elasticsearch/ElasticsearchClientFactory.php

@@ -15,7 +15,7 @@ public function __invoke(
         string $host,
         string $indexPrefix,
         string $schemasFolder,
-        bool $environment
+        string $environment
     ): ElasticsearchClient {
         $client = ClientBuilder::create()->setHosts([$host])->build();
 
@@ -33,7 +33,7 @@ private function generateIndexIfNotExists(
         $indexes = Utils::filesIn($schemasFolder, '.json');
 
         foreach ($indexes as $index) {
-            $indexName = sprintf('%s_%s', $indexPrefix, $index);
+            $indexName = str_replace('.json', '', sprintf('%s_%s', $indexPrefix, $index));
 
             if ('prod' !== $environment && !$this->indexExists($client, $indexName)) {
                 $indexBody = Utils::jsonDecode(file_get_contents("$schemasFolder/$index"));

src/Shared/Infrastructure/Persistence/Elasticsearch/ElasticQueryGenerator.php

@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace CodelyTv\Shared\Infrastructure\Persistence\Elasticsearch;
+
+use CodelyTv\Shared\Domain\Criteria\Filter;
+use CodelyTv\Shared\Domain\Criteria\FilterOperator;
+use function Lambdish\Phunctional\get;
+
+final class ElasticQueryGenerator
+{
+    private const MUST_TYPE     = 'must';
+    private const MUST_NOT_TYPE = 'must_not';
+    private const TERM_TERM     = 'term';
+    private const TERM_RANGE    = 'range';
+    private const TERM_WILDCARD = 'wildcard';
+    private static $termMapping = [
+        FilterOperator::EQUAL        => self::TERM_TERM,
+        FilterOperator::NOT_EQUAL    => '!=',
+        FilterOperator::GT           => self::TERM_RANGE,
+        FilterOperator::LT           => self::TERM_RANGE,
+        FilterOperator::CONTAINS     => self::TERM_WILDCARD,
+        FilterOperator::NOT_CONTAINS => self::TERM_WILDCARD,
+    ];
+    private static $mustNotFields = [FilterOperator::NOT_EQUAL, FilterOperator::NOT_CONTAINS];
+
+    public function __invoke(array $query, Filter $filter)
+    {
+        $type          = $this->typeFor($filter->operator());
+        $termLevel     = $this->termLeverFor($filter->operator());
+        $valueTemplate = $filter->operator()->isContaining() ? '*%s*' : '%s';
+
+        return array_merge_recursive(
+            $query,
+            [
+                $type => [
+                    $termLevel => [
+                        $filter->field()->value() => sprintf(
+                            $valueTemplate,
+                            strtolower($filter->value()->value())
+                        ),
+                    ],
+                ],
+            ]
+        );
+    }
+
+    private function typeFor(FilterOperator $operator): string
+    {
+        return in_array($operator->value(), self::$mustNotFields, true) ? self::MUST_NOT_TYPE : self::MUST_TYPE;
+    }
+
+    private function termLeverFor(FilterOperator $operator): string
+    {
+        return get($operator->value(), self::$termMapping);
+    }
+}

src/Shared/Infrastructure/Persistence/Elasticsearch/ElasticsearchCriteriaConverter.php

@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace CodelyTv\Shared\Infrastructure\Persistence\Elasticsearch;
+
+use CodelyTv\Shared\Domain\Criteria\Criteria;
+use function Lambdish\Phunctional\reduce;
+
+final class ElasticsearchCriteriaConverter
+{
+    public function convert(Criteria $criteria): array
+    {
+        return [
+            'body' => array_merge(
+                ['from' => $criteria->offset() ?: 0, 'size' => $criteria->limit() ?: 1000],
+                $this->formatQuery($criteria),
+                $this->formatSort($criteria)
+            ),
+        ];
+    }
+
+    private function formatQuery(Criteria $criteria): array
+    {
+        if ($criteria->hasFilters()) {
+            $multipleFilters = 1 < $criteria->filters()->count();
+
+            return [
+                'query' => [
+                    'bool' => reduce(new ElasticQueryGenerator(), $criteria->filters(), []),
+                ],
+            ];
+        }
+
+        return [];
+    }
+
+    private function formatSort(Criteria $criteria): array
+    {
+        if ($criteria->hasOrder()) {
+            $order = $criteria->order();
+
+            return ['sort' => [$order->orderBy()->value() => ['order' => $order->orderType()->value()]]];
+        }
+
+        return [];
+    }
+}

src/Shared/Infrastructure/Persistence/Elasticsearch/ElasticsearchRepository.php

@@ -4,10 +4,9 @@
 
 namespace CodelyTv\Shared\Infrastructure\Persistence\Elasticsearch;
 
-use CodelyTv\Shared\Domain\ValueObject\Uuid;
+use CodelyTv\Shared\Domain\Criteria\Criteria;
 use CodelyTv\Shared\Infrastructure\Elasticsearch\ElasticsearchClient;
 use Elasticsearch\Common\Exceptions\Missing404Exception;
-use function Lambdish\Phunctional\get;
 use function Lambdish\Phunctional\get_in;
 use function Lambdish\Phunctional\map;
 
@@ -27,39 +26,36 @@ protected function persist(string $id, array $plainBody): void
         $this->client->persist($this->aggregateName(), $id, $plainBody);
     }
 
-    protected function searchInElasticById(Uuid $id): ?array
+    protected function searchAllInElastic(): array
+    {
+        return $this->searchRawElasticsearchQuery([]);
+    }
+
+    protected function searchRawElasticsearchQuery(array $params): array
     {
         try {
-            $result = $this->client->get(
-                [
-                    'index' => $this->indexName(),
-                    'type'  => $this->typeName(),
-                    'id'    => $id->value(),
-                ]
-            );
-
-            return get('_source', $result);
+            $result = $this->client->client()->search(array_merge(['index' => $this->indexName()], $params));
+
+            $hits = get_in(['hits', 'hits'], $result, []);
+
+            return map($this->elasticValuesExtractor(), $hits);
         } catch (Missing404Exception $unused) {
-            return null;
+            return [];
         }
     }
 
-    protected function indexName(): string
+    public function searchByCriteria(Criteria $criteria): array
     {
-        return sprintf('%s_%s', $this->client->indexPrefix(), $this->aggregateName());
-    }
+        $converter = new ElasticsearchCriteriaConverter();
 
-    protected function searchAllInElastic(): array
-    {
-        $result = $this->client->client()->search(
-            [
-                'index' => $this->indexName(),
-            ]
-        );
+        $query = $converter->convert($criteria);
 
-        $hits = get_in(['hits', 'hits'], $result, []);
+        return $this->searchRawElasticsearchQuery($query);
+    }
 
-        return map($this->elasticValuesExtractor(), $hits);
+    protected function indexName(): string
+    {
+        return sprintf('%s_%s', $this->client->indexPrefix(), $this->aggregateName());
     }
 
     private function elasticValuesExtractor(): callable