fix the mess - kind of

Author: maticzav

src/index.ts

@@ -1,51 +1,91 @@
 import { IMiddleware } from 'graphql-middleware'
 import { GraphQLUpload } from 'apollo-upload-server'
-import { GraphQLResolveInfo } from 'graphql'
+import { GraphQLResolveInfo, GraphQLArgument, GraphQLField } from 'graphql'
 
-interface IConfig<output> {
-  uploadHandler: (file: IFile) => Promise<output>
+// GraphQL
+
+type Maybe<T> = T | null
+
+function getResolverField(
+  info: GraphQLResolveInfo,
+): GraphQLField<any, any, { [key: string]: any }> {
+  const { fieldName, parentType } = info
+  const typeFields = parentType.getFields()
+
+  return typeFields[fieldName]
+}
+
+function getFieldArguments<TSource, TContext, TArgs>(
+  field: GraphQLField<TSource, TContext, TArgs>,
+): GraphQLArgument[] {
+  return field.args
+}
+
+function filterMap<T, U>(f: (x: T) => Maybe<U>, xs: T[]): U[] {
+  return xs.reduce((acc, x) => {
+    const res = f(x)
+    if (res !== null) {
+      return [res, ...acc]
+    } else {
+      return acc
+    }
+  }, [])
+}
+
+function getArgumentValue(args: { [key: string]: any }, arg: GraphQLArgument) {
+  return args.get(arg.name)
 }
 
-export interface IFile {
+export function executeWithArgumentType<T>(
+  f: (definition: GraphQLArgument, arg: any) => Maybe<T>,
+  info: GraphQLResolveInfo,
+  args: { [key: string]: any },
+): T[] {
+  const field = getResolverField(info)
+  const fieldArguments = getFieldArguments(field)
+
+  const fWithArguments = arg => f(arg, getArgumentValue(args, arg))
+
+  return filterMap(fWithArguments, fieldArguments)
+}
+
+// Upload
+
+export interface IUpload {
   stream: string
   filename: string
   mimetype: string
   encoding: string
 }
 
-function getUploadArgumentsNames(info: GraphQLResolveInfo): string[] {
-  const typeFields = info.parentType.getFields()
-  const args = typeFields[info.fieldName].args
-  const uploadArgs = args.filter(arg => arg.type === GraphQLUpload)
+declare type IUploadHandler<T> = (upload: Promise<IUpload>) => Promise<T>
 
-  return uploadArgs.map(arg => arg.name)
+interface IConfig<T> {
+  uploadHandler: IUploadHandler<T>
 }
 
-export const upload = <output>(config: IConfig<output>): IMiddleware => {
-  return async (resolve, parent, args, ctx, info) => {
-    const uploadArgumentsNames = getUploadArgumentsNames(info)
-    const nonEmptyUploadArgumentsNames = uploadArgumentsNames.filter(
-      argName => args[argName] !== undefined,
-    )
-
-    const uploads = await Promise.all(
-      nonEmptyUploadArgumentsNames.map(uploadArgumentName =>
-        args[uploadArgumentName]
-          .then(config.uploadHandler)
-          .then(res => ({ [uploadArgumentName]: res })),
-      ),
-    )
+function isGraphQLUploadArgument(
+  x: GraphQLArgument,
+): x is GraphQLArgument & { type: GraphQLUpload } {
+  return x.type instanceof GraphQLUpload
+}
 
-    const normalizedUploads = uploads.reduce(
-      (args, arg) => ({ ...args, ...arg }),
-      {},
-    )
+// function processor<T>
 
-    const argsWithUploads = {
-      ...args,
-      ...normalizedUploads,
+async function processor<T>(uploadFunction: IUploadHandler<T>) {
+  return async (def, value) => {
+    if (isGraphQLUploadArgument(def)) {
+      return (value as Promise<IUpload>).then(uploadFunction)
+    } else {
+      return null
     }
+  }
+}
+
+export function upload<T>({ uploadHandler }: IConfig<T>): IMiddleware {
+  return (resolve, parent, args, ctx, info) => {
+    const executed = executeWithArgumentType(uploadHandler, info)
 
-    return resolve(parent, argsWithUploads, ctx, info)
+    return resolve()
   }
 }

test.js

@@ -1,57 +1,72 @@
 import test from 'ava'
-import { GraphQLUpload } from 'apollo-upload-server'
-import { graphql } from 'graphql'
+import { graphql, GraphQLString, GraphQLInteger } from 'graphql'
 import { makeExecutableSchema } from 'graphql-tools'
 import { applyMiddleware } from 'graphql-middleware'
-import { upload } from './'
+import { executeWithArgumentType } from './'
 
-test('Finds the right arguments', async t => {
-  const typeDefs = `
-    scalar Upload
+// Helpers
 
-    type Query {
-      foo: String
-    }
+const isStringType = x => {
+  return x.type instanceof GraphQLString
+}
+
+// Tests
 
-    type Mutation {
-      test(nonUpload: String!, upload: Upload!): Boolean
+test('Finds Argument With Type - Triggers', async t => {
+  t.plan(2)
+
+  // Schema
+  const typeDefs = `
+    type Query {
+      test(string: String, boolean: Boolean!): String!
     }
   `
 
   const resolvers = {
     Query: {
-      foo: () => '',
-    },
-    Mutation: {
-      test: async (parent, args, ctx, info) => {
-        t.is(args.upload, 'passes')
-        t.is(args.nonUpload, 'passes')
-      },
+      test: (parent, args, ctx, infp) => 'pass',
     },
-    Upload: GraphQLUpload,
   }
 
-  const uploadFunction = async file => {
-    return 'passes'
+  // Middleware
+  const processor = arg => {
+    if (isStringType(arg)) {
+      t.pass()
+      return 'pass'
+    } else {
+      return null
+    }
   }
 
-  const _schema = makeExecutableSchema({
-    typeDefs,
-    resolvers,
-  })
+  const middleware = {
+    Query: {
+      test: async (resolve, parent, args, ctx, info) => {
+        executeWithArgumentType(processor, info, args)
+
+        return resolve()
+      },
+    },
+  }
 
-  const schema = applyMiddleware(
-    _schema,
-    upload({ uploadHandler: uploadFunction }),
-  )
+  // Schema with Middleware
+  const schema = makeExecutableSchema({ typeDefs, resolvers })
+  const schemaWithMiddleware = applyMiddleware(schema, middleware)
 
   const query = `
-    mutation {
-      test(nonUpload: "passes", upload: "fails")
+    query {
+      test(string: "trigger", boolean: true)
     }
   `
 
   const res = await graphql(schema, query)
 
-  console.log(res)
+  t.is(res.data.test, 'pass')
 })
+
+test.todo('Finds Argument With Type - Does not trigger')
+test.todo('Finds Argument With Type - values in processor match')
+test.todo('Finds Argument With Type - values in resolver match')
+test.todo('Is GraphQLUpload type')
+test.todo('Is not GraphQLUpload type')
+test.todo('Is GraphQLUpload List type')
+test.todo('Is not GraphQLUpload List type')