Updated to most recent version of spec proposal.

This is now *a breaking change*. The default validation rules are stricter, however with a configuration flag the previous lax behavior can be used which will ensure an existing service can support all existing incoming operations.

For example to continue to support existing queries after updating to the new version, replace:

```js
graphql({ schema, source })
```

With:

```js
graphql({ schema, source, options: {
  allowNullableVariablesInNonNullPositions: true
}})
```

Another more minor breaking change is that the final `typeInfo` argument to `validate` has moved positions. However very few should be reliant on this experimental arg.

Author: leebyron

src/graphql.js

@@ -9,13 +9,14 @@
 
 import { validateSchema } from './type/validate';
 import { parse } from './language/parser';
-import { validate } from './validation/validate';
+import { validate, specifiedRules } from './validation';
 import { execute } from './execution/execute';
 import type { ObjMap } from './jsutils/ObjMap';
-import type { Source } from './language/source';
+import type { ParseOptions, Source } from './language';
 import type { GraphQLFieldResolver } from './type/definition';
 import type { GraphQLSchema } from './type/schema';
 import type { ExecutionResult } from './execution/execute';
+import type { ValidationOptions } from './validation';
 import type { MaybePromise } from './jsutils/MaybePromise';
 
 /**
@@ -47,6 +48,9 @@ import type { MaybePromise } from './jsutils/MaybePromise';
  *    A resolver function to use when one is not provided by the schema.
  *    If not provided, the default field resolver is used (which looks for a
  *    value or method on the source value with the field's name).
+ * options:
+ *    An additional set of flags which enable legacy, compataibility, or
+ *    experimental behavior.
  */
 export type GraphQLArgs = {|
   schema: GraphQLSchema,
@@ -56,6 +60,7 @@ export type GraphQLArgs = {|
   variableValues?: ?ObjMap<mixed>,
   operationName?: ?string,
   fieldResolver?: ?GraphQLFieldResolver<any, any>,
+  options?: ParseOptions & ValidationOptions,
 |};
 declare function graphql(GraphQLArgs, ..._: []): Promise<ExecutionResult>;
 /* eslint-disable no-redeclare */
@@ -67,6 +72,7 @@ declare function graphql(
   variableValues?: ?ObjMap<mixed>,
   operationName?: ?string,
   fieldResolver?: ?GraphQLFieldResolver<any, any>,
+  options?: ParseOptions & ValidationOptions,
 ): Promise<ExecutionResult>;
 export function graphql(
   argsOrSchema,
@@ -76,6 +82,7 @@ export function graphql(
   variableValues,
   operationName,
   fieldResolver,
+  options,
 ) {
   /* eslint-enable no-redeclare */
   // Always return a Promise for a consistent API.
@@ -91,6 +98,7 @@ export function graphql(
             argsOrSchema.variableValues,
             argsOrSchema.operationName,
             argsOrSchema.fieldResolver,
+            argsOrSchema.options,
           )
         : graphqlImpl(
             argsOrSchema,
@@ -100,6 +108,7 @@ export function graphql(
             variableValues,
             operationName,
             fieldResolver,
+            options,
           ),
     ),
   );
@@ -121,6 +130,7 @@ declare function graphqlSync(
   variableValues?: ?ObjMap<mixed>,
   operationName?: ?string,
   fieldResolver?: ?GraphQLFieldResolver<any, any>,
+  options?: ParseOptions & ValidationOptions,
 ): ExecutionResult;
 export function graphqlSync(
   argsOrSchema,
@@ -130,6 +140,7 @@ export function graphqlSync(
   variableValues,
   operationName,
   fieldResolver,
+  options,
 ) {
   // Extract arguments from object args if provided.
   const result =
@@ -142,6 +153,7 @@ export function graphqlSync(
           argsOrSchema.variableValues,
           argsOrSchema.operationName,
           argsOrSchema.fieldResolver,
+          argsOrSchema.options,
         )
       : graphqlImpl(
           argsOrSchema,
@@ -151,6 +163,7 @@ export function graphqlSync(
           variableValues,
           operationName,
           fieldResolver,
+          options,
         );
 
   // Assert that the execution was synchronous.
@@ -169,6 +182,7 @@ function graphqlImpl(
   variableValues,
   operationName,
   fieldResolver,
+  options,
 ): MaybePromise<ExecutionResult> {
   // Validate Schema
   const schemaValidationErrors = validateSchema(schema);
@@ -179,13 +193,13 @@ function graphqlImpl(
   // Parse
   let document;
   try {
-    document = parse(source);
+    document = parse(source, options);
   } catch (syntaxError) {
     return { errors: [syntaxError] };
   }
 
   // Validate
-  const validationErrors = validate(schema, document);
+  const validationErrors = validate(schema, document, specifiedRules, options);
   if (validationErrors.length > 0) {
     return { errors: validationErrors };
   }

src/index.js

@@ -268,6 +268,7 @@ export { subscribe, createSourceEventStream } from './subscription';
 // Validate GraphQL queries.
 export {
   validate,
+  ValidationOptions,
   ValidationContext,
   // All validation rules in the GraphQL Specification.
   specifiedRules,

src/validation/ValidationContext.js

@@ -33,6 +33,21 @@ import { TypeInfo } from '../utilities/TypeInfo';
 type NodeWithSelectionSet = OperationDefinitionNode | FragmentDefinitionNode;
 type VariableUsage = { node: VariableNode, type: ?GraphQLInputType };
 
+/**
+ * Configuration options to control validation behavior.
+ */
+export type ValidationOptions = {
+  /**
+   * If enabled, validation will allow nullable variables with default values
+   * to be used in non-null positions. Earlier versions explicitly allowed such
+   * operations due to a slightly different interpretation of default values and
+   * null values. GraphQL services accepting operations written before this
+   * version may continue to allow such operations by enabling this option,
+   * however GraphQL services established after this version should not.
+   */
+  allowNullableVariablesInNonNullPositions?: boolean,
+};
+
 /**
  * An instance of this class is passed as the "this" context to all validators,
  * allowing access to commonly useful contextual information from within a
@@ -42,6 +57,7 @@ export default class ValidationContext {
   _schema: GraphQLSchema;
   _ast: DocumentNode;
   _typeInfo: TypeInfo;
+  options: ValidationOptions;
   _errors: Array<GraphQLError>;
   _fragments: ObjMap<FragmentDefinitionNode>;
   _fragmentSpreads: Map<SelectionSetNode, $ReadOnlyArray<FragmentSpreadNode>>;
@@ -59,10 +75,12 @@ export default class ValidationContext {
     schema: GraphQLSchema,
     ast: DocumentNode,
     typeInfo: TypeInfo,
+    options?: ValidationOptions,
   ): void {
     this._schema = schema;
     this._ast = ast;
     this._typeInfo = typeInfo;
+    this.options = options || {};
     this._errors = [];
     this._fragmentSpreads = new Map();
     this._recursivelyReferencedFragments = new Map();

src/validation/__tests__/VariablesInAllowedPosition-test.js

@@ -6,7 +6,12 @@
  */
 
 import { describe, it } from 'mocha';
-import { expectPassesRule, expectFailsRule } from './harness';
+import {
+  expectPassesRule,
+  expectFailsRule,
+  expectPassesRuleWithOptions,
+  expectFailsRuleWithOptions,
+} from './harness';
 import {
   VariablesInAllowedPosition,
   badVarPosMessage,
@@ -91,20 +96,6 @@ describe('Validate: Variables are in allowed positions', () => {
     );
   });
 
-  it('Int => Int! with non-null default value', () => {
-    expectPassesRule(
-      VariablesInAllowedPosition,
-      `
-      query Query($intArg: Int = 1)
-      {
-        complicatedArgs {
-          nonNullIntArgField(nonNullIntArg: $intArg)
-        }
-      }
-    `,
-    );
-  });
-
   it('[String] => [String]', () => {
     expectPassesRule(
       VariablesInAllowedPosition,
@@ -201,18 +192,6 @@ describe('Validate: Variables are in allowed positions', () => {
     );
   });
 
-  it('Boolean => Boolean! in directive with default', () => {
-    expectPassesRule(
-      VariablesInAllowedPosition,
-      `
-      query Query($boolVar: Boolean = false)
-      {
-        dog @include(if: $boolVar)
-      }
-    `,
-    );
-  });
-
   it('Int => Int!', () => {
     expectFailsRule(
       VariablesInAllowedPosition,
@@ -233,26 +212,6 @@ describe('Validate: Variables are in allowed positions', () => {
     );
   });
 
-  it('Int => Int! with null default value', () => {
-    expectFailsRule(
-      VariablesInAllowedPosition,
-      `
-      query Query($intArg: Int = null) {
-        complicatedArgs {
-          nonNullIntArgField(nonNullIntArg: $intArg)
-        }
-      }
-    `,
-      [
-        {
-          message: badVarPosMessage('intArg', 'Int', 'Int!'),
-          locations: [{ line: 2, column: 19 }, { line: 4, column: 45 }],
-          path: undefined,
-        },
-      ],
-    );
-  });
-
   it('Int => Int! within fragment', () => {
     expectFailsRule(
       VariablesInAllowedPosition,
@@ -401,4 +360,73 @@ describe('Validate: Variables are in allowed positions', () => {
       ],
     );
   });
+
+  describe('allowNullableVariablesInNonNullPositions', () => {
+    it('Int => Int! with non-null default value without option', () => {
+      expectFailsRule(
+        VariablesInAllowedPosition,
+        `
+        query Query($intVar: Int = 1) {
+          complicatedArgs {
+            nonNullIntArgField(nonNullIntArg: $intVar)
+          }
+        }
+      `,
+        [
+          {
+            message: badVarPosMessage('intVar', 'Int', 'Int!'),
+            locations: [{ line: 2, column: 21 }, { line: 4, column: 47 }],
+            path: undefined,
+          },
+        ],
+      );
+    });
+
+    it('Int => Int! with null default value fails with option', () => {
+      expectFailsRuleWithOptions(
+        { allowNullableVariablesInNonNullPositions: true },
+        VariablesInAllowedPosition,
+        `
+          query Query($intVar: Int = null) {
+            complicatedArgs {
+              nonNullIntArgField(nonNullIntArg: $intVar)
+            }
+          }
+        `,
+        [
+          {
+            message: badVarPosMessage('intVar', 'Int', 'Int!'),
+            locations: [{ line: 2, column: 23 }, { line: 4, column: 49 }],
+            path: undefined,
+          },
+        ],
+      );
+    });
+
+    it('Int => Int! with non-null default value with option', () => {
+      expectPassesRuleWithOptions(
+        { allowNullableVariablesInNonNullPositions: true },
+        VariablesInAllowedPosition,
+        `
+        query Query($intVar: Int = 1) {
+          complicatedArgs {
+            nonNullIntArgField(nonNullIntArg: $intVar)
+          }
+        }
+      `,
+      );
+    });
+
+    it('Boolean => Boolean! in directive with default value with option', () => {
+      expectPassesRuleWithOptions(
+        { allowNullableVariablesInNonNullPositions: true },
+        VariablesInAllowedPosition,
+        `
+      query Query($boolVar: Boolean = false) {
+        dog @include(if: $boolVar)
+      }
+    `,
+      );
+    });
+  });
 });

src/validation/__tests__/harness.js

@@ -422,13 +422,15 @@ export const testSchema = new GraphQLSchema({
   ],
 });
 
-function expectValid(schema, rules, queryString) {
-  const errors = validate(schema, parse(queryString), rules);
+function expectValid(schema, rules, queryString, options) {
+  const ast = parse(queryString);
+  const errors = validate(schema, ast, rules, options);
   expect(errors).to.deep.equal([], 'Should validate');
 }
 
-function expectInvalid(schema, rules, queryString, expectedErrors) {
-  const errors = validate(schema, parse(queryString), rules);
+function expectInvalid(schema, rules, queryString, expectedErrors, options) {
+  const ast = parse(queryString);
+  const errors = validate(schema, ast, rules, options);
   expect(errors).to.have.length.of.at.least(1, 'Should not validate');
   expect(errors.map(formatError)).to.deep.equal(expectedErrors);
   return errors;
@@ -442,6 +444,14 @@ export function expectFailsRule(rule, queryString, errors) {
   return expectInvalid(testSchema, [rule], queryString, errors);
 }
 
+export function expectPassesRuleWithOptions(options, rule, queryString) {
+  return expectValid(testSchema, [rule], queryString, options);
+}
+
+export function expectFailsRuleWithOptions(options, rule, queryString, errors) {
+  return expectInvalid(testSchema, [rule], queryString, errors, options);
+}
+
 export function expectPassesRuleWithSchema(schema, rule, queryString, errors) {
   return expectValid(schema, [rule], queryString, errors);
 }

src/validation/__tests__/validation-test.js

@@ -73,7 +73,7 @@ describe('Validate: Supports full validation', () => {
       }
     `);
 
-    const errors = validate(testSchema, ast, specifiedRules, typeInfo);
+    const errors = validate(testSchema, ast, specifiedRules, {}, typeInfo);
 
     const errorMessages = errors.map(err => err.message);
 

src/validation/index.js

@@ -12,6 +12,7 @@ export { validate } from './validate';
 // https://github.com/tc39/proposal-export-default-from
 import ValidationContext from './ValidationContext';
 export { ValidationContext };
+export type { ValidationOptions } from './ValidationContext';
 
 export { specifiedRules } from './specifiedRules';