Problem uploading a file with GraphQLFile

[Cleversou1983]

Currently I have a mutation like this:

mutation uploadFile($file:Upload!) {

}

extension UploadFileMutation {
public typealias Upload = GraphQLFile
}

I've made an extension, so the compiler doesn't complain about the type

When I try use GraphQLFile as parameter
Cannot convert value of type 'UploadFileMutation.Upload' (aka 'GraphQLFile') to expected dictionary value type 'Optional'

I couldn't upload with HTTPTransportNetwork as well.. Could someone give some hints?

Thanks!

[designatednerd]

This is related to #681 (missing documentation).

If you take a look at the expected string in the multi-part form data and the docs for the multi-part upload spec you can see the type of query you'd want to have is something like this:

mutation ($file: Upload!) { 
  singleUpload(file: $file) { 
    id 
  }
}

That singleUpload is the name of the method your schema provides for uploading the file. The upload method should take care of doing all the multipart handling nonsense for you.

[Cleversou1983]

Thanks a lot for your help, Ellen... I hope the example arrive soon, I still don't have success sending GraphQLFile to a GraphQL on a rails server...
Cheers!
Cleverson

[designatednerd]

Is the issue you're having on the server side? If so, can we close this issue out?

If not, can you be more specific about what's going wrong?

[Cleversou1983]

To be honest, I'm not sure if is server side issue...

I'm doing:
let file= GraphQLFile(fieldName: "file", originalName: "file", mimeType: "image/png", data: imageData!)
let mutation = UploadFileMutation(file: file)

I then create an extension
extension UploadFileMutation {
public typealias Upload = GraphQLFile
}

Then in this line,
public var variables: GraphQLMap? {
return ["file": file]
}

I get this error
Cannot convert value of type 'UploadFileMutation.Upload' (aka 'GraphQLFile') to expected dictionary value type 'Optional'

I'm totally lost!
Thanks a lot, Ellen

[designatednerd]

You should not need to create that typealias yourself - can you post the generated code for UploadFileMutation please?

[Cleversou1983]

Sure! Thanks a lot, Ellen! Cheers!

public final class UploadFileMutation: GraphQLMutation {
public let operationDefinition =
"mutation UploadFile($file: Upload!) {\n uploadFile(input: {file: $file}) {\n __typename\n attachment {\n __typename\n id\n }\n errors\n }\n}"

public let operationName = "UploadFile"

public var file: Upload

public init(file: Upload) {
self.file = file
}

public var variables: GraphQLMap? {
return ["file": file]
}

public struct Data: GraphQLSelectionSet {
public static let possibleTypes = ["Mutation"]

public static let selections: [GraphQLSelection] = [
  GraphQLField("uploadFile", arguments: ["input": ["file": GraphQLVariable("file")]], type: .object(UploadFile.selections)),
]

public private(set) var resultMap: ResultMap

public init(unsafeResultMap: ResultMap) {
  self.resultMap = unsafeResultMap
}

public init(uploadFile: UploadFile? = nil) {
  self.init(unsafeResultMap: ["__typename": "Mutation", "uploadFile": uploadFile.flatMap { (value: UploadFile) -> ResultMap in value.resultMap }])
}

public var uploadFile: UploadFile? {
  get {
    return (resultMap["uploadFile"] as? ResultMap).flatMap { UploadFile(unsafeResultMap: $0) }
  }
  set {
    resultMap.updateValue(newValue?.resultMap, forKey: "uploadFile")
  }
}

public struct UploadFile: GraphQLSelectionSet {
  public static let possibleTypes = ["UploadFilePayload"]

  public static let selections: [GraphQLSelection] = [
    GraphQLField("__typename", type: .nonNull(.scalar(String.self))),
    GraphQLField("attachment", type: .object(Attachment.selections)),
    GraphQLField("errors", type: .list(.nonNull(.scalar(String.self)))),
  ]

  public private(set) var resultMap: ResultMap

  public init(unsafeResultMap: ResultMap) {
    self.resultMap = unsafeResultMap
  }

  public init(attachment: Attachment? = nil, errors: [String]? = nil) {
    self.init(unsafeResultMap: ["__typename": "UploadFilePayload", "attachment": attachment.flatMap { (value: Attachment) -> ResultMap in value.resultMap }, "errors": errors])
  }

  public var __typename: String {
    get {
      return resultMap["__typename"]! as! String
    }
    set {
      resultMap.updateValue(newValue, forKey: "__typename")
    }
  }

  public var attachment: Attachment? {
    get {
      return (resultMap["attachment"] as? ResultMap).flatMap { Attachment(unsafeResultMap: $0) }
    }
    set {
      resultMap.updateValue(newValue?.resultMap, forKey: "attachment")
    }
  }

