*add - new traits / parameters for queries (boost, case_insensitive, format, minimum_should_match, rewrite)

*edit - queries - new parameters
*edit - tests including new parameters
*fix - PrefixQuery has no boost (according to documentation)
*fix - QueryStringTest renamed to QueryStringQueryTest, RankFeatureTest renamed to RankFeatureQueryTest
*add - missing tests
*edit - phpstan - highest level is 9 now
*edit - .gitignore - .editorconfig added (but I can recommend to add it to the repository - but with yours settings)

Author: xsuchy09

.gitignore

@@ -1,3 +1,4 @@
 vendor
 composer.lock
-.phpunit.result.cache
+.phpunit.result.cache
+.editorconfig

phpstan.neon

@@ -12,8 +12,8 @@ parameters:
         - src
         - tests
 
-    # The level 8 is the highest level
-    level: 8
+    # The level 9 is the highest level
+    level: 9
 
     # it is impossible to map build()
     checkMissingIterableValueType: false

src/Features/HasBoost.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Erichard\ElasticQueryBuilder\Features;
+
+trait HasBoost
+{
+    protected ?float $boost = null;
+
+    public function setBoost(?float $boost): self
+    {
+        $this->boost = $boost;
+
+        return $this;
+    }
+
+    public function buildBoostTo(array &$array): self
+    {
+        if (null === $this->boost) {
+            return $this;
+        }
+
+        $array['boost'] = $this->boost;
+
+        return $this;
+    }
+
+    public function getBoost(): ?float
+    {
+        return $this->boost;
+    }
+}

src/Features/HasCaseInsensitive.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Erichard\ElasticQueryBuilder\Features;
+
+trait HasCaseInsensitive
+{
+    protected ?bool $caseInsensitive = null;
+
+    public function setCaseInsensitive(?bool $caseInsensitive): self
+    {
+        $this->caseInsensitive = $caseInsensitive;
+
+        return $this;
+    }
+
+    public function buildCaseInsensitiveTo(array &$array): self
+    {
+        if (null === $this->caseInsensitive) {
+            return $this;
+        }
+
+        $array['case_insensitive'] = $this->caseInsensitive;
+
+        return $this;
+    }
+
+    public function getCaseInsensitive(): ?bool
+    {
+        return $this->caseInsensitive;
+    }
+}

src/Features/HasFormat.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Erichard\ElasticQueryBuilder\Features;
+
+trait HasFormat
+{
+    protected ?string $format = null;
+
+    public function setFormat(?string $format): self
+    {
+        $this->format = $format;
+
+        return $this;
+    }
+
+    public function buildFormatTo(array &$array): self
+    {
+        if (null === $this->format) {
+            return $this;
+        }
+
+        $array['format'] = $this->format;
+
+        return $this;
+    }
+
+    public function getFormat(): ?string
+    {
+        return $this->format;
+    }
+}

src/Features/HasMinimumShouldMatch.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Erichard\ElasticQueryBuilder\Features;
+
+trait HasMinimumShouldMatch
+{
+    protected ?string $minimumShouldMatch = null;
+
+    public function setMinimumShouldMatch(?string $minimumShouldMatch): self
+    {
+        $this->minimumShouldMatch = $minimumShouldMatch;
+
+        return $this;
+    }
+
+    public function buildMinimumShouldMatchTo(array &$array): self
+    {
+        if (null === $this->minimumShouldMatch) {
+            return $this;
+        }
+
+        $array['minimum_should_match'] = $this->minimumShouldMatch;
+
+        return $this;
+    }
+
+    public function getMinimumShouldMatch(): ?string
+    {
+        return $this->minimumShouldMatch;
+    }
+}

src/Features/HasRewrite.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Erichard\ElasticQueryBuilder\Features;
+
+trait HasRewrite
+{
+    protected ?string $rewrite = null;
+
+    public function setRewrite(?string $rewrite): self
+    {
+        $this->rewrite = $rewrite;
+
+        return $this;
+    }
+
+    public function buildRewriteTo(array &$array): self
+    {
+        if (null === $this->rewrite) {
+            return $this;
+        }
+
+        $array['rewrite'] = $this->rewrite;
+
+        return $this;
+    }
+
+    public function getRewrite(): ?string
+    {
+        return $this->rewrite;
+    }
+}

src/Query/MatchQuery.php

