Make allowEmptySelectionSet the default

Author: martinbonnin

src/execution/__tests__/executor-test.ts

@@ -234,14 +234,14 @@ describe('Execute: Handles basic execution tasks', () => {
     const schema = new GraphQLSchema({ query: Type });
 
     const document = parse('{ a deep { } ...Frag } fragment Frag on Type { }', {
-      experimentalEmptySelectionSets: true,
+      allowEmptySelectionSets: true,
     });
 
     const result = executeSync({ schema, document });
     expect(result).to.deep.equal({ data: { a: 'Apple', deep: {} } });
 
     const emptyDocument = parse('{ }', {
-      experimentalEmptySelectionSets: true,
+      allowEmptySelectionSets: true,
     });
     expect(executeSync({ schema, document: emptyDocument })).to.deep.equal({
       data: {},

src/language/__tests__/parser-test.ts

@@ -17,6 +17,7 @@ import type {
   OperationDefinitionNode,
 } from '../ast.ts';
 import { Kind } from '../kinds.ts';
+import type { ParseOptions } from '../parser.ts';
 import {
   parse,
   parseConstValue,
@@ -27,8 +28,8 @@ import {
 import { Source } from '../source.ts';
 import { TokenKind } from '../tokenKind.ts';
 
-function expectSyntaxError(text: string) {
-  return expectToThrowJSON(() => parse(text));
+function expectSyntaxError(text: string, options?: ParseOptions) {
+  return expectToThrowJSON(() => parse(text, options));
 }
 
 describe('Parser', () => {
@@ -508,7 +509,6 @@ describe('Parser', () => {
 
   it('allows parsing empty selection sets', () => {
     const document = parse('{ node { } }', {
-      experimentalEmptySelectionSets: true,
       noLocation: true,
     });
 
@@ -545,7 +545,6 @@ describe('Parser', () => {
 
   it('allows parsing an empty operation selection set', () => {
     const document = parse('{ }', {
-      experimentalEmptySelectionSets: true,
       noLocation: true,
     });
     const operation = document.definitions[0] as OperationDefinitionNode;
@@ -555,16 +554,17 @@ describe('Parser', () => {
 
   it('allows parsing an empty fragment selection set', () => {
     const document = parse('fragment a on t { }', {
-      experimentalEmptySelectionSets: true,
       noLocation: true,
     });
     const fragment = document.definitions[0] as FragmentDefinitionNode;
 
     expect(fragment.selectionSet.selections).to.deep.equal([]);
   });
 
-  it('disallows parsing empty selection sets without experimental flag', () => {
-    expectSyntaxError('{ node { } }').to.deep.equal({
+  it('disallows parsing empty selection sets when disabled', () => {
+    expectSyntaxError('{ node { } }', {
+      allowEmptySelectionSets: false,
+    }).to.deep.equal({
       message: 'Syntax Error: Expected Name, found "}".',
       locations: [{ line: 1, column: 10 }],
     });

src/language/__tests__/printer-test.ts

@@ -20,7 +20,7 @@ describe('Printer: Query document', () => {
 
   it('prints empty selection sets', () => {
     const ast = parse('{ foo { } bar { ... on Baz { } } }', {
-      experimentalEmptySelectionSets: true,
+      allowEmptySelectionSets: true,
     });
     expect(print(ast)).to.equal(dedent`
       {
@@ -32,7 +32,7 @@ describe('Printer: Query document', () => {
     `);
 
     const emptyOperationAST = parse('{ }', {
-      experimentalEmptySelectionSets: true,
+      allowEmptySelectionSets: true,
     });
     expect(print(emptyOperationAST)).to.equal('{}');
   });

src/language/parser.ts

@@ -119,11 +119,9 @@ export interface ParseOptions {
   experimentalFragmentArguments?: boolean | undefined;
 
   /**
-   * EXPERIMENTAL:
-   *
-   * If enabled, the parser accepts selection sets that contain no
-   * selections, changing the grammar from `SelectionSet : { Selection+ }` to
-   * `SelectionSet : { Selection* }`.
+   * If enabled (the default), the parser accepts selection sets that contain
+   * no selections, changing the grammar from `SelectionSet : { Selection+ }`
+   * to `SelectionSet : { Selection* }`.
    *
    * See https://github.com/graphql/graphql-spec/pull/1227
    * @example
@@ -133,7 +131,7 @@ export interface ParseOptions {
    * }
    * ```
    */
-  experimentalEmptySelectionSets?: boolean | undefined;
+  allowEmptySelectionSets?: boolean | undefined;
 
   /**
    * Internal parser hook for GraphQL.js entry points that need to parse a
@@ -595,7 +593,7 @@ export class Parser {
    * SelectionSet : { Selection+ }
    * ```
    *
-   * With `experimentalEmptySelectionSets` enabled:
+   * With `allowEmptySelectionSets` enabled (the default):
    *
    * ```
    * SelectionSet : { Selection* }
@@ -607,13 +605,9 @@ export class Parser {
     return this.node<SelectionSetNode>(this._lexer.token, {
       kind: Kind.SELECTION_SET,
       selections:
-        this._options.experimentalEmptySelectionSets === true
-          ? this.any(TokenKind.BRACE_L, this.parseSelection, TokenKind.BRACE_R)
-          : this.many(
-              TokenKind.BRACE_L,
-              this.parseSelection,
-              TokenKind.BRACE_R,
-            ),
+        this._options.allowEmptySelectionSets === false
+          ? this.many(TokenKind.BRACE_L, this.parseSelection, TokenKind.BRACE_R)
+          : this.any(TokenKind.BRACE_L, this.parseSelection, TokenKind.BRACE_R),
     });
   }
 

src/validation/ValidationContext.ts

@@ -181,7 +181,7 @@ interface ValidationContextOptions {
   /** Whether suggestion text should be omitted from errors. */
   hideSuggestions?: Maybe<boolean>;
   /** Whether selection sets on composite types may be empty. */
-  experimentalEmptySelectionSets?: Maybe<boolean>;
+  allowEmptySelectionSets?: Maybe<boolean>;
 }
 
 /** Validation context passed to query validation rules. */
@@ -198,7 +198,7 @@ export class ValidationContext extends ASTValidationContext {
     ReadonlyArray<VariableUsage>
   >;
   private _hideSuggestions: boolean;
-  private _experimentalEmptySelectionSets: boolean;
+  private _allowEmptySelectionSets: boolean;
 
   /**
    * Creates a ValidationContext instance.
@@ -262,15 +262,14 @@ export class ValidationContext extends ASTValidationContext {
       typeof hideSuggestionsOrOptions === 'boolean'
         ? { hideSuggestions: hideSuggestionsOrOptions }
         : (hideSuggestionsOrOptions ?? {});
-    const { hideSuggestions, experimentalEmptySelectionSets } = options;
+    const { hideSuggestions, allowEmptySelectionSets } = options;
     super(ast, onError);
     this._schema = schema;
     this._typeInfo = typeInfo;
     this._variableUsages = new Map();
     this._recursiveVariableUsages = new Map();
     this._hideSuggestions = hideSuggestions ?? false;
-    this._experimentalEmptySelectionSets =
-      experimentalEmptySelectionSets ?? false;
+    this._allowEmptySelectionSets = allowEmptySelectionSets ?? true;
   }
 
   /**
@@ -291,13 +290,10 @@ export class ValidationContext extends ASTValidationContext {
 
   /**
    * Returns whether empty selection sets on composite types are allowed.
-   *
-   * Note: empty selection sets are experimental and may be changed or removed
-   * in the future.
    * @returns True when a selection set on a composite type may be empty.
    */
-  get experimentalEmptySelectionSets(): boolean {
-    return this._experimentalEmptySelectionSets;
+  get allowEmptySelectionSets(): boolean {
+    return this._allowEmptySelectionSets;
   }
 
   /**

src/validation/__tests__/ScalarLeafsRule-test.ts

@@ -67,7 +67,9 @@ describe('Validate: Scalar leafs', () => {
     // We can't leverage expectErrors since it doesn't support passing in the
     // documentNode directly. We have to do this because this is technically
     // an invalid document.
-    const errors = validate(testSchema, doc, [ScalarLeafsRule]);
+    const errors = validate(testSchema, doc, [ScalarLeafsRule], {
+      allowEmptySelectionSets: false,
+    });
     expectJSON(errors).toDeepEqual([
       {
         message:
@@ -76,25 +78,17 @@ describe('Validate: Scalar leafs', () => {
     ]);
   });
 
-  it('object type having no selections is allowed with experimentalEmptySelectionSets', () => {
-    const doc = parse('{ human { } }', {
-      experimentalEmptySelectionSets: true,
-    });
+  it('object type having no selections is allowed by default', () => {
+    const doc = parse('{ human { } }');
 
-    const errors = validate(testSchema, doc, [ScalarLeafsRule], {
-      experimentalEmptySelectionSets: true,
-    });
+    const errors = validate(testSchema, doc, [ScalarLeafsRule]);
     expectJSON(errors).toDeepEqual([]);
   });
 
-  it('scalar selection is still rejected with experimentalEmptySelectionSets', () => {
-    const doc = parse('{ human { name { } } }', {
-      experimentalEmptySelectionSets: true,
-    });
+  it('scalar selection is still rejected with allowEmptySelectionSets', () => {
+    const doc = parse('{ human { name { } } }');
 
-    const errors = validate(testSchema, doc, [ScalarLeafsRule], {
-      experimentalEmptySelectionSets: true,
-    });
+    const errors = validate(testSchema, doc, [ScalarLeafsRule]);
     expectJSON(errors).toDeepEqual([
       {
         message:
@@ -195,37 +189,4 @@ describe('Validate: Scalar leafs', () => {
       },
     ]);
   });
-
-  it('object type having only one selection', () => {
-    const doc: DocumentNode = {
-      kind: Kind.DOCUMENT,
-      definitions: [
-        {
-          kind: Kind.OPERATION_DEFINITION,
-          operation: OperationTypeNode.QUERY,
-          selectionSet: {
-            kind: Kind.SELECTION_SET,
-            selections: [
-              {
-                kind: Kind.FIELD,
-                name: { kind: Kind.NAME, value: 'human' },
-                selectionSet: { kind: Kind.SELECTION_SET, selections: [] },
-              },
-            ],
-          },
-        },
-      ],
-    };
-
-    // We can't leverage expectErrors since it doesn't support passing in the
-    // documentNode directly. We have to do this because this is technically
-    // an invalid document.
-    const errors = validate(testSchema, doc, [ScalarLeafsRule]);
-    expectJSON(errors).toDeepEqual([
-      {
-        message:
-          'Field "human" of type "Human" must have at least one field selected.',
-      },
-    ]);
-  });
 });

src/validation/rules/ScalarLeafsRule.ts

@@ -72,7 +72,7 @@ export function ScalarLeafsRule(context: ValidationContext): ASTVisitor {
           );
         } else if (
           selectionSet.selections.length === 0 &&
-          !context.experimentalEmptySelectionSets
+          !context.allowEmptySelectionSets
         ) {
           const fieldName = node.name.value;
           const typeStr = inspect(type);

src/validation/validate.ts

@@ -33,16 +33,14 @@ export interface ValidationOptions {
   /** Whether suggestion text should be omitted from validation errors. */
   hideSuggestions?: Maybe<boolean>;
   /**
-   * EXPERIMENTAL:
+   * If enabled (the default), a selection set on an object, interface or
+   * union type is only required to be present, rather than to be non-empty.
    *
-   * If enabled, a selection set on an object, interface or union type is only
-   * required to be present, rather than to be non-empty.
-   *
-   * Pair this with the `experimentalEmptySelectionSets` parse option.
+   * Pair this with the `allowEmptySelectionSets` parse option.
    *
    * See https://github.com/graphql/graphql-spec/pull/1227
    */
-  experimentalEmptySelectionSets?: boolean | undefined;
+  allowEmptySelectionSets?: boolean | undefined;
 }
 
 // Per the specification, descriptions must not affect validation.
@@ -148,8 +146,7 @@ function validateImpl(
 ): ReadonlyArray<GraphQLError> {
   const maxErrors = options?.maxErrors ?? 100;
   const hideSuggestions = options?.hideSuggestions ?? false;
-  const experimentalEmptySelectionSets =
-    options?.experimentalEmptySelectionSets ?? false;
+  const allowEmptySelectionSets = options?.allowEmptySelectionSets ?? true;
 
   // If the schema used for validation is invalid, throw an error.
   assertValidSchema(schema);
@@ -166,7 +163,7 @@ function validateImpl(
       }
       errors.push(error);
     },
-    { hideSuggestions, experimentalEmptySelectionSets },
+    { hideSuggestions, allowEmptySelectionSets },
   );
 
   // This uses a specialized visitor which runs multiple visitors in parallel,

website/pages/docs/experimental-specification-features.mdx

@@ -65,47 +65,3 @@ fragment spreads pass values for them. GraphQL.js exposes the syntax through the
 `FragmentArgumentNode`, and execution supports the resulting values.
 
 See [Fragment Arguments](/docs/fragment-arguments).
-
-## Empty selection sets
-
-Empty selection sets relax the grammar from `SelectionSet : { Selection+ }` to
-`SelectionSet : { Selection* }`, so a selection set on an object, interface, or
-union type only has to be present rather than non-empty. Leaf fields are
-unaffected: a scalar or enum field must still have no selection set at all, and
-`name { }` remains invalid.
-
-This helps clients that strip fields during query preprocessing. When every
-server-directed field of a selection set is handled locally (Apollo's `@client`,
-Relay Resolvers, and similar client-side extensions), what remains is an empty
-selection set, and the client no longer has to inject a placeholder field such
-as `__typename` or rewrite the enclosing selection away.
-
-GraphQL.js exposes the syntax through the `experimentalEmptySelectionSets`
-parser option and the matching `experimentalEmptySelectionSets` validation
-option; `graphql()` and `graphqlSync()` accept both from their single arguments
-object. Execution needs no flag — an empty selection set resolves to an empty
-object.
-
-```js
-import { graphql, buildSchema } from 'graphql';
-
-const schema = buildSchema(`
-  type Query {
-    viewer: Viewer
-  }
-
-  type Viewer {
-    id: ID
-  }
-`);
-
-const result = await graphql({
-  schema,
-  source: '{ viewer { } }',
-  rootValue: { viewer: { id: '1' } },
-  experimentalEmptySelectionSets: true,
-});
-// { data: { viewer: {} } }
-```
-
-See [the specification proposal](https://github.com/graphql/graphql-spec/pull/1227).