graphql 14.1.1 → 14.3.1

package/utilities/lexicographicSortSchema.js

@@ -7,6 +7,8 @@ exports.lexicographicSortSchema = lexicographicSortSchema;
 
 var _objectValues = _interopRequireDefault(require("../polyfills/objectValues"));
 
+var _inspect = _interopRequireDefault(require("../jsutils/inspect"));
+
 var _keyValMap = _interopRequireDefault(require("../jsutils/keyValMap"));
 
 var _schema = require("../type/schema");
@@ -15,8 +17,6 @@ var _directives = require("../type/directives");
 
 var _definition = require("../type/definition");
 
-var _scalars = require("../type/scalars");
-
 var _introspection = require("../type/introspection");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -29,163 +29,124 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
  * Sort GraphQLSchema.
  */
 function lexicographicSortSchema(schema) {
-  var cache = Object.create(null);
-
-  var sortMaybeType = function sortMaybeType(maybeType) {
-    return maybeType && sortNamedType(maybeType);
-  };
-
-  return new _schema.GraphQLSchema({
-    types: sortTypes((0, _objectValues.default)(schema.getTypeMap())),
-    directives: sortByName(schema.getDirectives()).map(sortDirective),
-    query: sortMaybeType(schema.getQueryType()),
-    mutation: sortMaybeType(schema.getMutationType()),
-    subscription: sortMaybeType(schema.getSubscriptionType()),
-    astNode: schema.astNode
-  });
+  var schemaConfig = schema.toConfig();
+  var typeMap = (0, _keyValMap.default)(sortByName(schemaConfig.types), function (type) {
+    return type.name;
+  }, sortNamedType);
+  return new _schema.GraphQLSchema(_objectSpread({}, schemaConfig, {
+    types: (0, _objectValues.default)(typeMap),
+    directives: sortByName(schemaConfig.directives).map(sortDirective),
+    query: replaceMaybeType(schemaConfig.query),
+    mutation: replaceMaybeType(schemaConfig.mutation),
+    subscription: replaceMaybeType(schemaConfig.subscription)
+  }));
+
+  function replaceType(type) {
+    if ((0, _definition.isListType)(type)) {
+      return new _definition.GraphQLList(replaceType(type.ofType));
+    } else if ((0, _definition.isNonNullType)(type)) {
+      return new _definition.GraphQLNonNull(replaceType(type.ofType));
+    }
+
+    return replaceNamedType(type);
+  }
+
+  function replaceNamedType(type) {
+    return typeMap[type.name];
+  }
+
+  function replaceMaybeType(maybeType) {
+    return maybeType && replaceNamedType(maybeType);
+  }
 
   function sortDirective(directive) {
-    return new _directives.GraphQLDirective({
-      name: directive.name,
-      description: directive.description,
-      locations: sortBy(directive.locations, function (x) {
+    var config = directive.toConfig();
+    return new _directives.GraphQLDirective(_objectSpread({}, config, {
+      locations: sortBy(config.locations, function (x) {
         return x;
       }),
-      args: sortArgs(directive.args),
-      astNode: directive.astNode
-    });
+      args: sortArgs(config.args)
+    }));
   }
 
   function sortArgs(args) {
-    return (0, _keyValMap.default)(sortByName(args), function (arg) {
-      return arg.name;
-    }, function (arg) {
+    return sortObjMap(args, function (arg) {
       return _objectSpread({}, arg, {
-        type: sortType(arg.type)
+        type: replaceType(arg.type)
       });
     });
   }
 
   function sortFields(fieldsMap) {
     return sortObjMap(fieldsMap, function (field) {
-      return {
-        type: sortType(field.type),
-        args: sortArgs(field.args),
-        resolve: field.resolve,
-        subscribe: field.subscribe,
-        deprecationReason: field.deprecationReason,
-        description: field.description,
-        astNode: field.astNode
-      };
+      return _objectSpread({}, field, {
+        type: replaceType(field.type),
+        args: sortArgs(field.args)
+      });
     });
   }
 
   function sortInputFields(fieldsMap) {
     return sortObjMap(fieldsMap, function (field) {
-      return {
-        type: sortType(field.type),
-        defaultValue: field.defaultValue,
-        description: field.description,
-        astNode: field.astNode
-      };
+      return _objectSpread({}, field, {
+        type: replaceType(field.type)
+      });
     });
   }
 
-  function sortType(type) {
-    if ((0, _definition.isListType)(type)) {
-      return new _definition.GraphQLList(sortType(type.ofType));
-    } else if ((0, _definition.isNonNullType)(type)) {
-      return new _definition.GraphQLNonNull(sortType(type.ofType));
-    }
-
-    return sortNamedType(type);
-  }
-
   function sortTypes(arr) {
-    return sortByName(arr).map(sortNamedType);
+    return sortByName(arr).map(replaceNamedType);
   }
 
   function sortNamedType(type) {
-    if ((0, _scalars.isSpecifiedScalarType)(type) || (0, _introspection.isIntrospectionType)(type)) {
-      return type;
-    }
-
-    var sortedType = cache[type.name];
-
-    if (!sortedType) {
-      sortedType = sortNamedTypeImpl(type);
-      cache[type.name] = sortedType;
-    }
-
-    return sortedType;
-  }
-
-  function sortNamedTypeImpl(type) {
-    if ((0, _definition.isScalarType)(type)) {
+    if ((0, _definition.isScalarType)(type) || (0, _introspection.isIntrospectionType)(type)) {
       return type;
     } else if ((0, _definition.isObjectType)(type)) {
-      return new _definition.GraphQLObjectType({
-        name: type.name,
+      var config = type.toConfig();
+      return new _definition.GraphQLObjectType(_objectSpread({}, config, {
         interfaces: function interfaces() {
-          return sortTypes(type.getInterfaces());
+          return sortTypes(config.interfaces);
         },
         fields: function fields() {
-          return sortFields(type.getFields());
-        },
-        isTypeOf: type.isTypeOf,
-        description: type.description,
-        astNode: type.astNode,
-        extensionASTNodes: type.extensionASTNodes
-      });
+          return sortFields(config.fields);
+        }
+      }));
     } else if ((0, _definition.isInterfaceType)(type)) {
-      return new _definition.GraphQLInterfaceType({
-        name: type.name,
+      var _config = type.toConfig();
+
+      return new _definition.GraphQLInterfaceType(_objectSpread({}, _config, {
         fields: function fields() {
-          return sortFields(type.getFields());
-        },
-        resolveType: type.resolveType,
-        description: type.description,
-        astNode: type.astNode,
-        extensionASTNodes: type.extensionASTNodes
-      });
+          return sortFields(_config.fields);
+        }
+      }));
     } else if ((0, _definition.isUnionType)(type)) {
-      return new _definition.GraphQLUnionType({
-        name: type.name,
+      var _config2 = type.toConfig();
+
+      return new _definition.GraphQLUnionType(_objectSpread({}, _config2, {
         types: function types() {
-          return sortTypes(type.getTypes());
-        },
-        resolveType: type.resolveType,
-        description: type.description,
-        astNode: type.astNode
-      });
+          return sortTypes(_config2.types);
+        }
+      }));
     } else if ((0, _definition.isEnumType)(type)) {
-      return new _definition.GraphQLEnumType({
-        name: type.name,
-        values: (0, _keyValMap.default)(sortByName(type.getValues()), function (val) {
-          return val.name;
-        }, function (val) {
-          return {
-            value: val.value,
-            deprecationReason: val.deprecationReason,
-            description: val.description,
-            astNode: val.astNode
-          };
-        }),
-        description: type.description,
-        astNode: type.astNode
-      });
+      var _config3 = type.toConfig();
+
+      return new _definition.GraphQLEnumType(_objectSpread({}, _config3, {
+        values: sortObjMap(_config3.values)
+      }));
     } else if ((0, _definition.isInputObjectType)(type)) {
-      return new _definition.GraphQLInputObjectType({
-        name: type.name,
+      var _config4 = type.toConfig();
+
+      return new _definition.GraphQLInputObjectType(_objectSpread({}, _config4, {
         fields: function fields() {
-          return sortInputFields(type.getFields());
-        },
-        description: type.description,
-        astNode: type.astNode
-      });
-    }
+          return sortInputFields(_config4.fields);
+        }
+      }));
+    } // Not reachable. All possible types have been considered.
+
+    /* istanbul ignore next */
 
-    throw new Error("Unknown type: \"".concat(type, "\""));
+
+    throw new Error("Unexpected type: \"".concat((0, _inspect.default)(type), "\"."));
   }
 }
 
