Add support for query_string queries with options

Introduces searchQueryString and related methods to Builder for building query_string and simple_query_string queries. Adds QueryStringOptions for managing query string options, updates DslFactory and Grammar to handle query_string clauses, and registers QueryStringOptions in ManagesOptions.

Author: pdphilip

src/Eloquent/Docs/ModelDocs.php

@@ -127,6 +127,11 @@
  * @method static $this orSearchFuzzyPrefix($term, $fields = ['*'], $options = [])
  * @method static $this searchNotFuzzyPrefix($term, $fields = ['*'], $options = [])
  * @method static $this orSearchNotFuzzyPrefix($term, $fields = ['*'], $options = [])
+ *                                                                                    -----------------------------------
+ * @method static $this searchQueryString($query, $fields = '*', $options = [])
+ * @method static $this orSearchQueryString($query, $fields = '*', $options = [])
+ * @method static $this searchNotQueryString($query, $fields = '*', $options = [])
+ * @method static $this orSearchNotQueryString($query, $fields = '*', $options = [])
  *===========================================
  * Speciality methods
  *===========================================

src/Query/Builder.php

@@ -1331,38 +1331,6 @@ public function orWhereNotRegex($column, string $value, array $options = []): se
         return $this->whereRegex($column, $value, 'or', true, $options);
     }
 
-    /**
-     *  Add a 'query_string' statement to query
-     */
-    public function whereQueryString($column, $value, array $options = []): self
-    {
-        return $this->_buildQueryStringWheres($column, $value, 'and', false, $options);
-    }
-
-    public function orWhereQueryString($column, $value, array $options = []): self
-    {
-        return $this->_buildQueryStringWheres($column, $value, 'or', false, $options);
-    }
-
-    public function whereNotQueryString($column, $value, array $options = []): self
-    {
-        return $this->_buildQueryStringWheres($column, $value, 'and', true, $options);
-    }
-
-    public function orWhereNotQueryString($column, $value, array $options = []): self
-    {
-        return $this->_buildQueryStringWheres($column, $value, 'or', true, $options);
-    }
-
-    private function _buildQueryStringWheres($column, $value, $boolean, $not, $options): self
-    {
-        $type = 'QueryString';
-
-        $this->wheres[] = compact('column', 'value', 'type', 'boolean', 'not', 'options');
-
-        return $this;
-    }
-
     /**
      * Add any where clause with given options.
      */
@@ -1595,6 +1563,52 @@ public function orSearchNotFuzzyPrefix($query, mixed $columns = null, $options =
         return $this->search($query, 'bool_prefix', $columns, $options, true, 'or', ['fuzziness' => 'AUTO']);
     }
 
