Move ElasticInterval object in separated file, fix some problems.

Author: markok4

docs/overview/queries/elastic_query_interval.md

@@ -37,7 +37,7 @@ val queryWithMaxGaps: IntervalQuery[Document] =
 If you want to specify the word order requirement, use the `orderedOn` method:
 ```scala
 val queryWithOrder: IntervalQuery[Document] =
-  intervals(field = "content", rule = intervalMatch("targetWord").orderedOn())
+  intervals(field = "content", rule = intervalMatch("targetWord").orderedOn)
 ```
 
 You can also apply additional filters to the query:
@@ -53,7 +53,7 @@ val queryManually: IntervalQuery[Document] =
     field = "content",
     rule = intervalMatch("targetWord")
       .maxGaps(2)
-      .orderedOn()
+      .orderedOn
       .filter(IntervalFilter.someFilter)
       .analyzer("standard")
   )

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

@@ -19,14 +19,14 @@ package zio.elasticsearch
 import zio.Chunk
 import zio.elasticsearch.ElasticAggregation._
 import zio.elasticsearch.ElasticHighlight.highlight
+import zio.elasticsearch.ElasticIntervalQuery.intervalMatch
 import zio.elasticsearch.ElasticQuery.{contains => _, _}
 import zio.elasticsearch.ElasticSort.sortBy
 import zio.elasticsearch.aggregation.AggregationOrder
 import zio.elasticsearch.data.GeoPoint
 import zio.elasticsearch.domain.{PartialTestDocument, TestDocument, TestSubDocument}
 import zio.elasticsearch.executor.Executor
 import zio.elasticsearch.query.DistanceUnit.Kilometers
-import zio.elasticsearch.query.ElasticIntervalQuery.intervalMatch
 import zio.elasticsearch.query.FunctionScoreFunction.randomScoreFunction
 import zio.elasticsearch.query.MultiMatchType._
 import zio.elasticsearch.query.sort.SortMode.Max
