Async API+Command

.codecov.yml

@@ -6,6 +6,6 @@ coverage:
     changes: false
     project:
       default:
-        target: 30
+        target: 45
 comment:
   require_changes: true

.github/workflows/swift.yml

@@ -1,61 +1,77 @@
-name: Swift
+name: build
 
 on:
   push:
     branches: [ master ]
   pull_request:
     branches: [ master ]
 
+env:
+  CI_XCODE_VER: '/Applications/Xcode_11.6.app/Contents/Developer'
+
 jobs:
-  build-test-ios:
+  swift-test-ios:
 
     runs-on: macos-latest
 
     steps:
     - uses: actions/checkout@v2
-    - name: Build
-      run: xcodebuild -workspace Parse.xcworkspace -scheme ParseSwift\ \(iOS\) -destination platform\=iOS\ Simulator,OS\=13.6,name\=iPhone\ 11\ Pro\ Max build test | xcpretty
-
-  build-macos:
+    - name: Build-Test
+      run: xcodebuild -workspace Parse.xcworkspace -scheme ParseSwift\ \(iOS\) -destination platform\=iOS\ Simulator,name\=iPhone\ 11\ Pro\ Max build test | xcpretty
+      env: 
+        DEVELOPER_DIR: ${{ env.CI_XCODE_VER }}
+
+  swift-macos:
 
     runs-on: macos-latest
 
     steps:
     - uses: actions/checkout@v2
     - name: Build
       run: xcodebuild -target ParseSwift\ \(macOS\) | xcpretty
+      env: 
+        DEVELOPER_DIR: ${{ env.CI_XCODE_VER }}
 
-  build-tvos:
+  swift-tvos:
 
     runs-on: macos-latest
 
     steps:
     - uses: actions/checkout@v2
     - name: Build
       run: xcodebuild -target ParseSwift\ \(tvOS\) | xcpretty
+      env: 
+        DEVELOPER_DIR: ${{ env.CI_XCODE_VER }}
 
-  build-watchos:
+  swift-watchos:
 
     runs-on: macos-latest
 
     steps:
     - uses: actions/checkout@v2
     - name: Build
       run: xcodebuild -target ParseSwift\ \(watchOS\) | xcpretty
+      env: 
+        DEVELOPER_DIR: ${{ env.CI_XCODE_VER }}
 
   build-test-swift:
 
     runs-on: macos-latest
-
     steps:
     - uses: actions/checkout@v2
     - name: Build
       run: swift build -v
-    - name: Run tests
+      env:
+        DEVELOPER_DIR: ${{ env.CI_XCODE_VER }}
+    - name: Test
       run: swift test --enable-code-coverage -v
-    - name: Prepare Codecov Files
+      env:
+        DEVELOPER_DIR: ${{ env.CI_XCODE_VER }}
+    - name: Prepare codecov
       run: xcrun llvm-cov export -format="lcov" .build/debug/ParseSwiftPackageTests.xctest/Contents/MacOS/ParseSwiftPackageTests -instr-profile .build/debug/codecov/default.profdata > info.lcov
