this could actually work

Author: maticzav

package.json

@@ -26,7 +26,7 @@
     "@types/graphql": "0.13.3",
     "ava": "0.25.0",
     "graphql": "0.13.2",
-    "graphql-middleware": "1.3.3",
+    "graphql-middleware": "^1.4.2",
     "graphql-tools": "3.0.5",
     "prettier": "1.13.7",
     "prettier-check": "2.0.0",
@@ -38,7 +38,7 @@
   },
   "peerDependencies": {
     "graphql": "^0.13.2",
-    "graphql-middleware": "^1.3.0"
+    "graphql-middleware": "^1.4.2"
   },
   "release": {
     "branch": "master"

src/index.ts

@@ -1,11 +1,23 @@
-import { IMiddleware } from 'graphql-middleware'
+import {
+  GraphQLResolveInfo,
+  GraphQLArgument,
+  GraphQLField,
+  getNamedType,
+} from 'graphql'
 import { GraphQLUpload } from 'apollo-upload-server'
-import { GraphQLResolveInfo, GraphQLArgument, GraphQLField } from 'graphql'
+import { IMiddlewareFunction } from 'graphql-middleware'
 
-// GraphQL
+// GraphQL -------------------------------------------------------------------
 
 type Maybe<T> = T | null
 
+/**
+ *
+ * @param info
+ *
+ * Returns GraphQLField type of the current resolver.
+ *
+ */
 function getResolverField(
   info: GraphQLResolveInfo,
 ): GraphQLField<any, any, { [key: string]: any }> {
@@ -15,12 +27,28 @@ function getResolverField(
   return typeFields[fieldName]
 }
 
+/**
+ *
+ * @param field
+ *
+ * Returns arguments that certain field accepts.
+ *
+ */
 function getFieldArguments<TSource, TContext, TArgs>(
   field: GraphQLField<TSource, TContext, TArgs>,
 ): GraphQLArgument[] {
   return field.args
 }
 
+/**
+ *
+ * @param f
+ * @param xs
+ *
+ * Maps an array of functions and filters out the values
+ * which converted to null.
+ *
+ */
 function filterMap<T, U>(f: (x: T) => Maybe<U>, xs: T[]): U[] {
   return xs.reduce((acc, x) => {
     const res = f(x)
@@ -32,11 +60,30 @@ function filterMap<T, U>(f: (x: T) => Maybe<U>, xs: T[]): U[] {
   }, [])
 }
 
+/**
+ *
+ * @param args
+ * @param arg
+ *
+ * Finds the value of argument from provided argument values and
+ * argument definition.
+ *
+ */
 function getArgumentValue(args: { [key: string]: any }, arg: GraphQLArgument) {
   return args.get(arg.name)
 }
 
-export function executeWithArgumentType<T>(
+/**
+ *
+ * @param f
+ * @param info
+ * @param args
+ *
+ * Executes a funcition on all arguments of a particular field
+ * and filters out the results which returned null.
+ *
+ */
+export function filterMapFieldArguments<T>(
   f: (definition: GraphQLArgument, arg: any) => Maybe<T>,
   info: GraphQLResolveInfo,
   args: { [key: string]: any },
@@ -49,7 +96,23 @@ export function executeWithArgumentType<T>(
   return filterMap(fWithArguments, fieldArguments)
 }
 
-// Upload
+/**
+ *
+ * @param type
+ * @param x
+ *
+ * Checks whether a certain non-nullable, list or regular type
+ * is of predicted type.
+ *
+ */
+export function isGraphQLArgumentType(
+  type,
+  argument: GraphQLArgument,
+): boolean {
+  return getNamedType(argument.type) instanceof type
+}
+
+// Upload --------------------------------------------------------------------
 
 export interface IUpload {
   stream: string
@@ -58,34 +121,133 @@ export interface IUpload {
   encoding: string
 }
 
-declare type IUploadHandler<T> = (upload: Promise<IUpload>) => Promise<T>
+interface IUploadArgument {
+  argumentName: string
+  upload: Promise<IUpload> | Promise<IUpload>[]
+}
+
+interface IProcessedUploadArgument<T> {
+  argumentName: string
+  upload: T | T[]
+}
+
+declare type IUploadHandler<T> = (upload: IUpload) => Promise<T>
 
 interface IConfig<T> {
   uploadHandler: IUploadHandler<T>
 }
 
-function isGraphQLUploadArgument(
-  x: GraphQLArgument,
-): x is GraphQLArgument & { type: GraphQLUpload } {
-  return x.type instanceof GraphQLUpload
+/**
+ *
+ * @param def
+ * @param value
+ *
+ * Funciton used to identify GraphQLUpload arguments.
+ *
+ */
+function uploadTypeIdentifier(
+  def: GraphQLArgument,
+  value: any,
+): IUploadArgument {
+  if (isGraphQLArgumentType(GraphQLUpload, def)) {
+    return {
+      argumentName: def.name,
+      upload: value,
+    }
+  } else {
+    return null
+  }
 }
 
-// function processor<T>
+/**
+ *
+ * @param args
+ * @param info
+ *
+ * Function used to extract GraphQLUpload argumetns from a field.
+ *
+ */
+function extractUploadArguments(
+  args: { [key: string]: any },
+  info: GraphQLResolveInfo,
+): IUploadArgument[] {
+  return filterMapFieldArguments(uploadTypeIdentifier, info, args)
+}
 
-async function processor<T>(uploadFunction: IUploadHandler<T>) {
-  return async (def, value) => {
-    if (isGraphQLUploadArgument(def)) {
-      return (value as Promise<IUpload>).then(uploadFunction)
+/**
+ *
+ * @param arr
+ *
+ * Converts an array of processed uploads to one object which can
+ * be later used as arguments definition.
+ *
+ */
+function normaliseArguments<T>(
+  args: IProcessedUploadArgument<T>[],
+): { [key: string]: T } {
+  return args.reduce((acc, val) => {
+    return {
+      ...acc,
+      [val.argumentName]: val.upload,
+    }
+  }, {})
+}
+
+/**
+ *
+ * @param uploadHandler
+ *
+ * Function used to process file uploads.
+ *
+ */
+function processor<T>(uploadHandler: IUploadHandler<T>) {
+  return function({
+    argumentName,
+    upload,
+  }: IUploadArgument): Maybe<Promise<IProcessedUploadArgument<T>>> {
+    if (Array.isArray(upload)) {
+      const uploads = upload.map(file => file.then(uploadHandler))
+
+      return Promise.all(uploads).then(res => ({
+        argumentName: argumentName,
+        upload: res,
+      }))
+    } else if (upload !== undefined) {
+      return upload.then(uploadHandler).then(res => ({
+        argumentName: argumentName,
+        upload: res,
+      }))
     } else {
       return null
     }
   }
 }
 
-export function upload<T>({ uploadHandler }: IConfig<T>): IMiddleware {
-  return (resolve, parent, args, ctx, info) => {
-    const executed = executeWithArgumentType(uploadHandler, info)
-
-    return resolve()
+/**
+ *
+ * @param config
+ *
+ * Exposed upload function which handles file upload in resolvers.
+ * Internally, it returns a middleware function which is later processed
+ * by GraphQL Middleware.
+ * The first step is to extract upload arguments using identifier
+ * which can be found above.
+ * Once we found all the GraphQLUpload arguments we check whether they
+ * carry a value or not and return a Promise to resolve them.
+ * Once Promises get processed we normalise outputs and merge them
+ * with old arguments to replace the old values with the new ones.
+ *
+ */
+export function upload<T>({ uploadHandler }: IConfig<T>): IMiddlewareFunction {
+  return async (resolve, parent, args, ctx, info) => {
+    const files = extractUploadArguments(args, info)
+    const uploads = filterMap(processor(uploadHandler), files)
+
+    const uploaded = await Promise.all(uploads)
+    const argsUploaded = normaliseArguments(uploaded)
+
+    const argsWithUploads = { ...args, ...argsUploaded }
+
+    return resolve(parent, argsWithUploads, ctx, info)
   }
 }

yarn.lock

@@ -1935,9 +1935,9 @@ graceful-fs@^4.1.11, graceful-fs@^4.1.2, graceful-fs@^4.1.6:
   version "4.1.11"
   resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.1.11.tgz#0e8bdfe4d1ddb8854d64e04ea7c00e2a026e5658"
 
-graphql-middleware@1.3.3:
-  version "1.3.3"
-  resolved "https://registry.yarnpkg.com/graphql-middleware/-/graphql-middleware-1.3.3.tgz#c6898df07c8d58a2f49c6ba3b0a49ec946f3d300"
+graphql-middleware@^1.4.2:
+  version "1.4.2"
+  resolved "https://registry.yarnpkg.com/graphql-middleware/-/graphql-middleware-1.4.2.tgz#db1738587c14e87317ce9d8ae5787750db3b4680"
   dependencies:
     graphql-tools "^3.0.2"