(dsl): Support matchPhrasePrefix query

docs/overview/queries/elastic_query_match_phrase_prefix.md

@@ -0,0 +1,25 @@
+---
+id: elastic_query_match_phrase_prefix
+title: "Match Phrase Prefix Query"
+---
+
+The `MatchPhrasePrefix` returns documents that contain the words of a provided text, in the same order as provided. 
+The last term of the provided text is treated as a prefix, matching any words that begin with that term.
+
+In order to use the `MatchPhrasePrefix` query import the following:
+```scala
+import zio.elasticsearch.query.MatchPhrasePrefixQuery
+import zio.elasticsearch.ElasticQuery._
+```
+
+You can create a `MatchPhrasePrefix` query using the `matchPhrasePrefix` method this way:
+```scala
+val query: MatchPhrasePrefixQuery = matchPhrasePrefix(field = "stringField", value = "test")
+```
+
+You can create a [type-safe](https://lambdaworks.github.io/zio-elasticsearch/overview/overview_zio_prelude_schema) `MatchPhrasePrefix` query using the `matchPhrasePrefix` method this way:
+```scala
+val query: MatchPhrasePrefixQuery = matchPhrasePrefix(field = Document.stringField, value = "test")
+```
+
+You can find more information about `MatchPhrasePrefix` query [here](https://www.elastic.co/guide/en/elasticsearch/reference/7.17/query-dsl-match-query-phrase-prefix.html).

modules/integration/src/test/scala/zio/elasticsearch/HttpExecutorSpec.scala

@@ -941,6 +941,30 @@ object HttpExecutorSpec extends IntegrationSpec {
             Executor.execute(ElasticRequest.createIndex(firstSearchIndex)),
             Executor.execute(ElasticRequest.deleteIndex(firstSearchIndex)).orDie
           ),
+          test("search for a document using a match phrase prefix query") {
+            checkOnce(genDocumentId, genTestDocument, genDocumentId, genTestDocument) {
+              (firstDocumentId, firstDocument, secondDocumentId, secondDocument) =>
+                for {
+                  _       <- Executor.execute(ElasticRequest.deleteByQuery(firstSearchIndex, matchAll))
+                  document = firstDocument.copy(stringField = s"${firstDocument.stringField} test")
+                  _ <-
+                    Executor.execute(ElasticRequest.upsert[TestDocument](firstSearchIndex, firstDocumentId, document))
+                  _ <- Executor.execute(
+                         ElasticRequest
+                           .upsert[TestDocument](firstSearchIndex, secondDocumentId, secondDocument)
+                           .refreshTrue
+                       )
+                  query = matchPhrasePrefix(
+                            field = TestDocument.stringField,
+                            value = s"${firstDocument.stringField} te"
+                          )
+                  res <- Executor.execute(ElasticRequest.search(firstSearchIndex, query)).documentAs[TestDocument]
+                } yield assert(res)(Assertion.contains(document))
+            }
+          } @@ around(
+            Executor.execute(ElasticRequest.createIndex(firstSearchIndex)),
+            Executor.execute(ElasticRequest.deleteIndex(firstSearchIndex)).orDie
+          ),
           test("search for a document using a terms query") {
             checkOnce(genDocumentId, genTestDocument, genDocumentId, genTestDocument, genDocumentId, genTestDocument) {
               (firstDocumentId, firstDocument, secondDocumentId, secondDocument, thirdDocumentId, thirdDocument) =>

modules/library/src/main/scala/zio/elasticsearch/ElasticQuery.scala

@@ -447,6 +447,42 @@ object ElasticQuery {
   final def matchPhrase(field: String, value: String): MatchPhraseQuery[Any] =
     MatchPhrase(field = field, value = value, boost = None)
 
+  /**
+   * Constructs a type-safe instance of [[zio.elasticsearch.query.MatchPhrasePrefixQuery]] using the specified
+   * parameters. [[zio.elasticsearch.query.MatchPhrasePrefixQuery]] returns documents that contain the words of a
+   * provided text, in the same order as provided. The last term of the provided text is treated as a prefix, matching
+   * any words that begin with that term.
+   *
+   * @param field
+   *   the type-safe field for which query is specified for
+   * @param value
+   *   the value to be matched, represented by an instance of type `String`
+   * @tparam S
+   *   document for which field query is executed
+   * @return
+   *   an instance of [[zio.elasticsearch.query.MatchPhrasePrefixQuery]] that represents the match phrase prefix query
+   *   to be performed.
+   */
+  final def matchPhrasePrefix[S](field: Field[S, String], value: String): MatchPhrasePrefixQuery[S] =
+    MatchPhrasePrefix(field = field.toString, value = value)
+
+  /**
+   * Constructs an instance of [[zio.elasticsearch.query.MatchPhrasePrefixQuery]] using the specified parameters.
+   * [[zio.elasticsearch.query.MatchPhrasePrefixQuery]] returns documents that contain the words of a provided text, in
+   * the same order as provided. The last term of the provided text is treated as a prefix, matching any words that
+   * begin with that term.
+   *
+   * @param field
+   *   the field for which query is specified for
+   * @param value
+   *   the value to be matched, represented by an instance of type `String`
+   * @return
+   *   an instance of [[zio.elasticsearch.query.MatchPhrasePrefixQuery]] that represents the match phrase prefix query
+   *   to be performed.
+   */
+  final def matchPhrasePrefix(field: String, value: String): MatchPhrasePrefixQuery[Any] =
+    MatchPhrasePrefix(field = field, value = value)
+
   /**
    * Constructs a type-safe instance of [[zio.elasticsearch.query.BoolQuery]] with queries that must satisfy the
    * criteria using the specified parameters.

modules/library/src/main/scala/zio/elasticsearch/query/Queries.scala

@@ -584,6 +584,14 @@ private[elasticsearch] final case class MatchPhrase[S](field: String, value: Str
     )
 }
 
+sealed trait MatchPhrasePrefixQuery[S] extends ElasticQuery[S]
+
+private[elasticsearch] final case class MatchPhrasePrefix[S](field: String, value: String)
+    extends MatchPhrasePrefixQuery[S] {
+  private[elasticsearch] def toJson(fieldPath: Option[String]): Json =
+    Obj("match_phrase_prefix" -> Obj(fieldPath.foldRight(field)(_ + "." + _) -> value.toJson))
+}
+
 sealed trait NestedQuery[S]
     extends ElasticQuery[S]
     with HasIgnoreUnmapped[NestedQuery[S]]

modules/library/src/test/scala/zio/elasticsearch/ElasticQuerySpec.scala

@@ -890,6 +890,15 @@ object ElasticQuerySpec extends ZIOSpecDefault {
             equalTo(MatchPhrase[TestDocument](field = "stringField", value = "this is a test", boost = Some(3)))
           )
         },
+        test("matchPhrasePrefix") {
+          val query   = matchPhrasePrefix("stringField", "test")
+          val queryTs = matchPhrasePrefix(TestDocument.stringField, "test")
+
+          assert(query)(equalTo(MatchPhrasePrefix[Any](field = "stringField", value = "test"))) &&
+          assert(queryTs)(
+            equalTo(MatchPhrasePrefix[TestDocument](field = "stringField", value = "test"))
+          )
+        },
         test("nested") {
           val query                   = nested("testField", matchAll)
           val queryTs                 = nested(TestDocument.subDocumentList, matchAll)

website/sidebars.js

@@ -23,6 +23,7 @@ module.exports = {
                     'overview/queries/elastic_query_match',
                     'overview/queries/elastic_query_match_all',
                     'overview/queries/elastic_query_match_phrase',
+                    'overview/queries/elastic_query_match_phrase_prefix',
                     'overview/queries/elastic_query_nested',
                     'overview/queries/elastic_query_prefix',
                     'overview/queries/elastic_query_range',