-    - name: Codecov
+      env: 
+        DEVELOPER_DIR: ${{ env.CI_XCODE_VER }}      
+    - name: Send codecov
       run: bash <(curl https://codecov.io/bash)
 
   deploy_docs:
@@ -81,6 +97,8 @@ jobs:
 
       - name: Create Jazzy Docs
         run: ./Scripts/jazzy.sh
+        env: 
+          DEVELOPER_DIR: ${{ env.CI_XCODE_VER }}
 
       - name: Deploy Jazzy Docs
         if: github.ref == 'refs/heads/master'
@@ -97,7 +115,8 @@ jobs:
       - uses: actions/checkout@v2
       - name: CocoaPods
         run: pod lib lint
-
+        env: 
+          DEVELOPER_DIR: ${{ env.CI_XCODE_VER }} 
   carthage:
 
    needs: build-test-swift
@@ -107,3 +126,5 @@ jobs:
      - uses: actions/checkout@v2
      - name: Carthage 
        run: carthage build --no-skip-current
+       env: 
+        DEVELOPER_DIR: ${{ env.CI_XCODE_VER }} 

README.md

@@ -16,9 +16,10 @@
 </p>
 
 <p align="center">
-    <a href="https://github.com/parse-community/Parse-Swift"><img alt="Dependencies" src="https://img.shields.io/badge/dependencies-0-yellowgreen.svg"></a>
-    <a href="https://github.com/parse-community/Parse-Swift/actions?query=workflow%3ASwift"><img alt="Build status" src="https://github.com/parse-community/Parse-Swift/workflows/Build%20Status/badge.svg?branch=master"></a>
+<a href="https://github.com/parse-community/Parse-Swift"><img alt="Swift 5.0" src="https://img.shields.io/badge/swift-5.0-brightgreen.svg"></a>
+    <a href="https://github.com/parse-community/Parse-Swift/actions?query=workflow%3ASwift+branch%3Amaster"><img alt="Build status" src="https://github.com/parse-community/Parse-Swift/workflows/build/badge.svg?branch=master"></a>
     <a href="https://codecov.io/gh/parse-community/Parse-Swift/branches"><img alt="Code coverage" src="https://codecov.io/gh/parse-community/Parse-Swift/branch/master/graph/badge.svg"></a>
+    <a href="https://github.com/parse-community/Parse-Swift"><img alt="Dependencies" src="https://img.shields.io/badge/dependencies-0-yellowgreen.svg"></a>
     <a href="https://community.parseplatform.org/"><img alt="Join the conversation" src="https://img.shields.io/discourse/https/community.parseplatform.org/topics.svg"></a>
 </p>
 <br>

Sources/ParseSwift/API/API+Commands.swift

@@ -3,12 +3,13 @@
 //  ParseSwift (iOS)
 //
 //  Created by Florent Vilmart on 17-09-24.
-//  Copyright © 2017 Parse. All rights reserved.
+//  Copyright © 2020 Parse Community. All rights reserved.
 //
 
 import Foundation
 
 internal extension API {
+
     struct Command<T, U>: Encodable where T: Encodable {
         typealias ReturnType = U // swiftlint:disable:this nesting
         let method: API.Method
@@ -34,27 +35,53 @@ internal extension API {
         }
 
         public func execute(options: API.Options) throws -> U {
+            var responseResult: Result<U, ParseError>?
+
+            let group = DispatchGroup()
+            group.enter()
+            self.executeAsync(options: options, callbackQueue: nil) { result in
+                responseResult = result
+                group.leave()
+            }
+            group.wait()
+
+            guard let response = responseResult else {
+                throw ParseError(code: .unknownError,
+                                 message: "couldn't unrwrap server response")
+            }
+            return try response.get()
+        }
+
+        public func executeAsync(options: API.Options, callbackQueue: DispatchQueue?,
+                                 completion: @escaping(Result<U, ParseError>) -> Void) {
             let params = self.params?.getQueryItems()
             let headers = API.getHeaders(options: options)
             let url = ParseConfiguration.serverURL.appendingPathComponent(path.urlComponent)
 
-            var components = URLComponents(url: url, resolvingAgainstBaseURL: false)!
+            guard var components = URLComponents(url: url, resolvingAgainstBaseURL: false),
+                let urlComponents = components.url else {
+                    completion(.failure(ParseError(code: .unknownError,
+                                                   message: "couldn't unrwrap url components for \(url)")))
+                return
+            }
             components.queryItems = params
 
-            var urlRequest = URLRequest(url: components.url!)
+            var urlRequest = URLRequest(url: urlComponents)
             urlRequest.allHTTPHeaderFields = headers
             if let body = data {
                 urlRequest.httpBody = body
             }
             urlRequest.httpMethod = method.rawValue
-            let responseData = try URLSession.shared.syncDataTask(with: urlRequest).get()
-            do {
-                return try mapper(responseData)
-            } catch {
-                do {
-                    throw try getDecoder().decode(ParseError.self, from: responseData)
-                } catch {
-                    throw ParseError(code: .unknownError, message: "cannot decode response: \(error)")
+
+            URLSession.shared.dataTask(with: urlRequest, callbackQueue: callbackQueue, mapper: mapper) { result in
+                switch result {
+
+                case .success(let decoded):
+
+                    completion(.success(decoded))
+
+                case .failure(let error):
+                    completion(.failure(error))
                 }
             }
         }
@@ -77,7 +104,7 @@ internal extension API.Command {
     // MARK: Saving - private
     private static func createCommand<T>(_ object: T) -> API.Command<T, T> where T: ObjectType {
         let mapper = { (data) -> T in
-            try getDecoder().decode(SaveResponse.self, from: data).apply(object)
+            try getDecoder().decode(SaveResponse.self, from: data).apply(to: object)
         }
         return API.Command<T, T>(method: .POST,
                                  path: object.endpoint,
@@ -87,7 +114,7 @@ internal extension API.Command {
 
     private static func updateCommand<T>(_ object: T) -> API.Command<T, T> where T: ObjectType {
         let mapper = { (data: Data) -> T in
-            try getDecoder().decode(UpdateResponse.self, from: data).apply(object)
+            try getDecoder().decode(UpdateResponse.self, from: data).apply(to: object)
         }
         return API.Command<T, T>(method: .PUT,
                                  path: object.endpoint,
@@ -102,7 +129,7 @@ internal extension API.Command {
         }
         return API.Command<T, T>(method: .GET,
                                  path: object.endpoint) { (data) -> T in
-                                    try getDecoder().decode(T.self, from: data)
+                                    try getDecoder().decode(FetchResponse.self, from: data).apply(to: object)
         }
     }
 }
@@ -123,20 +150,34 @@ extension API.Command where T: ObjectType {
             return API.Command<T, T>(method: command.method, path: .any(path),
                                      body: body, mapper: command.mapper)
         }
-        let bodies = commands.compactMap { (command) -> T? in
-            return command.body
+        let bodies = commands.compactMap { (command) -> (body: T, command: API.Method)?  in
+            guard let body = command.body else {
+                return nil
+            }
+            return (body: body, command: command.method)
         }
-        let mapper = { (data: Data) -> [(T, ParseError?)] in
-            let decodingType = [BatchResponseItem<SaveOrUpdateResponse>].self
-            let responses = try getDecoder().decode(decodingType, from: data)
-            return bodies.enumerated().map({ (object) -> (T, ParseError?) in
-                let response = responses[object.0]
-                if let success = response.success {
-                    return (success.apply(object.1), nil)
-                } else {
-                    return (object.1, response.error)
+        let mapper = { (data: Data) -> [Result<T, ParseError>] in
+            let decodingType = [BatchResponseItem<WriteResponse>].self
+            do {
+                let responses = try getDecoder().decode(decodingType, from: data)
+                return bodies.enumerated().map({ (object) -> (Result<T, ParseError>) in
+                    let response = responses[object.offset]
+                    if let success = response.success {
+                        return .success(success.apply(to: object.element.body, method: object.element.command))
+                    } else {
+                        guard let parseError = response.error else {
+                            return .failure(ParseError(code: .unknownError, message: "unknown error"))
+                        }
+
+                        return .failure(parseError)
+                    }
+                })
+            } catch {
+                guard let parseError = error as? ParseError else {
+                    return [(.failure(ParseError(code: .unknownError, message: "decoding error: \(error)")))]
                 }
-            })
+                return [(.failure(parseError))]
+            }
         }
         let batchCommand = BatchCommand(requests: commands)
         return RESTBatchCommandType<T>(method: .POST, path: .batch, body: batchCommand, mapper: mapper)

Sources/ParseSwift/API/BatchUtils.swift

@@ -3,35 +3,31 @@
 //  ParseSwift
 //
 //  Created by Florent Vilmart on 17-08-19.
-//  Copyright © 2017 Parse. All rights reserved.
+//  Copyright © 2020 Parse Community. All rights reserved.
 //
 
 import Foundation
 
 typealias ParseObjectBatchCommand<T> = BatchCommand<T, T> where T: ObjectType
-typealias ParseObjectBatchResponse<T> = [(T, ParseError?)]
+typealias ParseObjectBatchResponse<T> = [(Result<T, ParseError>)]
 // swiftlint:disable line_length
 typealias RESTBatchCommandType<T> = API.Command<ParseObjectBatchCommand<T>, ParseObjectBatchResponse<T>> where T: ObjectType
 // swiftlint:enable line_length
 
-public struct BatchCommand<T, U>: Encodable where T: Encodable {
+internal struct BatchCommand<T, U>: Encodable where T: Encodable {
     let requests: [API.Command<T, U>]
 }
 
-public struct BatchResponseItem<T>: Decodable where T: Decodable {
+internal struct BatchResponseItem<T>: Codable where T: Codable {
     let success: T?
     let error: ParseError?
 }
 
-struct SaveOrUpdateResponse: Decodable {
+internal struct WriteResponse: Codable {
     var objectId: String?
     var createdAt: Date?
     var updatedAt: Date?
 
-    var isCreate: Bool {
-        return objectId != nil && createdAt != nil
-    }
-
     func asSaveResponse() -> SaveResponse {
         guard let objectId = objectId, let createdAt = createdAt else {
             fatalError("Cannot create a SaveResponse without objectId")
@@ -46,11 +42,23 @@ struct SaveOrUpdateResponse: Decodable {
         return UpdateResponse(updatedAt: updatedAt)
     }
 
-    func apply<T>(_ object: T) -> T where T: ObjectType {
-        if isCreate {
-            return asSaveResponse().apply(object)
-        } else {
-            return asUpdateResponse().apply(object)
+    func asFetchResponse() -> FetchResponse {
+        guard let createdAt = createdAt, let updatedAt = updatedAt else {
+            fatalError("Cannot create a SaveResponse without objectId")
+        }
+        return FetchResponse(createdAt: createdAt, updatedAt: updatedAt)
+    }
+
+    func apply<T>(to object: T, method: API.Method) -> T where T: ObjectType {
+        switch method {
+        case .POST:
+            return asSaveResponse().apply(to: object)
+        case .PUT:
+            return asUpdateResponse().apply(to: object)
+        case .GET:
+            return asFetchResponse().apply(to: object)
+        default:
+            fatalError("There is no configured way to apply for method: \(method)")
         }
     }
 }

Sources/ParseSwift/API/Responses.swift

@@ -3,7 +3,7 @@
 //  ParseSwift
 //
 //  Created by Florent Vilmart on 17-08-20.
-//  Copyright © 2017 Parse. All rights reserved.
+//  Copyright © 2020 Parse Community. All rights reserved.
 //
 
 import Foundation
@@ -15,7 +15,7 @@ internal struct SaveResponse: Decodable {
         return createdAt
     }
 
-    func apply<T>(_ object: T) -> T where T: ObjectType {
+    func apply<T>(to object: T) -> T where T: ObjectType {
         var object = object
         object.objectId = objectId
         object.createdAt = createdAt
@@ -27,9 +27,21 @@ internal struct SaveResponse: Decodable {
 internal struct UpdateResponse: Decodable {
     var updatedAt: Date
 
-    func apply<T>(_ object: T) -> T where T: ObjectType {
+    func apply<T>(to object: T) -> T where T: ObjectType {
         var object = object
         object.updatedAt = updatedAt
         return object
     }
 }
+
+internal struct FetchResponse: Decodable {
+    var createdAt: Date
+    var updatedAt: Date
+
+    func apply<T>(to object: T) -> T where T: ObjectType {
+        var object = object
+        object.createdAt = createdAt
+        object.updatedAt = updatedAt
+        return object
+    }
+}