Issue title: Upload cors error
 Issue body: Hi Dear,
When use credentials include processing upload and after minute show cors error every one can help me for fix it?
this my my error

![Capture](https://user-images.githubusercontent.com/36853974/117359609-ded51500-aecc-11eb-8f4c-6d1bd12f6b82.PNG)
 
**Server Code:**
```
const apolloServer = new ApolloServer({
  typeDefs: typeDefs,
  resolvers: resolvers,
  schemaDirectives,
  subscriptions: {
    onConnect: (connectionParams, ws) => {
      sessionMiddleware(ws.upgradeReq, {}, () => {
        if (!getUserId(ws.upgradeReq)) {
          throw new AuthenticationError("you must be sigin");
        }
      });
    },
  },
  context: contexts,
  uploads: false,
  introspection: process.env.NODE_ENV !== "production",
  playground:
    process.env.NODE_ENV === "production"
      ? false
      : {
          settings: {
            "editor.theme": "light",
            "request.credentials": "include",
          },
        },
});

app.use(
  cors({
    origin: ["https://explore.mazust.ac.ir", "https://apiexplore.mazust.ac.ir"],
    credentials: true,
  })
);

app.use(graphqlUploadExpress());

apolloServer.applyMiddleware({ app, cors: false });
```

**Client Code:**

```
import React from "react";
import {
  ApolloClient,
  ApolloLink,
  ApolloProvider,
  InMemoryCache,
  split,
} from "@apollo/client";
import { WebSocketLink } from "@apollo/client/link/ws";
import { onError } from "@apollo/client/link/error";
import { getMainDefinition } from "@apollo/client/utilities";
import { createUploadLink } from "apollo-upload-client";

const parseHeaders = (rawHeaders) => {
  const headers = new Headers();
  // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
  // https://tools.ietf.org/html/rfc7230#section-3.2
  const preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " ");
  preProcessedHeaders.split(/\r?\n/).forEach((line) => {
    const parts = line.split(":");
    const key = parts.shift().trim();
    if (key) {
      const value = parts.join(":").trim();
      headers.append(key, value);
    }
  });
  return headers;
};

export const uploadFetch = (url, options) =>
  new Promise((resolve, reject) => {
    const xhr = new XMLHttpRequest();
    xhr.withCredentials = true;
    xhr.onload = () => {
      const opts = {
        status: xhr.status,
        statusText: xhr.statusText,
        headers: parseHeaders(xhr.getAllResponseHeaders() || ""),
      };
      opts.url =
        "responseURL" in xhr
          ? xhr.responseURL
          : opts.headers.get("X-Request-URL");
      const body = "response" in xhr ? xhr.response : xhr.responseText;
      resolve(new Response(body, opts));
    };
    xhr.onerror = () => {
      reject(new TypeError("Network request failed"));
    };
    xhr.ontimeout = () => {
      reject(new TypeError("Network request failed"));
    };
    xhr.open(options.method, url, true);

    Object.keys(options.headers).forEach((key) => {
      xhr.setRequestHeader(key, options.headers[key]);
    });

    if (xhr.upload) {
      xhr.upload.onprogress = options.onProgress;
    }

    options.onAbortPossible(() => {
      xhr.abort();
    });

    xhr.send(options.body);
  });

const customFetch = (uri, options) => {
  if (options.onProgress) {
    return uploadFetch(uri, options);
  }
  return fetch(uri, options);
};

const cache = new InMemoryCache();

const errorLink = onError(
  ({ graphQLErrors, networkError, forward, operation }) => {
    if (graphQLErrors)
      graphQLErrors.map(({ message, extensions, path }) => {
        if (extensions.code === "UNAUTHENTICATED") {
          return (window.location = "/");
        }

        return forward(operation);
      });

    if (networkError) console.log(`[Network error]: ${networkError}`);
  }
);

const httpLink = new ApolloLink.from([
  errorLink,
  new ApolloLink((operation, forward) => {
    return forward(operation);
  }),
  createUploadLink({
    uri: process.env.REACT_APP_SERVER_HOST,
    credentials: "include",
    fetch: customFetch,
  }),
]);

const wsLink = new WebSocketLink({
  uri: process.env.REACT_APP_WS_SERVER_HOST,
  options: {
    lazy: true,
    reconnect: true,
  },
});

const isSubscription = (operation) => {
  const definition = getMainDefinition(operation.query);
  return (
    definition.kind === "OperationDefinition" &&
    definition.operation === "subscription"
  );
};

export const client = new ApolloClient({
  cache: cache,
  link: split(isSubscription, wsLink, httpLink),
  defaultOptions: {
    watchQuery: {
      fetchPolicy: "cache-and-network",
    },
  },
});

function Apollo({ children }) {
  return <ApolloProvider client={client}>{children}</ApolloProvider>;
}

export default Apollo;

```

**Nginx Config For Api:**

```
server {
    listen       443 ssl;
    listen       [38d1:d2b4:3d06:83e8:96a5:8c2:893d:aba5]:443 ssl;
    server_name  apiexplore.mazust.ac.ir;

    ssl_certificate      "C:/ssl/cert.pem";
    ssl_certificate_key  "C:/ssl/key.key";

    ssl_session_cache    shared:SSL:1m;
    ssl_session_timeout  5m;

    ssl_ciphers  HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers  on;

    location / {
     proxy_pass http://localhost:4077;

     proxy_http_version 1.1;
     proxy_set_header Upgrade $http_upgrade;
     proxy_set_header Connection 'upgrade';
     proxy_set_header Host $host;
     proxy_set_header X-Forwarded-For $remote_addr;
     proxy_set_header X-Forwarded-Host $host;
     proxy_set_header X-Forwarded-Proto $scheme;
     proxy_cache_bypass $http_upgrade;   

    # THESE ARE IMPORTANT
     proxy_set_header X-Real-IP $remote_addr;
     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    } 
}

server {
  listen 80;
  server_name apiexplore.mazust.ac.ir;
  return 301 https://apiexplore.mazust.ac.ir$request_uri;

}
```

Please help.
 Comments: 
 Comment 0: Closing because this issue tracker is for reporting reproducible `apollo-upload-client` bugs and is not really the right place to ask for help with your project, and your question is not a quick and easy one to help with.

I can offer a suggestion to check that your API server has the right CORS stuff for error pages, otherwise if there is an error (e.g. 403, 404, etc.) you might get distracted by all the CORS problems instead of seeing what the actually error page was.

Hope that helps!
{'source': 'GithubIssues', 'repo_name_with_owner': 'jaydenseric/apollo-upload-client', 'issue_id': 877981402, 'repo_stars': 1428.0}