buildSchema: optimise perfomance by extracting 'extendSchemaImpl'

Author: IvanGoncharov

src/type/schema.js

@@ -270,14 +270,7 @@ export class GraphQLSchema {
     return find(this.getDirectives(), directive => directive.name === name);
   }
 
-  toConfig(): {|
-    ...GraphQLSchemaConfig,
-    types: Array<GraphQLNamedType>,
-    directives: Array<GraphQLDirective>,
-    extensions: ?ReadOnlyObjMap<mixed>,
-    extensionASTNodes: ?$ReadOnlyArray<SchemaExtensionNode>,
-    assumeValid: boolean,
-  |} {
+  toConfig(): GraphQLSchemaNormalizedConfig {
     return {
       query: this.getQueryType(),
       mutation: this.getMutationType(),
@@ -325,6 +318,18 @@ export type GraphQLSchemaConfig = {|
   ...GraphQLSchemaValidationOptions,
 |};
 
+/**
+ * @internal
+ */
+export type GraphQLSchemaNormalizedConfig = {|
+  ...GraphQLSchemaConfig,
+  types: Array<GraphQLNamedType>,
+  directives: Array<GraphQLDirective>,
+  extensions: ?ReadOnlyObjMap<mixed>,
+  extensionASTNodes: ?$ReadOnlyArray<SchemaExtensionNode>,
+  assumeValid: boolean,
+|};
+
 function collectImplementations(
   types: $ReadOnlyArray<GraphQLNamedType>,
 ): ObjMap<InterfaceImplementations> {

src/utilities/buildASTSchema.js

@@ -19,7 +19,7 @@ import {
   GraphQLDeprecatedDirective,
 } from '../type/directives';
 
-import { extendSchema } from './extendSchema';
+import { extendSchemaImpl } from './extendSchema';
 
 export type BuildSchemaOptions = {|
   ...GraphQLSchemaValidationOptions,
@@ -71,20 +71,28 @@ export function buildASTSchema(
     assertValidSDL(documentAST);
   }
 
-  const emptySchema = new GraphQLSchema({ directives: [] });
-  const extendedSchema = extendSchema(emptySchema, documentAST, {
+  const config = extendSchemaImpl(emptySchemaConfig, documentAST, {
     ...options,
     assumeValidSDL: true,
   });
 
-  const config = extendedSchema.toConfig();
-  if (extendedSchema.astNode == null) {
-    // Note: While this could make early assertions to get the correctly
-    // typed values below, that would throw immediately while type system
-    // validation with validateSchema() will produce more actionable results.
-    config.query = (extendedSchema.getType('Query'): any);
-    config.mutation = (extendedSchema.getType('Mutation'): any);
-    config.subscription = (extendedSchema.getType('Subscription'): any);
+  if (config.astNode == null) {
+    for (const type of config.types) {
+      switch (type.name) {
+        // Note: While this could make early assertions to get the correctly
+        // typed values below, that would throw immediately while type system
+        // validation with validateSchema() will produce more actionable results.
+        case 'Query':
+          config.query = (type: any);
+          break;
+        case 'Mutation':
+          config.mutation = (type: any);
+          break;
+        case 'Subscription':
+          config.subscription = (type: any);
+          break;
+      }
+    }
   }
 
   const { directives } = config;
@@ -101,10 +109,11 @@ export function buildASTSchema(
     directives.push(GraphQLDeprecatedDirective);
   }
 
-  config.assumeValid = (options && options.assumeValid) || false;
   return new GraphQLSchema(config);
 }
 
+const emptySchemaConfig = new GraphQLSchema({ directives: [] }).toConfig();
+
 /**
  * A helper function to build a GraphQLSchema directly from a source
  * document.

src/utilities/extendSchema.js

@@ -57,6 +57,7 @@ import {
   type GraphQLSchemaValidationOptions,
   assertSchema,
   GraphQLSchema,
+  type GraphQLSchemaNormalizedConfig,
 } from '../type/schema';
 import {
   type GraphQLType,
@@ -140,6 +141,18 @@ export function extendSchema(
     assertValidSDLExtension(documentAST, schema);
   }
 
+  const schemaConfig = schema.toConfig();
+  const extendedConfig = extendSchemaImpl(schemaConfig, documentAST, options);
+  return schemaConfig === extendedConfig
+    ? schema
+    : new GraphQLSchema(extendedConfig);
+}
+
+export function extendSchemaImpl(
+  schemaConfig: GraphQLSchemaNormalizedConfig,
+  documentAST: DocumentNode,
+  options?: Options,
+): GraphQLSchemaNormalizedConfig {
   // Collect the type definitions and extensions found in the document.
   const typeDefs = [];
   const typeExtensionsMap = Object.create(null);
@@ -179,7 +192,7 @@ export function extendSchema(
     schemaExtensions.length === 0 &&
     !schemaDef
   ) {
-    return schema;
+    return schemaConfig;
   }
 
   const astBuilder = new ASTDefinitionBuilder(options, typeName => {
@@ -191,7 +204,6 @@ export function extendSchema(
   });
 
   const typeMap = astBuilder.buildTypeMap(typeDefs, typeExtensionsMap);
-  const schemaConfig = schema.toConfig();
   for (const existingType of schemaConfig.types) {
     typeMap[existingType.name] = extendNamedType(existingType);
   }
@@ -208,19 +220,21 @@ export function extendSchema(
   };
 
   // Then produce and return a Schema with these types.
-  return new GraphQLSchema({
+  return {
     ...operationTypes,
     types: objectValues(typeMap),
     directives: [
       ...schemaConfig.directives.map(replaceDirective),
       ...astBuilder.buildDirectives(directiveDefs),
     ],
+    extensions: Object.create(null),
     astNode: schemaDef || schemaConfig.astNode,
     extensionASTNodes: concatMaybeArrays(
       schemaConfig.extensionASTNodes,
       schemaExtensions,
     ),
-  });
+    assumeValid: (options && options.assumeValid) || false,
+  };
 
   // Below are functions used for producing this schema that have closed over
   // this scope and have access to the schema, cache, and newly defined types.