feat(DataStore): DataStore.delete(modelType:where:) API (#1723)

* feat(DataStore): DataStore.delete(modelType:where:) API

* update integration test

Author: lawmicha

Amplify/Categories/DataStore/DataStoreCategory+Behavior+Combine.swift

@@ -41,6 +41,22 @@ public extension DataStoreBaseBehavior {
         }.eraseToAnyPublisher()
     }
 
+    /// Deletes models matching the `predicate` from the DataStore. If sync is enabled, this will delete the
+    /// model from the remote store as well.
+    ///
+    /// - Parameters:
+    ///   - modelType: The type of the model to delete
+    ///   - predicate: The models that match this predicate to be deleted
+    /// - Returns: A DataStorePublisher with the results of the operation
+    func delete<M: Model>(
+        _ modelType: M.Type,
+        where predicate: QueryPredicate
+    ) -> DataStorePublisher<Void> {
+        Future { promise in
+            self.delete(modelType, where: predicate) { promise($0) }
+        }.eraseToAnyPublisher()
+    }
+
     /// Deletes the specified model instance from the DataStore. If sync is enabled, this will delete the
     /// model from the remote store as well.
     ///

Amplify/Categories/DataStore/DataStoreCategory+Behavior.swift

@@ -39,6 +39,12 @@ extension DataStoreCategory: DataStoreBaseBehavior {
         plugin.delete(modelType, withId: id, where: predicate, completion: completion)
     }
 
+    public func delete<M: Model>(_ modelType: M.Type,
+                                 where predicate: QueryPredicate,
+                                 completion: @escaping DataStoreCallback<Void>) {
+        plugin.delete(modelType, where: predicate, completion: completion)
+    }
+
     public func start(completion: @escaping DataStoreCallback<Void>) {
         plugin.start(completion: completion)
     }

Amplify/Categories/DataStore/DataStoreCategoryBehavior.swift

@@ -34,6 +34,11 @@ public protocol DataStoreBaseBehavior {
                           withId id: String,
                           where predicate: QueryPredicate?,
                           completion: @escaping DataStoreCallback<Void>)
+
+    func delete<M: Model>(_ modelType: M.Type,
+                          where predicate: QueryPredicate,
+                          completion: @escaping DataStoreCallback<Void>)
+
     /**
      Synchronization starts automatically whenever you run any DataStore operation (query(), save(), delete())
      however, you can explicitly begin the process with DatasStore.start()

AmplifyPlugins/DataStore/AWSDataStoreCategoryPluginIntegrationTests/Connection/DataStoreConnectionScenario6Tests.swift

@@ -7,7 +7,7 @@
 
 import XCTest
 import AmplifyPlugins
-import AWSMobileClient
+import Combine
 
 @testable import Amplify
 @testable import AmplifyTestCommon
@@ -39,6 +39,7 @@ import AWSMobileClient
  ```
  */
 