@@ -4,10 +4,39 @@
 
 namespace Erichard\ElasticQueryBuilder\Query;
 
+use Erichard\ElasticQueryBuilder\Features\HasMinimumShouldMatch;
+use Erichard\ElasticQueryBuilder\Features\HasOperator;
+
 class MatchQuery extends AbstractMatchQuery
 {
+    use HasOperator;
+    use HasMinimumShouldMatch;
+
+    public function __construct(string $field, string $query, ?string $analyzer = null, ?string $operator = null, ?string $minimumShouldMatch = null)
+    {
+        parent::__construct($field, $query, $analyzer);
+
+        $this->operator = $operator;
+        $this->minimumShouldMatch = $minimumShouldMatch;
+    }
+
     public function getQueryName(): string
     {
         return 'match';
     }
+
+    public function build(): array
+    {
+        $build = parent::build();
+
+        if (null !== $this->operator) {
+            $this->buildOperatorTo($build[$this->getQueryName()][$this->field]);
+        }
+
+        if (null !== $this->minimumShouldMatch) {
+            $this->buildMinimumShouldMatchTo($build[$this->getQueryName()][$this->field]);
+        }
+
+        return $build;
+    }
 }

src/Query/MultiMatchQuery.php

@@ -5,11 +5,15 @@
 namespace Erichard\ElasticQueryBuilder\Query;
 
 use Erichard\ElasticQueryBuilder\Contracts\QueryInterface;
+use Erichard\ElasticQueryBuilder\Features\HasBoost;
+use Erichard\ElasticQueryBuilder\Features\HasMinimumShouldMatch;
 use Erichard\ElasticQueryBuilder\Features\HasOperator;
 
 class MultiMatchQuery implements QueryInterface
 {
     use HasOperator;
+    use HasBoost;
+    use HasMinimumShouldMatch;
 
     /**
      * @param mixed[]|string[] $fields
@@ -19,9 +23,13 @@ public function __construct(
         protected string $query,
         protected ?string $type = null,
         protected ?string $fuzziness = null,
-        ?string $operator = null
+        ?string $operator = null,
+        ?float $boost = null,
+        ?string $minimumShouldMatch = null
     ) {
         $this->operator = $operator;
+        $this->boost = $boost;
+        $this->minimumShouldMatch = $minimumShouldMatch;
     }
 
     public function setFields(array $fields): self
@@ -68,6 +76,8 @@ public function build(): array
         }
 
         $this->buildOperatorTo($data);
+        $this->buildBoostTo($data);
+        $this->buildMinimumShouldMatchTo($data);
 
         return [
             'multi_match' => $data,

src/Query/PrefixQuery.php

@@ -5,21 +5,28 @@
 namespace Erichard\ElasticQueryBuilder\Query;
 
 use Erichard\ElasticQueryBuilder\Contracts\QueryInterface;
+use Erichard\ElasticQueryBuilder\Features\HasCaseInsensitive;
 use Erichard\ElasticQueryBuilder\Features\HasField;
+use Erichard\ElasticQueryBuilder\Features\HasRewrite;
 
 /**
  * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-prefix-query.html
  */
 class PrefixQuery implements QueryInterface
 {
     use HasField;
+    use HasRewrite;
+    use HasCaseInsensitive;
 
     public function __construct(
         string $field,
         protected string $value,
-        protected ?float $boost = null
+        ?string $rewrite = null,
+        ?bool $caseInsensitive = null
     ) {
         $this->field = $field;
+        $this->rewrite = $rewrite;
+        $this->caseInsensitive = $caseInsensitive;
     }
 
     public function setValue(string $value): self
@@ -29,28 +36,19 @@ public function setValue(string $value): self
         return $this;
     }
 
-    public function setBoost(?float $boost): self
-    {
-        $this->boost = $boost;
-
-        return $this;
-    }
-
     public function build(): array
     {
-        $value = $this->value;
+        $build = [
+            'value' => $this->value,
+        ];
 
-        if (null !== $this->boost) {
-            $value = [
-                'value' => $this->value,
-                'boost' => $this->boost,
-            ];
-        }
+        $this->buildRewriteTo($build);
+        $this->buildCaseInsensitiveTo($build);
 
         return [
             'prefix' => [
-                $this->field => $value,
-            ],
+                $this->field => $build,
+            ]
         ];
     }
 }