Upload single file does not fall on resolver
Hello, I'm trying to make a file upload from a mutation using `apollo-upload-client` and `apollo-upload-server`, but as I send the mutation the server does not respond on any available resolver and it seems that no errors are produced. Can someone help me? I tried following the example approach fro `jaydenseric` but my server is using `apollo-server-express`. Here are some depicts:

creating server:

```
const { ApolloServer } = require('apollo-server-express');
const { apolloUploadExpress } = require('apollo-upload-server');
const jwt = require('express-jwt');
const createGraphQLSchema = require('./graphql');

app.use(
    '/graphql',
    cors(),
    jwt({ secret, credentialsRequired: false }),
    apolloUploadExpress(),
  );

  const server = new ApolloServer({
    schema,
    context: ({ req }) => ({ user: req.user, db }),
  });

  server.applyMiddleware({ app });
```

executable schema

```
const glue = require('schemaglue');
const { makeExecutableSchema } = require('apollo-server-express');
const schemaDirectives = require('./directives');

const createSchema = async () => {
  const { schema, resolver } = glue('graphql/types');

  return makeExecutableSchema({
    typeDefs: schema,
    resolvers: resolver,
    schemaDirectives,
    formatError: () => new Error('Internal server error'),
  });
};
```
schema
```
scalar Upload

type Photo {
    id: ID!
}

type Mutation {
    uploadPhoto(file: Upload!, caption: String, isPrivate: Boolean): Photo
}

```

my resolver is more or less like:

```
(root,  { file, caption, private: isPrivate }, { user, db }) => { 
     const {
        createReadStream, filename, mimetype, encoding,
      } = await file;

      const imageStream = createReadStream();

      console.log('stream', imageStream);
      console.log('caption', caption);
      console.log('private', isPrivate);
} 
```


that is, configuring the apollo client like:

```
import { ApolloClient } from 'apollo-client';
import { InMemoryCache } from 'apollo-cache-inmemory';
import { createUploadLink } from 'apollo-upload-client';

const apolloClient = new ApolloClient({
    cache: new InMemoryCache().restore({ }),
    createUploadLink({ uri: 'http://localhost:3001/graphql' }),
    ]),
});
```

Whenever I send the mutation, I see the request being sent and parsed, but in no way the request falls under the uploadPhoto resolver. Here is a console log of my resolver from `schemaglue`;

```
{ Mutation:
   { register: [AsyncFunction: register],
     login: [AsyncFunction: login],
     uploadPhoto: [Function: uploadPhoto],
     editPhoto: [AsyncFunction: editPhoto],
     deletePhoto: [AsyncFunction: deletePhoto] },
  Upload:
   { name: 'Upload',
     description: 'The `Upload` scalar type represents a file upload.',
     serialize: [Function: serialize],
     parseValue: [Function: parseValue],
     parseLiteral: [Function: parseLiteral],
     astNode: undefined,
     extensionASTNodes: undefined },
  Photo: { id: [Function: id], owner: [Function: owner] },
```