(dsl): Support intervalQuery

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

@@ -16,11 +16,12 @@
 
 package zio.elasticsearch
 
-import zio.Chunk
+import zio.{Chunk, NonEmptyChunk}
 import zio.elasticsearch.ElasticPrimitive.ElasticPrimitive
 import zio.elasticsearch.data.GeoPoint
 import zio.elasticsearch.query._
 import zio.elasticsearch.script.Script
+import zio.json.ast.Json
 import zio.schema.Schema
 
 object ElasticQuery {
@@ -548,6 +549,48 @@ object ElasticQuery {
   final def ids(value: String, values: String*): IdsQuery[Any] =
     Ids(values = Chunk.fromIterable(value +: values))
 
+
+  /**
+   * Constructs an intervals query by combining a field and an interval query.
+   *
+   * The resulting query wraps the specified interval query under the given field in the intervals query structure.
+   *
+   * @param field
+   *   the name of the field to be queried.
+   * @param rule
+   *   an instance of [[zio.elasticsearch.query.IntervalRule]] representing the interval query rule.
+   * @return
+   *   an [[zio.elasticsearch.ElasticQuery]] instance representing the intervals query.
+   */
+
+  final def intervals(
+    field: String,
+    rule: IntervalRule
+  ): ElasticQuery[Any] =
+    Intervals(field, rule)
+
+  /**
+   * Constructs a type-safe intervals query by combining a field and an interval query.
+   *
+   * The resulting query wraps the specified interval query under the given type-safe field in the intervals query
+   * structure.
+   *
+   * @param field
+   *   the type-safe field on which the query is executed.
+   * @param rule
+   *   an instance of [[zio.elasticsearch.query.IntervalRule]] representing the interval query rule.
+   * @tparam S
+   *   the document type for which the query is defined.
+   * @return
+   *   an [[zio.elasticsearch.ElasticQuery]] instance representing the intervals query.
+   */
+
+  final def intervals[S](
+    field: Field[S, _],
+    rule: IntervalRule
+  ): ElasticQuery[S] =
+    Intervals(field.toString, rule)
+
   /**
    * Constructs a type-safe instance of [[zio.elasticsearch.query.KNNQuery]] using the specified parameters.
    * [[zio.elasticsearch.query.KNNQuery]] is used to perform a k-nearest neighbor (kNN) search and returns the matching

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

@@ -0,0 +1,261 @@
+package zio.elasticsearch.query
+
+import zio.Chunk
+import zio.elasticsearch.ElasticPrimitive.ElasticPrimitiveOps
+import zio.json.ast.Json
+import zio.json.ast.Json.{Arr, Obj, Str}
+
+sealed trait IntervalRule {
+  private[elasticsearch] def toJson: Json
+}
+
+private[elasticsearch] final case class IntervalAllOf[S](
+  intervals: Chunk[IntervalRule],
+  maxGaps: Option[Int],
+  ordered: Option[Boolean],
+  filter: Option[IntervalFilter[S]]
+) extends IntervalRule {
+  private[elasticsearch] def toJson: Json =
+    Obj(
+      "all_of" -> Obj(
+        Chunk(
+          Some("intervals" -> Arr(intervals.map(_.toJson): _*)),
+          maxGaps.map("max_gaps" -> _.toJson),
+          ordered.map("ordered" -> _.toJson),
+          filter.map("filter" -> _.toJson)
+        ).flatten: _*
+      )
+    )
+}
+
+private[elasticsearch] final case class IntervalAnyOf[S](
+  intervals: Chunk[IntervalRule],
+  filter: Option[IntervalFilter[S]]
+) extends IntervalRule { self =>
+
+  def withFilter(f: IntervalFilter[S]): IntervalAnyOf[S] = copy(filter = Some(f))
+
+  override private[elasticsearch] def toJson: Json =
+    Obj(
+      "any_of" -> Obj(
+        Chunk(
+          Some("intervals" -> Arr(intervals.map(_.toJson): _*)),
+          filter.map("filter" -> _.toJson)
+        ).flatten: _*
+      )
+    )
+}
+
+private[elasticsearch] final case class IntervalFilter[S](
+  after: Option[IntervalRule] = None,
+  before: Option[IntervalRule] = None,
+  containedBy: Option[IntervalRule] = None,
+  containing: Option[IntervalRule] = None,
+  notContainedBy: Option[IntervalRule] = None,
+  notContaining: Option[IntervalRule] = None,
+  notOverlapping: Option[IntervalRule] = None,
+  overlapping: Option[IntervalRule] = None,
+  script: Option[Json] = None
+) {
+  private[elasticsearch] def toJson: Json =
+    Obj(
+      Chunk(
+        after.map("after" -> _.toJson),
+        before.map("before" -> _.toJson),
+        containedBy.map("contained_by" -> _.toJson),
+        containing.map("containing" -> _.toJson),
+        notContainedBy.map("not_contained_by" -> _.toJson),
+        notContaining.map("not_containing" -> _.toJson),
+        notOverlapping.map("not_overlapping" -> _.toJson),
+        overlapping.map("overlapping" -> _.toJson),
+        script.map("script" -> _)
+      ).flatten: _*
+    )
+}
+
+private[elasticsearch] final case class IntervalFuzzy[S](
+  term: String,
+  prefixLength: Option[Int],
+  transpositions: Option[Boolean],
+  fuzziness: Option[String],
+  analyzer: Option[String],
+  useField: Option[String]
+) extends IntervalRule {
+  private[elasticsearch] def toJson: Json =
+    Obj(
+      "fuzzy" -> Obj(
+        Chunk(
+          Some("term" -> term.toJson),
+          prefixLength.map("prefix_length" -> _.toJson),
+          transpositions.map("transpositions" -> _.toJson),
+          fuzziness.map("fuzziness" -> _.toJson),
+          analyzer.map("analyzer" -> _.toJson),
+          useField.map("use_field" -> _.toJson)
+        ).flatten: _*
+      )
+    )
+}
+
+private[elasticsearch] final case class IntervalMatch[S](
+  query: String,
+  analyzer: Option[String],
+  useField: Option[String],
+  maxGaps: Option[Int],
+  ordered: Option[Boolean],
+  filter: Option[IntervalFilter[S]]
+) extends IntervalRule { self =>
+
+  def withAnalyzer(a: String)          = copy(analyzer = Some(a))
+  def withUseField(f: String)          = copy(useField = Some(f))
+  def withMaxGaps(g: Int)              = copy(maxGaps = Some(g))
+  def withOrdered(o: Boolean)          = copy(ordered = Some(o))
+  def withFilter(f: IntervalFilter[S]) = copy(filter = Some(f))
+
+  override private[elasticsearch] def toJson: Json =
+    Obj(
+      "match" -> Obj(
+        Chunk(
+          Some("query" -> Str(query)),
+          analyzer.map("analyzer" -> _.toJson),
+          useField.map("use_field" -> _.toJson),
+          maxGaps.map("max_gaps" -> _.toJson),
+          ordered.map("ordered" -> _.toJson),
+          filter.map("filter" -> _.toJson)
+        ).flatten: _*
+      )
+    )
+}
+
+private[elasticsearch] final case class IntervalPrefix(
+  prefix: String,
+  analyzer: Option[String],
+  useField: Option[String]
+) extends IntervalRule {
+
+  def withAnalyzer(a: String) = copy(analyzer = Some(a))
+  def withUseField(f: String) = copy(useField = Some(f))
+
+  override private[elasticsearch] def toJson: Json =
+    Obj(
+      "prefix" -> Obj(
+        Chunk(
+          Some("prefix" -> Str(prefix)),
+          analyzer.map(a => "analyzer" -> Str(a)),
+          useField.map(u => "use_field" -> Str(u))
+        ).flatten: _*
+      )
+    )
+}
+
+private[elasticsearch] final case class IntervalRange[S](
+  lower: Option[Either[String, String]],
+  upper: Option[Either[String, String]],
+  analyzer: Option[String],
+  useField: Option[String]
+) extends IntervalRule {
+  private[elasticsearch] def toJson: Json = {
+    val lowerJson = lower.map {
+      case Left(gt)   => "gt"  -> gt.toJson
+      case Right(gte) => "gte" -> gte.toJson
+    }
+    val upperJson = upper.map {
+      case Left(lt)   => "lt"  -> lt.toJson
+      case Right(lte) => "lte" -> lte.toJson
+    }
+
+    Obj(
+      "range" -> Obj(
+        Chunk(
+          lowerJson,
+          upperJson,
+          analyzer.map("analyzer" -> _.toJson),
+          useField.map("use_field" -> _.toJson)
+        ).flatten: _*
+      )
+    )
+  }
+}
+
+private[elasticsearch] final case class IntervalRegexp[S](
+  pattern: Regexp[S],
+  analyzer: Option[String],
+  useField: Option[String]
+) extends IntervalRule {
+  private[elasticsearch] def toJson: Json =
+    Obj(
+      "regexp" -> Obj(
+        Chunk(
+          Some("pattern" -> pattern.toJson(None)),
+          analyzer.map("analyzer" -> _.toJson),
+          useField.map("use_field" -> _.toJson)
+        ).flatten: _*
+      )
+    )
+}
+
+private[elasticsearch] final case class IntervalWildcard[S](
+  pattern: String,
+  analyzer: Option[String],
+  useField: Option[String]
+) extends IntervalRule {
+
+  def withAnalyzer(a: String): IntervalWildcard[S] =
+    copy(analyzer = Some(a))
+
+  def withUseField(f: String): IntervalWildcard[S] =
+    copy(useField = Some(f))
+
+  private[elasticsearch] def toJson: Json =
+    Obj(
+      "wildcard" -> Obj(
+        Chunk(
+          Some("pattern" -> pattern.toJson),
+          analyzer.map("analyzer" -> _.toJson),
+          useField.map("use_field" -> _.toJson)
+        ).flatten: _*
+      )
+    )
+}
+object ElasticIntervalQuery {
+
+  def intervalAllOf[S](intervals: Chunk[IntervalRule]): IntervalAllOf[S] =
+    IntervalAllOf(intervals, maxGaps = None, ordered = None, filter = None)
+
+  def intervalAnyOf[S](intervals: Chunk[IntervalRule]): IntervalAnyOf[S] =
+    IntervalAnyOf(intervals, filter = None)
+
+  def intervalContains[S](pattern: String): IntervalWildcard[S] =
+    IntervalWildcard(s"*$pattern*", analyzer = None, useField = None)
+
+  def intervalEndsWith[S](pattern: String): IntervalWildcard[S] =
+    IntervalWildcard(s"*$pattern", analyzer = None, useField = None)
+
+  def intervalFilter[S](): IntervalFilter[S] =
+    IntervalFilter()
+
+  def intervalFuzzy[S](term: String): IntervalFuzzy[S] =
+    IntervalFuzzy(term, prefixLength = None, transpositions = None, fuzziness = None, analyzer = None, useField = None)
+
+  def intervalMatch[S](query: String): IntervalMatch[S] =
+    IntervalMatch(query, analyzer = None, useField = None, maxGaps = None, ordered = None, filter = None)
+
+  def intervalPrefix[S](prefix: String): IntervalPrefix =
+    IntervalPrefix(prefix, analyzer = None, useField = None)
+
+  def intervalRange[S](
+    lower: Option[Either[String, String]] = None,
+    upper: Option[Either[String, String]] = None,
+    analyzer: Option[String] = None,
+    useField: Option[String] = None
+  ): IntervalRange[S] =
+    IntervalRange(lower, upper, analyzer, useField)
+
+  def intervalRegexp[S](pattern: Regexp[S]): IntervalRegexp[S] =
+    IntervalRegexp(pattern, analyzer = None, useField = None)
+
+  def intervalStartsWith[S](pattern: String): IntervalWildcard[S] =
+    IntervalWildcard(s"$pattern*", analyzer = None, useField = None)
+
+  def intervalWildcard[S](pattern: String): IntervalWildcard[S] =
+    IntervalWildcard(pattern, analyzer = None, useField = None)
+}