+@available(iOS 13.0, *)
 class DataStoreConnectionScenario6Tests: SyncEngineIntegrationTestBase {
 
     func testGetBlogThenFetchPostsThenFetchComments() throws {
@@ -203,6 +204,103 @@ class DataStoreConnectionScenario6Tests: SyncEngineIntegrationTestBase {
         }
     }
 
+    func testDeleteAll() throws {
+        try startAmplifyAndWaitForReady()
+        var cancellables = Set<AnyCancellable>()
+        let remoteEventReceived = expectation(description: "received mutation event with version 1")
+        let commentId = UUID().uuidString
+        Amplify.DataStore.publisher(for: Comment6.self).sink { completion in
+            switch completion {
+            case .finished:
+                break
+            case .failure(let error):
+                XCTFail("Failed \(error)")
+            }
+        } receiveValue: { mutationEvent in
+            if mutationEvent.modelId == commentId && mutationEvent.version == 1 {
+                remoteEventReceived.fulfill()
+            }
+        }.store(in: &cancellables)
+        guard let blog = saveBlog(name: "name"),
+              let post = savePost(title: "title", blog: blog),
+              saveComment(id: commentId, post: post, content: "content") != nil else {
+            XCTFail("Could not create blog, post, and comment")
+            return
+        }
+        wait(for: [remoteEventReceived], timeout: 5)
+
+        var blogCount = 0
+        let retrievedBlogCount = expectation(description: "retrieved blog count")
+        Amplify.DataStore.query(Blog6.self) { result in
+            switch result {
+            case .success(let blogs):
+                blogCount = blogs.count
+                retrievedBlogCount.fulfill()
+            case .failure(let error):
+                XCTFail("\(error)")
+            }
+        }
+        wait(for: [retrievedBlogCount], timeout: 10)
+        var postCount = 0
+        let retrievedPostCount = expectation(description: "retrieved post count")
+        Amplify.DataStore.query(Post6.self) { result in
+            switch result {
+            case .success(let posts):
+                postCount = posts.count
+                retrievedPostCount.fulfill()
+            case .failure(let error):
+                XCTFail("\(error)")
+            }
+        }
+        wait(for: [retrievedPostCount], timeout: 10)
+
+        var commentCount = 0
+        let retrievedCommentCount = expectation(description: "retrieved comment count")
+        Amplify.DataStore.query(Comment6.self) { result in
+            switch result {
+            case .success(let comments):
+                commentCount = comments.count
+                retrievedCommentCount.fulfill()
+            case .failure(let error):
+                XCTFail("\(error)")
+            }
+        }
+
+        wait(for: [retrievedCommentCount], timeout: 10)
+
+        let totalCount = blogCount + postCount + commentCount
+        Amplify.Logging.verbose("Retrieved blog \(blogCount) post \(postCount) comment \(commentCount)")
+
+        let outboxMutationProcessed = expectation(description: "received outboxMutationProcessed")
+        var processedSoFar = 0
+        Amplify.Hub.publisher(for: .dataStore)
+            .sink { payload in
+                let event = DataStoreHubEvent(payload: payload)
+                switch event {
+                case .outboxMutationProcessed:
+                    processedSoFar += 1
+                    print("Processed so far \(processedSoFar)")
+                    if processedSoFar == totalCount {
+                        outboxMutationProcessed.fulfill()
+                    }
+                default:
+                    break
+                }
+            }.store(in: &cancellables)
+
+        let deleteSuccess = expectation(description: "Delete all successful")
+        Amplify.DataStore.delete(Blog6.self, where: QueryPredicateConstant.all) { result in
+            switch result {
+            case .success:
+                deleteSuccess.fulfill()
+            case .failure(let error):
+                XCTFail("\(error)")
+            }
+        }
+
+        wait(for: [deleteSuccess, outboxMutationProcessed], timeout: 10)
+    }
+
     func saveBlog(id: String = UUID().uuidString, name: String) -> Blog6? {
         let blog = Blog6(id: id, name: name)
         var result: Blog6?

AmplifyPlugins/DataStore/AWSDataStoreCategoryPluginIntegrationTests/DataStoreLocalStoreTests.swift

@@ -421,14 +421,78 @@ class DataStoreLocalStoreTests: LocalStoreIntegrationTestBase {
         sink.cancel()
     }
 
+    func testDeleteModelTypeWithPredicate() {
+        _ = setUpLocalStore(numberOfPosts: 5)
+        let queryOnSetUpSuccess = expectation(description: "query returns non-empty result")
+        Amplify.DataStore.query(Post.self, where: Post.keys.status.eq(PostStatus.draft)) { result in
+            switch result {
+            case .success(let posts):
+                XCTAssertFalse(posts.isEmpty)
+                queryOnSetUpSuccess.fulfill()
+            case .failure(let error):
+                XCTFail("\(error)")
+            }
+        }
+        wait(for: [queryOnSetUpSuccess], timeout: 1)
+        let deleteSuccess = expectation(description: "Delete all successful")
+        Amplify.DataStore.delete(Post.self, where: Post.keys.status.eq(PostStatus.draft)) { result in
+            switch result {
+            case .success:
+                deleteSuccess.fulfill()
+            case .failure(let error):
+                XCTFail("\(error)")
+            }
+        }
+        wait(for: [deleteSuccess], timeout: 1)
+
+        let queryComplete = expectation(description: "query returns empty result")
+        Amplify.DataStore.query(Post.self, where: Post.keys.status.eq(PostStatus.draft)) { result in
+            switch result {
+            case .success(let posts):
+                XCTAssertEqual(posts.count, 0)
+                queryComplete.fulfill()
+            case .failure(let error):
+                XCTFail("\(error)")
+            }
+        }
+        wait(for: [queryComplete], timeout: 1)
+    }
+
+    func testDeleteAll() {
+        _ = setUpLocalStore(numberOfPosts: 5)
+        let deleteSuccess = expectation(description: "Delete all successful")
+        Amplify.DataStore.delete(Post.self, where: QueryPredicateConstant.all) { result in
+            switch result {
+            case .success:
+                deleteSuccess.fulfill()
+            case .failure(let error):
+                XCTFail("\(error)")
+            }
+        }
+        wait(for: [deleteSuccess], timeout: 1)
+
+        let queryComplete = expectation(description: "query returns empty result")
+        Amplify.DataStore.query(Post.self) { result in
+            switch result {
+            case .success(let posts):
+                XCTAssertEqual(posts.count, 0)
+                queryComplete.fulfill()
+            case .failure(let error):
+                XCTFail("\(error)")
+            }
+        }
+        wait(for: [queryComplete], timeout: 1)
+    }
+
     func setUpLocalStore(numberOfPosts: Int) -> [Post] {
         var savedPosts = [Post]()
         for id in 0 ..< numberOfPosts {
             let saveSuccess = expectation(description: "Save post completed")
             let post = Post(title: "title\(Int.random(in: 0 ... 5))",
                             content: "content",
                             createdAt: .now(),
-                            rating: Double(Int.random(in: 0 ... 5)))
+                            rating: Double(Int.random(in: 0 ... 5)),
+                            status: .draft)
             savedPosts.append(post)
             print("\(id) \(post.id)")
             Amplify.DataStore.save(post) { result in

AmplifyTestCommon/Mocks/MockAuthCategoryPlugin.swift

@@ -69,7 +69,7 @@ class MockAuthCategoryPlugin: MessageReporter, AuthCategoryPlugin {
                         listener: AuthSignOutOperation.ResultListener?) -> AuthSignOutOperation {
         fatalError()
     }
-    
+
     public func deleteUser(listener: AuthDeleteUserOperation.ResultListener?) -> AuthDeleteUserOperation {
         fatalError()
     }

AmplifyTestCommon/Mocks/MockDataStoreCategoryPlugin.swift

@@ -80,6 +80,18 @@ class MockDataStoreCategoryPlugin: MessageReporter, DataStoreCategoryPlugin {
         }
     }
 
+    func delete<M: Model>(_ modelType: M.Type,
+                          where predicate: QueryPredicate,
+                          completion: (DataStoreResult<Void>) -> Void) {
+        notify("deleteModelTypeByPredicate")
+
+        if let responder = responders[.deleteModelTypeListener] as? DeleteModelTypeResponder<M> {
+            if let callback = responder.callback((modelType: modelType, where: predicate)) {
+                completion(callback)
+            }
+        }
+    }
+
     func delete<M: Model>(_ model: M,
                           where predicate: QueryPredicate? = nil,
                           completion: @escaping DataStoreCallback<Void>) {

AmplifyTestCommon/Mocks/MockDataStoreResponders.swift

@@ -13,6 +13,7 @@ extension MockDataStoreCategoryPlugin {
         case queryByIdListener
         case queryModelsListener
         case deleteByIdListener
+        case deleteModelTypeListener
         case deleteModelListener
         case clearListener
         case startListener
@@ -39,6 +40,11 @@ typealias DeleteByIdResponder<M: Model> = MockResponder<
     DataStoreResult<Void>?
 >
 
+typealias DeleteModelTypeResponder<M: Model> = MockResponder<
+    (modelType: M.Type, where: QueryPredicate),
+    DataStoreResult<Void>?
+>
+
 typealias DeleteModelResponder<M: Model> = MockResponder<
     (model: M, where: QueryPredicate?),
     DataStoreResult<Void>?