fix(visitAllArgs): resolve serious issue reconstructing args

update internal detail to be less surpising:  use object
rather than two-element array
update tests
improve package.json dependencies

Author: tgerk

.vscode/launch.json

@@ -4,7 +4,8 @@
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
-        {	"type": "node",
+        {
+            "type": "node",
             "request": "launch",
             "name": "Run AVA test",
             "program": "${workspaceRoot}/node_modules/ava/profile.js",

package.json

@@ -14,22 +14,21 @@
   "author": "Tim Gerk <[email protected]>, Matic Zavadlal <[email protected]>",
   "scripts": {
     "prepublish": "npm run test",
-    "build": "rm -rf dist && tsc -d",
-    "lint": "tslint --project tsconfig.json {src}/**/*.ts && prettier-check --ignore-path .gitignore {src,.}/{*.ts,*.js}",
     "test": "npm run lint && npm run build && npm run test-ava",
+    "lint": "tslint --project tsconfig.json {src}/**/*.ts && prettier-check --ignore-path .gitignore src{,/**}/{*.ts,*.js}",
+    "build": "rm -rf dist && tsc -d",
     "test-ava": "ava --verbose",
     "semantic-release": "semantic-release",
-    "pretty": "npx prettier --write --ignore-path .gitignore {src,.}/{*.ts,*.js}"
+    "pretty": "npx prettier --ignore-path .gitignore src{,/**}/{*.ts,*.js} --write"
   },
   "dependencies": {
-    "graphql-middleware": "^1.4.2"
+    "graphql-middleware": "1.7.8",
+    "graphql-upload": "^8.0.1"
   },
   "devDependencies": {
     "@types/graphql": "0.13.4",
     "ava": "0.25.0",
-    "graphql": "0.13.2",
-    "graphql-middleware": "1.7.8",
-    "graphql-tools": "4.0.2",
+    "graphql": "^0.13.2",
     "prettier": "1.14.3",
     "prettier-check": "2.0.0",
     "semantic-release": "15.8.1",
@@ -40,7 +39,6 @@
     "typescript": "2.9.2"
   },
   "peerDependencies": {
-    "apollo-upload-server": "^5.0.0",
     "graphql": "^0.13.2"
   },
   "release": {

src/index.ts

@@ -90,7 +90,7 @@ export function getArgumentValue(
 
 // Helper --------------------------------------------------------------------
 
-declare type IHandledArg<T> = [string, T | T[]]
+declare type IHandledArg<T> = { [key: string]: T | T[] }
 
 /**
  *
@@ -137,19 +137,19 @@ export function makeArgumentTransform<T, V>(
           },
           [],
         ),
-      ).then((res: T[]): IHandledArg<T> => [argumentName, res])
+      ).then((newValue: T[]): IHandledArg<T> => ({ [argumentName]: newValue }))
     }
 
     if (argumentValue !== undefined && argumentValue !== null) {
       if (argumentValue instanceof Promise) {
         return argumentValue
           .then(e => transform(e, parent, args, ctx, info))
-          .then((res: T): IHandledArg<T> => [argumentName, res])
+          .then((newValue: T): IHandledArg<T> => ({ [argumentName]: newValue }))
       }
 
       return Promise.resolve(
         transform(argumentValue, parent, args, ctx, info),
-      ).then((res: T): IHandledArg<T> => [argumentName, res])
+      ).then((newValue: T): IHandledArg<T> => ({ [argumentName]: newValue }))
     }
 
     return null // exclude arguments when no value provided
@@ -199,11 +199,8 @@ export function processTypeArgs<V, T>({
           ),
         )
           // substitute the transformed values into the args object
-          .then(result =>
-            result.reduce(
-              (args, [name, newValue]) => { args[name] = newValue; return args },
-              args,
-            ),
+          .then(newArgs =>
+            newArgs.reduce((args, newArg) => ({ ...args, ...newArg }), args),
           )
           .then(newArgs => resolve(parent, newArgs, ctx, info))
       )
@@ -213,27 +210,24 @@ export function processTypeArgs<V, T>({
   }
 }
 
-export function visitAllArgs({ visitor }): IMiddlewareFunction {
+export function visitAllArgs({ transform }): IMiddlewareFunction {
   return (resolve, parent, args, ctx, info) => {
     const argDefs = getFieldArguments(info)
     if (argDefs.length) {
       // Apply argument transform function to all arguments
-      // The caller's visitor function is applied to values that may be embedded
+      // The caller's transform function is applied to values that may be embedded
       // in lists and promises, but not to null or undefined values
       // Finally the resolver is called with transformed argument values
       return (
         Promise.all(
           filterMap(
-            makeArgumentTransform(visitor, parent, args, ctx, info),
+            makeArgumentTransform(transform, parent, args, ctx, info),
             argDefs,
           ),
         )
           // substitute the transformed values into the args object
-          .then(result =>
-            result.reduce(
-              (args, [name, newValue]) => (args[name] = newValue),
-              args,
-            ),
+          .then(newArgs =>
+            newArgs.reduce((args, newArg) => ({ ...args, ...newArg }), args),
           )
           .then(newArgs => resolve(parent, newArgs, ctx, info))
       )

src/test/index.test.ts

@@ -1,7 +1,7 @@
 import test from 'ava'
 import { makeExecutableSchema } from 'graphql-tools'
 import { applyMiddleware } from 'graphql-middleware'
-import { GraphQLUpload } from 'apollo-upload-server'
+import { GraphQLUpload } from 'graphql-upload'
 import { graphql, GraphQLList, GraphQLString, GraphQLScalarType } from 'graphql'
 import {
   findArgumentsOfType,
@@ -316,14 +316,14 @@ test('Processor handles single file correctly', async t => {
   let args = {
     test: new Promise(resolve =>
       resolve({ stream: 's', filename: 'f', mimetype: 'm', encoding: 'e' }),
-    )
+    ),
   }
   const res = await makeArgumentTransform(uploadHandler, {}, args, {}, {})({
     name: 'test',
     type: GraphQLUpload,
   })
 
-  t.deepEqual(res, ['test', 'sfme'])
+  t.deepEqual(res, { test: 'sfme' })
 })
 
 test('Processor handles multiple files correctly', async t => {
@@ -346,14 +346,14 @@ test('Processor handles multiple files correctly', async t => {
     )
 
   const args = {
-    test: [file(1), file(2)]
+    test: [file(1), file(2)],
   }
   const res = await makeArgumentTransform(uploadHandler, {}, args, {}, {})({
     name: 'test',
     type: new GraphQLList(GraphQLUpload),
   })
 
-  t.deepEqual(res, ['test', ['s1f1m1e1', 's2f2m2e2']])
+  t.deepEqual(res, { test: ['s1f1m1e1', 's2f2m2e2'] })
 })
 
 test('Processor handles empty files correctly', async t => {
@@ -376,14 +376,14 @@ test('Processor handles empty files correctly', async t => {
     )
 
   const args = {
-    test: [file(1), null, undefined]
+    test: [file(1), null, undefined],
   }
   const res = await makeArgumentTransform(uploadHandler, {}, args, {}, {})({
     name: 'test',
     type: new GraphQLList(GraphQLUpload),
   })
 
-  t.deepEqual(res, ['test', ['s1f1m1e1']])
+  t.deepEqual(res, { test: ['s1f1m1e1'] })
 })
 
 test('Processor handles no file correctly', async t => {
@@ -395,7 +395,7 @@ test('Processor handles no file correctly', async t => {
       ),
     )
   const args = {
-    test: null
+    test: null,
   }
   const res = await makeArgumentTransform(uploadHandler, {}, args, {}, {})({
     name: 'test',
@@ -405,11 +405,11 @@ test('Processor handles no file correctly', async t => {
   t.is(res, null)
 })
 
-test('processTypeArgs applies a transformations correctly', async t => {
+test('processTypeArgs applies a transformation correctly', async t => {
   // write a schema, an arg transform, and a query
   t.plan(5)
 
-  let theValue = "some-random-string"
+  let theValue = 'some-random-string'
 
   const typeDefs = `
     scalar Custom
@@ -422,26 +422,30 @@ test('processTypeArgs applies a transformations correctly', async t => {
   const resolvers = {
     Query: {
       test: (parent, args, ctx, infp) => {
-        t.deepEqual(args, { pass: String('-'+theValue+'-').toUpperCase() })
+        t.deepEqual(args, { pass: String('-' + theValue + '-').toUpperCase() })
         return String(args.pass).split('-')
-      }
+      },
     },
     Custom: new GraphQLScalarType({
       name: 'Custom',
       serialize: x => x,
       parseValue: x => x,
       parseLiteral: x => {
-        t.is(x['value'], theValue); return `-${x['value']}-`
-      }
+        t.is(x['value'], theValue)
+        return `-${x['value']}-`
+      },
     }),
   }
 
   const middleware = {
     Query: {
-      test: processTypeArgs({ type: 'Custom', transform: x=> {
-        t.is(x, '-'+theValue+'-');
-        return Promise.resolve(String(x).toUpperCase())
-      }})
+      test: processTypeArgs({
+        type: 'Custom',
+        transform: x => {
+          t.is(x, '-' + theValue + '-')
+          return Promise.resolve(String(x).toUpperCase())
+        },
+      }),
     },
   }
 
@@ -456,6 +460,10 @@ test('processTypeArgs applies a transformations correctly', async t => {
 
   // Execution
   const res = await graphql(schema, query)
-  console.log(res)
-  t.deepEqual(res.data.test, String('-'+theValue+'-').toUpperCase().split('-'))
+  t.deepEqual(
+    res.data.test,
+    String('-' + theValue + '-')
+      .toUpperCase()
+      .split('-'),
+  )
 })

src/upload.ts

@@ -1,4 +1,4 @@
-import { GraphQLUpload } from 'apollo-upload-server'
+import { GraphQLUpload } from 'graphql-upload'
 import { processTypeArgs } from './index'
 import { IMiddlewareFunction } from 'graphql-middleware'
 

tsconfig.json

@@ -7,8 +7,7 @@
     "outDir": "./dist",
     "sourceMap": true,
     "lib": ["dom", "es2017", "esnext.asynciterable"],
-    "experimentalDecorators": true,
-    "watch": true
+    "experimentalDecorators": true
   },
   "exclude": ["node_modules"]
 }