Include possible field, argument, type names when validation fails

src/utilities/__tests__/suggestionList-test.js

@@ -0,0 +1,28 @@
+/**
+ *  Copyright (c) 2015, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+import { expect } from 'chai';
+import { describe, it } from 'mocha';
+import { suggestionList } from '../suggestionList';
+
+describe('suggestionList', () => {
+
+  it('Returns results when input is empty', () => {
+    expect(suggestionList('', [ 'a' ])).to.deep.equal([ 'a' ]);
+  });
+
+  it('Returns empty array when there are no options', () => {
+    expect(suggestionList('input', [])).to.deep.equal([]);
+  });
+
+  it('Returns options sorted based on simularity', () => {
+    expect(suggestionList('abc', [ 'a', 'ab', 'abc' ]))
+      .to.deep.equal([ 'abc', 'ab', 'a' ]);
+  });
+});

src/utilities/suggestionList.js

@@ -0,0 +1,78 @@
+/* @flow */
+/**
+ *  Copyright (c) 2015, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+/**
+ * Given a JavaScript value and a GraphQL type, determine if the value will be
+ * accepted for that type. This is primarily useful for validating the
+ * runtime values of query variables.
+ */
+export function suggestionList(
+    input: string,
+    options: Array<string>
+  ): Array<string> {
+  let i;
+  const d = {};
+  const oLength = options.length;
+  for (i = 0; i < oLength; i++) {
+    d[options[i]] = lexicalDistance(input, options[i]);
+  }
+  const result = options.slice();
+  return result.sort((a , b) => d[a] - d[b]);
+}
+
+/**
+ * Computes the lexical distance between strings A and B.
+ *
+ * The "distance" between two strings is given by counting the minimum number
+ * of edits needed to transform string A into string B. An edit can be an
+ * insertion, deletion, or substitution of a single character, or a swap of two
+ * adjacent characters.
+ *
+ * This distance can be useful for detecting typos in input or sorting
+ *
+ * @param {string} a
+ * @param {string} b
+ * @return {int} distance in number of edits
+ */
+function lexicalDistance(a, b) {
+  let i;
+  let j;
+  const d = [];
+  const aLength = a.length;
+  const bLength = b.length;
+
+  for (i = 0; i <= aLength; i++) {
+    d[i] = [ i ];
+  }
+
+  for (j = 1; j <= bLength; j++) {
+    d[0][j] = j;
+  }
+
+  for (i = 1; i <= aLength; i++) {
+    for (j = 1; j <= bLength; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+
+      d[i][j] = Math.min(
+        d[i - 1][j] + 1,
+        d[i][j - 1] + 1,
+        d[i - 1][j - 1] + cost
+      );
+
+      if (i > 1 && j > 1 &&
+          a[i - 1] === b[j - 2] &&
+          a[i - 2] === b[j - 1]) {
+        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + cost);
+      }
+    }
+  }
+
+  return d[aLength][bLength];
+}

src/validation/__tests__/FieldsOnCorrectType-test.js

@@ -16,9 +16,21 @@ import {
 } from '../rules/FieldsOnCorrectType';
 
 
-function undefinedField(field, type, suggestions, line, column) {
+function undefinedField(
+  field,
+  type,
+  suggestedTypes,
+  suggestedFields,
+  line,
+  column
+) {
   return {
-    message: undefinedFieldMessage(field, type, suggestions),
+    message: undefinedFieldMessage(
+      field,
+      type,
+      suggestedTypes,
+      suggestedFields
+    ),
     locations: [ { line, column } ],
   };
 }
@@ -85,8 +97,16 @@ describe('Validate: Fields on correct type', () => {
           }
         }
       }`,
-      [ undefinedField('unknown_pet_field', 'Pet', [], 3, 9),
-        undefinedField('unknown_cat_field', 'Cat', [], 5, 13) ]
+      [ undefinedField('unknown_pet_field', 'Pet', [], [ 'name' ], 3, 9),
+        undefinedField(
+          'unknown_cat_field',
+          'Cat',
+          [],
+          [ 'nickname', 'name', 'meowVolume', 'meows', 'furColor' ],
+          5,
+          13
+        )
+      ]
     );
   });
 
@@ -95,7 +115,22 @@ describe('Validate: Fields on correct type', () => {
       fragment fieldNotDefined on Dog {
         meowVolume
       }`,
-      [ undefinedField('meowVolume', 'Dog', [], 3, 9) ]
+      [ undefinedField(
+          'meowVolume',
+          'Dog',
+          [],
+          [ 'barkVolume',
+            'name',
+            'nickname',
+            'barks',
+            'doesKnowCommand',
+            'isAtLocation',
+            'isHousetrained',
+          ],
+          3,
+          9
+        )
+      ]
     );
   });
 
@@ -106,7 +141,22 @@ describe('Validate: Fields on correct type', () => {
           deeper_unknown_field
         }
       }`,
-      [ undefinedField('unknown_field', 'Dog', [], 3, 9) ]
+      [ undefinedField(
+          'unknown_field',
+          'Dog',
+          [],
+          [ 'nickname',
+            'name',
+            'barkVolume',
+            'doesKnowCommand',
+            'isHousetrained',
+            'isAtLocation',
+            'barks',
+          ],
+          3,
+          9
+        )
+      ]
     );
   });
 
@@ -117,7 +167,7 @@ describe('Validate: Fields on correct type', () => {
           unknown_field
         }
       }`,
