graphql 14.0.0 → 14.1.1

package/validation/rules/UniqueFieldDefinitionNames.mjs

@@ -0,0 +1,92 @@
+/**
+ * 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.
+ *
+ * 
+ */
+import { GraphQLError } from '../../error/GraphQLError';
+import { isObjectType, isInterfaceType, isInputObjectType } from '../../type/definition';
+export function duplicateFieldDefinitionNameMessage(typeName, fieldName) {
+  return "Field \"".concat(typeName, ".").concat(fieldName, "\" can only be defined once.");
+}
+export function existedFieldDefinitionNameMessage(typeName, fieldName) {
+  return "Field \"".concat(typeName, ".").concat(fieldName, "\" already exists in the schema. ") + 'It cannot also be defined in this type extension.';
+}
+/**
+ * Unique field definition names
+ *
+ * A GraphQL complex type is only valid if all its fields are uniquely named.
+ */
+
+export function UniqueFieldDefinitionNames(context) {
+  var schema = context.getSchema();
+  var existingTypeMap = schema ? schema.getTypeMap() : Object.create(null);
+  var knownFieldNames = Object.create(null);
+  return {
+    InputObjectTypeDefinition: checkFieldUniqueness,
+    InputObjectTypeExtension: checkFieldUniqueness,
+    InterfaceTypeDefinition: checkFieldUniqueness,
+    InterfaceTypeExtension: checkFieldUniqueness,
+    ObjectTypeDefinition: checkFieldUniqueness,
+    ObjectTypeExtension: checkFieldUniqueness
+  };
+
+  function checkFieldUniqueness(node) {
+    var typeName = node.name.value;
+
+    if (!knownFieldNames[typeName]) {
+      knownFieldNames[typeName] = Object.create(null);
+    }
+
+    var fieldNames = knownFieldNames[typeName];
+
+    if (node.fields) {
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = node.fields[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var fieldDef = _step.value;
+          var fieldName = fieldDef.name.value;
+
+          if (hasField(existingTypeMap[typeName], fieldName)) {
+            context.reportError(new GraphQLError(existedFieldDefinitionNameMessage(typeName, fieldName), fieldDef.name));
+            continue;
+          }
+
+          if (fieldNames[fieldName]) {
+            context.reportError(new GraphQLError(duplicateFieldDefinitionNameMessage(typeName, fieldName), [fieldNames[fieldName], fieldDef.name]));
+          } else {
+            fieldNames[fieldName] = fieldDef.name;
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+    }
+
+    return false;
+  }
+}
+
+function hasField(type, fieldName) {
+  if (isObjectType(type) || isInterfaceType(type) || isInputObjectType(type)) {
+    return type.getFields()[fieldName];
+  }
+
+  return false;
+}

package/validation/rules/UniqueFragmentNames.js

@@ -14,7 +14,7 @@ var _GraphQLError = require("../../error/GraphQLError");
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 function duplicateFragmentNameMessage(fragName) {
   return "There can be only one fragment named \"".concat(fragName, "\".");

package/validation/rules/UniqueFragmentNames.mjs

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 import { GraphQLError } from '../../error/GraphQLError';
 export function duplicateFragmentNameMessage(fragName) {

package/validation/rules/UniqueInputFieldNames.js

@@ -14,7 +14,7 @@ var _GraphQLError = require("../../error/GraphQLError");
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 function duplicateInputFieldMessage(fieldName) {
   return "There can be only one input field named \"".concat(fieldName, "\".");

package/validation/rules/UniqueInputFieldNames.mjs

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 import { GraphQLError } from '../../error/GraphQLError';
 export function duplicateInputFieldMessage(fieldName) {

package/validation/rules/UniqueOperationNames.js

@@ -14,7 +14,7 @@ var _GraphQLError = require("../../error/GraphQLError");
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 function duplicateOperationNameMessage(operationName) {
   return "There can be only one operation named \"".concat(operationName, "\".");

package/validation/rules/UniqueOperationNames.mjs

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 import { GraphQLError } from '../../error/GraphQLError';
 export function duplicateOperationNameMessage(operationName) {

package/validation/rules/UniqueOperationTypes.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.duplicateOperationTypeMessage = duplicateOperationTypeMessage;
+exports.existedOperationTypeMessage = existedOperationTypeMessage;
+exports.UniqueOperationTypes = UniqueOperationTypes;
+
+var _GraphQLError = require("../../error/GraphQLError");
+
+/**
+ * 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.
+ *
+ * 
+ */
+function duplicateOperationTypeMessage(operation) {
+  return "There can be only one ".concat(operation, " type in schema.");
+}
+
+function existedOperationTypeMessage(operation) {
+  return "Type for ".concat(operation, " already defined in the schema. ") + 'It cannot be redefined.';
+}
+/**
+ * Unique operation types
+ *
+ * A GraphQL document is only valid if it has only one type per operation.
+ */
+
+
+function UniqueOperationTypes(context) {
+  var schema = context.getSchema();
+  var definedOperationTypes = Object.create(null);
+  var existingOperationTypes = schema ? {
+    query: schema.getQueryType(),
+    mutation: schema.getMutationType(),
+    subscription: schema.getSubscriptionType()
+  } : {};
+  return {
+    SchemaDefinition: checkOperationTypes,
+    SchemaExtension: checkOperationTypes
+  };
+
+  function checkOperationTypes(node) {
+    if (node.operationTypes) {
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = (node.operationTypes || [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var operationType = _step.value;
+          var operation = operationType.operation;
+          var alreadyDefinedOperationType = definedOperationTypes[operation];
+
+          if (existingOperationTypes[operation]) {
+            context.reportError(new _GraphQLError.GraphQLError(existedOperationTypeMessage(operation), operationType));
+          } else if (alreadyDefinedOperationType) {
+            context.reportError(new _GraphQLError.GraphQLError(duplicateOperationTypeMessage(operation), [alreadyDefinedOperationType, operationType]));
+          } else {
+            definedOperationTypes[operation] = operationType;
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+    }
+
+    return false;
+  }
+}

package/validation/rules/UniqueOperationTypes.js.flow

@@ -0,0 +1,76 @@
+/**
+ * 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/GraphQLError';
+import type { ASTVisitor } from '../../language/visitor';
+
+export function duplicateOperationTypeMessage(operation: string): string {
+  return `There can be only one ${operation} type in schema.`;
+}
+
+export function existedOperationTypeMessage(operation: string): string {
+  return (
+    `Type for ${operation} already defined in the schema. ` +
+    'It cannot be redefined.'
+  );
+}
+
+/**
+ * Unique operation types
+ *
+ * A GraphQL document is only valid if it has only one type per operation.
+ */
+export function UniqueOperationTypes(
+  context: SDLValidationContext,
+): ASTVisitor {
+  const schema = context.getSchema();
+  const definedOperationTypes = Object.create(null);
+  const existingOperationTypes = schema
+    ? {
+        query: schema.getQueryType(),
+        mutation: schema.getMutationType(),
+        subscription: schema.getSubscriptionType(),
+      }
+    : {};
+
+  return {
+    SchemaDefinition: checkOperationTypes,
+    SchemaExtension: checkOperationTypes,
+  };
+
+  function checkOperationTypes(node) {
+    if (node.operationTypes) {
+      for (const operationType of node.operationTypes || []) {
+        const operation = operationType.operation;
+        const alreadyDefinedOperationType = definedOperationTypes[operation];
+
+        if (existingOperationTypes[operation]) {
+          context.reportError(
+            new GraphQLError(
+              existedOperationTypeMessage(operation),
+              operationType,
+            ),
+          );
+        } else if (alreadyDefinedOperationType) {
+          context.reportError(
+            new GraphQLError(duplicateOperationTypeMessage(operation), [
+              alreadyDefinedOperationType,
+              operationType,
+            ]),
+          );
+        } else {
+          definedOperationTypes[operation] = operationType;
+        }
+      }
+    }
+
+    return false;
+  }
+}

package/validation/rules/UniqueOperationTypes.mjs

@@ -0,0 +1,73 @@
+/**
+ * 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.
+ *
+ * 
+ */
+import { GraphQLError } from '../../error/GraphQLError';
+export function duplicateOperationTypeMessage(operation) {
+  return "There can be only one ".concat(operation, " type in schema.");
+}
+export function existedOperationTypeMessage(operation) {
+  return "Type for ".concat(operation, " already defined in the schema. ") + 'It cannot be redefined.';
+}
+/**
+ * Unique operation types
+ *
+ * A GraphQL document is only valid if it has only one type per operation.
+ */
+
+export function UniqueOperationTypes(context) {
+  var schema = context.getSchema();
+  var definedOperationTypes = Object.create(null);
+  var existingOperationTypes = schema ? {
+    query: schema.getQueryType(),
+    mutation: schema.getMutationType(),
+    subscription: schema.getSubscriptionType()
+  } : {};
+  return {
+    SchemaDefinition: checkOperationTypes,
+    SchemaExtension: checkOperationTypes
+  };
+
+  function checkOperationTypes(node) {
+    if (node.operationTypes) {
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = (node.operationTypes || [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var operationType = _step.value;
+          var operation = operationType.operation;
+          var alreadyDefinedOperationType = definedOperationTypes[operation];
+
+          if (existingOperationTypes[operation]) {
+            context.reportError(new GraphQLError(existedOperationTypeMessage(operation), operationType));
+          } else if (alreadyDefinedOperationType) {
+            context.reportError(new GraphQLError(duplicateOperationTypeMessage(operation), [alreadyDefinedOperationType, operationType]));
+          } else {
+            definedOperationTypes[operation] = operationType;
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+    }
+
+    return false;
+  }
+}

package/validation/rules/UniqueTypeNames.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.duplicateTypeNameMessage = duplicateTypeNameMessage;
+exports.existedTypeNameMessage = existedTypeNameMessage;
+exports.UniqueTypeNames = UniqueTypeNames;
+
+var _GraphQLError = require("../../error/GraphQLError");
+
+/**
+ * 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.
+ *
+ * 
+ */
+function duplicateTypeNameMessage(typeName) {
+  return "There can be only one type named \"".concat(typeName, "\".");
+}
+
+function existedTypeNameMessage(typeName) {
+  return "Type \"".concat(typeName, "\" already exists in the schema. ") + 'It cannot also be defined in this type definition.';
+}
+/**
+ * Unique type names
+ *
+ * A GraphQL document is only valid if all defined types have unique names.
+ */
+
+
+function UniqueTypeNames(context) {
+  var knownTypeNames = Object.create(null);
+  var schema = context.getSchema();
+  return {
+    ScalarTypeDefinition: checkTypeName,
+    ObjectTypeDefinition: checkTypeName,
+    InterfaceTypeDefinition: checkTypeName,
+    UnionTypeDefinition: checkTypeName,
+    EnumTypeDefinition: checkTypeName,
+    InputObjectTypeDefinition: checkTypeName
+  };
+
+  function checkTypeName(node) {
+    var typeName = node.name.value;
+
+    if (schema && schema.getType(typeName)) {
+      context.reportError(new _GraphQLError.GraphQLError(existedTypeNameMessage(typeName), node.name));
+      return;
+    }
+
+    if (knownTypeNames[typeName]) {
+      context.reportError(new _GraphQLError.GraphQLError(duplicateTypeNameMessage(typeName), [knownTypeNames[typeName], node.name]));
+    } else {
+      knownTypeNames[typeName] = node.name;
+    }
+
+    return false;
+  }
+}

package/validation/rules/UniqueTypeNames.js.flow

@@ -0,0 +1,67 @@
+/**
+ * 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/GraphQLError';
+import type { ASTVisitor } from '../../language/visitor';
+import type { TypeDefinitionNode } from '../../language/ast';
+
+export function duplicateTypeNameMessage(typeName: string): string {
+  return `There can be only one type named "${typeName}".`;
+}
+
+export function existedTypeNameMessage(typeName: string): string {
+  return (
+    `Type "${typeName}" already exists in the schema. ` +
+    'It cannot also be defined in this type definition.'
+  );
+}
+
+/**
+ * Unique type names
+ *
+ * A GraphQL document is only valid if all defined types have unique names.
+ */
+export function UniqueTypeNames(context: SDLValidationContext): ASTVisitor {
+  const knownTypeNames = Object.create(null);
+  const schema = context.getSchema();
+
+  return {
+    ScalarTypeDefinition: checkTypeName,
+    ObjectTypeDefinition: checkTypeName,
+    InterfaceTypeDefinition: checkTypeName,
+    UnionTypeDefinition: checkTypeName,
+    EnumTypeDefinition: checkTypeName,
+    InputObjectTypeDefinition: checkTypeName,
+  };
+
+  function checkTypeName(node: TypeDefinitionNode) {
+    const typeName = node.name.value;
+
+    if (schema && schema.getType(typeName)) {
+      context.reportError(
+        new GraphQLError(existedTypeNameMessage(typeName), node.name),
+      );
+      return;
+    }
+
+    if (knownTypeNames[typeName]) {
+      context.reportError(
+        new GraphQLError(duplicateTypeNameMessage(typeName), [
+          knownTypeNames[typeName],
+          node.name,
+        ]),
+      );
+    } else {
+      knownTypeNames[typeName] = node.name;
+    }
+
+    return false;
+  }
+}

package/validation/rules/UniqueTypeNames.mjs

@@ -0,0 +1,50 @@
+/**
+ * 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.
+ *
+ * 
+ */
+import { GraphQLError } from '../../error/GraphQLError';
+export function duplicateTypeNameMessage(typeName) {
+  return "There can be only one type named \"".concat(typeName, "\".");
+}
+export function existedTypeNameMessage(typeName) {
+  return "Type \"".concat(typeName, "\" already exists in the schema. ") + 'It cannot also be defined in this type definition.';
+}
+/**
+ * Unique type names
+ *
+ * A GraphQL document is only valid if all defined types have unique names.
+ */
+
+export function UniqueTypeNames(context) {
+  var knownTypeNames = Object.create(null);
+  var schema = context.getSchema();
+  return {
+    ScalarTypeDefinition: checkTypeName,
+    ObjectTypeDefinition: checkTypeName,
+    InterfaceTypeDefinition: checkTypeName,
+    UnionTypeDefinition: checkTypeName,
+    EnumTypeDefinition: checkTypeName,
+    InputObjectTypeDefinition: checkTypeName
+  };
+
+  function checkTypeName(node) {
+    var typeName = node.name.value;
+
+    if (schema && schema.getType(typeName)) {
+      context.reportError(new GraphQLError(existedTypeNameMessage(typeName), node.name));
+      return;
+    }
+
+    if (knownTypeNames[typeName]) {
+      context.reportError(new GraphQLError(duplicateTypeNameMessage(typeName), [knownTypeNames[typeName], node.name]));
+    } else {
+      knownTypeNames[typeName] = node.name;
+    }
+
+    return false;
+  }
+}

package/validation/rules/UniqueVariableNames.js

@@ -14,7 +14,7 @@ var _GraphQLError = require("../../error/GraphQLError");
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 function duplicateVariableMessage(variableName) {
   return "There can be only one variable named \"".concat(variableName, "\".");

package/validation/rules/UniqueVariableNames.mjs

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 import { GraphQLError } from '../../error/GraphQLError';
 export function duplicateVariableMessage(variableName) {

package/validation/rules/ValuesOfCorrectType.js

@@ -8,6 +8,8 @@ exports.requiredFieldMessage = requiredFieldMessage;
 exports.unknownFieldMessage = unknownFieldMessage;
 exports.ValuesOfCorrectType = ValuesOfCorrectType;
 
+var _objectValues = _interopRequireDefault(require("../../polyfills/objectValues"));
+
 var _GraphQLError = require("../../error/GraphQLError");
 
 var _printer = require("../../language/printer");
@@ -32,7 +34,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 function badValueMessage(typeName, valueName, message) {
   return "Expected type ".concat(typeName, ", found ").concat(valueName) + (message ? "; ".concat(message) : '.');
@@ -81,21 +83,35 @@ function ValuesOfCorrectType(context) {
       } // Ensure every required field exists.
 
 
-      var inputFields = type.getFields();
       var fieldNodeMap = (0, _keyMap.default)(node.fields, function (field) {
         return field.name.value;
       });
-
-      var _arr = Object.keys(inputFields);
-
-      for (var _i = 0; _i < _arr.length; _i++) {
-        var fieldName = _arr[_i];
-        var fieldDef = inputFields[fieldName];
-        var fieldNode = fieldNodeMap[fieldName];
-
-        if (!fieldNode && (0, _definition.isRequiredInputField)(fieldDef)) {
-          var typeStr = (0, _inspect.default)(fieldDef.type);
-          context.reportError(new _GraphQLError.GraphQLError(requiredFieldMessage(type.name, fieldName, typeStr), node));
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = (0, _objectValues.default)(type.getFields())[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var fieldDef = _step.value;
+          var fieldNode = fieldNodeMap[fieldDef.name];
+
+          if (!fieldNode && (0, _definition.isRequiredInputField)(fieldDef)) {
+            var typeStr = (0, _inspect.default)(fieldDef.type);
+            context.reportError(new _GraphQLError.GraphQLError(requiredFieldMessage(type.name, fieldDef.name, typeStr), node));
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
         }
       }
     },

package/validation/rules/ValuesOfCorrectType.js.flow

@@ -7,6 +7,7 @@
  * @flow strict
  */
 
+import objectValues from '../../polyfills/objectValues';
 import type { ValidationContext } from '../ValidationContext';
 import { GraphQLError } from '../../error/GraphQLError';
 import type { ValueNode } from '../../language/ast';
@@ -94,16 +95,14 @@ export function ValuesOfCorrectType(context: ValidationContext): ASTVisitor {
         return false; // Don't traverse further.
       }
       // Ensure every required field exists.
-      const inputFields = type.getFields();
       const fieldNodeMap = keyMap(node.fields, field => field.name.value);
-      for (const fieldName of Object.keys(inputFields)) {
-        const fieldDef = inputFields[fieldName];
-        const fieldNode = fieldNodeMap[fieldName];
+      for (const fieldDef of objectValues(type.getFields())) {
+        const fieldNode = fieldNodeMap[fieldDef.name];
         if (!fieldNode && isRequiredInputField(fieldDef)) {
           const typeStr = inspect(fieldDef.type);
           context.reportError(
             new GraphQLError(
-              requiredFieldMessage(type.name, fieldName, typeStr),
+              requiredFieldMessage(type.name, fieldDef.name, typeStr),
               node,
             ),
           );