#111039 add collapsing by field

Author: gkarkavin

composer.lock

@@ -9,5 +9,6 @@
         'sort' => 'sort',
         'aggregate' => 'aggregate',
         'facet' => 'facet',
+        'collapse' => 'collapse',
     ],
 ];

config/elastic-query-specification.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Ensi\LaravelElasticQuerySpecification\Collapsing;
+
+use Ensi\LaravelElasticQuerySpecification\Contracts\Collapse;
+use Ensi\LaravelElasticQuery\Contracts\CollapsibleQuery;
+use Webmozart\Assert\Assert;
+
+class AllowedCollapse implements Collapse
+{
+    private string $name;
+
+    protected string $field;
+
+    public function __construct(string $name, ?string $field = null)
+    {
+        Assert::stringNotEmpty($name);
+        Assert::nullOrStringNotEmpty($field);
+
+        $this->name = $name;
+        $this->field = $field ?? $this->name;
+    }
+
+    public function __invoke(CollapsibleQuery $query): void
+    {
+        $query->collapse($this->field);
+    }
+
+    public function name(): string
+    {
+        return $this->name;
+    }
+
+    public static function field(string $name, ?string $field = null): self
+    {
+        return new static($name, $field);
+    }
+
+    public static function wrap(self|string $source): self
+    {
+        return $source instanceof self
+            ? $source
+            : self::field($source);
+    }
+}

src/Collapsing/AllowedCollapse.php

@@ -37,6 +37,18 @@ public function facets(): Collection
         return $this->extractNames($key);
     }
 
+    public function collapse(): ?string
+    {
+        $key = $this->config('collapse');
+        $result = $this->extract($key);
+
+        if (!is_string($result) || empty(trim($result))) {
+            return null;
+        }
+
+        return trim($result);
+    }
+
     protected function extractNames(string $key): Collection
     {
         return collect($this->extractArray($key))

src/Concerns/ExtractsQueryParameters.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Ensi\LaravelElasticQuerySpecification\Contracts;
+
+use Ensi\LaravelElasticQuery\Contracts\CollapsibleQuery;
+
+interface Collapse
+{
+    public function __invoke(CollapsibleQuery $query): void;
+}

src/Contracts/Collapse.php

@@ -13,4 +13,6 @@ public function sorts(): Collection;
     public function aggregates(): Collection;
 
     public function facets(): Collection;
+
+    public function collapse(): ?string;
 }

src/Contracts/QueryParameters.php

@@ -40,6 +40,13 @@ public static function notAllowedFacets(Collection $facets): self
         return new self(Response::HTTP_BAD_REQUEST, $message);
     }
 
+    public static function notAllowedCollapse(string $collapse): self
+    {
+        $message = "Requested collapse \"$collapse\" are not allowed";
+
+        return new self(Response::HTTP_BAD_REQUEST, $message);
+    }
+
     public static function notSupportMultipleValues(string $filter): self
     {
         return new self(

src/Exceptions/InvalidQueryException.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Ensi\LaravelElasticQuerySpecification\Processors;
+
+use Ensi\LaravelElasticQuery\Contracts\CollapsibleQuery;
+use Ensi\LaravelElasticQuerySpecification\Exceptions\InvalidQueryException;
+use Ensi\LaravelElasticQuerySpecification\Specification\Specification;
+use Ensi\LaravelElasticQuerySpecification\Specification\Visitor;
+use Illuminate\Support\Collection;
+
+class CollapseProcessor implements Visitor
+{
+    private ?string $collapseField;
+    private Collection $allowedCollapses;
+
+    public function __construct(private CollapsibleQuery $query, ?string $field)
+    {
+        $this->collapseField = $field;
+        $this->allowedCollapses = new Collection();
+    }
+
+    public function visitRoot(Specification $specification): void
+    {
+        $this->allowedCollapses = $specification->collapses();
+    }
+
+    public function visitNested(string $field, Specification $specification): void
+    {
+    }
+
+    public function done(): void
+    {
+        $field = $this->collapseField;
+
+        if ($field === null) {
+            return;
+        }
+
+        $isAllowedCollapse = $this->allowedCollapses->has($field);
+
+        if (!$isAllowedCollapse) {
+            throw InvalidQueryException::notAllowedCollapse($field);
+        }
+
+        $this->allowedCollapses[$field]($this->query);
+    }
+}

src/Processors/CollapseProcessor.php

@@ -3,6 +3,7 @@
 namespace Ensi\LaravelElasticQuerySpecification;
 
 use Ensi\LaravelElasticQuery\Search\SearchQuery;
+use Ensi\LaravelElasticQuerySpecification\Processors\CollapseProcessor;
 use Ensi\LaravelElasticQuerySpecification\Processors\ConstraintProcessor;
 use Ensi\LaravelElasticQuerySpecification\Processors\FilterProcessor;
 use Ensi\LaravelElasticQuerySpecification\Processors\SortProcessor;
@@ -19,5 +20,6 @@ protected function processors(): Generator
         yield new FilterProcessor($this->parameters->filters());
         yield new ConstraintProcessor($this->query);
         yield new SortProcessor($this->query, $this->parameters->sorts());
+        yield new CollapseProcessor($this->query, $this->parameters->collapse());
     }
 }

src/SearchQueryBuilder.php

@@ -5,6 +5,7 @@
 use Closure;
 use Ensi\LaravelElasticQuery\Contracts\BoolQuery;
 use Ensi\LaravelElasticQuerySpecification\Agregating\AllowedAggregate;
+use Ensi\LaravelElasticQuerySpecification\Collapsing\AllowedCollapse;
 use Ensi\LaravelElasticQuerySpecification\Contracts\Constraint;
 use Ensi\LaravelElasticQuerySpecification\Exceptions\ComponentExistsException;
 use Ensi\LaravelElasticQuerySpecification\Faceting\AllowedFacet;
@@ -30,6 +31,9 @@ class Specification
     /** @var array|AllowedFacet[] */
     protected array $facets = [];
 
+    /** @var array|AllowedCollapse[] */
+    protected array $collapses = [];
+
     public static function new(): static
     {
         return new static();
@@ -194,6 +198,27 @@ public function activeFacets(): Collection
     }
     //endregion
 
+    //region Collapse
+    public function allowedCollapses(array $collapses): static
+    {
+        foreach ($collapses as $collapse) {
+            $collapse = AllowedCollapse::wrap($collapse);
+
+            $this->addComponent($this->collapses, $collapse->name(), $collapse, 'collapse');
+        }
+
+        return $this;
+    }
+
+    /**
+     * @return Collection<int,AllowedCollapse>
+     */
+    public function collapses(): Collection
+    {
+        return new Collection($this->collapses);
+    }
+    //endregion
+
     private function addComponent(array &$target, string $name, mixed $component, string $type): void
     {
         if (array_key_exists($name, $target)) {