Add SDL validation rule to validate schema uniques

Author: IvanGoncharov

src/utilities/buildASTSchema.js

@@ -11,6 +11,7 @@ import keyMap from '../jsutils/keyMap';
 import keyValMap from '../jsutils/keyValMap';
 import type { ObjMap } from '../jsutils/ObjMap';
 import { valueFromAST } from './valueFromAST';
+import { assertValidSDL } from '../validation/validate';
 import blockStringValue from '../language/blockStringValue';
 import { TokenKind } from '../language/lexer';
 import { parse } from '../language/parser';
@@ -86,6 +87,13 @@ export type BuildSchemaOptions = {
    * Default: false
    */
   commentDescriptions?: boolean,
+
+  /**
+   * Set to true to assume the SDL is valid.
+   *
+   * Default: false
+   */
+  assumeValidSDL?: boolean,
 };
 
 /**
@@ -112,6 +120,10 @@ export function buildASTSchema(
     throw new Error('Must provide a document ast.');
   }
 
+  if (!options || !options.assumeValidSDL) {
+    assertValidSDL(ast);
+  }
+
   let schemaDef: ?SchemaDefinitionNode;
 
   const typeDefs: Array<TypeDefinitionNode> = [];
@@ -121,9 +133,6 @@ export function buildASTSchema(
     const d = ast.definitions[i];
     switch (d.kind) {
       case Kind.SCHEMA_DEFINITION:
-        if (schemaDef) {
-          throw new Error('Must provide only one schema definition.');
-        }
         schemaDef = d;
         break;
       case Kind.SCALAR_TYPE_DEFINITION:

src/utilities/extendSchema.js

@@ -12,6 +12,7 @@ import keyMap from '../jsutils/keyMap';
 import keyValMap from '../jsutils/keyValMap';
 import objectValues from '../jsutils/objectValues';
 import { ASTDefinitionBuilder } from './buildASTSchema';
+import { assertValidSDLExtension } from '../validation/validate';
 import { GraphQLError } from '../error/GraphQLError';
 import { isSchema, GraphQLSchema } from '../type/schema';
 import { isIntrospectionType } from '../type/introspection';
@@ -67,6 +68,13 @@ type Options = {|
    * Default: false
    */
   commentDescriptions?: boolean,
+
+  /**
+   * Set to true to assume the SDL is valid.
+   *
+   * Default: false
+   */
+  assumeValidSDL?: boolean,
 |};
 
 /**
@@ -99,6 +107,10 @@ export function extendSchema(
     'Must provide valid Document AST',
   );
 
+  if (!options || !options.assumeValidSDL) {
+    assertValidSDLExtension(documentAST, schema);
+  }
+
   // Collect the type definitions and extensions found in the document.
   const typeDefinitionMap = Object.create(null);
   const typeExtensionsMap = Object.create(null);
@@ -115,18 +127,6 @@ export function extendSchema(
     const def = documentAST.definitions[i];
     switch (def.kind) {
       case Kind.SCHEMA_DEFINITION:
-        // Sanity check that a schema extension is not overriding the schema
-        if (
-          schema.astNode ||
-          schema.getQueryType() ||
-          schema.getMutationType() ||
-          schema.getSubscriptionType()
-        ) {
-          throw new GraphQLError(
-            'Cannot define a new schema within a schema extension.',
-            [def],
-          );
-        }
         schemaDef = def;
         break;
       case Kind.SCHEMA_EXTENSION:

src/validation/ValidationContext.js

@@ -19,6 +19,7 @@ import type {
   FragmentSpreadNode,
   FragmentDefinitionNode,
 } from '../language/ast';
+import type { ASTVisitor } from '../language/visitor';
 import type { GraphQLSchema } from '../type/schema';
 import type {
   GraphQLInputType,
@@ -64,6 +65,21 @@ export class ASTValidationContext {
   }
 }
 
+export class SDLValidationContext extends ASTValidationContext {
+  _schema: ?GraphQLSchema;
+
+  constructor(ast: DocumentNode, schema?: ?GraphQLSchema): void {
+    super(ast);
+    this._schema = schema;
+  }
+
+  getSchema(): ?GraphQLSchema {
+    return this._schema;
+  }
+}
+
+export type SDLValidationRule = SDLValidationContext => ASTVisitor;
+
 export class ValidationContext extends ASTValidationContext {
   _schema: GraphQLSchema;
   _typeInfo: TypeInfo;
@@ -234,3 +250,5 @@ export class ValidationContext extends ASTValidationContext {
     return this._typeInfo.getArgument();
   }
 }
+
+export type ValidationRule = ValidationContext => ASTVisitor;

src/validation/rules/LoneSchemaDefinition.js

@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) 2018-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ */
+
+import type { SDLValidationContext } from '../ValidationContext';
+import { GraphQLError } from '../../error';
+import type { ASTVisitor } from '../../language/visitor';
+
+export function schemaDefinitionNotAloneMessage(): string {
+  return 'Must provide only one schema definition.';
+}
+
+export function canNotDefineSchemaWithinExtension(): string {
+  return 'Cannot define a new schema within a schema extension.';
+}
+
+/**
+ * Lone Schema definition
+ *
+ * A GraphQL document is only valid if it contains only one schema definition.
+ */
+export function LoneSchemaDefinition(
+  context: SDLValidationContext,
+): ASTVisitor {
+  const oldSchema = context.getSchema();
+  const alreadyDefined =
+    oldSchema &&
+    (oldSchema.astNode ||
+      oldSchema.getQueryType() ||
+      oldSchema.getMutationType() ||
+      oldSchema.getSubscriptionType());
+
+  const schemaNodes = [];
+  return {
+    SchemaDefinition(node) {
+      if (alreadyDefined) {
+        context.reportError(
+          new GraphQLError(canNotDefineSchemaWithinExtension(), [node]),
+        );
+        return;
+      }
+      schemaNodes.push(node);
+    },
+    Document: {
+      leave() {
+        if (schemaNodes.length > 1) {
+          context.reportError(
+            new GraphQLError(schemaDefinitionNotAloneMessage(), schemaNodes),
+          );
+        }
+      },
+    },
+  };
+}