+    /**
+     *   Add a 'query_string' statement to query
+     *
+     * @throws Exception
+     */
+    public function searchQueryString(mixed $query, string|array $columns = '*', $options = []): self
+    {
+        return $this->_buildQueryStringWheres($columns, $query, 'and', false, $options);
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function orSearchQueryString(mixed $query, string|array $columns = '*', $options = []): self
+    {
+        return $this->_buildQueryStringWheres($columns, $query, 'or', false, $options);
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function searchNotQueryString(mixed $query, string|array $columns = '*', $options = []): self
+    {
+        return $this->_buildQueryStringWheres($columns, $query, 'and', true, $options);
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function orSearchNotQueryString(mixed $query, string|array $columns = '*', $options = []): self
+    {
+        return $this->_buildQueryStringWheres($columns, $query, 'or', true, $options);
+    }
+
+    /**
+     * @throws Exception
+     */
+    private function _buildQueryStringWheres($column, $value, $boolean, $not, $options): self
+    {
+        $type = 'QueryString';
+        $options = $this->setOptions($options, 'querystring')->toArray();
+        $this->wheres[] = compact('column', 'value', 'type', 'boolean', 'not', 'options');
+
+        return $this;
+    }
+
     // ----------------------------------------------------------------------
     // Ordering
     // ----------------------------------------------------------------------

src/Query/DSL/DslFactory.php

@@ -267,6 +267,26 @@ public static function functionScore(array $query, string $functionType, array $
         ];
     }
 
+    public static function queryString(string|array $field, mixed $query, array $options = [])
+    {
+        $fields = is_array($field) ? $field : [$field];
+        $type = 'query_string';
+        if (! empty($options['simple_query_string'])) {
+            $type = 'simple_query_string';
+        }
+        unset($options['simple_query_string']);
+
+        return [
+            $type => array_merge(
+                [
+                    'query' => (string) $query,
+                    'fields' => $fields,
+                ],
+                $options
+            ),
+        ];
+    }
+
     // ----------------------------------------------------------------------
     // Aggregations
     // ----------------------------------------------------------------------

src/Query/Grammar.php

@@ -721,6 +721,15 @@ protected function compileWhereSearch(Builder $builder, array $where): array
 
     }
 
+    private function compileWhereQueryString(Builder $builder, array $where)
+    {
+        $fields = $where['column'];
+        $query = $where['value'];
+        $options = $where['options'] ?? [];
+
+        return DslFactory::queryString($fields, $query, $options);
+    }
+
     /**
      * Compile a child clause
      */

src/Query/ManagesOptions.php

@@ -13,6 +13,7 @@
 use PDPhilip\Elasticsearch\Query\Options\PhraseOptions;
 use PDPhilip\Elasticsearch\Query\Options\PhrasePrefixOptions;
 use PDPhilip\Elasticsearch\Query\Options\PrefixOptions;
+use PDPhilip\Elasticsearch\Query\Options\QueryStringOptions;
 use PDPhilip\Elasticsearch\Query\Options\RegexOptions;
 use PDPhilip\Elasticsearch\Query\Options\SearchOptions;
 use PDPhilip\Elasticsearch\Query\Options\TermOptions;
@@ -219,6 +220,7 @@ protected function getOptionClass($type)
             'prefix' => PrefixOptions::class,
             'regex' => RegexOptions::class,
             'nested' => NestedOptions::class,
+            'querystring' => QueryStringOptions::class,
             default => null
         };
     }

src/Query/Options/QueryOptions.php

@@ -22,11 +22,6 @@ public function __call($method, $parameters)
     {
         $key = Str::snake($method);
 
-        // Let ES validate the option
-        //        if (! in_array($key, $this->allowedOptions(), true)) {
-        //            throw new \InvalidArgumentException("Option '{$key}' is not allowed for this query type.");
-        //        }
-
         $this->{$key} = $parameters[0];
 
         return $this;

src/Query/Options/QueryStringOptions.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace PDPhilip\Elasticsearch\Query\Options;
+
+/**
+ * QueryStringOptions for Query String Queries.
+ *
+ *
+ * @method $this allowLeadingWildcard(bool $value)
+ * @method $this analyzeWildcard(bool $value)
+ * @method $this analyzer(string $analyzer)
+ * @method $this autoGenerateSynonymsPhraseQuery(bool $value)
+ * @method $this boost(float $value)
+ * @method $this defaultOperator(string $value) OR|AND
+ * @method $this fuzziness(string|int $value)
+ * @method $this fuzzyMaxExpansions(int $value)
+ * @method $this fuzzyPrefixLength(int $value)
+ * @method $this fuzzyTranspositions(bool $value)
+ * @method $this lenient(bool $value)
+ * @method $this maxDeterminizedStates(int $value)
+ * @method $this minimumShouldMatch(string $value)
+ * @method $this quoteAnalyzer(string $value)
+ * @method $this phraseSlop(int $value)
+ * @method $this quoteFieldSuffix(string $value)
+ * @method $this rewrite(string $value)
+ * @method $this timeZone(string $value)
+ * @method $this simpleQueryString(bool $value)
+ */
+class QueryStringOptions extends QueryOptions
+{
+    public function allowedOptions(): array
+    {
+        return [
+            'allow_leading_wildcard',
+            'analyze_wildcard',
+            'analyzer',
+            'auto_generate_synonyms_phrase_query',
+            'boost',
+            'default_operator',
+            'fuzziness',
+            'fuzzy_max_expansions',
+            'fuzzy_prefix_length',
+            'fuzzy_transpositions',
+            'fuzzy_rewrite',
+            'fuzzy_transpositions',
+            'lenient',
+            'max_determinized_states',
+            'minimum_should_match',
+            'quote_analyzer',
+            'phrase_slop',
+            'quote_field_suffix',
+            'rewrite',
+            'time_zone',
+            'simple_query_string',
+        ];
+    }
+
+    public function asSimple()
+    {
+        $this->simpleQueryString(true);
+    }
+}