Merge pull request #5 from ensi-platform/dev-range

Range filters

Author: zix2

README.md

@@ -129,8 +129,12 @@ $this->allowedFilters([AllowedFilter::exact('name', 'name')]);
 Types of filters
 
 ```php
-AllowedFilter::exact('name', 'field');  // The field value is checked for equality to one of the specified
-AllowedFilter::exists('name', 'field'); // There is a check that the field is in the document and has a non-zero value.
+AllowedFilter::exact('name', 'field');          // The field value is checked for equality to one of the specified
+AllowedFilter::exists('name', 'field');         // There is a check that the field is in the document and has a non-zero value.
+AllowedFilter::greater('name', 'field');        // The field value must be greater than the specified one.
+AllowedFilter::greaterOrEqual('name', 'field'); // The field value must be greater than or equal to the specified one.
+AllowedFilter::less('name', 'field');           // The field value must be less than the specified one.
+AllowedFilter::lessOrEqual('name', 'field');    // The field value must be less than or equal to the specified one.
 ```
 
 The sorts available to the client are added by the `allowedSorts` method. The sorting direction is set in its name.

composer.json

@@ -20,7 +20,8 @@
         "ensi/laravel-elastic-query": "^0.3.0",
         "illuminate/contracts": "^8.37 || ^9.0",
         "illuminate/support": "^8.0 || ^9.0",
-        "spatie/laravel-package-tools": "^1.4.3"
+        "spatie/laravel-package-tools": "^1.4.3",
+        "webmozart/assert": "^1.11"
     },
     "require-dev": {
         "friendsofphp/php-cs-fixer": "^3.2",

composer.lock

@@ -39,4 +39,12 @@ public static function notAllowedFacets(Collection $facets): self
 
         return new self(Response::HTTP_BAD_REQUEST, $message);
     }
+
+    public static function notSupportMultipleValues(string $filter): self
+    {
+        return new self(
+            Response::HTTP_BAD_REQUEST,
+            "Filter \"{$filter}\" does not support multiple values"
+        );
+    }
 }

src/Exceptions/InvalidQueryException.php

@@ -97,6 +97,26 @@ public static function exists(string $name, ?string $field = null): self
         return new static($name, new ExistsFilterAction(), $field);
     }
 