src/validation/specifiedRules.js

@@ -7,8 +7,7 @@
  * @flow strict
  */
 
-import type { ASTVisitor } from '../language/visitor';
-import type { ValidationContext } from './ValidationContext';
+import type { ValidationRule, SDLValidationRule } from './ValidationContext';
 
 // Spec Section: "Executable Definitions"
 import { ExecutableDefinitions } from './rules/ExecutableDefinitions';
@@ -94,7 +93,7 @@ import { UniqueInputFieldNames } from './rules/UniqueInputFieldNames';
  * The order of the rules in this list has been adjusted to lead to the
  * most clear output when encountering multiple validation errors.
  */
-export const specifiedRules: Array<(ValidationContext) => ASTVisitor> = [
+export const specifiedRules: $ReadOnlyArray<ValidationRule> = [
   ExecutableDefinitions,
   UniqueOperationNames,
   LoneAnonymousOperation,
@@ -122,3 +121,10 @@ export const specifiedRules: Array<(ValidationContext) => ASTVisitor> = [
   OverlappingFieldsCanBeMerged,
   UniqueInputFieldNames,
 ];
+
+import { LoneSchemaDefinition } from './rules/LoneSchemaDefinition';
+
+// @internal
+export const specifiedSDLRules: $ReadOnlyArray<SDLValidationRule> = [
+  LoneSchemaDefinition,
+];

src/validation/validate.js

@@ -9,14 +9,14 @@
 
 import invariant from '../jsutils/invariant';
 import type { GraphQLError } from '../error';
-import type { ASTVisitor } from '../language/visitor';
 import { visit, visitInParallel, visitWithTypeInfo } from '../language/visitor';
 import type { DocumentNode } from '../language/ast';
 import type { GraphQLSchema } from '../type/schema';
 import { assertValidSchema } from '../type/validate';
 import { TypeInfo } from '../utilities/TypeInfo';
-import { specifiedRules } from './specifiedRules';
-import { ValidationContext } from './ValidationContext';
+import { specifiedRules, specifiedSDLRules } from './specifiedRules';
+import type { SDLValidationRule, ValidationRule } from './ValidationContext';
+import { SDLValidationContext, ValidationContext } from './ValidationContext';
 
 /**
  * Implements the "Validation" section of the spec.
@@ -37,7 +37,7 @@ import { ValidationContext } from './ValidationContext';
 export function validate(
   schema: GraphQLSchema,
   documentAST: DocumentNode,
-  rules?: $ReadOnlyArray<(ValidationContext) => ASTVisitor> = specifiedRules,
+  rules?: $ReadOnlyArray<ValidationRule> = specifiedRules,
   typeInfo?: TypeInfo = new TypeInfo(schema),
 ): $ReadOnlyArray<GraphQLError> {
   invariant(documentAST, 'Must provide document');
@@ -52,3 +52,44 @@ export function validate(
   visit(documentAST, visitWithTypeInfo(typeInfo, visitor));
   return context.getErrors();
 }
+
+// @internal
+export function validateSDL(
+  documentAST: DocumentNode,
+  schemaToExtend?: ?GraphQLSchema,
+  rules?: $ReadOnlyArray<SDLValidationRule> = specifiedSDLRules,
+): $ReadOnlyArray<GraphQLError> {
+  const context = new SDLValidationContext(documentAST, schemaToExtend);
+  const visitors = rules.map(rule => rule(context));
+  visit(documentAST, visitInParallel(visitors));
+  return context.getErrors();
+}
+
+/**
+ * Utility function which asserts a SDL document is valid by throwing an error
+ * if it is invalid.
+ *
+ * @internal
+ */
+export function assertValidSDL(documentAST: DocumentNode): void {
+  const errors = validateSDL(documentAST);
+  if (errors.length !== 0) {
+    throw new Error(errors.map(error => error.message).join('\n\n'));
+  }
+}
+
+/**
+ * Utility function which asserts a SDL document is valid by throwing an error
+ * if it is invalid.
+ *
+ * @internal
+ */
+export function assertValidSDLExtension(
+  documentAST: DocumentNode,
+  schema: GraphQLSchema,
+): void {
+  const errors = validateSDL(documentAST, schema);
+  if (errors.length !== 0) {
+    throw new Error(errors.map(error => error.message).join('\n\n'));
+  }
+}