  public var errors: [String]? {
    get {
      return resultMap["errors"] as? [String]
    }
    set {
      resultMap.updateValue(newValue, forKey: "errors")
    }
  }

  public struct Attachment: GraphQLSelectionSet {
    public static let possibleTypes = ["Attachment"]

    public static let selections: [GraphQLSelection] = [
      GraphQLField("__typename", type: .nonNull(.scalar(String.self))),
      GraphQLField("id", type: .nonNull(.scalar(GraphQLID.self))),
    ]

    public private(set) var resultMap: ResultMap

    public init(unsafeResultMap: ResultMap) {
      self.resultMap = unsafeResultMap
    }

    public init(id: GraphQLID) {
      self.init(unsafeResultMap: ["__typename": "Attachment", "id": id])
    }

    public var __typename: String {
      get {
        return resultMap["__typename"]! as! String
      }
      set {
        resultMap.updateValue(newValue, forKey: "__typename")
      }
    }

    public var id: GraphQLID {
      get {
        return resultMap["id"]! as! GraphQLID
      }
      set {
        resultMap.updateValue(newValue, forKey: "id")
      }
    }
  }
}

}
}

[kimdv]

Hi!
Hope this can help

This is my mutation

mutation AddImage($id: ID!, $image: ImageInput!) {
  addImage(id: $id, image: $image) {
    ...ImageFragment
  }
}

This is my swift method:

    @discardableResult
    func addImage(id: String,
                  image: Data,
                  source: String?,
                  copyright: String,
                  completion: @escaping (Swift.Result<ImageFragment, SupertrendsClientError>) -> Void) -> Cancellable {
        let name = UUID().uuidString
        let file = GraphQLFile(fieldName: name, originalName: name, mimeType: "image/jpeg", data: image)
        let imageInput = ImageInput(copyright: copyright, source: source, upload: name, url: nil)
        let query = AddImageMutation(id: id, image: imageInput)

        return performUpload(query: query, files: [file], resultMap: { $0.addImage?.fragments.imageFragment }, completion: completion)
    }

performUpload is just a generic method for sharing the upload function.

I have also added a type alias for my Upload file public typealias Upload = String

[Cleversou1983]

@kimdv Thanks a lot friend! I'll try that!

One question the performUpload you've talked about just execute te mutation within Apollo? Thanks!!!!!!!!

[kimdv]

    private func performUpload<Query: GraphQLMutation, Res>(query: Query,
                                                            files: [GraphQLFile],
                                                            resultMap: @escaping (Query.Data) -> Res?,
                                                            completion: @escaping (Swift.Result<Res, SupertrendsClientError>) -> Void) -> Cancellable {
        return networkTransport.upload(operation: query, files: files) { result in
            switch result {
            case .success(let data):
                if let object = try? Query.Data.init(jsonObject: data.body),
                    let model = resultMap(object) {
                    completion(.success(model))
                } else {
                    completion(.failure(SupertrendsClientError.unknown))
                }
            case .failure(let error):
                completion(.failure(SupertrendsClientError.unknown))
            }
        }
    }

Here it is

[kimdv]

And related to this.

@designatednerd the reason I first had added the upload method to ApolloClient was for the same result type. Now we get a more generic one, and not the same as "normal" mutation.

I think we should make is similar somehow

[Cleversou1983]

@kimdv Thanks a lot my friend, I'll try that now, I really appreciate your help!
Cheers!

[Cleversou1983]

@kdvtrifork Can you give me a little help with that?
I got a response from my backend developer, my mutation is now returning this, shouldn't the. be Content-Disposition: form-data, multipart-data instead?

2019-08-07T12:55:07.405171+00:00 app[web.1]: UploadFile
2019-08-07T12:55:07.405173+00:00 app[web.1]: --apollo-ios.boundary.0D94B585-41E9-42A6-B29F-7BBAE60AF397
2019-08-07T12:55:07.405175+00:00 app[web.1]: Content-Disposition: form-data; name="file"; filename="file"
2019-08-07T12:55:07.405176+00:00 app[web.1]: Content-Type: image/jpeg

////
let fileFieldName = "file"
let file = GraphQLFile(fieldName: fileFieldName, originalName: fileFieldName, mimeType: "image/jpeg", data: imageData)

        let uploadInput = UploadFileMutation(file: fileFieldName)

let configuration = URLSessionConfiguration.default
let transport = HTTPNetworkTransport(url: AppParameters.APIPublicUrl, configuration: configuration)
let upload = transport.upload(operation: uploadInput, files: [file]) { (result) in
///////
}

Thanks a lot brother!
Cheers!

[kimdv]

I don't understand the question?

The mutation and file creation looks good.
Is the server not accepting it?