-      [ undefinedField('unknown_field', 'Pet', [], 4, 11) ]
+      [ undefinedField('unknown_field', 'Pet', [], [ 'name' ], 4, 11) ]
     );
   });
 
@@ -128,7 +178,22 @@ describe('Validate: Fields on correct type', () => {
           meowVolume
         }
       }`,
-      [ undefinedField('meowVolume', 'Dog', [], 4, 11) ]
+      [ undefinedField(
+          'meowVolume',
+          'Dog',
+          [],
+          [ 'barkVolume',
+            'name',
+            'nickname',
+            'barks',
+            'doesKnowCommand',
+            'isAtLocation',
+            'isHousetrained',
+          ],
+          4,
+          11
+        )
+      ]
     );
   });
 
@@ -137,7 +202,22 @@ describe('Validate: Fields on correct type', () => {
       fragment aliasedFieldTargetNotDefined on Dog {
         volume : mooVolume
       }`,
-      [ undefinedField('mooVolume', 'Dog', [], 3, 9) ]
+      [ undefinedField(
+          'mooVolume',
+          'Dog',
+          [],
+          [ 'barkVolume',
+            'name',
+            'nickname',
+            'barks',
+            'isAtLocation',
+            'doesKnowCommand',
+            'isHousetrained',
+          ],
+          3,
+          9
+        )
+      ]
     );
   });
 
@@ -146,7 +226,22 @@ describe('Validate: Fields on correct type', () => {
       fragment aliasedLyingFieldTargetNotDefined on Dog {
         barkVolume : kawVolume
       }`,
-      [ undefinedField('kawVolume', 'Dog', [], 3, 9) ]
+      [ undefinedField(
+          'kawVolume',
+          'Dog',
+          [],
+          [ 'barkVolume',
+            'name',
+            'nickname',
+            'barks',
+            'isAtLocation',
+            'doesKnowCommand',
+            'isHousetrained',
+          ],
+          3,
+          9
+        )
+      ]
     );
   });
 
@@ -155,7 +250,7 @@ describe('Validate: Fields on correct type', () => {
       fragment notDefinedOnInterface on Pet {
         tailLength
       }`,
-      [ undefinedField('tailLength', 'Pet', [], 3, 9) ]
+      [ undefinedField('tailLength', 'Pet', [], [ 'name' ], 3, 9) ]
     );
   });
 
@@ -164,7 +259,7 @@ describe('Validate: Fields on correct type', () => {
       fragment definedOnImplementorsButNotInterface on Pet {
         nickname
       }`,
-      [ undefinedField('nickname', 'Pet', [ 'Cat', 'Dog' ], 3, 9) ]
+      [ undefinedField('nickname', 'Pet', [ 'Cat', 'Dog' ], [ 'name' ], 3, 9) ]
     );
   });
 
@@ -181,7 +276,7 @@ describe('Validate: Fields on correct type', () => {
       fragment directFieldSelectionOnUnion on CatOrDog {
         directField
       }`,
-      [ undefinedField('directField', 'CatOrDog', [], 3, 9) ]
+      [ undefinedField('directField', 'CatOrDog', [], [], 3, 9) ]
     );
   });
 
@@ -195,6 +290,7 @@ describe('Validate: Fields on correct type', () => {
           'name',
           'CatOrDog',
           [ 'Being', 'Pet', 'Canine', 'Cat', 'Dog' ],
+          [],
           3,
           9
         )
@@ -218,25 +314,33 @@ describe('Validate: Fields on correct type', () => {
   describe('Fields on correct type error message', () => {
     it('Works with no suggestions', () => {
       expect(
-        undefinedFieldMessage('T', 'f', [])
-      ).to.equal('Cannot query field "T" on type "f".');
+        undefinedFieldMessage('f', 'T', [], [])
+      ).to.equal('Cannot query field "f" on type "T".');
     });
 
     it('Works with no small numbers of suggestions', () => {
       expect(
-        undefinedFieldMessage('T', 'f', [ 'A', 'B' ])
-      ).to.equal('Cannot query field "T" on type "f". ' +
+        undefinedFieldMessage('f', 'T', [ 'A', 'B' ], [ 'z', 'y' ])
+      ).to.equal('Cannot query field "f" on type "T". ' +
         'However, this field exists on "A", "B". ' +
-        'Perhaps you meant to use an inline fragment?');
+        'Perhaps you meant to use an inline fragment? ' +
+        'Did you mean to query "z", "y"?');
     });
 
     it('Works with lots of suggestions', () => {
       expect(
-        undefinedFieldMessage('T', 'f', [ 'A', 'B', 'C', 'D', 'E', 'F' ])
-      ).to.equal('Cannot query field "T" on type "f". ' +
+        undefinedFieldMessage(
+          'f',
+          'T',
+          [ 'A', 'B', 'C', 'D', 'E', 'F' ],
+          [ 'z', 'y', 'x', 'w', 'v', 'u' ]
+        )
+      ).to.equal('Cannot query field "f" on type "T". ' +
         'However, this field exists on "A", "B", "C", "D", "E", ' +
         'and 1 other types. ' +
-        'Perhaps you meant to use an inline fragment?');
+        'Perhaps you meant to use an inline fragment? ' +
+        'Did you mean to query "z", "y", "x", "w", "v", or 1 other field?'
+      );
     });
   });
 });