graphql 14.1.1 → 14.3.1

package/utilities/lexicographicSortSchema.mjs

@@ -3,7 +3,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 /**
- * 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.
@@ -11,174 +11,135 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
  * 
  */
 import objectValues from '../polyfills/objectValues';
+import inspect from '../jsutils/inspect';
 import keyValMap from '../jsutils/keyValMap';
 import { GraphQLSchema } from '../type/schema';
 import { GraphQLDirective } from '../type/directives';
 import { GraphQLObjectType, GraphQLInterfaceType, GraphQLUnionType, GraphQLEnumType, GraphQLInputObjectType, GraphQLList, GraphQLNonNull, isListType, isNonNullType, isScalarType, isObjectType, isInterfaceType, isUnionType, isEnumType, isInputObjectType } from '../type/definition';
-import { isSpecifiedScalarType } from '../type/scalars';
 import { isIntrospectionType } from '../type/introspection';
 /**
  * Sort GraphQLSchema.
  */
 
 export function lexicographicSortSchema(schema) {
-  var cache = Object.create(null);
-
-  var sortMaybeType = function sortMaybeType(maybeType) {
-    return 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
-  });
+  var schemaConfig = schema.toConfig();
+  var typeMap = keyValMap(sortByName(schemaConfig.types), function (type) {
+    return type.name;
+  }, sortNamedType);
+  return new GraphQLSchema(_objectSpread({}, 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(type) {
+    return typeMap[type.name];
+  }
+
+  function replaceMaybeType(maybeType) {
+    return maybeType && replaceNamedType(maybeType);
+  }
 
   function sortDirective(directive) {
-    return new GraphQLDirective({
-      name: directive.name,
-      description: directive.description,
-      locations: sortBy(directive.locations, function (x) {
+    var config = directive.toConfig();
+    return new 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 keyValMap(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 (isListType(type)) {
-      return new GraphQLList(sortType(type.ofType));
-    } else if (isNonNullType(type)) {
-      return new GraphQLNonNull(sortType(type.ofType));
-    }
-
-    return sortNamedType(type);
-  }
-
   function sortTypes(arr) {
-    return sortByName(arr).map(sortNamedType);
+    return sortByName(arr).map(replaceNamedType);
   }
 
   function sortNamedType(type) {
-    if (isSpecifiedScalarType(type) || isIntrospectionType(type)) {
-      return type;
-    }
-
-    var sortedType = cache[type.name];
-
-    if (!sortedType) {
-      sortedType = sortNamedTypeImpl(type);
-      cache[type.name] = sortedType;
-    }
-
-    return sortedType;
-  }
-
-  function sortNamedTypeImpl(type) {
-    if (isScalarType(type)) {
+    if (isScalarType(type) || isIntrospectionType(type)) {
       return type;
     } else if (isObjectType(type)) {
-      return new GraphQLObjectType({
-        name: type.name,
+      var config = type.toConfig();
+      return new 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 (isInterfaceType(type)) {
-      return new GraphQLInterfaceType({
-        name: type.name,
+      var _config = type.toConfig();
+
+      return new 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 (isUnionType(type)) {
-      return new GraphQLUnionType({
-        name: type.name,
+      var _config2 = type.toConfig();
+
+      return new 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 (isEnumType(type)) {
-      return new GraphQLEnumType({
-        name: type.name,
-        values: keyValMap(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 GraphQLEnumType(_objectSpread({}, _config3, {
+        values: sortObjMap(_config3.values)
+      }));
     } else if (isInputObjectType(type)) {
-      return new GraphQLInputObjectType({
-        name: type.name,
+      var _config4 = type.toConfig();
+
+      return new 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(inspect(type), "\"."));
   }
 }
 
@@ -188,8 +149,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;
   }
@@ -209,4 +170,4 @@ function sortBy(array, mapToKey) {
     var key2 = mapToKey(obj2);
     return key1.localeCompare(key2);
   });
-}
+}

package/utilities/schemaPrinter.js

@@ -7,16 +7,18 @@ exports.printSchema = printSchema;
 exports.printIntrospectionSchema = printIntrospectionSchema;
 exports.printType = printType;
 
-var _objectValues = _interopRequireDefault(require("../polyfills/objectValues"));
+var _flatMap = _interopRequireDefault(require("../polyfills/flatMap"));
 
-var _isNullish = _interopRequireDefault(require("../jsutils/isNullish"));
+var _objectValues = _interopRequireDefault(require("../polyfills/objectValues"));
 
-var _isInvalid = _interopRequireDefault(require("../jsutils/isInvalid"));
+var _inspect = _interopRequireDefault(require("../jsutils/inspect"));
 
 var _astFromValue = require("../utilities/astFromValue");
 
 var _printer = require("../language/printer");
 
+var _blockString = require("../language/blockString");
+
 var _definition = require("../type/definition");
 
 var _scalars = require("../type/scalars");
@@ -28,7 +30,7 @@ var _introspection = require("../type/introspection");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /**
- * 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.
@@ -145,11 +147,12 @@ function printType(type, options) {
     return printEnum(type, options);
   } else if ((0, _definition.isInputObjectType)(type)) {
     return printInputObject(type, options);
-  }
+  } // 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), "\"."));
 }
 
 function printScalar(type, options) {
@@ -161,39 +164,42 @@ function printObject(type, options) {
   var implementedInterfaces = interfaces.length ? ' implements ' + interfaces.map(function (i) {
     return i.name;
   }).join(' & ') : '';
-  return printDescription(options, type) + "type ".concat(type.name).concat(implementedInterfaces, " {\n") + printFields(options, type) + '\n' + '}';
+  return printDescription(options, type) + "type ".concat(type.name).concat(implementedInterfaces) + printFields(options, type);
 }
 
 function printInterface(type, options) {
-  return printDescription(options, type) + "interface ".concat(type.name, " {\n") + printFields(options, type) + '\n' + '}';
+  return printDescription(options, type) + "interface ".concat(type.name) + printFields(options, type);
 }
 
 function printUnion(type, options) {
-  return printDescription(options, type) + "union ".concat(type.name, " = ").concat(type.getTypes().join(' | '));
+  var types = type.getTypes();
+  var possibleTypes = types.length ? ' = ' + types.join(' | ') : '';
+  return printDescription(options, type) + 'union ' + type.name + possibleTypes;
 }
 
 function printEnum(type, options) {
-  return printDescription(options, type) + "enum ".concat(type.name, " {\n") + printEnumValues(type.getValues(), options) + '\n' + '}';
-}
-
-function printEnumValues(values, options) {
-  return values.map(function (value, i) {
+  var values = type.getValues().map(function (value, i) {
     return printDescription(options, value, '  ', !i) + '  ' + value.name + printDeprecated(value);
-  }).join('\n');
+  });
+  return printDescription(options, type) + "enum ".concat(type.name) + printBlock(values);
 }
 
 function printInputObject(type, options) {
-  var fields = (0, _objectValues.default)(type.getFields());
-  return printDescription(options, type) + "input ".concat(type.name, " {\n") + fields.map(function (f, i) {
+  var fields = (0, _objectValues.default)(type.getFields()).map(function (f, i) {
     return printDescription(options, f, '  ', !i) + '  ' + printInputValue(f);
-  }).join('\n') + '\n' + '}';
+  });
+  return printDescription(options, type) + "input ".concat(type.name) + printBlock(fields);
 }
 
 function printFields(options, type) {
-  var fields = (0, _objectValues.default)(type.getFields());
-  return fields.map(function (f, i) {
+  var fields = (0, _objectValues.default)(type.getFields()).map(function (f, i) {
     return printDescription(options, f, '  ', !i) + '  ' + f.name + printArgs(options, f.args, '  ') + ': ' + String(f.type) + printDeprecated(f);
-  }).join('\n');
+  });
+  return printBlock(fields);
+}
+
+function printBlock(items) {
+  return items.length !== 0 ? ' {\n' + items.join('\n') + '\n}' : '';
 }
 
 function printArgs(options, args) {
@@ -216,10 +222,11 @@ function printArgs(options, args) {
 }
 
 function printInputValue(arg) {
+  var defaultAST = (0, _astFromValue.astFromValue)(arg.defaultValue, arg.type);
   var argDecl = arg.name + ': ' + String(arg.type);
 
-  if (!(0, _isInvalid.default)(arg.defaultValue)) {
-    argDecl += " = ".concat((0, _printer.print)((0, _astFromValue.astFromValue)(arg.defaultValue, arg.type)));
+  if (defaultAST) {
+    argDecl += " = ".concat((0, _printer.print)(defaultAST));
   }
 
   return argDecl;
@@ -235,12 +242,13 @@ function printDeprecated(fieldOrEnumVal) {
   }
 
   var reason = fieldOrEnumVal.deprecationReason;
+  var reasonAST = (0, _astFromValue.astFromValue)(reason, _scalars.GraphQLString);
 
-  if ((0, _isNullish.default)(reason) || reason === '' || reason === _directives.DEFAULT_DEPRECATION_REASON) {
-    return ' @deprecated';
+  if (reasonAST && reason !== '' && reason !== _directives.DEFAULT_DEPRECATION_REASON) {
+    return ' @deprecated(reason: ' + (0, _printer.print)(reasonAST) + ')';
   }
 
-  return ' @deprecated(reason: ' + (0, _printer.print)((0, _astFromValue.astFromValue)(reason, _scalars.GraphQLString)) + ')';
+  return ' @deprecated';
 }
 
 function printDescription(options, def) {
@@ -257,33 +265,11 @@ function printDescription(options, def) {
     return printDescriptionWithComments(lines, indentation, firstInBlock);
   }
 
-  var description = indentation && !firstInBlock ? '\n' + indentation + '"""' : indentation + '"""'; // In some circumstances, a single line can be used for the description.
-
-  if (lines.length === 1 && lines[0].length < 70 && lines[0][lines[0].length - 1] !== '"') {
-    return description + escapeQuote(lines[0]) + '"""\n';
-  } // Format a multi-line block quote to account for leading space.
-
-
-  var hasLeadingSpace = lines[0][0] === ' ' || lines[0][0] === '\t';
-
-  if (!hasLeadingSpace) {
-    description += '\n';
-  }
-
-  for (var i = 0; i < lines.length; i++) {
-    if (i !== 0 || !hasLeadingSpace) {
-      description += indentation;
-    }
-
-    description += escapeQuote(lines[i]) + '\n';
-  }
-
-  description += indentation + '"""\n';
-  return description;
-}
-
-function escapeQuote(line) {
-  return line.replace(/"""/g, '\\"""');
+  var text = lines.join('\n');
+  var preferMultipleLines = text.length > 70;
+  var blockString = (0, _blockString.printBlockString)(text, '', preferMultipleLines);
+  var prefix = indentation && !firstInBlock ? '\n' + indentation : indentation;
+  return prefix + blockString.replace(/\n/g, '\n' + indentation) + '\n';
 }
 
 function printDescriptionWithComments(lines, indentation, firstInBlock) {
@@ -301,31 +287,19 @@ function printDescriptionWithComments(lines, indentation, firstInBlock) {
 }
 
 function descriptionLines(description, maxLen) {
-  var lines = [];
   var rawLines = description.split('\n');
+  return (0, _flatMap.default)(rawLines, function (line) {
+    if (line.length < maxLen + 5) {
+      return line;
+    } // For > 120 character long lines, cut at space boundaries into sublines
+    // of ~80 chars.
 
-  for (var i = 0; i < rawLines.length; i++) {
-    if (rawLines[i] === '') {
-      lines.push(rawLines[i]);
-    } else {
-      // For > 120 character long lines, cut at space boundaries into sublines
-      // of ~80 chars.
-      var sublines = breakLine(rawLines[i], maxLen);
 
-      for (var j = 0; j < sublines.length; j++) {
-        lines.push(sublines[j]);
-      }
-    }
-  }
-
-  return lines;
+    return breakLine(line, maxLen);
+  });
 }
 
 function breakLine(line, maxLen) {
-  if (line.length < maxLen + 5) {
-    return [line];
-  }
-
   var parts = line.split(new RegExp("((?: |^).{15,".concat(maxLen - 40, "}(?= |$))")));
 
   if (parts.length < 4) {
@@ -339,4 +313,4 @@ function breakLine(line, maxLen) {
   }
 
   return sublines;
-}
+}