@@ -2774,24 +2774,16 @@ object HttpExecutorSpec extends IntegrationSpec {
         ),
         suite("intervals query")(
           test("intervalMatch returns only matching document") {
-            checkOnce(genDocumentId, genTestDocument, Gen.alphaNumericString, genDocumentId, genTestDocument) {
-              (idMatch, docMatch, targetWord, idNoMatch, docNoMatch) =>
-                val docShouldMatch    = docMatch.copy(stringField = s"prefix $targetWord suffix")
-                val docShouldNotMatch = docNoMatch.copy(stringField = "completely unrelated text")
-                val field             = TestDocument.stringField.toString
-                val query             = intervals(field, intervalMatch(targetWord))
+            checkOnce(genDocumentId, genTestDocument, Gen.alphaNumericString.filter(_.nonEmpty)) {
+              (idMatch, docMatch, targetWord) =>
+                val docShouldMatch = docMatch.copy(stringField = s"prefix $targetWord suffix")
+                val query          = intervals(TestDocument.stringField, intervalMatch(targetWord))
 
                 for {
-                  _ <- Executor.execute(ElasticRequest.deleteByQuery(firstSearchIndex, matchAll))
-                  _ <- Executor.execute(ElasticRequest.upsert(firstSearchIndex, idMatch, docShouldMatch))
-                  _ <- Executor.execute(
-                         ElasticRequest.upsert(firstSearchIndex, idNoMatch, docShouldNotMatch).refreshTrue
-                       )
+                  _   <- Executor.execute(ElasticRequest.deleteByQuery(firstSearchIndex, matchAll))
+                  _   <- Executor.execute(ElasticRequest.upsert(firstSearchIndex, idMatch, docShouldMatch).refreshTrue)
                   res <- Executor.execute(ElasticRequest.search(firstSearchIndex, query)).documentAs[TestDocument]
-                } yield assert(res)(
-                  Assertion.contains(docShouldMatch) &&
-                    Assertion.not(Assertion.contains(docShouldNotMatch))
-                )
+                } yield assert(res)(Assertion.hasSameElements(Chunk(docShouldMatch)))
             }
           } @@ around(
             Executor.execute(ElasticRequest.createIndex(firstSearchIndex)),

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

@@ -0,0 +1,95 @@
+package zio.elasticsearch
+
+import zio.NonEmptyChunk
+import zio.elasticsearch.query.{
+  IntervalAllOf,
+  IntervalAnyOf,
+  IntervalFilter,
+  IntervalFuzzy,
+  IntervalMatch,
+  IntervalPrefix,
+  IntervalRange,
+  IntervalRegexp,
+  IntervalRule,
+  IntervalWildcard,
+  Regexp
+}
+import zio.json.ast.Json
+
+object ElasticIntervalQuery {
+
+  def intervalAllOf[S](intervals: NonEmptyChunk[IntervalRule]): IntervalAllOf[S] =
+    IntervalAllOf(intervals = intervals, maxGaps = None, ordered = None, filter = None)
+
+  def intervalAnyOf[S](intervals: NonEmptyChunk[IntervalRule]): IntervalAnyOf[S] =
+    IntervalAnyOf(intervals = 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](
+    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
+  ): Option[IntervalFilter[S]] = {
+
+    val filter: IntervalFilter[S] = IntervalFilter(
+      after = after,
+      before = before,
+      containedBy = containedBy,
+      containing = containing,
+      notContainedBy = notContainedBy,
+      notContaining = notContaining,
+      notOverlapping = notOverlapping,
+      overlapping = overlapping,
+      script = script
+    )
+
+    Some(filter).filterNot(_ =>
+      List(after, before, containedBy, containing, notContainedBy, notContaining, notOverlapping, overlapping, script)
+        .forall(_.isEmpty)
+    )
+  }
+
+  def intervalFuzzy[S](term: String): IntervalFuzzy[S] =
+    IntervalFuzzy(
+      term = term,
+      prefixLength = None,
+      transpositions = None,
+      fuzziness = None,
+      analyzer = None,
+      useField = None
+    )
+
+  def intervalMatch[S](query: String): IntervalMatch[S] =
+    IntervalMatch(query = query, analyzer = None, useField = None, maxGaps = None, ordered = None, filter = None)
+
+  def intervalPrefix[S](prefix: String): IntervalPrefix[S] =
+    IntervalPrefix(prefix = prefix, analyzer = None, useField = None)
+
+  def intervalRange[S](
+    lower: Option[IntervalRule] = None,
+    upper: Option[IntervalRule] = None,
+    analyzer: Option[String] = None,
+    useField: Option[String] = None
+  ): IntervalRange[S] =
+    IntervalRange(lower = lower, upper = upper, analyzer = analyzer, useField = useField)
+
+  def intervalRegexp[S](pattern: Regexp[S]): IntervalRegexp[S] =
+    IntervalRegexp(pattern = 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 = pattern, analyzer = None, useField = None)
+}

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

@@ -21,7 +21,7 @@ import zio.elasticsearch.Field
 import zio.elasticsearch.query.options.{HasAnalyzer, HasUseField}
 import zio.json.ast.Json
 import zio.json.ast.Json.{Arr, Obj, Str}
-import zio.{Chunk, NonEmptyChunk}
+import zio.Chunk
 
 private[elasticsearch] sealed trait BoundType
 private[elasticsearch] sealed trait Inclusive extends BoundType
@@ -138,9 +138,9 @@ private[elasticsearch] final case class IntervalFuzzy[S](
 
   def analyzer(value: String): IntervalFuzzy[S] = copy(analyzer = Some(value))
 
-  def useField(field: Field[_, _]): IntervalFuzzy[S] = copy(useField = Some(field.toString))
+  def useField(field: Field[_, _]): IntervalFuzzy[S] = copy(useField = Some(field.name))
 
-  def useField(field: String): IntervalFuzzy[S] = copy(useField = Some(Field(None, field).toString))
+  def useField(field: String): IntervalFuzzy[S] = copy(useField = Some(field))
 
   def prefixLength(length: Int): IntervalFuzzy[S] = copy(prefixLength = Some(length))
 
@@ -184,9 +184,9 @@ private[elasticsearch] final case class IntervalMatch[S](
 
   def orderedOff: IntervalMatch[S] = copy(ordered = Some(false))
 
-  def useField(field: Field[_, _]): IntervalMatch[S] = copy(useField = Some(field.toString))
+  def useField(field: Field[_, _]): IntervalMatch[S] = copy(useField = Some(field.name))
 
-  def useField(field: String): IntervalMatch[S] = copy(useField = Some(Field(None, field).toString))
+  def useField(field: String): IntervalMatch[S] = copy(useField = Some(field))
 
   override private[elasticsearch] def toJson: Json =
     Obj(
@@ -213,9 +213,9 @@ private[elasticsearch] final case class IntervalPrefix[S](
 
   def analyzer(value: String): IntervalPrefix[S] = copy(analyzer = Some(value))
 
-  def useField(field: Field[_, _]): IntervalPrefix[S] = copy(useField = Some(field.toString))
+  def useField(field: Field[_, _]): IntervalPrefix[S] = copy(useField = Some(field.name))
 
-  def useField(field: String): IntervalPrefix[S] = copy(useField = Some(Field(None, field).toString))
+  def useField(field: String): IntervalPrefix[S] = copy(useField = Some(field))
 
   override private[elasticsearch] def toJson: Json =
     Obj(
@@ -240,25 +240,21 @@ private[elasticsearch] final case class IntervalRange[S](
 
   def analyzer(value: String): IntervalRange[S] = copy(analyzer = Some(value))
 
-  def lower[B <: BoundType](b: Bound[B]): IntervalRange[S] = copy(lower = Some(GreaterThanInterval(b.value)))
+  def gt[B <: BoundType](value: String): IntervalRange[S] = copy(lower = Some(GreaterThanInterval(value)))
 
-  def upper[B <: BoundType](b: Bound[B]): IntervalRange[S] = copy(upper = Some(LessThanInterval(b.value)))
+  def gte[B <: BoundType](value: String): IntervalRange[S] = copy(lower = Some(GreaterThanOrEqualToInterval(value)))
 
-  def useField(field: Field[_, _]): IntervalRange[S] = copy(useField = Some(field.toString))
+  def lower[B <: BoundType](b: Bound[B]): IntervalRange[S] = copy(lower = Some(GreaterThanInterval(b.value)))
 
-  def useField(field: String): IntervalRange[S] = copy(useField = Some(Field(None, field).toString))
+  def lt[B <: BoundType](value: String): IntervalRange[S] = copy(upper = Some(LessThanInterval(value)))
 
-  def gte[B <: BoundType](value: String): IntervalRange[S] =
-    copy(lower = Some(GreaterThanOrEqualToInterval(value)))
+  def lte[B <: BoundType](value: String): IntervalRange[S] = copy(upper = Some(LessThanOrEqualToInterval(value)))
 
-  def gt[B <: BoundType](value: String): IntervalRange[S] =
-    copy(lower = Some(GreaterThanInterval(value)))
+  def upper[B <: BoundType](b: Bound[B]): IntervalRange[S] = copy(upper = Some(LessThanInterval(b.value)))
 
-  def lte[B <: BoundType](value: String): IntervalRange[S] =
-    copy(upper = Some(LessThanOrEqualToInterval(value)))
+  def useField(field: Field[_, _]): IntervalRange[S] = copy(useField = Some(field.name))
 
-  def lt[B <: BoundType](value: String): IntervalRange[S] =
-    copy(upper = Some(LessThanInterval(value)))
+  def useField(field: String): IntervalRange[S] = copy(useField = Some(field))
 
   private[elasticsearch] def toJson: Json =
     Obj(
@@ -283,9 +279,9 @@ private[elasticsearch] final case class IntervalRegexp[S](
 
   def analyzer(value: String): IntervalRegexp[S] = copy(analyzer = Some(value))
 
-  def useField(field: Field[_, _]): IntervalRegexp[S] = copy(useField = Some(field.toString))
+  def useField(field: Field[_, _]): IntervalRegexp[S] = copy(useField = Some(field.name))
 
-  def useField(field: String): IntervalRegexp[S] = copy(useField = Some(Field(None, field).toString))
+  def useField(field: String): IntervalRegexp[S] = copy(useField = Some(field))
 
   private[elasticsearch] def toJson: Json =
     Obj(
@@ -309,9 +305,9 @@ private[elasticsearch] final case class IntervalWildcard[S](
 
   def analyzer(value: String): IntervalWildcard[S] = copy(analyzer = Some(value))
 
-  def useField(field: Field[_, _]): IntervalWildcard[S] = copy(useField = Some(field.toString))
+  def useField(field: Field[_, _]): IntervalWildcard[S] = copy(useField = Some(field.name))
 
-  def useField(field: String): IntervalWildcard[S] = copy(useField = Some(Field(None, field).toString))
+  def useField(field: String): IntervalWildcard[S] = copy(useField = Some(field))
 
   private[elasticsearch] def toJson: Json =
     Obj(
@@ -324,81 +320,3 @@ private[elasticsearch] final case class IntervalWildcard[S](
       )
     )
 }
-
-object ElasticIntervalQuery {
-
-  def intervalAllOf[S](intervals: NonEmptyChunk[IntervalRule]): IntervalAllOf[S] =
-    IntervalAllOf(intervals = intervals, maxGaps = None, ordered = None, filter = None)
-
-  def intervalAnyOf[S](intervals: NonEmptyChunk[IntervalRule]): IntervalAnyOf[S] =
-    IntervalAnyOf(intervals = 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](
-    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
-  ): Option[IntervalFilter[S]] = {
-
-    val filter: IntervalFilter[S] = IntervalFilter(
-      after = after,
-      before = before,
-      containedBy = containedBy,
-      containing = containing,
-      notContainedBy = notContainedBy,
-      notContaining = notContaining,
-      notOverlapping = notOverlapping,
-      overlapping = overlapping,
-      script = script
-    )
-
-    Some(filter).filterNot(_ =>
-      List(after, before, containedBy, containing, notContainedBy, notContaining, notOverlapping, overlapping, script)
-        .forall(_.isEmpty)
-    )
-  }
-
-  def intervalFuzzy[S](term: String): IntervalFuzzy[S] =
-    IntervalFuzzy(
-      term = term,
-      prefixLength = None,
-      transpositions = None,
-      fuzziness = None,
-      analyzer = None,
-      useField = None
-    )
-
-  def intervalMatch[S](query: String): IntervalMatch[S] =
-    IntervalMatch(query = query, analyzer = None, useField = None, maxGaps = None, ordered = None, filter = None)
-
-  def intervalPrefix[S](prefix: String): IntervalPrefix[S] =
-    IntervalPrefix(prefix = prefix, analyzer = None, useField = None)
-
-  def intervalRange[S](
-    lower: Option[IntervalRule] = None,
-    upper: Option[IntervalRule] = None,
-    analyzer: Option[String] = None,
-    useField: Option[String] = None
-  ): IntervalRange[S] =
-    IntervalRange(lower = lower, upper = upper, analyzer = analyzer, useField = useField)
-
-  def intervalRegexp[S](pattern: Regexp[S]): IntervalRegexp[S] =
-    IntervalRegexp(pattern = 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 = pattern, analyzer = None, useField = None)
-}