Merge branch 'feat/createIfNotExists'

Author: Clément Le Provost

Source/Error.swift

@@ -99,6 +99,9 @@ public enum StatusCode: Int {
     /// Operation unauthorized with the provided credentials.
     case forbidden                                              = 403
 
+    /// The targeted resource does not exist.
+    case notFound                                               = 404
+    
     /// The HTTP method used in the request is not supported for the targeted endpoint.
     ///
     /// + Note: Should never occur when using this library.

Source/Index.swift

@@ -213,18 +213,38 @@ import Foundation
     /// - parameter completionHandler: Completion handler to be notified of the request's outcome.
     /// - returns: A cancellable operation.
     ///
+    /// + Note: If the object does not exist, it will be created. You can avoid automatic creation of the object by
+    ///   passing `false` to `createIfNotExists` in `partialUpdateObject(_:withID:createIfNotExists:completionHandler:)`.
+    ///
     @objc
     @discardableResult public func partialUpdateObject(_ partialObject: JSONObject, withID objectID: String, completionHandler: CompletionHandler? = nil) -> Operation {
         let path = "1/indexes/\(urlEncodedName)/\(objectID.urlEncodedPathComponent())/partial"
         return client.performHTTPQuery(path: path, method: .POST, body: partialObject, hostnames: client.writeHosts, completionHandler: completionHandler)
     }
 
+    /// Partially update an object.
+    ///
+    /// - parameter partialObject: New values/operations for the object.
+    /// - parameter objectID: Identifier of object to be updated.
+    /// - parameter createIfNotExists: Whether an update on a nonexistent object ID should create the object.
+    /// - parameter completionHandler: Completion handler to be notified of the request's outcome.
+    /// - returns: A cancellable operation.
+    ///
+    @objc
+    @discardableResult public func partialUpdateObject(_ partialObject: JSONObject, withID objectID: String, createIfNotExists: Bool, completionHandler: CompletionHandler? = nil) -> Operation {
+        let path = "1/indexes/\(urlEncodedName)/\(objectID.urlEncodedPathComponent())/partial?createIfNotExists=\(String(createIfNotExists).urlEncodedQueryParam())"
+        return client.performHTTPQuery(path: path, method: .POST, body: partialObject, hostnames: client.writeHosts, completionHandler: completionHandler)
+    }
+
     /// Partially update several objects.
     ///
     /// - parameter objects: New values/operations for the objects. Each object must contain an `objectID` attribute.
     /// - parameter completionHandler: Completion handler to be notified of the request's outcome.
     /// - returns: A cancellable operation.
     ///
+    /// + Note: If an object does not exist, it will be created. You can avoid automatic creation of objects by
+    ///   passing `false` to `createIfNotExists` in `partialUpdateObjects(_:createIfNotExists:completionHandler:)`.
+    ///
     @objc
     @discardableResult public func partialUpdateObjects(_ objects: [JSONObject], completionHandler: CompletionHandler? = nil) -> Operation {
         let path = "1/indexes/\(urlEncodedName)/batch"
@@ -242,7 +262,32 @@ import Foundation
 
         return client.performHTTPQuery(path: path, method: .POST, body: request, hostnames: client.writeHosts, completionHandler: completionHandler)
     }
-    
+
+    /// Partially update several objects.
+    ///
+    /// - parameter objects: New values/operations for the objects. Each object must contain an `objectID` attribute.
+    /// - parameter createIfNotExists: Whether an update on a nonexistent object ID should create the object.
+    /// - parameter completionHandler: Completion handler to be notified of the request's outcome.
+    /// - returns: A cancellable operation.
+    ///
+    @objc
+    @discardableResult public func partialUpdateObjects(_ objects: [JSONObject], createIfNotExists: Bool, completionHandler: CompletionHandler? = nil) -> Operation {
+        let path = "1/indexes/\(urlEncodedName)/batch"
+        let action = createIfNotExists ? "partialUpdateObject" : "partialUpdateObjectNoCreate"
+        var requests = [Any]()
+        requests.reserveCapacity(objects.count)
+        for object in objects {
+            requests.append([
+                "action": action,
+                "objectID": object["objectID"] as! String,
+                "body": object
+                ])
+        }
+        let request = ["requests": requests]
+        
+        return client.performHTTPQuery(path: path, method: .POST, body: request, hostnames: client.writeHosts, completionHandler: completionHandler)
+    }
+
     /// Update an object.
     ///
     /// - parameter object: New version of the object to update. Must contain an `objectID` attribute.

Tests/IndexTests.swift

@@ -376,6 +376,46 @@ class IndexTests: OnlineTestCase {
 
         self.waitForExpectations(timeout: expectationTimeout, handler: nil)
     }
+
+    func testPartialUpdateObjectCreateIfNotExists() {
+        let expectation = self.expectation(description: "testPartialUpdateObject")
+        let objectID = "unknown"
+
+        // Partial update with `createIfNotExists=false` should not create object.
+        self.index.partialUpdateObject(["city": "Los Angeles"], withID: objectID, createIfNotExists: false) { (content, error) -> Void in
+            guard error == nil else { XCTFail(error!.localizedDescription); expectation.fulfill(); return }
+            self.index.waitTask(withID: content!["taskID"] as! Int) { (content, error) -> Void in
+                guard error == nil else { XCTFail(error!.localizedDescription); expectation.fulfill(); return }
+                self.index.getObject(withID: objectID) { (content, error) -> Void in
+                    guard let error = error else {
+                        XCTFail("The object should not have been created")
+                        expectation.fulfill()
+                        return
+                    }
+                    XCTAssertEqual(StatusCode.notFound.rawValue, (error as NSError).code)
+                    
+                    // Partial update with `createIfNotExists=true` should create object.
+                    self.index.partialUpdateObject(["city": "Los Angeles"], withID: objectID, createIfNotExists: true) { (content, error) -> Void in
+                        guard error == nil else { XCTFail(error!.localizedDescription); expectation.fulfill(); return }
+                        self.index.waitTask(withID: content!["taskID"] as! Int) { (content, error) -> Void in
+                            guard error == nil else { XCTFail(error!.localizedDescription); expectation.fulfill(); return }
+                            self.index.getObject(withID: objectID) { (content, error) -> Void in
+                                guard error == nil else {
+                                    XCTFail("The object should have been created (\(error!.localizedDescription))")
+                                    expectation.fulfill()
+                                    return
+                                }
+                                XCTAssertEqual(content?["objectID"] as? String, objectID)
+                                XCTAssertEqual(content?["city"] as? String, "Los Angeles")
+                                expectation.fulfill()
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        self.waitForExpectations(timeout: expectationTimeout, handler: nil)
+    }
 
     func testPartialUpdateObjects() {
         let expectation = self.expectation(description: "testPartialUpdateObjects")
@@ -425,7 +465,53 @@ class IndexTests: OnlineTestCase {
 
         self.waitForExpectations(timeout: expectationTimeout, handler: nil)
     }
-    
+
+    func testPartialUpdateObjectsCreateIfNotExists() {
+        let expectation = self.expectation(description: #function)
+        let objectUpdates: [JSONObject] = [
+            ["city": "Paris", "objectID": "a/go/?à"],
+            ["city": "Strasbourg", "objectID": "a/go/?à$"]
+        ]
+        // Partial updates with `createIfNotExists=false` should not create objects.
+        self.index.partialUpdateObjects(objectUpdates, createIfNotExists: false) { (content, error) -> Void in
+            guard error == nil else { XCTFail(error!.localizedDescription); expectation.fulfill(); return }
+            self.index.waitTask(withID: content!["taskID"] as! Int) { (content, error) -> Void in
+                guard error == nil else { XCTFail(error!.localizedDescription); expectation.fulfill(); return }
+                self.index.getObjects(withIDs: ["a/go/?à", "a/go/?à$"]) { (content, error) -> Void in
+                    // NOTE: Multiple get does not return an error, but simply returns `null` for missing objects.
+                    guard error == nil else { XCTFail(error!.localizedDescription); expectation.fulfill(); return }
+                    guard let results = content?["results"] as? [Any] else { XCTFail("Invalid results"); expectation.fulfill(); return }
+                    XCTAssertEqual(results.count, 2)
+                    for i in 0..<2 {
+                        XCTAssert(results[i] is NSNull)
+                    }
+
+                    // Partial updates with `createIfNotExists=true` should create objects.
+                    self.index.partialUpdateObjects(objectUpdates, createIfNotExists: true) { (content, error) -> Void in
+                        guard error == nil else { XCTFail(error!.localizedDescription); expectation.fulfill(); return }
+                        self.index.waitTask(withID: content!["taskID"] as! Int) { (content, error) -> Void in
+                            guard error == nil else { XCTFail(error!.localizedDescription); expectation.fulfill(); return }
+                            self.index.getObjects(withIDs: ["a/go/?à", "a/go/?à$"]) { (content, error) -> Void in
+                                guard error == nil else {
+                                    XCTFail("Objects should have been created (\(error!.localizedDescription))")
+                                    expectation.fulfill()
+                                    return
+                                }
+                                guard let results = content?["results"] as? [JSONObject] else { XCTFail("Invalid results"); expectation.fulfill(); return }
+                                XCTAssertEqual(results.count, 2)
+                                for i in 0..<2 {
+                                    XCTAssertEqual(results[i]["objectID"] as? String, objectUpdates[i]["objectID"] as? String)
+                                }
+                                expectation.fulfill()
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        self.waitForExpectations(timeout: expectationTimeout, handler: nil)
+    }
+
     func testSaveObject() {
         let expectation = self.expectation(description: "testSaveObject")
         let object: JSONObject = ["city": "New York", "initial": "NY", "objectID": "a/go/?à"]

Tests/ObjectiveCBridging.m

@@ -225,9 +225,15 @@ - (void)testIndex {
     [index partialUpdateObject:DUMMY_JSON withID:@"snoopy" completionHandler:^(NSDictionary<NSString*,id>* content, NSError* error) {
         // Do nothing.
     }];
+    [index partialUpdateObject:DUMMY_JSON withID:@"snoopy" createIfNotExists:NO completionHandler:^(NSDictionary<NSString*,id>* content, NSError* error) {
+        // Do nothing.
+    }];
     [index partialUpdateObjects:@[ DUMMY_JSON ] completionHandler:^(NSDictionary<NSString*,id>* content, NSError* error) {
         // Do nothing.
     }];
+    [index partialUpdateObjects:@[ DUMMY_JSON ] createIfNotExists:NO completionHandler:^(NSDictionary<NSString*,id>* content, NSError* error) {
+        // Do nothing.
+    }];
     [index search:[Query new] completionHandler:^(NSDictionary<NSString*,id>* content, NSError* error) {
         // Do nothing.
     }];