Merge pull request #5 from rcarver/sort

rcarver · web-flow · commit 68813e22124e · 2024-09-23T13:12:48.000-07:00
Sort
diff --git a/Package.resolved b/Package.resolved
diff --git a/Sources/ElasticsearchQueryBuilder/Components.swift b/Sources/ElasticsearchQueryBuilder/Components.swift
@@ -199,6 +199,22 @@ extension esb {
         }
     }
 
+    /// Adds `sort` block to the query syntax.
+    public struct Sort<Component: ArrayComponent>: DictComponent {
+        var component: Component
+        public init(@QueryArrayBuilder component: () -> Component) {
+            self.component = component()
+        }
+        public func makeDict() -> QueryDict {
+            let values: [QueryDict] = self.component.makeCompactArray()
+            if values.isEmpty {
+                return [:]
+            } else {
+                return [ "sort" :  .array(values.map(QueryValue.dict)) ]
+            }
+        }
+    }
+
     /// Adds `term` block to the query syntax.
     ///
     /// Excludes the component if value is nil.
diff --git a/Tests/ElasticsearchQueryBuilderTests/ComponentTests.swift b/Tests/ElasticsearchQueryBuilderTests/ComponentTests.swift
@@ -8,7 +8,7 @@ final class NothingTests: XCTestCase {
         @ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {
             esb.Nothing()
         }
-        XCTAssertNoDifference(build().makeQuery(), [:])
+        expectNoDifference(build().makeQuery(), [:])
     }
 }
 
@@ -17,7 +17,7 @@ final class KeyTests: XCTestCase {
         @ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {
             esb.Key("boost", .float(1.2))
         }
-        XCTAssertNoDifference(build().makeQuery(), [
+        expectNoDifference(build().makeQuery(), [
             "boost": 1.2
         ])
     }
@@ -29,7 +29,7 @@ final class KeyTests: XCTestCase {
                 ]
             }
         }
