fix: Query HealthKit samples over specified date interval

CareKitStore/CareKitStore/CoreData/OCKStore+CarePlans.swift

@@ -128,6 +128,7 @@ extension OCKStore {
             switch order {
             case .effectiveDate(let ascending): return NSSortDescriptor(keyPath: \OCKCDCarePlan.effectiveDate, ascending: ascending)
             case .title(let ascending): return NSSortDescriptor(keyPath: \OCKCDCarePlan.title, ascending: ascending)
+            case .groupIdentifier(let ascending): return NSSortDescriptor(keyPath: \OCKCDCarePlan.groupIdentifier, ascending: ascending)
             }
         } + query.defaultSortDescriptors()
     }

CareKitStore/CareKitStore/CoreData/OCKStore+Contacts.swift

@@ -129,6 +129,7 @@ extension OCKStore {
             case .effectiveDate(ascending: let ascending): return NSSortDescriptor(keyPath: \OCKCDContact.effectiveDate, ascending: ascending)
             case .familyName(ascending: let ascending): return NSSortDescriptor(keyPath: \OCKCDContact.name.familyName, ascending: ascending)
             case .givenName(ascending: let ascending): return NSSortDescriptor(keyPath: \OCKCDContact.name.givenName, ascending: ascending)
+            case .groupIdentifier(let ascending): return NSSortDescriptor(keyPath: \OCKCDContact.groupIdentifier, ascending: ascending)
             }
         } + query.defaultSortDescriptors()
     }

CareKitStore/CareKitStore/CoreData/OCKStore+Outcomes.swift

