(dsl): Support prefix query

modules/library/src/it/scala/zio/elasticsearch/HttpExecutorSpec.scala

@@ -686,6 +686,32 @@ object HttpExecutorSpec extends IntegrationSpec {
             Executor.execute(ElasticRequest.createIndex(secondSearchIndex)),
             Executor.execute(ElasticRequest.deleteIndex(secondSearchIndex)).orDie
           ),
+          test("search for a document which contains a specific prefix using a prefix query") {
+            checkOnce(genDocumentId, genTestDocument, genDocumentId, genTestDocument) {
+              (firstDocumentId, firstDocument, secondDocumentId, secondDocument) =>
+                for {
+                  _ <- Executor.execute(ElasticRequest.deleteByQuery(firstSearchIndex, matchAll))
+                  _ <- Executor.execute(
+                         ElasticRequest.upsert[TestDocument](firstSearchIndex, firstDocumentId, firstDocument)
+                       )
+                  _ <- Executor.execute(
+                         ElasticRequest
+                           .upsert[TestDocument](firstSearchIndex, secondDocumentId, secondDocument)
+                           .refreshTrue
+                       )
+                  query = ElasticQuery.prefix(
+                            field = TestDocument.stringField.keyword,
+                            value = firstDocument.stringField.take(3)
+                          )
+                  res <- Executor
+                           .execute(ElasticRequest.search(firstSearchIndex, query))
+                           .documentAs[TestDocument]
+                } yield assert(res)(Assertion.contains(firstDocument))
+            }
+          } @@ around(
+            Executor.execute(ElasticRequest.createIndex(firstSearchIndex)),
+            Executor.execute(ElasticRequest.deleteIndex(firstSearchIndex)).orDie
+          ),
           test("search for a document which contains a term using a wildcard query") {
             checkOnce(genDocumentId, genTestDocument, genDocumentId, genTestDocument) {
               (firstDocumentId, firstDocument, secondDocumentId, secondDocument) =>

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

@@ -544,6 +544,38 @@ object ElasticQuery {
   final def nested(path: String, query: ElasticQuery[_]): NestedQuery[Any] =
     Nested(path = path, query = query, scoreMode = None, ignoreUnmapped = None, innerHitsField = None)
 
+  /**
+   * Constructs a type-safe instance of [[zio.elasticsearch.query.PrefixQuery]] using the specified parameters.
+   * [[zio.elasticsearch.query.PrefixQuery]] is used for matching documents that contain a specific prefix in a provided
+   * field.
+   *
+   * @param field
+   *   the type-safe field for which query is specified for
+   * @param value
+   *   the value that will be used for the query, represented by an instance of type `A`
+   * @tparam S
+   *   document for which field query is executed
+   * @return
+   *   an instance of [[zio.elasticsearch.query.PrefixQuery]] that represents the prefix query to be performed.
+   */
+  final def prefix[S](field: Field[S, String], value: String): PrefixQuery[S] =
+    Prefix(field = field.toString, value = value, caseInsensitive = None)
+
+  /**
+   * Constructs an instance of [[zio.elasticsearch.query.PrefixQuery]] using the specified parameters.
+   * [[zio.elasticsearch.query.PrefixQuery]] is used for matching documents that contain a specific prefix in a provided
+   * field.
+   *
+   * @param field
+   *   the field for which query is specified for
+   * @param value
+   *   the value that will be used for the query, represented by an instance of type `A`
+   * @return
+   *   an instance of [[zio.elasticsearch.query.PrefixQuery]] that represents the prefix query to be performed.
+   */
+  final def prefix(field: String, value: String): Prefix[Any] =
+    Prefix(field = field, value = value, caseInsensitive = None)
+
   /**
    * Constructs a type-safe unbounded instance of [[zio.elasticsearch.query.RangeQuery]] using the specified parameters.
    *

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

@@ -665,6 +665,25 @@ private[elasticsearch] case object Unbounded extends LowerBound with UpperBound
   private[elasticsearch] def toJson: Option[(String, Json)] = None
 }
 
+sealed trait PrefixQuery[S] extends ElasticQuery[S] with HasCaseInsensitive[PrefixQuery[S]]
+
+private[elasticsearch] final case class Prefix[S](
+  field: String,
+  value: String,
+  caseInsensitive: Option[Boolean]
+) extends PrefixQuery[S] { self =>
+
+  override def caseInsensitive(value: Boolean): PrefixQuery[S] =
+    self.copy(caseInsensitive = Some(value))
+
+  override private[elasticsearch] def toJson(fieldPath: Option[String]): Json = {
+    val prefixFields = Some("value" -> value.toJson) ++ caseInsensitive.map(
+      "case_insensitive" -> _.toJson
+    )
+    Obj("prefix" -> Obj(fieldPath.foldRight(field)(_ + "." + _) -> Obj(Chunk.fromIterable(prefixFields))))
+  }
+}
+
 sealed trait RangeQuery[S, A, LB <: LowerBound, UB <: UpperBound]
     extends ElasticQuery[S]
     with HasBoost[RangeQuery[S, A, LB, UB]]

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

@@ -2531,6 +2531,50 @@ object ElasticQuerySpec extends ZIOSpecDefault {
           assert(queryWithScoreMode.toJson(fieldPath = None))(equalTo(expectedWithScoreMode.toJson)) &&
           assert(queryWithAllParams.toJson(fieldPath = None))(equalTo(expectedWithAllParams.toJson))
         },
+        test("prefix") {
+          val query                    = prefix(TestDocument.stringField, "test")
+          val queryWithCaseInsensitive = prefix(TestDocument.stringField, "test").caseInsensitiveTrue
+          val queryWithAllParams       = prefix(TestDocument.stringField, "test").caseInsensitiveFalse
+
+          val expected =
+            """
+              |{
+              |  "prefix": {
+              |    "stringField": {
+              |      "value": "test"
+              |    }
+              |  }
+              |}
+              |""".stripMargin
+
+          val expectedWithCaseInsensitive =
+            """
+              |{
+              |  "prefix": {
+              |    "stringField": {
+              |      "value": "test",
+              |      "case_insensitive": true
+              |    }
+              |  }
+              |}
+              |""".stripMargin
+
+          val expectedWithAllParams =
+            """
+              |{
+              |  "prefix": {
+              |    "stringField": {
+              |      "value": "test",
+              |      "case_insensitive": false
+              |    }
+              |  }
+              |}
+              |""".stripMargin
+
+          assert(query.toJson(fieldPath = None))(equalTo(expected.toJson)) &&
+          assert(queryWithCaseInsensitive.toJson(fieldPath = None))(equalTo(expectedWithCaseInsensitive.toJson)) &&
+          assert(queryWithAllParams.toJson(fieldPath = None))(equalTo(expectedWithAllParams.toJson))
+        },
         test("range") {
           val queryEmpty                = range(TestDocument.intField)
           val queryEmptyWithBoost       = range(TestDocument.intField).boost(3.14)