-        XCTAssertNoDifference(build().makeQuery(), [
+        expectNoDifference(build().makeQuery(), [
             "match_bool_prefix": [
                 "message": "quick brown f"
             ]
@@ -39,7 +39,7 @@ final class KeyTests: XCTestCase {
         @ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {
             esb.Key("match", .dict([:]))
         }
-        XCTAssertNoDifference(build().makeQuery(), [:])
+        expectNoDifference(build().makeQuery(), [:])
     }
 }
 
@@ -57,7 +57,7 @@ final class ComposableBuilderTests: XCTestCase {
                 makeKey()
             }
         }
-        XCTAssertNoDifference(build().makeQuery(), [
+        expectNoDifference(build().makeQuery(), [
             "query": [
                 "match_bool_prefix": [
                     "message": "quick brown f"
@@ -80,7 +80,7 @@ final class ComposableBuilderTests: XCTestCase {
                 makeKey(true)
             }
         }
-        XCTAssertNoDifference(build().makeQuery(), [
+        expectNoDifference(build().makeQuery(), [
             "filter": [
                 [
                     "match_bool_prefix": [
@@ -107,7 +107,7 @@ final class ComposableBuilderTests: XCTestCase {
                 makeKey(true, 3)
             }
         }
-        XCTAssertNoDifference(build().makeQuery(), [
+        expectNoDifference(build().makeQuery(), [
             "filter": [
                 [
                     "match_bool_prefix": [
@@ -135,7 +135,7 @@ final class QueryTests: XCTestCase {
                 }
             }
         }
-        XCTAssertNoDifference(build().makeQuery(), [
+        expectNoDifference(build().makeQuery(), [
             "query": [
                 "match_bool_prefix": [
                     "message": "quick brown f"
@@ -149,7 +149,7 @@ final class QueryTests: XCTestCase {
                 esb.Key("match", .dict([:]))
             }
         }
-        XCTAssertNoDifference(build().makeQuery(), [:])
+        expectNoDifference(build().makeQuery(), [:])
     }
 }
 
@@ -196,7 +196,7 @@ final class BoolTests: XCTestCase {
                 }
             }
         }
-        XCTAssertNoDifference(build(true).makeQuery(), [
+        expectNoDifference(build(true).makeQuery(), [
             "bool": [
                 "minimum_should_match": 1,
                 "should": [
@@ -229,7 +229,7 @@ final class BoolTests: XCTestCase {
                 ]
             ]
         ])
-        XCTAssertNoDifference(build(false).makeQuery(), [
+        expectNoDifference(build(false).makeQuery(), [
             "bool": [
                 "minimum_should_match": 1
             ]
@@ -252,7 +252,44 @@ final class BoolTests: XCTestCase {
                 }
             }
         }
-        XCTAssertNoDifference(build().makeQuery(), [:])
+        expectNoDifference(build().makeQuery(), [:])
+    }
+}
+
+final class SortTests: XCTestCase {
+    func testBuild() throws {
+        @ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {
+            esb.Sort {
+                esb.Key("_score") {
+                    [ "order": "desc" ]
+                }
+                esb.Key("name") {
+                    [ "order": "asc" ]
+                }
+            }
+        }
+        expectNoDifference(build().makeQuery(), [
+            "sort": [
+                [
+                    "_score": [ "order": "desc" ]
+                ],
+                [
+                    "name": [ "order": "asc" ]
+                ]
+            ]
+        ])
+    }
+    func testBuildEmpty() throws {
+        @ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {
+            esb.Sort {
+                if false {
+                    esb.Key("_score") {
+                        [ "order": "desc" ]
+                    }
+                }
+            }
+        }
+        expectNoDifference(build().makeQuery(), [:])
     }
 }
 
@@ -261,15 +298,15 @@ final class TermTests: XCTestCase {
         @ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {
             esb.Term("name", "joe")
         }
-        XCTAssertNoDifference(build().makeQuery(), [
+        expectNoDifference(build().makeQuery(), [
             "term": [ "name": "joe" ]
         ])
     }
     func testBuildEmpty() throws {
         @ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {
             esb.Term("name", nil)
         }
-        XCTAssertNoDifference(build().makeQuery(), [:])
+        expectNoDifference(build().makeQuery(), [:])
     }
 }
 
@@ -278,15 +315,15 @@ final class TermsORTests: XCTestCase {
         @ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {
             esb.TermsOR("name", ["joe", "mary"])
         }
-        XCTAssertNoDifference(build().makeQuery(), [
+        expectNoDifference(build().makeQuery(), [
             "terms": [ "name": ["joe", "mary"] ]
         ])
     }
     func testBuildEmpty() throws {
         @ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {
             esb.TermsOR("name", [])
         }
-        XCTAssertNoDifference(build().makeQuery(), [:])
+        expectNoDifference(build().makeQuery(), [:])
     }
 }
 
@@ -297,7 +334,7 @@ final class TermsANDTests: XCTestCase {
                 esb.TermsAND("name", ["joe", "mary"])
             }
         }
-        XCTAssertNoDifference(build().makeQuery(), [
+        expectNoDifference(build().makeQuery(), [
             "filter": [
                 [ "term": [ "name": "joe" ] ],
                 [ "term": [ "name": "mary" ] ],
@@ -310,7 +347,7 @@ final class TermsANDTests: XCTestCase {
                 esb.TermsAND("name", [])
             }
         }
-        XCTAssertNoDifference(build().makeQuery(), [:])
+        expectNoDifference(build().makeQuery(), [:])
     }
 }
 
@@ -319,7 +356,7 @@ final class KNearestNeighborTests: XCTestCase {
         @ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {
             esb.kNearestNeighbor("vector_field", [1,2,3])
         }
-        XCTAssertNoDifference(build().makeQuery(), [
+        expectNoDifference(build().makeQuery(), [
             "knn": [
                 "field": "vector_field",
                 "query_vector": [1.0, 2.0, 3.0],
@@ -341,7 +378,7 @@ final class KNearestNeighborTests: XCTestCase {
                 }
             }
         }
-        XCTAssertNoDifference(build().makeQuery(), [
+        expectNoDifference(build().makeQuery(), [
             "knn": [
                 "field": "vector_field",
                 "query_vector": [1.0, 2.0, 3.0],
@@ -385,7 +422,7 @@ final class FunctionScoreTests: XCTestCase {
                 }
             }
         }
-        XCTAssertNoDifference(build().makeQuery(), [
+        expectNoDifference(build().makeQuery(), [
             "function_score": [
                 "bool": [
                     "should": [
@@ -415,21 +452,21 @@ final class SearchPaginationTests: XCTestCase {
         @ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {
             esb.Pagination()
         }
-        XCTAssertNoDifference(build().makeQuery(), [:])
+        expectNoDifference(build().makeQuery(), [:])
     }
     func testBuildFirst() throws {
         @ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {
             esb.Pagination(from: 10)
         }
-        XCTAssertNoDifference(build().makeQuery(), [
+        expectNoDifference(build().makeQuery(), [
             "from": 10
         ])
     }
     func testBuildFirstSize() throws {
         @ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {
             esb.Pagination(from: 10, size: 20)
         }
-        XCTAssertNoDifference(build().makeQuery(), [
+        expectNoDifference(build().makeQuery(), [
             "from": 10,
             "size": 20,
         ])

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ final class NothingTests: XCTestCase {`
`8`	`8`	`@ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {`
`9`	`9`	`esb.Nothing()`
`10`	`10`	`}`
`11`		`- XCTAssertNoDifference(build().makeQuery(), [:])`
	`11`	`+ expectNoDifference(build().makeQuery(), [:])`
`12`	`12`	`}`
`13`	`13`	`}`
`14`	`14`
`@@ -17,7 +17,7 @@ final class KeyTests: XCTestCase {`
`17`	`17`	`@ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {`
`18`	`18`	`esb.Key("boost", .float(1.2))`
`19`	`19`	`}`
`20`		`- XCTAssertNoDifference(build().makeQuery(), [`
	`20`	`+ expectNoDifference(build().makeQuery(), [`
`21`	`21`	`"boost": 1.2`
`22`	`22`	`])`
`23`	`23`	`}`
`@@ -29,7 +29,7 @@ final class KeyTests: XCTestCase {`
`29`	`29`	`]`
`30`	`30`	`}`
`31`	`31`	`}`
`32`		`- XCTAssertNoDifference(build().makeQuery(), [`
	`32`	`+ expectNoDifference(build().makeQuery(), [`
`33`	`33`	`"match_bool_prefix": [`
`34`	`34`	`"message": "quick brown f"`
`35`	`35`	`]`
`@@ -39,7 +39,7 @@ final class KeyTests: XCTestCase {`
`39`	`39`	`@ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {`
`40`	`40`	`esb.Key("match", .dict([:]))`
`41`	`41`	`}`
`42`		`- XCTAssertNoDifference(build().makeQuery(), [:])`
	`42`	`+ expectNoDifference(build().makeQuery(), [:])`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`
`@@ -57,7 +57,7 @@ final class ComposableBuilderTests: XCTestCase {`
`57`	`57`	`makeKey()`
`58`	`58`	`}`
`59`	`59`	`}`
`60`		`- XCTAssertNoDifference(build().makeQuery(), [`
	`60`	`+ expectNoDifference(build().makeQuery(), [`
`61`	`61`	`"query": [`
`62`	`62`	`"match_bool_prefix": [`
`63`	`63`	`"message": "quick brown f"`
`@@ -80,7 +80,7 @@ final class ComposableBuilderTests: XCTestCase {`
`80`	`80`	`makeKey(true)`
`81`	`81`	`}`
`82`	`82`	`}`
`83`		`- XCTAssertNoDifference(build().makeQuery(), [`
	`83`	`+ expectNoDifference(build().makeQuery(), [`
`84`	`84`	`"filter": [`
`85`	`85`	`[`
`86`	`86`	`"match_bool_prefix": [`
`@@ -107,7 +107,7 @@ final class ComposableBuilderTests: XCTestCase {`
`107`	`107`	`makeKey(true, 3)`
`108`	`108`	`}`
`109`	`109`	`}`
`110`		`- XCTAssertNoDifference(build().makeQuery(), [`
	`110`	`+ expectNoDifference(build().makeQuery(), [`
`111`	`111`	`"filter": [`
`112`	`112`	`[`
`113`	`113`	`"match_bool_prefix": [`
`@@ -135,7 +135,7 @@ final class QueryTests: XCTestCase {`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`	`}`
`138`		`- XCTAssertNoDifference(build().makeQuery(), [`
	`138`	`+ expectNoDifference(build().makeQuery(), [`
`139`	`139`	`"query": [`
`140`	`140`	`"match_bool_prefix": [`
`141`	`141`	`"message": "quick brown f"`
`@@ -149,7 +149,7 @@ final class QueryTests: XCTestCase {`
`149`	`149`	`esb.Key("match", .dict([:]))`
`150`	`150`	`}`
`151`	`151`	`}`
`152`		`- XCTAssertNoDifference(build().makeQuery(), [:])`
	`152`	`+ expectNoDifference(build().makeQuery(), [:])`
`153`	`153`	`}`
`154`	`154`	`}`
`155`	`155`
`@@ -196,7 +196,7 @@ final class BoolTests: XCTestCase {`
`196`	`196`	`}`
`197`	`197`	`}`
`198`	`198`	`}`
`199`		`- XCTAssertNoDifference(build(true).makeQuery(), [`
	`199`	`+ expectNoDifference(build(true).makeQuery(), [`
`200`	`200`	`"bool": [`
`201`	`201`	`"minimum_should_match": 1,`
`202`	`202`	`"should": [`
`@@ -229,7 +229,7 @@ final class BoolTests: XCTestCase {`
`229`	`229`	`]`
`230`	`230`	`]`
`231`	`231`	`])`
`232`		`- XCTAssertNoDifference(build(false).makeQuery(), [`
	`232`	`+ expectNoDifference(build(false).makeQuery(), [`
`233`	`233`	`"bool": [`
`234`	`234`	`"minimum_should_match": 1`
`235`	`235`	`]`
`@@ -252,7 +252,44 @@ final class BoolTests: XCTestCase {`
`252`	`252`	`}`
`253`	`253`	`}`
`254`	`254`	`}`
`255`		`- XCTAssertNoDifference(build().makeQuery(), [:])`
	`255`	`+ expectNoDifference(build().makeQuery(), [:])`
	`256`	`+ }`
	`257`	`+}`
	`258`	`+`
	`259`	`+final class SortTests: XCTestCase {`
	`260`	`+ func testBuild() throws {`
	`261`	`+ @ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {`
	`262`	`+ esb.Sort {`
	`263`	`+ esb.Key("_score") {`
	`264`	`+ [ "order": "desc" ]`
	`265`	`+ }`
	`266`	`+ esb.Key("name") {`
	`267`	`+ [ "order": "asc" ]`
	`268`	`+ }`
	`269`	`+ }`
	`270`	`+ }`
	`271`	`+ expectNoDifference(build().makeQuery(), [`
	`272`	`+ "sort": [`
	`273`	`+ [`
	`274`	`+ "_score": [ "order": "desc" ]`
	`275`	`+ ],`
	`276`	`+ [`
	`277`	`+ "name": [ "order": "asc" ]`
	`278`	`+ ]`
	`279`	`+ ]`
	`280`	`+ ])`
	`281`	`+ }`
	`282`	`+ func testBuildEmpty() throws {`
	`283`	`+ @ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {`
	`284`	`+ esb.Sort {`
	`285`	`+ if false {`
	`286`	`+ esb.Key("_score") {`
	`287`	`+ [ "order": "desc" ]`
	`288`	`+ }`
	`289`	`+ }`
	`290`	`+ }`
	`291`	`+ }`
	`292`	`+ expectNoDifference(build().makeQuery(), [:])`
`256`	`293`	`}`
`257`	`294`	`}`
`258`	`295`
`@@ -261,15 +298,15 @@ final class TermTests: XCTestCase {`
`261`	`298`	`@ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {`
`262`	`299`	`esb.Term("name", "joe")`
`263`	`300`	`}`
`264`		`- XCTAssertNoDifference(build().makeQuery(), [`
	`301`	`+ expectNoDifference(build().makeQuery(), [`
`265`	`302`	`"term": [ "name": "joe" ]`
`266`	`303`	`])`
`267`	`304`	`}`
`268`	`305`	`func testBuildEmpty() throws {`
`269`	`306`	`@ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {`
`270`	`307`	`esb.Term("name", nil)`
`271`	`308`	`}`
`272`		`- XCTAssertNoDifference(build().makeQuery(), [:])`
	`309`	`+ expectNoDifference(build().makeQuery(), [:])`
`273`	`310`	`}`
`274`	`311`	`}`
`275`	`312`
`@@ -278,15 +315,15 @@ final class TermsORTests: XCTestCase {`
`278`	`315`	`@ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {`
`279`	`316`	`esb.TermsOR("name", ["joe", "mary"])`
`280`	`317`	`}`
`281`		`- XCTAssertNoDifference(build().makeQuery(), [`
	`318`	`+ expectNoDifference(build().makeQuery(), [`
`282`	`319`	`"terms": [ "name": ["joe", "mary"] ]`
`283`	`320`	`])`
`284`	`321`	`}`
`285`	`322`	`func testBuildEmpty() throws {`
`286`	`323`	`@ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {`
`287`	`324`	`esb.TermsOR("name", [])`
`288`	`325`	`}`
`289`		`- XCTAssertNoDifference(build().makeQuery(), [:])`
	`326`	`+ expectNoDifference(build().makeQuery(), [:])`
`290`	`327`	`}`
`291`	`328`	`}`
`292`	`329`
`@@ -297,7 +334,7 @@ final class TermsANDTests: XCTestCase {`
`297`	`334`	`esb.TermsAND("name", ["joe", "mary"])`
`298`	`335`	`}`
`299`	`336`	`}`
`300`		`- XCTAssertNoDifference(build().makeQuery(), [`
	`337`	`+ expectNoDifference(build().makeQuery(), [`
`301`	`338`	`"filter": [`
`302`	`339`	`[ "term": [ "name": "joe" ] ],`
`303`	`340`	`[ "term": [ "name": "mary" ] ],`
`@@ -310,7 +347,7 @@ final class TermsANDTests: XCTestCase {`
`310`	`347`	`esb.TermsAND("name", [])`
`311`	`348`	`}`
`312`	`349`	`}`
`313`		`- XCTAssertNoDifference(build().makeQuery(), [:])`
	`350`	`+ expectNoDifference(build().makeQuery(), [:])`
`314`	`351`	`}`
`315`	`352`	`}`
`316`	`353`
`@@ -319,7 +356,7 @@ final class KNearestNeighborTests: XCTestCase {`
`319`	`356`	`@ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {`
`320`	`357`	`esb.kNearestNeighbor("vector_field", [1,2,3])`
`321`	`358`	`}`
`322`		`- XCTAssertNoDifference(build().makeQuery(), [`
	`359`	`+ expectNoDifference(build().makeQuery(), [`
`323`	`360`	`"knn": [`
`324`	`361`	`"field": "vector_field",`
`325`	`362`	`"query_vector": [1.0, 2.0, 3.0],`
`@@ -341,7 +378,7 @@ final class KNearestNeighborTests: XCTestCase {`
`341`	`378`	`}`
`342`	`379`	`}`
`343`	`380`	`}`
`344`		`- XCTAssertNoDifference(build().makeQuery(), [`
	`381`	`+ expectNoDifference(build().makeQuery(), [`
`345`	`382`	`"knn": [`
`346`	`383`	`"field": "vector_field",`
`347`	`384`	`"query_vector": [1.0, 2.0, 3.0],`
`@@ -385,7 +422,7 @@ final class FunctionScoreTests: XCTestCase {`
`385`	`422`	`}`
`386`	`423`	`}`
`387`	`424`	`}`
`388`		`- XCTAssertNoDifference(build().makeQuery(), [`
	`425`	`+ expectNoDifference(build().makeQuery(), [`
`389`	`426`	`"function_score": [`
`390`	`427`	`"bool": [`
`391`	`428`	`"should": [`
`@@ -415,21 +452,21 @@ final class SearchPaginationTests: XCTestCase {`
`415`	`452`	`@ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {`
`416`	`453`	`esb.Pagination()`
`417`	`454`	`}`
`418`		`- XCTAssertNoDifference(build().makeQuery(), [:])`
	`455`	`+ expectNoDifference(build().makeQuery(), [:])`
`419`	`456`	`}`
`420`	`457`	`func testBuildFirst() throws {`
`421`	`458`	`@ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {`
`422`	`459`	`esb.Pagination(from: 10)`
`423`	`460`	`}`
`424`		`- XCTAssertNoDifference(build().makeQuery(), [`
	`461`	`+ expectNoDifference(build().makeQuery(), [`
`425`	`462`	`"from": 10`
`426`	`463`	`])`
`427`	`464`	`}`
`428`	`465`	`func testBuildFirstSize() throws {`
`429`	`466`	`@ElasticsearchQueryBuilder func build() -> some esb.QueryDSL {`
`430`	`467`	`esb.Pagination(from: 10, size: 20)`
`431`	`468`	`}`
`432`		`- XCTAssertNoDifference(build().makeQuery(), [`
	`469`	`+ expectNoDifference(build().makeQuery(), [`
`433`	`470`	`"from": 10,`
`434`	`471`	`"size": 20,`
`435`	`472`	`])`