@@ -303,7 +303,12 @@ extension OCKStore {
     }
 
     private func buildSortDescriptors(for query: OCKOutcomeQuery) -> [NSSortDescriptor] {
-        query.defaultSortDescriptors()
+        query.sortDescriptors.map { order -> NSSortDescriptor in
+            switch order {
+            case .effectiveDate(let ascending): return NSSortDescriptor(keyPath: \OCKCDOutcome.effectiveDate, ascending: ascending)
+            case .groupIdentifier(let ascending): return NSSortDescriptor(keyPath: \OCKCDOutcome.groupIdentifier, ascending: ascending)
+            }
+        } + query.defaultSortDescriptors()
     }
 
     private func doesEventForOutcomeOccur(in interval: DateInterval) -> NSPredicate {

CareKitStore/CareKitStore/HealthKit/OCKHealthKitPassthroughStore+EventUtilities.swift

@@ -530,12 +530,23 @@ extension OCKHealthKitPassthroughStore {
 
     func makeTaskQuery(from outcomeQuery: OCKOutcomeQuery) -> OCKTaskQuery {
 
-        let dateInterval = Calendar.current.dateInterval(of: .day, for: Date())!
+        // Search over the interval provided by OCKOutcomeQuery if present
+        // or else constrain sample query over the current day.
+        let dateInterval = outcomeQuery.dateInterval ??
+            Calendar.current.dateInterval(of: .day, for: Date())!
 
         var taskQuery = OCKTaskQuery(dateInterval: dateInterval)
         taskQuery.ids = outcomeQuery.taskIDs
         taskQuery.remoteIDs = outcomeQuery.taskRemoteIDs
         taskQuery.uuids = outcomeQuery.taskUUIDs
+        taskQuery.sortDescriptors = outcomeQuery.sortDescriptors.map { descriptor in
+            switch descriptor {
+            case .effectiveDate(ascending: let ascending):
+                return OCKTaskQuery.SortDescriptor.effectiveDate(ascending: ascending)
+            case .groupIdentifier(ascending: let ascending):
+                return OCKTaskQuery.SortDescriptor.groupIdentifier(ascending: ascending)
+            }
+        }
 
         return taskQuery
     }

CareKitStore/CareKitStore/Protocols/CarePlans/OCKAnyCarePlanStore.swift

@@ -137,7 +137,7 @@ public extension OCKAnyReadOnlyCarePlanStore {
                           completion: @escaping OCKResultClosure<OCKAnyCarePlan>) {
         var query = OCKCarePlanQuery(for: Date())
         query.limit = 1
-        query.sortDescriptors = [.effectiveDate(ascending: true)]
+        query.sortDescriptors = [.effectiveDate(ascending: false)]
         query.ids = [id]
 
         fetchAnyCarePlans(query: query, callbackQueue: callbackQueue, completion:

CareKitStore/CareKitStore/Protocols/CarePlans/OCKCarePlanStore.swift

@@ -131,7 +131,7 @@ public extension OCKReadableCarePlanStore {
     func fetchCarePlan(withID id: String, callbackQueue: DispatchQueue = .main, completion: @escaping OCKResultClosure<Plan>) {
         var query = OCKCarePlanQuery(for: Date())
         query.limit = 1
-        query.sortDescriptors = [.effectiveDate(ascending: true)]
+        query.sortDescriptors = [.effectiveDate(ascending: false)]
         query.ids = [id]
 
         fetchCarePlans(query: query, callbackQueue: callbackQueue, completion:

CareKitStore/CareKitStore/Protocols/Contacts/OCKAnyContactStore.swift

@@ -126,7 +126,7 @@ public extension OCKAnyReadOnlyContactStore {
                          completion: @escaping OCKResultClosure<OCKAnyContact>) {
         var query = OCKContactQuery(for: Date())
         query.limit = 1
-        query.sortDescriptors = [.effectiveDate(ascending: true)]
+        query.sortDescriptors = [.effectiveDate(ascending: false)]
         query.ids = [id]
 
         fetchAnyContacts(query: query, callbackQueue: callbackQueue, completion:

CareKitStore/CareKitStore/Protocols/Contacts/OCKContactStore.swift

@@ -132,7 +132,7 @@ public extension OCKReadableContactStore {
         var query = OCKContactQuery(for: Date())
         query.limit = 1
         query.ids = [id]
-        query.sortDescriptors = [.effectiveDate(ascending: true)]
+        query.sortDescriptors = [.effectiveDate(ascending: false)]
 
         fetchContacts(query: query, callbackQueue: callbackQueue, completion:
             chooseFirst(then: completion, replacementError: .fetchFailed(reason: "No contact with matching ID")))

CareKitStore/CareKitStore/Protocols/Patients/OCKAnyPatientStore.swift

@@ -133,7 +133,7 @@ public extension OCKAnyReadOnlyPatientStore {
     ) {
         var query = OCKPatientQuery(for: Date())
         query.limit = 1
-        query.sortDescriptors = [.effectiveDate(ascending: true)]
+        query.sortDescriptors = [.effectiveDate(ascending: false)]
         query.ids = [id]
 
         fetchAnyPatients(query: query, callbackQueue: callbackQueue, completion:

CareKitStore/CareKitStore/Protocols/Patients/OCKPatientStore.swift

@@ -134,7 +134,7 @@ public extension OCKReadablePatientStore {
         var query = OCKPatientQuery(for: Date())
         query.limit = 1
         query.ids = [id]
-        query.sortDescriptors = [.effectiveDate(ascending: true)]
+        query.sortDescriptors = [.effectiveDate(ascending: false)]
 
         fetchPatients(query: query, callbackQueue: callbackQueue, completion:
             chooseFirst(then: completion, replacementError: .fetchFailed(reason: "No patient with matching ID")))

CareKitStore/CareKitStore/Protocols/Tasks/OCKAnyTaskStore.swift

@@ -133,7 +133,7 @@ public protocol OCKAnyTaskStore: OCKAnyReadOnlyTaskStore {
 
 public extension OCKAnyReadOnlyTaskStore {
     func fetchAnyTask(withID id: String, callbackQueue: DispatchQueue = .main, completion: @escaping OCKResultClosure<OCKAnyTask>) {
-        var query = OCKTaskQuery(id: id)
+        var query = OCKTaskQuery(for: Date())
         query.sortDescriptors = [.effectiveDate(ascending: false)]
         query.ids = [id]
         query.limit = 1

CareKitStore/CareKitStore/Protocols/Tasks/OCKTaskStore.swift

@@ -130,7 +130,7 @@ public protocol OCKTaskStore: OCKReadableTaskStore, OCKAnyTaskStore {
 public extension OCKReadableTaskStore {
     func fetchTask(withID id: String, callbackQueue: DispatchQueue = .main, completion: @escaping OCKResultClosure<Task>) {
         var query = OCKTaskQuery(for: Date())
-        query.sortDescriptors = [.effectiveDate(ascending: true)]
+        query.sortDescriptors = [.effectiveDate(ascending: false)]
         query.ids = [id]
         query.limit = 1
 

CareKitStore/CareKitStore/StoreCoordinator/OCKPersistentStoreCoordinator+Outcomes.swift

@@ -44,12 +44,11 @@ extension OCKStoreCoordinator {
             sequences: outcomesStreams,
             makeSortDescriptors: {
 
-                let sortDescriptor = NSSortDescriptor(
-                    keyPath: \OCKCDOutcome.id,
-                    ascending: true
-                )
+                let sortDescriptors = query
+                    .sortDescriptors
+                    .map(\.nsSortDescriptor)
 
-                return [sortDescriptor]
+                return sortDescriptors
             }
         )
 

CareKitStore/CareKitStore/Structs/Queries/OCKCarePlanQuery.swift

@@ -38,13 +38,16 @@ public struct OCKCarePlanQuery: Equatable, Sendable, OCKQueryProtocol {
 
         case title(ascending: Bool)
         case effectiveDate(ascending: Bool)
+        case groupIdentifier(ascending: Bool)
 
         var nsSortDescriptor: NSSortDescriptor {
             switch self {
             case let .effectiveDate(ascending):
                 return NSSortDescriptor(keyPath: \OCKCDCarePlan.effectiveDate, ascending: ascending)
             case let .title(ascending):
                 return NSSortDescriptor(keyPath: \OCKCDCarePlan.title, ascending: ascending)
+            case let .groupIdentifier(ascending):
+                return NSSortDescriptor(keyPath: \OCKCDCarePlan.groupIdentifier, ascending: ascending)
             }
         }
     }

CareKitStore/CareKitStore/Structs/Queries/OCKContactQuery.swift

@@ -39,15 +39,18 @@ public struct OCKContactQuery: Equatable, Sendable, OCKQueryProtocol {
         case givenName(ascending: Bool)
         case familyName(ascending: Bool)
         case effectiveDate(ascending: Bool)
+        case groupIdentifier(ascending: Bool)
 
         var nsSortDescriptor: NSSortDescriptor {
             switch self {
-            case let .effectiveDate(ascending):
-                return NSSortDescriptor(keyPath: \OCKCDContact.effectiveDate, ascending: ascending)
             case let .givenName(ascending):
                 return NSSortDescriptor(keyPath: \OCKCDContact.name.givenName, ascending: ascending)
             case let .familyName(ascending):
                 return NSSortDescriptor(keyPath: \OCKCDContact.name.familyName, ascending: ascending)
+            case let .effectiveDate(ascending):
+                return NSSortDescriptor(keyPath: \OCKCDContact.effectiveDate, ascending: ascending)
+            case let .groupIdentifier(ascending):
+                return NSSortDescriptor(keyPath: \OCKCDContact.groupIdentifier, ascending: ascending)
             }
         }
     }

CareKitStore/CareKitStore/Structs/Queries/OCKOutcomeQuery.swift

@@ -33,6 +33,22 @@ import Foundation
 /// A query that limits which outcomes will be returned when fetching.
 public struct OCKOutcomeQuery: Equatable, Sendable, OCKQueryProtocol {
 
+    /// Specifies the order in which query results will be sorted.
+	public enum SortDescriptor: Equatable, Sendable {
+
+        case effectiveDate(ascending: Bool)
+        case groupIdentifier(ascending: Bool)
+
+        var nsSortDescriptor: NSSortDescriptor {
+            switch self {
+            case let .effectiveDate(ascending):
+                return NSSortDescriptor(keyPath: \OCKCDOutcome.effectiveDate, ascending: ascending)
+            case let .groupIdentifier(ascending):
+                return NSSortDescriptor(keyPath: \OCKCDOutcome.groupIdentifier, ascending: ascending)
+            }
+        }
+    }
+
     /// An array of task identifiers to match against.
     public var taskIDs: [String] = []
 
@@ -42,6 +58,9 @@ public struct OCKOutcomeQuery: Equatable, Sendable, OCKQueryProtocol {
     /// An array of remote IDs of tasks for which outcomes should be returned.
     public var taskRemoteIDs: [String] = []
 
+    /// The order in which the results will be sorted when returned from the query.
+    public var sortDescriptors: [SortDescriptor] = []
+
     // MARK: OCKQuery
     public var ids: [String] = []
     public var uuids: [UUID] = []

CareKitStore/CareKitStore/Structs/Queries/OCKTaskQuery.swift

@@ -72,7 +72,7 @@ public struct OCKTaskQuery: Equatable, Sendable, OCKQueryProtocol {
     /// The remote IDs of the care plans for which tasks should match.
     public var carePlanRemoteIDs: [String] = []
 
-    /// Determines if tasks with no events should be included in the query results or not. False be default.
+    /// Determines if tasks with no events should be included in the query results or not. False by default.
     public var excludesTasksWithNoEvents = false
 
     /// The order in which the results will be sorted when returned from the query.

CareKitStore/CareKitStoreTests/OCKHealthKitStore/TestHealthKitPassthroughStore+Outcomes.swift

@@ -142,6 +142,58 @@ class TestHealthKitPassthroughStoreOutcomes: XCTestCase {
         try passthroughStore.checkAbilityToDelete(outcomes: outcomes)
     }
 
+    func testTaskQueryDefaultsToCurrentDayDateInterval() async throws {
+        let outcomeTaskQuery = OCKOutcomeQuery()
+        let taskQuery = passthroughStore.makeTaskQuery(from: outcomeTaskQuery)
+        let currentDayDateInterval = Calendar.current.dateInterval(of: .day, for: Date())!
+
+        XCTAssertEqual(
+            taskQuery.dateInterval?.start,
+            currentDayDateInterval.start
+        )
+        XCTAssertEqual(
+            taskQuery.dateInterval?.end,
+            currentDayDateInterval.end
+        )
+        XCTAssertEqual(taskQuery.ids, outcomeTaskQuery.taskIDs)
+        XCTAssertEqual(taskQuery.remoteIDs, outcomeTaskQuery.taskRemoteIDs)
+        XCTAssertEqual(taskQuery.uuids, outcomeTaskQuery.taskUUIDs)
+        XCTAssertTrue(taskQuery.sortDescriptors.isEmpty)
+    }
+
+    func testTaskQueryPropertiesAdoptsOutcomeQueryProperties() async throws {
+        let yesterday = Calendar.current.date(
+            byAdding: .day,
+            value: -1,
+            to: Date()
+        )!
+        let yesterdayDateInterval = Calendar.current.dateInterval(
+            of: .day,
+            for: yesterday
+        )!
+        var outcomeTaskQuery = OCKOutcomeQuery(
+            dateInterval: yesterdayDateInterval
+        )
+        outcomeTaskQuery.taskIDs = ["id"]
+        outcomeTaskQuery.taskRemoteIDs = ["remoteID"]
+        outcomeTaskQuery.taskUUIDs = [UUID()]
+        outcomeTaskQuery.sortDescriptors = [
+            .effectiveDate(ascending: true),
+            .groupIdentifier(ascending: true)
+        ]
+        let taskQuery = passthroughStore.makeTaskQuery(from: outcomeTaskQuery)
+        let expectedTaskSortDescriptors: [OCKTaskQuery.SortDescriptor] = [
+            .effectiveDate(ascending: true),
+            .groupIdentifier(ascending: true)
+        ]
+
+        XCTAssertEqual(taskQuery.dateInterval, outcomeTaskQuery.dateInterval)
+        XCTAssertEqual(taskQuery.ids, outcomeTaskQuery.taskIDs)
+        XCTAssertEqual(taskQuery.remoteIDs, outcomeTaskQuery.taskRemoteIDs)
+        XCTAssertEqual(taskQuery.uuids, outcomeTaskQuery.taskUUIDs)
+        XCTAssertEqual(taskQuery.sortDescriptors, expectedTaskSortDescriptors)
+    }
+
     // MARK: - Utilities
 
     private func makeStepsTask() -> OCKHealthKitTask {

CareKitStore/CareKitStoreTests/OCKStore/TestStore+CarePlans.swift

@@ -230,6 +230,20 @@ class TestStoreCarePlans: XCTestCase {
         XCTAssertEqual(fetched.previousVersionUUIDs.first, versionA.uuid)
     }
 
+    func testCarePlanQueryByIdConvenienceMethodReturnsLatestVersionOfACarePlan() async throws {
+        let versionA = try await store.addCarePlan(OCKCarePlan(id: "A", title: "Amy", patientUUID: nil))
+        let versionB = try await store.updateCarePlan(OCKCarePlan(id: "A", title: "Jared", patientUUID: nil))
+        let fetched = try await store.fetchCarePlan(withID: versionA.id)
+		XCTAssertEqual(fetched.title, versionB.title)
+    }
+
+    func testAnyCarePlanQueryByIdConvenienceMethodReturnsLatestVersionOfACarePlan() async throws {
+        let versionA = try await store.addCarePlan(OCKCarePlan(id: "A", title: "Amy", patientUUID: nil))
+        let versionB = try await store.updateCarePlan(OCKCarePlan(id: "A", title: "Jared", patientUUID: nil))
+        let fetched = try await store.fetchAnyCarePlan(withID: versionA.id)
+		XCTAssertEqual(fetched.title, versionB.title)
+    }
+
     func testCarePlanQueryOnPastDateReturnsPastVersionOfACarePlan() async throws {
         let dateA = Date().addingTimeInterval(-100)
         var versionA = OCKCarePlan(id: "A", title: "a", patientUUID: nil)

CareKitStore/CareKitStoreTests/OCKStore/TestStore+Contacts.swift

@@ -252,11 +252,28 @@ class TestStoreContacts: XCTestCase {
         XCTAssertEqual(fetched.name, versionD.name)
     }
 
+    func testContactQueryByIdConvenienceMethodReturnsLatestVersionOfAContact() async throws {
+        let versionA = try await store.addContact(OCKContact(id: "contact", givenName: "A", familyName: "", carePlanUUID: nil))
+        let versionB = try await store.updateContact(OCKContact(id: "contact", givenName: "B", familyName: "", carePlanUUID: nil))
+
+        let fetched = try await store.fetchContact(withID: versionA.id)
+		XCTAssertEqual(fetched.name.givenName, versionB.name.givenName)
+    }
+
+    func testAnyContactQueryByIdConvenienceMethodReturnsLatestVersionOfAContact() async throws {
+        let versionA = try await store.addContact(OCKContact(id: "contact", givenName: "A", familyName: "", carePlanUUID: nil))
+        let versionB = try await store.updateContact(OCKContact(id: "contact", givenName: "B", familyName: "", carePlanUUID: nil))
+
+        let fetched = try await store.fetchContact(withID: versionA.id)
+		XCTAssertEqual(fetched.name.givenName, versionB.name.givenName)
+    }
+
     func testContactQueryWithDateOnlyReturnsLatestVersionOfAContact() async throws {
         try await store.addContact(OCKContact(id: "contact", givenName: "A", familyName: "", carePlanUUID: nil))
         try await store.updateContact(OCKContact(id: "contact", givenName: "B", familyName: "", carePlanUUID: nil))
         try await store.updateContact(OCKContact(id: "contact", givenName: "C", familyName: "", carePlanUUID: nil))
         try await store.updateContact(OCKContact(id: "contact", givenName: "D", familyName: "", carePlanUUID: nil))
+
         let fetched = try await store.fetchContacts(query: OCKContactQuery(for: Date()))
         XCTAssertEqual(fetched.count, 1)
         XCTAssertEqual(fetched.first?.name.givenName, "D")

CareKitStore/CareKitStoreTests/OCKStore/TestStore+Patients.swift

@@ -189,6 +189,20 @@ class TestStorePatients: XCTestCase {
         XCTAssertEqual(fetched, versionB)
     }
 
+    func testPatientQueryByIdConvenienceMethodReturnsLatestVersionOfAPatient() async throws {
+        let versionA = try await store.addPatient(OCKPatient(id: "A", givenName: "Jared", familyName: "Gosler"))
+        let versionB = try await store.updatePatient(OCKPatient(id: "A", givenName: "John", familyName: "Appleseed"))
+        let fetched = try await store.fetchPatient(withID: versionA.id)
+		XCTAssertEqual(fetched.name.familyName, versionB.name.familyName)
+    }
+
+    func testAnyPatientQueryByIdConvenienceMethodReturnsLatestVersionOfAPatient() async throws {
+        let versionA = try await store.addPatient(OCKPatient(id: "A", givenName: "Jared", familyName: "Gosler"))
+        let versionB = try await store.updatePatient(OCKPatient(id: "A", givenName: "John", familyName: "Appleseed"))
+        let fetched = try await store.fetchPatient(withID: versionA.id)
+		XCTAssertEqual(fetched.name.familyName, versionB.name.familyName)
+    }
+
     func testPatientQueryOnPastDateReturnsPastVersionOfAPatient() async throws {
         let dateA = Date().addingTimeInterval(-100)
         var versionA = OCKPatient(id: "A", givenName: "Jared", familyName: "Gosler")

CareKitStore/CareKitStoreTests/OCKStore/TestStore+Tasks.swift

@@ -374,11 +374,27 @@ class TestStoreTasks: XCTestCase {
 
         var taskV2 = taskV1
         taskV2.title = "V2"
-        taskV2.effectiveDate = Calendar.current.date(byAdding: .year, value: 1, to: Date())!
+        taskV2 = try await store.updateTask(taskV2)
+
+		let task = try await store.fetchTask(withID: "task")
+		XCTAssertEqual(task.title, taskV2.title)
+    }
+
+    func testFetchAnyTaskByIdConvenienceMethodReturnsNewestVersionOfTask() async throws {
+        let coordinator = OCKStoreCoordinator()
+        let store = OCKStore(name: "test", type: .inMemory)
+        coordinator.attach(store: store)
+
+        let schedule = OCKSchedule.dailyAtTime(hour: 0, minutes: 0, start: Date(), end: nil, text: nil)
+        var taskV1 = OCKTask(id: "task", title: "V1", carePlanUUID: nil, schedule: schedule)
+        taskV1 = try await store.addTask(taskV1)
+
+        var taskV2 = taskV1
+        taskV2.title = "V2"
         taskV2 = try await store.updateTask(taskV2)
 
         let fetchedTask = try await store.fetchAnyTask(withID: "task")
-        XCTAssertEqual(fetchedTask.title, "V2")
+        XCTAssertEqual(fetchedTask.title, taskV2.title)
     }
 
     func testTaskQueryStartingExactlyOnEffectiveDateOfNewVersion() async throws {