Allow empty selection sets

Author: martinbonnin

src/execution/__tests__/executor-test.ts

@@ -223,6 +223,27 @@ describe('Execute: Handles basic execution tasks', () => {
     });
   });
 
+  it('executes empty selection sets', () => {
+    const Type: GraphQLObjectType = new GraphQLObjectType({
+      name: 'Type',
+      fields: () => ({
+        a: { type: GraphQLString, resolve: () => 'Apple' },
+        deep: { type: Type, resolve: () => ({}) },
+      }),
+    });
+    const schema = new GraphQLSchema({ query: Type });
+
+    const document = parse('{ a deep { } ...Frag } fragment Frag on Type { }');
+
+    const result = executeSync({ schema, document });
+    expect(result).to.deep.equal({ data: { a: 'Apple', deep: {} } });
+
+    const emptyDocument = parse('{ }');
+    expect(executeSync({ schema, document: emptyDocument })).to.deep.equal({
+      data: {},
+    });
+  });
+
   it('provides info about current execution state', async () => {
     // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
     const { promise, resolve } = promiseWithResolvers<void>();

src/language/__tests__/parser-test.ts

@@ -12,6 +12,10 @@ import { kitchenSinkQuery } from '../../__testUtils__/kitchenSinkQuery.ts';
 
 import { inspect } from '../../jsutils/inspect.ts';
 
+import type {
+  FragmentDefinitionNode,
+  OperationDefinitionNode,
+} from '../ast.ts';
 import { Kind } from '../kinds.ts';
 import {
   parse,
@@ -502,6 +506,60 @@ describe('Parser', () => {
     expect(() => parse(document)).to.throw();
   });
 
+  it('allows parsing empty selection sets', () => {
+    const document = parse('{ node { } }', {
+      noLocation: true,
+    });
+
+    expectJSON(document).toDeepEqual({
+      kind: Kind.DOCUMENT,
+      definitions: [
+        {
+          kind: Kind.OPERATION_DEFINITION,
+          description: undefined,
+          operation: 'query',
+          name: undefined,
+          variableDefinitions: undefined,
+          directives: undefined,
+          selectionSet: {
+            kind: Kind.SELECTION_SET,
+            selections: [
+              {
+                kind: Kind.FIELD,
+                alias: undefined,
+                name: { kind: Kind.NAME, value: 'node' },
+                arguments: undefined,
+                directives: undefined,
+                selectionSet: {
+                  kind: Kind.SELECTION_SET,
+                  selections: [],
+                },
+              },
+            ],
+          },
+        },
+      ],
+    });
+  });
+
+  it('allows parsing an empty operation selection set', () => {
+    const document = parse('{ }', {
+      noLocation: true,
+    });
+    const operation = document.definitions[0] as OperationDefinitionNode;
+
+    expect(operation.selectionSet.selections).to.deep.equal([]);
+  });
+
+  it('allows parsing an empty fragment selection set', () => {
+    const document = parse('fragment a on t { }', {
+      noLocation: true,
+    });
+    const fragment = document.definitions[0] as FragmentDefinitionNode;
+
+    expect(fragment.selectionSet.selections).to.deep.equal([]);
+  });
+
   it('contains location that can be Object.toStringified, JSON.stringified, or jsutils.inspected', () => {
     const { loc } = parse('{ id }');
 

src/language/__tests__/printer-test.ts

@@ -18,6 +18,21 @@ describe('Printer: Query document', () => {
     expect(print(ast)).to.equal('foo');
   });
 
+  it('prints empty selection sets', () => {
+    const ast = parse('{ foo { } bar { ... on Baz { } } }');
+    expect(print(ast)).to.equal(dedent`
+      {
+        foo {}
+        bar {
+          ... on Baz {}
+        }
+      }
+    `);
+
+    const emptyOperationAST = parse('{ }');
+    expect(print(emptyOperationAST)).to.equal('{}');
+  });
+
   it('produces helpful error messages', () => {
     const badAST = { random: 'Data' };
 

src/language/parser.ts

@@ -575,15 +575,15 @@ export class Parser {
 
   /**
    * ```
-   * SelectionSet : { Selection+ }
+   * SelectionSet : { Selection* }
    * ```
    *
    * @internal
    */
   parseSelectionSet(): SelectionSetNode {
     return this.node<SelectionSetNode>(this._lexer.token, {
       kind: Kind.SELECTION_SET,
-      selections: this.many(
+      selections: this.any(
         TokenKind.BRACE_L,
         this.parseSelection,
         TokenKind.BRACE_R,

src/language/printer.ts

@@ -70,7 +70,10 @@ const printDocASTReducer: ASTReducer<string> = {
       wrap(' = ', defaultValue) +
       wrap(' ', join(directives, ' ')),
   },
-  SelectionSet: { leave: ({ selections }) => block(selections) },
+  SelectionSet: {
+    leave: ({ selections }) =>
+      selections.length === 0 ? '{}' : block(selections),
+  },
 
   Field: {
     leave({ alias, name, arguments: args, directives, selectionSet }) {

src/validation/__tests__/ScalarLeafsRule-test.ts

@@ -2,9 +2,7 @@ import { describe, it } from 'node:test';
 
 import { expectJSON } from '../../__testUtils__/expectJSON.ts';
 
-import type { DocumentNode } from '../../language/ast.ts';
-import { OperationTypeNode } from '../../language/ast.ts';
-import { Kind } from '../../language/kinds.ts';
+import { parse } from '../../language/parser.ts';
 
 import { ScalarLeafsRule } from '../rules/ScalarLeafsRule.ts';
 import { validate } from '../validate.ts';
@@ -42,35 +40,22 @@ 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.
+  it('object type having no selections is allowed', () => {
+    const doc = parse('{ human { } }');
+
+    const errors = validate(testSchema, doc, [ScalarLeafsRule]);
+    expectJSON(errors).toDeepEqual([]);
+  });
+
+  it('scalar selection is still rejected with an empty selection set', () => {
+    const doc = parse('{ human { name { } } }');
+
     const errors = validate(testSchema, doc, [ScalarLeafsRule]);
     expectJSON(errors).toDeepEqual([
       {
         message:
-          'Field "human" of type "Human" must have at least one field selected.',
+          'Field "name" must not have a selection since type "String" has no subfields.',
+        locations: [{ line: 1, column: 16 }],
       },
     ]);
   });
@@ -166,37 +151,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

@@ -70,15 +70,6 @@ export function ScalarLeafsRule(context: ValidationContext): ASTVisitor {
               { nodes: node },
             ),
           );
-        } else if (selectionSet.selections.length === 0) {
-          const fieldName = node.name.value;
-          const typeStr = inspect(type);
-          context.reportError(
-            new GraphQLError(
-              `Field "${fieldName}" of type "${typeStr}" must have at least one field selected.`,
-              { nodes: node },
-            ),
-          );
         }
       }
     },