fix(datastore): delete model with predicate (#1030)

* fix(datastore): delete model with predicate

* refactor DeleteInput

Author: lawmicha

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

@@ -33,10 +33,11 @@ public extension DataStoreBaseBehavior {
     /// - Returns: A DataStorePublisher with the results of the operation
     func delete<M: Model>(
         _ modelType: M.Type,
-        withId id: String
+        withId id: String,
+        where predicate: QueryPredicate? = nil
     ) -> DataStorePublisher<Void> {
         Future { promise in
-            self.delete(modelType, withId: id) { promise($0) }
+            self.delete(modelType, withId: id, where: predicate) { promise($0) }
         }.eraseToAnyPublisher()
     }
 

Amplify/Categories/DataStore/DataStoreCategory+Behavior.swift

@@ -34,8 +34,9 @@ extension DataStoreCategory: DataStoreBaseBehavior {
 
     public func delete<M: Model>(_ modelType: M.Type,
                                  withId id: String,
+                                 where predicate: QueryPredicate? = nil,
                                  completion: @escaping DataStoreCallback<Void>) {
-        plugin.delete(modelType, withId: id, completion: completion)
+        plugin.delete(modelType, withId: id, where: predicate, completion: completion)
     }
 
     public func start(completion: @escaping DataStoreCallback<Void>) {

Amplify/Categories/DataStore/DataStoreCategoryBehavior.swift

@@ -32,6 +32,7 @@ public protocol DataStoreBaseBehavior {
 
     func delete<M: Model>(_ modelType: M.Type,
                           withId id: String,
+                          where predicate: QueryPredicate?,
                           completion: @escaping DataStoreCallback<Void>)
     /**
      Synchronization starts automatically whenever you run any DataStore operation (query(), save(), delete())

AmplifyPlugins/API/Podfile.lock

@@ -108,4 +108,4 @@ SPEC CHECKSUMS:
 
 PODFILE CHECKSUM: 857e4ea8246683593b8a7db77014aeb7340c15a5
 
-COCOAPODS: 1.9.3
+COCOAPODS: 1.10.0

AmplifyPlugins/DataStore/AWSDataStoreCategoryPlugin/AWSDataStorePlugin+DataStoreBaseBehavior.swift

@@ -110,16 +110,18 @@ extension AWSDataStorePlugin: DataStoreBaseBehavior {
 
     public func delete<M: Model>(_ modelType: M.Type,
                                  withId id: String,
+                                 where predicate: QueryPredicate? = nil,
                                  completion: @escaping DataStoreCallback<Void>) {
-        delete(modelType, modelSchema: modelType.schema, withId: id, completion: completion)
+        delete(modelType, modelSchema: modelType.schema, withId: id, where: predicate, completion: completion)
     }
 
     public func delete<M: Model>(_ modelType: M.Type,
                                  modelSchema: ModelSchema,
                                  withId id: String,
+                                 where predicate: QueryPredicate? = nil,
                                  completion: @escaping DataStoreCallback<Void>) {
         reinitStorageEngineIfNeeded()
-        storageEngine.delete(modelType, modelSchema: modelSchema, withId: id) { result in
+        storageEngine.delete(modelType, modelSchema: modelSchema, withId: id, predicate: predicate) { result in
             self.onDeleteCompletion(result: result, modelSchema: modelSchema, completion: completion)
         }
     }
@@ -135,8 +137,10 @@ extension AWSDataStorePlugin: DataStoreBaseBehavior {
                                  where predicate: QueryPredicate? = nil,
                                  completion: @escaping DataStoreCallback<Void>) {
         reinitStorageEngineIfNeeded()
-        // TODO: handle query predicate like in the update flow
-        storageEngine.delete(type(of: model), modelSchema: modelSchema, withId: model.id) { result in
+        storageEngine.delete(type(of: model),
+                             modelSchema: modelSchema,
+                             withId: model.id,
+                             predicate: predicate) { result in
             self.onDeleteCompletion(result: result, modelSchema: modelSchema, completion: completion)
         }
     }

AmplifyPlugins/DataStore/AWSDataStoreCategoryPlugin/Storage/ModelStorageBehavior.swift

@@ -22,6 +22,7 @@ protocol ModelStorageBehavior {
     func delete<M: Model>(_ modelType: M.Type,
                           modelSchema: ModelSchema,
                           withId id: Model.Identifier,
+                          predicate: QueryPredicate?,
                           completion: @escaping DataStoreCallback<M?>)
 
     func delete<M: Model>(_ modelType: M.Type,

AmplifyPlugins/DataStore/AWSDataStoreCategoryPlugin/Storage/SQLite/SQLStatement+Delete.swift

@@ -29,8 +29,12 @@ struct DeleteStatement: SQLStatement {
         self.conditionStatement = conditionStatement
     }
 
-    init(modelSchema: ModelSchema, withId id: Model.Identifier) {
-        self.init(modelSchema: modelSchema, predicate: field("id") == id)
+    init(modelSchema: ModelSchema, withId id: Model.Identifier, predicate: QueryPredicate? = nil) {
+        var queryPredicate: QueryPredicate = field("id").eq(id)
+        if let predicate = predicate {
+            queryPredicate = field("id").eq(id).and(predicate)
+        }
+        self.init(modelSchema: modelSchema, predicate: queryPredicate)
     }
 
     init(model: Model) {

AmplifyPlugins/DataStore/AWSDataStoreCategoryPlugin/Storage/SQLite/StorageEngineAdapter+SQLite.swift

@@ -173,8 +173,9 @@ final class SQLiteStorageEngineAdapter: StorageEngineAdapter {
     func delete<M: Model>(_ modelType: M.Type,
                           modelSchema: ModelSchema,
                           withId id: Model.Identifier,
+                          predicate: QueryPredicate? = nil,
                           completion: (DataStoreResult<M?>) -> Void) {
-        delete(untypedModelType: modelType, modelSchema: modelSchema, withId: id) { result in
+        delete(untypedModelType: modelType, modelSchema: modelSchema, withId: id, predicate: predicate) { result in
             switch result {
             case .success:
                 completion(.success(nil))
@@ -187,9 +188,10 @@ final class SQLiteStorageEngineAdapter: StorageEngineAdapter {
     func delete(untypedModelType modelType: Model.Type,
                 modelSchema: ModelSchema,
                 withId id: Model.Identifier,
+                predicate: QueryPredicate? = nil,
                 completion: DataStoreCallback<Void>) {
         do {
-            let statement = DeleteStatement(modelSchema: modelSchema, withId: id)
+            let statement = DeleteStatement(modelSchema: modelSchema, withId: id, predicate: predicate)
             _ = try connection.prepare(statement.stringValue).run(statement.variables)
             completion(.emptyResult)
         } catch {

AmplifyPlugins/DataStore/AWSDataStoreCategoryPlugin/Storage/StorageEngine+DeleteTransaction.swift

@@ -11,9 +11,28 @@ import Foundation
 import AWSPluginsCore
 
 extension StorageEngine {
+
+    enum DeleteInput {
+        case withId(id: Model.Identifier)
+        case withIdAndPredicate(id: Model.Identifier, predicate: QueryPredicate)
+        case withPredicate(predicate: QueryPredicate)
+
+        /// Returns a computed predicate based on the type of delete scenario it is.
+        var predicate: QueryPredicate {
+            switch self {
+            case .withId(let id):
+                return field("id").eq(id)
+            case .withIdAndPredicate(let id, let predicate):
+                return field("id").eq(id).and(predicate)
+            case .withPredicate(let predicate):
+                return predicate
+            }
+        }
+    }
+
     func queryAndDeleteTransaction<M: Model>(_ modelType: M.Type,
                                              modelSchema: ModelSchema,
-                                             predicate: QueryPredicate) -> DataStoreResult<([M], [Model])> {
+                                             deleteInput: DeleteInput) -> DataStoreResult<([M], [Model])> {
         var queriedResult: DataStoreResult<[M]>?
         var deletedResult: DataStoreResult<[M]>?
         var associatedModels: [Model] = []
@@ -23,23 +42,47 @@ extension StorageEngine {
             guard case .success(let queriedModels) = queryResult else {
                 return
             }
+
+            guard !queriedModels.isEmpty else {
+                guard case .withIdAndPredicate(let id, _) = deleteInput else {
+                    // Query did not return any results, treat this as a successful no-op delete.
+                    deletedResult = .success([M]())
+                    return
+                }
+
+                // Query using the computed predicate did not return any results, check if model actually exists.
+                do {
+                    if try self.storageAdapter.exists(modelSchema, withId: id, predicate: nil) {
+                        queriedResult = .failure(
+                            DataStoreError.invalidCondition(
+                                "Delete failed due to condition did not match existing model instance.",
+                                "Subsequent deletes will continue to fail until the model instance is updated."))
+                    } else {
+                        deletedResult = .success([M]())
+                    }
+                } catch {
+                    queriedResult = .failure(DataStoreError.invalidOperation(causedBy: error))
+                }
+
+                return
+            }
+
             let modelIds = queriedModels.map {$0.id}
             associatedModels = self.recurseQueryAssociatedModels(modelSchema: modelSchema, ids: modelIds)
-
             let deleteCompletionWrapper: DataStoreCallback<[M]> = { deleteResult in
                 deletedResult = deleteResult
             }
             self.storageAdapter.delete(modelType,
                                        modelSchema: modelSchema,
-                                       predicate: predicate,
+                                       predicate: deleteInput.predicate,
                                        completion: deleteCompletionWrapper)
         }
 
         do {
             try storageAdapter.transaction {
                 storageAdapter.query(modelType,
                                      modelSchema: modelSchema,
-                                     predicate: predicate,
+                                     predicate: deleteInput.predicate,
                                      sort: nil,
                                      paginationInput: nil,
                                      completion: queryCompletionBlock)
@@ -48,7 +91,9 @@ extension StorageEngine {
             return .failure(causedBy: error)
         }
 
-        return collapseResults(queryResult: queriedResult, deleteResult: deletedResult, associatedModels: associatedModels)
+        return collapseResults(queryResult: queriedResult,
+                               deleteResult: deletedResult,
+                               associatedModels: associatedModels)
     }
 
     func recurseQueryAssociatedModels(modelSchema: ModelSchema, ids: [Model.Identifier]) -> [Model] {

AmplifyPlugins/DataStore/AWSDataStoreCategoryPlugin/Storage/StorageEngine.swift

@@ -204,10 +204,15 @@ final class StorageEngine: StorageEngineBehavior {
     func delete<M: Model>(_ modelType: M.Type,
                           modelSchema: ModelSchema,
                           withId id: Model.Identifier,
+                          predicate: QueryPredicate? = nil,
                           completion: @escaping (DataStoreResult<M?>) -> Void) {
+        var deleteInput = DeleteInput.withId(id: id)
+        if let predicate = predicate {
+            deleteInput = .withIdAndPredicate(id: id, predicate: predicate)
+        }
         let transactionResult = queryAndDeleteTransaction(modelType,
                                                           modelSchema: modelSchema,
-                                                          predicate: field("id").eq(id))
+                                                          deleteInput: deleteInput)
         let modelsFromTransactionResult = collapseMResult(transactionResult)
         let associatedModelsFromTransactionResult = resolveAssociatedModels(transactionResult)
 
@@ -264,7 +269,9 @@ final class StorageEngine: StorageEngineBehavior {
                           modelSchema: ModelSchema,
                           predicate: QueryPredicate,
                           completion: @escaping DataStoreCallback<[M]>) {
-        let transactionResult = queryAndDeleteTransaction(modelType, modelSchema: modelSchema, predicate: predicate)
+        let transactionResult = queryAndDeleteTransaction(modelType,
+                                                          modelSchema: modelSchema,
+                                                          deleteInput: .withPredicate(predicate: predicate))
         let modelsFromTransactionResult = collapseMResult(transactionResult)
         let associatedModelsFromTransactionResult = resolveAssociatedModels(transactionResult)