fix: refactor GraphQL response decoder (#971)

* fix: refactor GraphQL response decoder

* address PR comments

Author: lawmicha

AmplifyPlugins/API/APICategoryPlugin.xcodeproj/project.pbxproj

@@ -11,10 +11,7 @@ public extension AWSAPIPlugin {
 
     func query<R: Decodable>(request: GraphQLRequest<R>,
                              listener: GraphQLOperation<R>.ResultListener?) -> GraphQLOperation<R> {
-        let operationRequest = getOperationRequest(request: request,
-                                                   operationType: .query)
-
-        let operation = AWSGraphQLOperation(request: operationRequest,
+        let operation = AWSGraphQLOperation(request: request.toOperationRequest(operationType: .query),
                                             session: session,
                                             mapper: mapper,
                                             pluginConfig: pluginConfig,
@@ -25,10 +22,7 @@ public extension AWSAPIPlugin {
 
     func mutate<R: Decodable>(request: GraphQLRequest<R>,
                               listener: GraphQLOperation<R>.ResultListener?) -> GraphQLOperation<R> {
-        let operationRequest = getOperationRequest(request: request,
-                                                   operationType: .mutation)
-
-        let operation = AWSGraphQLOperation(request: operationRequest,
+        let operation = AWSGraphQLOperation(request: request.toOperationRequest(operationType: .mutation),
                                             session: session,
                                             mapper: mapper,
                                             pluginConfig: pluginConfig,
@@ -42,11 +36,8 @@ public extension AWSAPIPlugin {
         valueListener: GraphQLSubscriptionOperation<R>.InProcessListener?,
         completionListener: GraphQLSubscriptionOperation<R>.ResultListener?
     ) -> GraphQLSubscriptionOperation<R> {
-            let operationRequest = getOperationRequest(request: request,
-                                                       operationType: .subscription)
-
             let operation = AWSGraphQLSubscriptionOperation(
-                request: operationRequest,
+                request: request.toOperationRequest(operationType: .subscription),
                 pluginConfig: pluginConfig,
                 subscriptionConnectionFactory: subscriptionConnectionFactory,
                 authService: authService,
@@ -56,17 +47,4 @@ public extension AWSAPIPlugin {
             queue.addOperation(operation)
             return operation
     }
-
-    private func getOperationRequest<R: Decodable>(request: GraphQLRequest<R>,
-                                                   operationType: GraphQLOperationType) -> GraphQLOperationRequest<R> {
-
-        let operationRequest = GraphQLOperationRequest(apiName: request.apiName,
-                                                       operationType: operationType,
-                                                       document: request.document,
-                                                       variables: request.variables,
-                                                       responseType: request.responseType,
-                                                       decodePath: request.decodePath,
-                                                       options: GraphQLOperationRequest.Options())
-        return operationRequest
-    }
 }

AmplifyPlugins/API/AWSAPICategoryPlugin/AWSAPIPlugin+GraphQLBehavior.swift

@@ -36,7 +36,7 @@ extension AWSGraphQLOperation: APIOperation {
             return
         }
 
-        graphQLResponseData.append(data)
+        graphQLResponseDecoder.appendResponse(data)
     }
 
     func complete(with error: Error?, response: URLResponse?) {
@@ -59,13 +59,7 @@ extension AWSGraphQLOperation: APIOperation {
         }
 
         do {
-            let graphQLServiceResponse = try GraphQLResponseDecoder.deserialize(graphQLResponse: graphQLResponseData)
-
-            let graphQLResponse = try GraphQLResponseDecoder.decode(graphQLServiceResponse: graphQLServiceResponse,
-                                                                    responseType: request.responseType,
-                                                                    decodePath: request.decodePath,
-                                                                    rawGraphQLResponse: graphQLResponseData)
-
+            let graphQLResponse = try graphQLResponseDecoder.decodeToGraphQLResponse()
             dispatch(result: .success(graphQLResponse))
             finish()
         } catch let error as APIError {

AmplifyPlugins/API/AWSAPICategoryPlugin/Operation/AWSGraphQLOperation+APIOperation.swift

@@ -13,8 +13,7 @@ final public class AWSGraphQLOperation<R: Decodable>: GraphQLOperation<R> {
     let session: URLSessionBehavior
     let mapper: OperationTaskMapper
     let pluginConfig: AWSAPICategoryPluginConfiguration
-
-    var graphQLResponseData = Data()
+    let graphQLResponseDecoder: GraphQLResponseDecoder<R>
 
     init(request: GraphQLOperationRequest<R>,
          session: URLSessionBehavior,
@@ -25,6 +24,7 @@ final public class AWSGraphQLOperation<R: Decodable>: GraphQLOperation<R> {
         self.session = session
         self.mapper = mapper
         self.pluginConfig = pluginConfig
+        self.graphQLResponseDecoder = GraphQLResponseDecoder(request: request)
 
         super.init(categoryType: .api,
                    eventName: request.operationType.hubEventName,

AmplifyPlugins/API/AWSAPICategoryPlugin/Operation/AWSGraphQLOperation.swift

@@ -147,11 +147,8 @@ final public class AWSGraphQLSubscriptionOperation<R: Decodable>: GraphQLSubscri
 
     private func onGraphQLResponseData(_ graphQLResponseData: Data) {
         do {
-            let graphQLServiceResponse = try GraphQLResponseDecoder.deserialize(graphQLResponse: graphQLResponseData)
-            let graphQLResponse = try GraphQLResponseDecoder.decode(graphQLServiceResponse: graphQLServiceResponse,
-                                                                    responseType: request.responseType,
-                                                                    decodePath: request.decodePath,
-                                                                    rawGraphQLResponse: graphQLResponseData)
+            let graphQLResponseDecoder = GraphQLResponseDecoder(request: request, response: graphQLResponseData)
+            let graphQLResponse = try graphQLResponseDecoder.decodeToGraphQLResponse()
             dispatchInProcess(data: .data(graphQLResponse))
         } catch let error as APIError {
             dispatch(result: .failure(error))
@@ -169,7 +166,7 @@ final public class AWSGraphQLSubscriptionOperation<R: Decodable>: GraphQLSubscri
         let errorDescription = "Subscription item event failed with error"
         if case let ConnectionProviderError.subscription(_, payload) = error,
            let errors = payload?["errors"] as? AppSyncJSONValue,
-           let graphQLErrors = try? GraphQLResponseDecoder.decodeAppSyncErrors(errors) {
+           let graphQLErrors = try? GraphQLErrorDecoder.decodeAppSyncErrors(errors) {
             let graphQLResponseError = GraphQLResponseError<R>.error(graphQLErrors)
             dispatch(result: .failure(APIError.operationError(errorDescription, "", graphQLResponseError)))
             finish()

AmplifyPlugins/API/AWSAPICategoryPlugin/Operation/AWSGraphQLSubscriptionOperation.swift

@@ -5,12 +5,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-import Foundation
 import Amplify
 import AppSyncRealTimeClient
 
-extension GraphQLResponseDecoder {
-
+struct GraphQLErrorDecoder {
     static func decodeErrors(graphQLErrors: [JSONValue]) throws -> [GraphQLError] {
         var responseErrors = [GraphQLError]()
         for error in graphQLErrors {
@@ -35,7 +33,7 @@ extension GraphQLResponseDecoder {
             throw APIError.unknown("Expected 'errors' field not found in \(String(describing: appSyncJSON))", "", nil)
         }
         let convertedValues = errors.map(AppSyncJSONValue.toJSONValue)
-        return try GraphQLResponseDecoder.decodeErrors(graphQLErrors: convertedValues)
+        return try decodeErrors(graphQLErrors: convertedValues)
     }
 
     static func decode(graphQLErrorJSON: JSONValue) throws -> GraphQLError {

AmplifyPlugins/API/AWSAPICategoryPlugin/Support/Utils/GraphQLResponseDecoder+DecodeError.swift renamed to AmplifyPlugins/API/AWSAPICategoryPlugin/Support/Decode/GraphQLErrorDecoder.swift

@@ -0,0 +1,46 @@
+//
+// Copyright 2018-2020 Amazon.com,
+// Inc. or its affiliates. All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import Amplify
+import AWSPluginsCore
+
+extension GraphQLResponseDecoder {
+
+    func decodeToResponseType(_ graphQLData: [String: JSONValue]) throws -> R {
+        let graphQLData = try valueAtDecodePath(from: JSONValue.object(graphQLData))
+        if request.responseType == String.self {
+            let serializedJSON = try encoder.encode(graphQLData)
+            guard let responseString = String(data: serializedJSON, encoding: .utf8) else {
+                throw APIError.operationError("Could not get String from data", "", nil)
+            }
+            guard let response = responseString as? R else {
+                throw APIError.operationError("Not of type \(String(describing: R.self))", "", nil)
+            }
+            return response
+        } else if request.responseType == AnyModel.self {
+            let anyModel = try AnyModel(modelJSON: graphQLData)
+            let serializedJSON = try encoder.encode(anyModel)
+            return try decoder.decode(request.responseType, from: serializedJSON)
+        } else {
+            let serializedJSON = try encoder.encode(graphQLData)
+            let responseData = try decoder.decode(request.responseType, from: serializedJSON)
+            return responseData
+        }
+    }
+
+    private func valueAtDecodePath(from graphQLData: JSONValue) throws -> JSONValue {
+        guard let decodePath = request.decodePath else {
+            return graphQLData
+        }
+
+        guard let model = graphQLData.value(at: decodePath) else {
+            throw APIError.operationError("Could not retrieve object, given decode path: \(decodePath)", "", nil)
+        }
+
+        return model
+    }
+}

AmplifyPlugins/API/AWSAPICategoryPlugin/Support/Decode/GraphQLResponseDecoder+DecodeData.swift

@@ -0,0 +1,94 @@
+//
+// Copyright 2018-2020 Amazon.com,
+// Inc. or its affiliates. All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import Foundation
+import Amplify
+import AWSPluginsCore
+
+class GraphQLResponseDecoder<R: Decodable> {
+
+    let request: GraphQLOperationRequest<R>
+    var response: Data
+    let decoder = JSONDecoder()
+    let encoder = JSONEncoder()
+
+    public init(request: GraphQLOperationRequest<R>, response: Data = Data()) {
+        self.request = request
+        self.response = response
+        decoder.dateDecodingStrategy = ModelDateFormatting.decodingStrategy
+        encoder.dateEncodingStrategy = ModelDateFormatting.encodingStrategy
+    }
+
+    func appendResponse(_ data: Data) {
+        response.append(data)
+    }
+
+    func decodeToGraphQLResponse() throws -> GraphQLResponse<R> {
+        let appSyncGraphQLResponse = try AWSAppSyncGraphQLResponse.decodeToAWSAppSyncGraphQLResponse(response: response)
+        switch appSyncGraphQLResponse {
+        case .data(let data):
+            return try decodeData(data)
+        case .errors(let errors):
+            return try decodeErrors(errors)
+        case .partial(let data, let errors):
+            return try decodePartial(graphQLData: data, graphQLErrors: errors)
+        case .invalidResponse:
+            guard let rawGraphQLResponseString = String(data: response, encoding: .utf8) else {
+                throw APIError.operationError(
+                    "Could not get the String representation of the GraphQL response", "")
+            }
+            throw APIError.unknown("The service returned some data without any `data` and `errors`",
+                                   """
+                                   The service did not return an expected GraphQL response: \
+                                   \(rawGraphQLResponseString)
+                                   """)
+        }
+    }
+
+    func decodeData(_ graphQLData: [String: JSONValue]) throws -> GraphQLResponse<R> {
+        do {
+            let responseData = try decodeToResponseType(graphQLData)
+            return GraphQLResponse<R>.success(responseData)
+        } catch let decodingError as DecodingError {
+            let error = APIError(error: decodingError)
+            guard let rawGraphQLResponseString = String(data: response, encoding: .utf8) else {
+                throw APIError.operationError(
+                    "Could not get the String representation of the GraphQL response", "")
+            }
+            return GraphQLResponse<R>.failure(.transformationError(rawGraphQLResponseString, error))
+        } catch {
+            throw error
+        }
+    }
+
+    func decodeErrors(_ graphQLErrors: [JSONValue]) throws -> GraphQLResponse<R> {
+        let responseErrors = try GraphQLErrorDecoder.decodeErrors(graphQLErrors: graphQLErrors)
+        return GraphQLResponse<R>.failure(.error(responseErrors))
+    }
+
+    func decodePartial(graphQLData: [String: JSONValue],
+                       graphQLErrors: [JSONValue]) throws -> GraphQLResponse<R> {
+        do {
+            if let first = graphQLData.first, case .null = first.value {
+                let responseErrors = try GraphQLErrorDecoder.decodeErrors(graphQLErrors: graphQLErrors)
+                return GraphQLResponse<R>.failure(.error(responseErrors))
+            }
+            let responseData = try decodeToResponseType(graphQLData)
+            let responseErrors = try GraphQLErrorDecoder.decodeErrors(graphQLErrors: graphQLErrors)
+            return GraphQLResponse<R>.failure(.partial(responseData, responseErrors))
+        } catch let decodingError as DecodingError {
+            let error = APIError(error: decodingError)
+            guard let rawGraphQLResponseString = String(data: response, encoding: .utf8) else {
+                throw APIError.operationError(
+                    "Could not get the String representation of the GraphQL response", "")
+            }
+            return GraphQLResponse<R>.failure(.transformationError(rawGraphQLResponseString, error))
+        } catch {
+            throw error
+        }
+    }
+}

AmplifyPlugins/API/AWSAPICategoryPlugin/Support/Decode/GraphQLResponseDecoder.swift

@@ -8,7 +8,81 @@
 import Amplify
 
 /// The raw response coming back from the AppSync GraphQL service
-struct AWSAppSyncGraphQLResponse {
-    let data: [String: JSONValue]?
-    let errors: [JSONValue]?
+enum AWSAppSyncGraphQLResponse {
+    case data(_ graphQLData: [String: JSONValue])
+    case errors(_ graphQLErrors: [JSONValue])
+    case partial(graphQLData: [String: JSONValue], graphQLErrors: [JSONValue])
+    case invalidResponse
+
+    static func decodeToAWSAppSyncGraphQLResponse(response: Data) throws -> AWSAppSyncGraphQLResponse {
+        let jsonObject = try deserializeObject(graphQLResponse: response)
+        do {
+            let errors = try getAPIErrors(from: jsonObject)
+            let data = try getGraphQLData(from: jsonObject)
+            switch (data, errors) {
+            case (nil, nil):
+                return .invalidResponse
+            case (.some(let data), .none):
+                return .data(data)
+            case (.none, .some(let errors)):
+                return .errors(errors)
+            case (.some(let data), .some(let errors)):
+                return .partial(graphQLData: data, graphQLErrors: errors)
+            }
+        } catch is APIError {
+            return .invalidResponse
+        } catch {
+            throw error
+        }
+    }
+
+    private static func deserializeObject(graphQLResponse: Data) throws -> [String: JSONValue] {
+        let json: JSONValue
+
+        do {
+            let decoder = JSONDecoder()
+            decoder.dateDecodingStrategy = ModelDateFormatting.decodingStrategy
+            json = try decoder.decode(JSONValue.self, from: graphQLResponse)
+        } catch {
+            throw APIError.operationError("Could not decode to JSONValue from the GraphQL Response",
+                                          "Service issue",
+                                          error)
+        }
+
+        guard case .object(let jsonObject) = json else {
+            throw APIError.unknown("The GraphQL response is not an object",
+                                   "The AppSync service returned a malformed GraphQL response")
+        }
+
+        return jsonObject
+    }
+
+    private static func getAPIErrors(from jsonObject: [String: JSONValue]) throws -> [JSONValue]? {
+        guard let errors = jsonObject["errors"] else {
+            return nil
+        }
+
+        guard case .array(let errorArray) = errors else {
+            throw APIError.unknown("The GraphQL response containing errors should be an array",
+                                   "The AppSync service returned a malformed GraphQL response")
+        }
+
+        return errorArray
+    }
+
+    private static func getGraphQLData(from jsonObject: [String: JSONValue]) throws -> [String: JSONValue]? {
+        guard let data = jsonObject["data"] else {
+            return nil
+        }
+
+        switch data {
+        case .object(let dataObject):
+            return dataObject
+        case .null:
+            return nil
+        default:
+            throw APIError.unknown("Failed to get object or null from data.",
+                                   "The AppSync service returned a malformed GraphQL response")
+        }
+    }
 }

AmplifyPlugins/API/AWSAPICategoryPlugin/Support/Internal/AWSAppSyncGraphQLResponse.swift

@@ -0,0 +1,20 @@
+//
+// Copyright 2018-2020 Amazon.com,
+// Inc. or its affiliates. All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import Amplify
+
+extension GraphQLRequest {
+    func toOperationRequest(operationType: GraphQLOperationType) -> GraphQLOperationRequest<R> {
+        return GraphQLOperationRequest<R>(apiName: apiName,
+                                          operationType: operationType,
+                                          document: document,
+                                          variables: variables,
+                                          responseType: responseType,
+                                          decodePath: decodePath,
+                                          options: GraphQLOperationRequest.Options())
+    }
+}