minor improvement to child saving

Author: cbaker6

Sources/ParseSwift/API/API+Commands.swift

@@ -341,6 +341,49 @@ internal extension API.Command {
                                  mapper: mapper)
     }
 
+    // MARK: Saving ParseObjects - Encodable
+    static func saveCommand(object: T) throws -> API.Command<T, PointerType> where T: Encodable {
+        guard let objectable = object as? Objectable else {
+            throw ParseError(code: .unknownError, message: "Not able to cast to objectable. Not saving")
+        }
+        if objectable.isSaved {
+            return try updateCommand(object: object)
+        } else {
+            return try createCommand(object: object)
+        }
+    }
+
+    // MARK: Saving ParseObjects - [Encodable] - private
+    private static func createCommand(object: T) throws -> API.Command<T, PointerType> where T: Encodable {
+        guard var objectable = object as? Objectable else {
+            throw ParseError(code: .unknownError, message: "Not able to cast to objectable. Not saving")
+        }
+        let mapper = { (data: Data) -> PointerType in
+            let baseObjectable = try ParseCoding.jsonDecoder().decode(BaseObjectable.self, from: data)
+            objectable.objectId = baseObjectable.objectId
+            return try objectable.toPointer()
+        }
+        return API.Command<T, PointerType>(method: .POST,
+                                 path: objectable.endpoint,
+                                 body: object,
+                                 mapper: mapper)
+    }
+
+    private static func updateCommand(object: T) throws -> API.Command<T, PointerType> where T: Encodable {
+        guard var objectable = object as? Objectable else {
+            throw ParseError(code: .unknownError, message: "Not able to cast to objectable. Not saving")
+        }
+        let mapper = { (data: Data) -> PointerType in
+            let baseObjectable = try ParseCoding.jsonDecoder().decode(BaseObjectable.self, from: data)
+            objectable.objectId = baseObjectable.objectId
+            return try objectable.toPointer()
+        }
+        return API.Command<T, PointerType>(method: .PUT,
+                                 path: objectable.endpoint,
+                                 body: object,
+                                 mapper: mapper)
+    }
+
     // MARK: Saving ParseObjects - Encodable
     static func saveCommand<T>(_ object: T) throws -> API.Command<T, PointerType> where T: Encodable {
         guard let objectable = object as? Objectable else {
@@ -501,7 +544,7 @@ extension API.Command where T: ParseObject {
 
 //This has been disabled, looking into getting it working in the future.
 //It's only needed for sending batches of childObjects which currently isn't being used.
-/*
+
 // MARK: Batch - Child Objects
 extension API.Command where T: ParseType {
 
@@ -510,7 +553,8 @@ extension API.Command where T: ParseType {
         return try? ParseCoding.jsonEncoder().encode(body)
     }
 
-    static func batch(commands: [API.Command<T, PointerType>]) -> RESTBatchCommandTypeEncodable<T> {
+    static func batch(commands: [API.Command<T, PointerType>],
+                      transaction: Bool) -> RESTBatchCommandTypeEncodable<T> {
         let commands = commands.compactMap { (command) -> API.Command<T, PointerType>? in
             let path = ParseConfiguration.mountPath + command.path.urlComponent
             guard let body = command.body else {
@@ -551,10 +595,10 @@ extension API.Command where T: ParseType {
                 return [(.failure(parseError))]
             }
         }
-        let batchCommand = BatchCommand(requests: commands)
+        let batchCommand = BatchCommand(requests: commands, transaction: transaction)
         return RESTBatchCommandTypeEncodable<T>(method: .POST, path: .batch, body: batchCommand, mapper: mapper)
     }
-}*/
+}
 
 // MARK: API.NonParseBodyCommand
 internal extension API {

Sources/ParseSwift/API/BatchUtils.swift

@@ -16,13 +16,13 @@ typealias RESTBatchCommandType<T> = API.Command<ParseObjectBatchCommand<T>, Pars
 typealias ParseObjectBatchCommandNoBody<T> = BatchCommandNoBody<NoBody, NoBody>
 typealias ParseObjectBatchResponseNoBody<NoBody> = [(Result<Void, ParseError>)]
 typealias RESTBatchCommandNoBodyType<T> = API.NonParseBodyCommand<ParseObjectBatchCommandNoBody<T>, ParseObjectBatchResponseNoBody<T>> where T: Encodable
-/*
+
 typealias ParseObjectBatchCommandEncodable<T> = BatchCommand<T, PointerType> where T: ParseType
 typealias ParseObjectBatchResponseEncodable<U> = [(Result<PointerType, ParseError>)]
 // swiftlint:disable line_length
 typealias RESTBatchCommandTypeEncodable<T> = API.Command<ParseObjectBatchCommandEncodable<T>, ParseObjectBatchResponseEncodable<PointerType>> where T: ParseType
  // swiftlint:enable line_length
-*/
+
 internal struct BatchCommand<T, U>: ParseType where T: ParseType {
     let requests: [API.Command<T, U>]
     var transaction: Bool

Sources/ParseSwift/Objects/ParseObject.swift

@@ -477,11 +477,12 @@ public extension Sequence where Element: ParseObject {
      - returns: Returns a Result enum with the object if a save was successful or a `ParseError` if it failed.
      - throws: `ParseError`
     */
-    func saveAll(options: API.Options = []) throws -> [(Result<PointerType, ParseError>)] {
+    func saveAll(transaction: Bool = true,
+                 options: API.Options = []) throws -> [(Result<PointerType, ParseError>)] {
         let commands = try map { try $0.saveCommand() }
         return try API.Command<Self.Element, PointerType>
-                .batch(commands: commands)
-                .execute(options: options)
+                .batch(commands: commands, transaction: transaction)
+                .execute(options: options, callbackQueue: .main)
     }
 }*/
 
@@ -669,7 +670,7 @@ extension ParseObject {
                 var waitingToBeSaved = object.unsavedChildren
 
                 while waitingToBeSaved.count > 0 {
-                    var savableObjects = [Encodable]()
+                    var savableObjects = [ParseType]()
                     var savableFiles = [ParseFile]()
                     var nextBatch = [ParseType]()
                     try waitingToBeSaved.forEach { parseType in
@@ -706,14 +707,21 @@ extension ParseObject {
                     }
 
                     //Currently, batch isn't working for Encodable
-                    /*if let parseTypes = savableObjects as? [ParseType] {
-                        let savedChildObjects = try self.saveAll(options: options, objects: parseTypes)
+                    /*let savedChildObjects = try Self.saveAll(objects: savableObjects,
+                                                             options: options)
+                    let savedChildPointers = try savedChildObjects.compactMap { try $0.get() }
+                    if savedChildPointers.count != savableObjects.count {
+                        throw ParseError(code: .unknownError, message: "Couldn't save all child objects")
+                    }
+                    for (index, object) in savableObjects.enumerated() {
+                        let hash = try BaseObjectable.createHash(object)
+                        objectsFinishedSaving[hash] = savedChildPointers[index]
                     }*/
+
+                    //Saving children individually
                     try savableObjects.forEach {
                         let hash = try BaseObjectable.createHash($0)
-                        if let parseType = $0 as? ParseType {
-                            objectsFinishedSaving[hash] = try parseType.save(options: options)
-                        }
+                        objectsFinishedSaving[hash] = try $0.save(options: options)
                     }
 
                     try savableFiles.forEach {
@@ -747,11 +755,17 @@ internal extension ParseType {
         try API.Command<Self, PointerType>.saveCommand(self)
     }
 /*
-    func saveAll<T: ParseType>(options: API.Options = [], objects: [T]) throws -> [(Result<PointerType, ParseError>)] {
-        let commands = try objects.map { try API.Command<T, PointerType>.saveCommand($0) }
-        return try API.Command<T, PointerType>
-                .batch(commands: commands)
-                .execute(options: options)
+    static func saveAll(objects: [ParseType],
+                        transaction: Bool = true,
+                        options: API.Options = []) throws -> [(Result<PointerType, ParseError>)] {
+        let commands = try objects.map {
+            try API.Command<Self, PointerType>.saveCommand(object: $0)
+        }
+        return try API.Command<Self, PointerType>
+                .batch(commands: commands,
+                       transaction: transaction)
+                .execute(options: options,
+                         callbackQueue: .main)
     }*/
 }