+    public static function greater(string $name, ?string $field = null): self
+    {
+        return new static($name, new RangeFilterAction('>'), $field);
+    }
+
+    public static function greaterOrEqual(string $name, ?string $field = null): self
+    {
+        return new static($name, new RangeFilterAction('>='), $field);
+    }
+
+    public static function less(string $name, ?string $field = null): self
+    {
+        return new static($name, new RangeFilterAction('<'), $field);
+    }
+
+    public static function lessOrEqual(string $name, ?string $field = null): self
+    {
+        return new static($name, new RangeFilterAction('<='), $field);
+    }
+
     private function refineValue(mixed $value): mixed
     {
         if ($value === null) {

src/Filtering/AllowedFilter.php

@@ -9,27 +9,8 @@ class ExactFilterAction implements FilterAction
 {
     public function __invoke(BoolQuery $query, mixed $value, string $field): void
     {
-        $value = $this->normalizeValue($value);
-        if ($value === null) {
-            return;
-        }
-
-        is_array($value)
-            ? $query->whereIn($field, $value)
-            : $query->where($field, $value);
-    }
-
-    private function normalizeValue(mixed $value): mixed
-    {
-        if (!is_array($value)) {
-            return $value;
-        }
-
-        $normalized = array_filter($value);
-        if (!$normalized) {
-            return null;
-        }
-
-        return count($normalized) === 1 ? head($normalized) : array_values($normalized);
+        FilterValue::make($value)
+            ->whenMultiple(fn (array $value) => $query->whereIn($field, $value))
+            ->whenSingle(fn (mixed $value) => $query->where($field, $value));
     }
 }

src/Filtering/ExactFilterAction.php

@@ -9,8 +9,8 @@ class ExistsFilterAction implements FilterAction
 {
     public function __invoke(BoolQuery $query, mixed $value, string $field): void
     {
-        $value === true
-            ? $query->whereNotNull($field)
-            : $query->whereNull($field);
+        FilterValue::make($value)
+            ->whenSame(true, fn () => $query->whereNotNull($field))
+            ->orElse(fn () => $query->whereNull($field));
     }
 }

src/Filtering/ExistsFilterAction.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace Ensi\LaravelElasticQuerySpecification\Filtering;
+
+final class FilterValue
+{
+    protected function __construct(private mixed $value, private bool $disposed)
+    {
+    }
+
+    public static function make(mixed $value): self
+    {
+        return new self(self::normalizeValue($value), false);
+    }
+
+    private static function normalizeValue(mixed $value): mixed
+    {
+        if (!is_array($value)) {
+            return $value;
+        }
+
+        $normalized = array_filter($value);
+        if (!$normalized) {
+            return null;
+        }
+
+        return count($normalized) === 1 ? head($normalized) : array_values($normalized);
+    }
+
+    public function when(bool $condition, callable $callback): self
+    {
+        if ($this->disposed || !$condition) {
+            return $this;
+        }
+
+        $callback($this->value);
+
+        return new self($this->value, true);
+    }
+
+    public function whenMultiple(callable $callback): self
+    {
+        return $this->when(is_array($this->value), $callback);
+    }
+
+    public function whenSingle(callable $callback): self
+    {
+        return $this->when(!is_array($this->value), $callback);
+    }
+
+    public function whenSame(mixed $sample, callable $callback): self
+    {
+        return $this->when($this->value === $sample, $callback);
+    }
+
+    public function orElse(callable $callback): self
+    {
+        return $this->when(true, $callback);
+    }
+}

src/Filtering/FilterValue.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Ensi\LaravelElasticQuerySpecification\Filtering;
+
+use Ensi\LaravelElasticQuery\Contracts\BoolQuery;
+use Ensi\LaravelElasticQuerySpecification\Contracts\FilterAction;
+use Ensi\LaravelElasticQuerySpecification\Exceptions\InvalidQueryException;
+
+class RangeFilterAction implements FilterAction
+{
+    public function __construct(private string $operator)
+    {
+    }
+
+    public function __invoke(BoolQuery $query, mixed $value, string $field): void
+    {
+        FilterValue::make($value)
+            ->whenSingle(fn (mixed $value) => $query->where($field, $this->operator, $value))
+            ->whenMultiple(fn () => throw InvalidQueryException::notSupportMultipleValues($field));
+    }
+}

src/Filtering/RangeFilterAction.php

@@ -91,3 +91,28 @@
         ->assertBucketKeys('tags', ['water', 'drinks', 'video'])
         ->assertBucketKeys('seller_id', [10, 15, 20]);
 });
+
+test('facet with multiple filters', function () {
+    $spec = CompositeSpecification::new()
+        ->nested('offers', function (Specification $spec) {
+            $spec
+                ->allowedFilters([
+                    AllowedFilter::greaterOrEqual('price__gte', 'price'),
+                    AllowedFilter::lessOrEqual('price__lte', 'price'),
+                    AllowedFilter::exact('seller_id'),
+                ])
+                ->allowedFacets([
+                    AllowedFacet::minmax('price', ['price__gte', 'price__lte']),
+                    AllowedFacet::terms('seller_id'),
+                ]);
+        });
+
+    $request = [
+        'facet' => ['price', 'seller_id'],
+        'filter' => ['seller_id' => 20, 'price__gte' => 300, 'price__lte' => 20000],
+    ];
+
+    facetQuery($spec, $request)
+        ->assertBucketKeys('seller_id', [10, 15, 90])
+        ->assertMinMax('price', 200, 28990);
+});