Added Aggregate filter (#9)

* Added Aggregate filteer

* Added missing unit test coverage

Author: vladvildanov

src/Query/Filter/AbstractFilter.php

@@ -2,7 +2,6 @@
 
 namespace Vladvildanov\PredisVl\Query\Filter;
 
-use Vladvildanov\PredisVl\Enum\Condition;
 
 abstract class AbstractFilter implements FilterInterface
 {
@@ -17,13 +16,6 @@ abstract class AbstractFilter implements FilterInterface
         '!=' => '-'
     ];
 
-    /**
-     * @inheritDoc
-     */
-    public function __construct(protected string $fieldName, protected Condition $condition, protected mixed $value)
-    {
-    }
-
     /**
      * @inheritDoc
      */

src/Query/Filter/AggregateFilter.php

@@ -0,0 +1,95 @@
+<?php
+
+namespace Vladvildanov\PredisVl\Query\Filter;
+
+use Vladvildanov\PredisVl\Enum\Logical;
+
+class AggregateFilter extends AbstractFilter implements AggregateFilterInterface
+{
+    /**
+     * @var array
+     */
+    private array $filters = [];
+
+    /**
+     * Mapping for logical operators according to query syntax.
+     *
+     * @var array
+     * @link https://redis.io/docs/interact/search-and-query/query/combined/
+     */
+    private array $conjunctionMapping = [
+        '&&' => ' ',
+        '||' => ' | ',
+    ];
+
+    /**
+     * Creates an aggregated filter based on the set of given filters.
+     *
+     * If the same logical operator should be applied to all filters, you could pass them here in constructor.
+     * If you need a combination of logical operators use and() or() methods to build suitable aggregate filter.
+     *
+     * @param FilterInterface $filters
+     * @param Logical $conjunction
+     */
+    public function __construct($filters = [], Logical $conjunction = Logical::and)
+    {
+        if (!empty($filters)) {
+            $this->addFilters($filters, $conjunction);
+        }
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function and(FilterInterface ...$filter): AggregateFilterInterface
+    {
+        $this->addFilters(func_get_args(), Logical::and);
+
+        return $this;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function or(FilterInterface ...$filter): AggregateFilterInterface
+    {
+        $this->addFilters(func_get_args(), Logical::or);
+
+        return $this;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function toExpression(): string
+    {
+        return trim(implode('', $this->filters), ' |');
+    }
+
+    /**
+     * Add filters with given conjunction into array.
+     *
+     * @param FilterInterface[] $filters
+     * @param Logical $conjunction
+     * @return void
+     */
+    private function addFilters(array $filters, Logical $conjunction): void
+    {
+        if (count($filters) === 1) {
+            $this->filters[] = $this->conjunctionMapping[$conjunction->value];
+            $this->filters[] = $filters[0]->toExpression();
+        } else {
+            if (!empty($this->filters)) {
+                $this->filters[] = ' ';
+            }
+
+            foreach ($filters as $i => $filter) {
+                $this->filters[] = $filter->toExpression();
+
+                if ($i !== count($filters) - 1) {
+                    $this->filters[] = $this->conjunctionMapping[$conjunction->value];
+                }
+            }
+        }
+    }
+}

src/Query/Filter/AggregateFilterInterface.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Vladvildanov\PredisVl\Query\Filter;
+
+interface AggregateFilterInterface extends FilterInterface
+{
+    /**
+     * Creates an aggregated filter with intersection (AND).
+     *
+     * @param FilterInterface ...$filter
+     * @return AggregateFilterInterface
+     */
+    public function and(FilterInterface...$filter): AggregateFilterInterface;
+
+    /**
+     * Creates an aggregated filter with union (OR).
+     *
+     * @param FilterInterface ...$filter
+     * @return AggregateFilterInterface
+     */
+    public function or(FilterInterface...$filter): AggregateFilterInterface;
+}

src/Query/Filter/FilterInterface.php

@@ -2,19 +2,8 @@
 
 namespace Vladvildanov\PredisVl\Query\Filter;
 
-use Vladvildanov\PredisVl\Enum\Condition;
-
 interface FilterInterface
 {
-    /**
-     * Creates field-based filter.
-     *
-     * @param string $fieldName
-     * @param Condition $condition
-     * @param mixed $value
-     */
-    public function __construct(string $fieldName, Condition $condition, mixed $value);
-
     /**
      * Returns expression-string representation of current filter.
      *

src/Query/Filter/GeoFilter.php

@@ -19,16 +19,15 @@ class GeoFilter extends AbstractFilter
      * @param array{lon: float, lat: float, radius: int, unit: Unit} $value
      */
     public function __construct(
-        string $fieldName,
-        Condition $condition,
+        protected readonly string    $fieldName,
+        protected readonly Condition $condition,
         #[ArrayShape([
             'lon' => 'float',
             'lat' => 'float',
             'radius' => 'int',
             'unit' => Unit::class
-        ])] $value
+        ])] protected readonly array $value
     ) {
-        parent::__construct($fieldName, $condition, $value);
     }
 
     /**

src/Query/Filter/NumericFilter.php

@@ -16,7 +16,6 @@ public function __construct(
         protected Condition $condition,
         protected mixed $value
     ) {
-        parent::__construct($fieldName, $condition, $value);
     }
 
     /**

src/Query/Filter/TagFilter.php

@@ -24,7 +24,6 @@ public function __construct(
             'tags' => 'array',
         ])] protected mixed $value
     ) {
-        parent::__construct($this->fieldName, $this->condition, $this->value);
     }
 
     /**

src/Query/Filter/TextFilter.php

@@ -21,9 +21,8 @@ class TextFilter extends AbstractFilter
      * @param Condition $condition
      * @param string $value
      */
-    public function __construct(string $fieldName, Condition $condition, $value)
+    public function __construct(protected string $fieldName, protected Condition $condition, protected string $value)
     {
-        parent::__construct($fieldName, $condition, $value);
     }
 
     /**