@@ -195,8 +156,8 @@ function sortObjMap(map, sortValueFn) {
     return x;
   });
 
-  for (var _i = 0; _i < sortedKeys.length; _i++) {
-    var key = sortedKeys[_i];
+  for (var _i = 0, _sortedKeys = sortedKeys; _i < _sortedKeys.length; _i++) {
+    var key = _sortedKeys[_i];
     var value = map[key];
     sortedMap[key] = sortValueFn ? sortValueFn(value) : value;
   }
@@ -216,4 +177,4 @@ function sortBy(array, mapToKey) {
     var key2 = mapToKey(obj2);
     return key1.localeCompare(key2);
   });
-}
+}

package/utilities/lexicographicSortSchema.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2015-present, Facebook, Inc.
+ * Copyright (c) Facebook, Inc. and its affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -8,12 +8,13 @@
  */
 
 import objectValues from '../polyfills/objectValues';
-import type { ObjMap } from '../jsutils/ObjMap';
+import inspect from '../jsutils/inspect';
 import keyValMap from '../jsutils/keyValMap';
+import { type ObjMap } from '../jsutils/ObjMap';
 import { GraphQLSchema } from '../type/schema';
 import { GraphQLDirective } from '../type/directives';
-import type { GraphQLNamedType } from '../type/definition';
 import {
+  type GraphQLNamedType,
   GraphQLObjectType,
   GraphQLInterfaceType,
   GraphQLUnionType,
@@ -30,148 +31,119 @@ import {
   isEnumType,
   isInputObjectType,
 } from '../type/definition';
-import { isSpecifiedScalarType } from '../type/scalars';
 import { isIntrospectionType } from '../type/introspection';
 
 /**
  * Sort GraphQLSchema.
  */
 export function lexicographicSortSchema(schema: GraphQLSchema): GraphQLSchema {
-  const cache = Object.create(null);
+  const schemaConfig = schema.toConfig();
+  const typeMap = keyValMap(
+    sortByName(schemaConfig.types),
+    type => type.name,
+    sortNamedType,
+  );
 
-  const sortMaybeType = maybeType => maybeType && sortNamedType(maybeType);
   return new GraphQLSchema({
-    types: sortTypes(objectValues(schema.getTypeMap())),
-    directives: sortByName(schema.getDirectives()).map(sortDirective),
-    query: sortMaybeType(schema.getQueryType()),
-    mutation: sortMaybeType(schema.getMutationType()),
-    subscription: sortMaybeType(schema.getSubscriptionType()),
-    astNode: schema.astNode,
+    ...schemaConfig,
+    types: objectValues(typeMap),
+    directives: sortByName(schemaConfig.directives).map(sortDirective),
+    query: replaceMaybeType(schemaConfig.query),
+    mutation: replaceMaybeType(schemaConfig.mutation),
+    subscription: replaceMaybeType(schemaConfig.subscription),
   });
 
+  function replaceType(type) {
+    if (isListType(type)) {
+      return new GraphQLList(replaceType(type.ofType));
+    } else if (isNonNullType(type)) {
+      return new GraphQLNonNull(replaceType(type.ofType));
+    }
+    return replaceNamedType(type);
+  }
+
+  function replaceNamedType<T: GraphQLNamedType>(type: T): T {
+    return ((typeMap[type.name]: any): T);
+  }
+
+  function replaceMaybeType(maybeType) {
+    return maybeType && replaceNamedType(maybeType);
+  }
+
   function sortDirective(directive) {
+    const config = directive.toConfig();
     return new GraphQLDirective({
-      name: directive.name,
-      description: directive.description,
-      locations: sortBy(directive.locations, x => x),
-      args: sortArgs(directive.args),
-      astNode: directive.astNode,
+      ...config,
+      locations: sortBy(config.locations, x => x),
+      args: sortArgs(config.args),
     });
   }
 
   function sortArgs(args) {
-    return keyValMap(
-      sortByName(args),
-      arg => arg.name,
-      arg => ({
-        ...arg,
-        type: sortType(arg.type),
-      }),
-    );
+    return sortObjMap(args, arg => ({
+      ...arg,
+      type: replaceType(arg.type),
+    }));
   }
 
   function sortFields(fieldsMap) {
     return sortObjMap(fieldsMap, field => ({
-      type: sortType(field.type),
+      ...field,
+      type: replaceType(field.type),
       args: sortArgs(field.args),
-      resolve: field.resolve,
-      subscribe: field.subscribe,
-      deprecationReason: field.deprecationReason,
-      description: field.description,
-      astNode: field.astNode,
     }));
   }
 
   function sortInputFields(fieldsMap) {
     return sortObjMap(fieldsMap, field => ({
-      type: sortType(field.type),
-      defaultValue: field.defaultValue,
-      description: field.description,
-      astNode: field.astNode,
+      ...field,
+      type: replaceType(field.type),
     }));
   }
 
-  function sortType(type) {
-    if (isListType(type)) {
-      return new GraphQLList(sortType(type.ofType));
-    } else if (isNonNullType(type)) {
-      return new GraphQLNonNull(sortType(type.ofType));
-    }
-    return sortNamedType(type);
-  }
-
   function sortTypes<T: GraphQLNamedType>(arr: Array<T>): Array<T> {
-    return sortByName(arr).map(sortNamedType);
+    return sortByName(arr).map(replaceNamedType);
   }
 
-  function sortNamedType<T: GraphQLNamedType>(type: T): T {
-    if (isSpecifiedScalarType(type) || isIntrospectionType(type)) {
-      return type;
-    }
-
-    let sortedType = cache[type.name];
-    if (!sortedType) {
-      sortedType = sortNamedTypeImpl(type);
-      cache[type.name] = sortedType;
-    }
-    return ((sortedType: any): T);
-  }
-
-  function sortNamedTypeImpl(type) {
-    if (isScalarType(type)) {
+  function sortNamedType(type) {
+    if (isScalarType(type) || isIntrospectionType(type)) {
       return type;
     } else if (isObjectType(type)) {
+      const config = type.toConfig();
       return new GraphQLObjectType({
-        name: type.name,
-        interfaces: () => sortTypes(type.getInterfaces()),
-        fields: () => sortFields(type.getFields()),
-        isTypeOf: type.isTypeOf,
-        description: type.description,
-        astNode: type.astNode,
-        extensionASTNodes: type.extensionASTNodes,
+        ...config,
+        interfaces: () => sortTypes(config.interfaces),
+        fields: () => sortFields(config.fields),
       });
     } else if (isInterfaceType(type)) {
+      const config = type.toConfig();
       return new GraphQLInterfaceType({
-        name: type.name,
-        fields: () => sortFields(type.getFields()),
-        resolveType: type.resolveType,
-        description: type.description,
-        astNode: type.astNode,
-        extensionASTNodes: type.extensionASTNodes,
+        ...config,
+        fields: () => sortFields(config.fields),
       });
     } else if (isUnionType(type)) {
+      const config = type.toConfig();
       return new GraphQLUnionType({
-        name: type.name,
-        types: () => sortTypes(type.getTypes()),
-        resolveType: type.resolveType,
-        description: type.description,
-        astNode: type.astNode,
+        ...config,
+        types: () => sortTypes(config.types),
       });
     } else if (isEnumType(type)) {
+      const config = type.toConfig();
       return new GraphQLEnumType({
-        name: type.name,
-        values: keyValMap(
-          sortByName(type.getValues()),
-          val => val.name,
-          val => ({
-            value: val.value,
-            deprecationReason: val.deprecationReason,
-            description: val.description,
-            astNode: val.astNode,
-          }),
-        ),
-        description: type.description,
-        astNode: type.astNode,
+        ...config,
+        values: sortObjMap(config.values),
       });
     } else if (isInputObjectType(type)) {
+      const config = type.toConfig();
       return new GraphQLInputObjectType({
-        name: type.name,
-        fields: () => sortInputFields(type.getFields()),
-        description: type.description,
-        astNode: type.astNode,
+        ...config,
+        fields: () => sortInputFields(config.fields),
       });
     }
-    throw new Error(`Unknown type: "${type}"`);
+
+    // Not reachable. All possible types have been considered.
+    /* istanbul ignore next */
+    throw new Error(`Unexpected type: "${inspect((type: empty))}".`);
   }
 }