graphql 14.0.2 → 14.1.0

package/validation/rules/UniqueDirectiveNames.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.duplicateDirectiveNameMessage = duplicateDirectiveNameMessage;
+exports.existedDirectiveNameMessage = existedDirectiveNameMessage;
+exports.UniqueDirectiveNames = UniqueDirectiveNames;
+
+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 duplicateDirectiveNameMessage(directiveName) {
+  return "There can be only one directive named \"".concat(directiveName, "\".");
+}
+
+function existedDirectiveNameMessage(directiveName) {
+  return "Directive \"".concat(directiveName, "\" already exists in the schema. ") + 'It cannot be redefined.';
+}
+/**
+ * Unique directive names
+ *
+ * A GraphQL document is only valid if all defined directives have unique names.
+ */
+
+
+function UniqueDirectiveNames(context) {
+  var knownDirectiveNames = Object.create(null);
+  var schema = context.getSchema();
+  return {
+    DirectiveDefinition: function DirectiveDefinition(node) {
+      var directiveName = node.name.value;
+
+      if (schema && schema.getDirective(directiveName)) {
+        context.reportError(new _GraphQLError.GraphQLError(existedDirectiveNameMessage(directiveName), node.name));
+        return;
+      }
+
+      if (knownDirectiveNames[directiveName]) {
+        context.reportError(new _GraphQLError.GraphQLError(duplicateDirectiveNameMessage(directiveName), [knownDirectiveNames[directiveName], node.name]));
+      } else {
+        knownDirectiveNames[directiveName] = node.name;
+      }
+
+      return false;
+    }
+  };
+}

package/validation/rules/UniqueDirectiveNames.js.flow

@@ -0,0 +1,64 @@
+/**
+ * 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 duplicateDirectiveNameMessage(directiveName: string): string {
+  return `There can be only one directive named "${directiveName}".`;
+}
+
+export function existedDirectiveNameMessage(directiveName: string): string {
+  return (
+    `Directive "${directiveName}" already exists in the schema. ` +
+    'It cannot be redefined.'
+  );
+}
+
+/**
+ * Unique directive names
+ *
+ * A GraphQL document is only valid if all defined directives have unique names.
+ */
+export function UniqueDirectiveNames(
+  context: SDLValidationContext,
+): ASTVisitor {
+  const knownDirectiveNames = Object.create(null);
+  const schema = context.getSchema();
+
+  return {
+    DirectiveDefinition(node) {
+      const directiveName = node.name.value;
+
+      if (schema && schema.getDirective(directiveName)) {
+        context.reportError(
+          new GraphQLError(
+            existedDirectiveNameMessage(directiveName),
+            node.name,
+          ),
+        );
+        return;
+      }
+
+      if (knownDirectiveNames[directiveName]) {
+        context.reportError(
+          new GraphQLError(duplicateDirectiveNameMessage(directiveName), [
+            knownDirectiveNames[directiveName],
+            node.name,
+          ]),
+        );
+      } else {
+        knownDirectiveNames[directiveName] = node.name;
+      }
+
+      return false;
+    },
+  };
+}

package/validation/rules/UniqueDirectiveNames.mjs

@@ -0,0 +1,43 @@
+/**
+ * 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 duplicateDirectiveNameMessage(directiveName) {
+  return "There can be only one directive named \"".concat(directiveName, "\".");
+}
+export function existedDirectiveNameMessage(directiveName) {
+  return "Directive \"".concat(directiveName, "\" already exists in the schema. ") + 'It cannot be redefined.';
+}
+/**
+ * Unique directive names
+ *
+ * A GraphQL document is only valid if all defined directives have unique names.
+ */
+
+export function UniqueDirectiveNames(context) {
+  var knownDirectiveNames = Object.create(null);
+  var schema = context.getSchema();
+  return {
+    DirectiveDefinition: function DirectiveDefinition(node) {
+      var directiveName = node.name.value;
+
+      if (schema && schema.getDirective(directiveName)) {
+        context.reportError(new GraphQLError(existedDirectiveNameMessage(directiveName), node.name));
+        return;
+      }
+
+      if (knownDirectiveNames[directiveName]) {
+        context.reportError(new GraphQLError(duplicateDirectiveNameMessage(directiveName), [knownDirectiveNames[directiveName], node.name]));
+      } else {
+        knownDirectiveNames[directiveName] = node.name;
+      }
+
+      return false;
+    }
+  };
+}

package/validation/rules/UniqueDirectivesPerLocation.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 duplicateDirectiveMessage(directiveName) {
   return "The directive \"".concat(directiveName, "\" can only be used once at ") + 'this location.';

package/validation/rules/UniqueDirectivesPerLocation.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 duplicateDirectiveMessage(directiveName) {

package/validation/rules/UniqueEnumValueNames.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.duplicateEnumValueNameMessage = duplicateEnumValueNameMessage;
+exports.existedEnumValueNameMessage = existedEnumValueNameMessage;
+exports.UniqueEnumValueNames = UniqueEnumValueNames;
+
+var _GraphQLError = require("../../error/GraphQLError");
+
+var _definition = require("../../type/definition");
+
+/**
+ * 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 duplicateEnumValueNameMessage(typeName, valueName) {
+  return "Enum value \"".concat(typeName, ".").concat(valueName, "\" can only be defined once.");
+}
+
+function existedEnumValueNameMessage(typeName, valueName) {
+  return "Enum value \"".concat(typeName, ".").concat(valueName, "\" already exists in the schema. ") + 'It cannot also be defined in this type extension.';
+}
+/**
+ * Unique enum value names
+ *
+ * A GraphQL enum type is only valid if all its values are uniquely named.
+ */
+
+
+function UniqueEnumValueNames(context) {
+  var schema = context.getSchema();
+  var existingTypeMap = schema ? schema.getTypeMap() : Object.create(null);
+  var knownValueNames = Object.create(null);
+  return {
+    EnumTypeDefinition: checkValueUniqueness,
+    EnumTypeExtension: checkValueUniqueness
+  };
+
+  function checkValueUniqueness(node) {
+    var typeName = node.name.value;
+
+    if (!knownValueNames[typeName]) {
+      knownValueNames[typeName] = Object.create(null);
+    }
+
+    var valueNames = knownValueNames[typeName];
+
+    if (node.values) {
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = node.values[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var valueDef = _step.value;
+          var valueName = valueDef.name.value;
+          var existingType = existingTypeMap[typeName];
+
+          if ((0, _definition.isEnumType)(existingType) && existingType.getValue(valueName)) {
+            context.reportError(new _GraphQLError.GraphQLError(existedEnumValueNameMessage(typeName, valueName), valueDef.name));
+            continue;
+          }
+
+          if (valueNames[valueName]) {
+            context.reportError(new _GraphQLError.GraphQLError(duplicateEnumValueNameMessage(typeName, valueName), [valueNames[valueName], valueDef.name]));
+          } else {
+            valueNames[valueName] = valueDef.name;
+          }
+        }
+      } 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/UniqueEnumValueNames.js.flow

@@ -0,0 +1,87 @@
+/**
+ * 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 { isEnumType } from '../../type/definition';
+
+export function duplicateEnumValueNameMessage(
+  typeName: string,
+  valueName: string,
+): string {
+  return `Enum value "${typeName}.${valueName}" can only be defined once.`;
+}
+
+export function existedEnumValueNameMessage(
+  typeName: string,
+  valueName: string,
+): string {
+  return (
+    `Enum value "${typeName}.${valueName}" already exists in the schema. ` +
+    'It cannot also be defined in this type extension.'
+  );
+}
+
+/**
+ * Unique enum value names
+ *
+ * A GraphQL enum type is only valid if all its values are uniquely named.
+ */
+export function UniqueEnumValueNames(
+  context: SDLValidationContext,
+): ASTVisitor {
+  const schema = context.getSchema();
+  const existingTypeMap = schema ? schema.getTypeMap() : Object.create(null);
+  const knownValueNames = Object.create(null);
+
+  return {
+    EnumTypeDefinition: checkValueUniqueness,
+    EnumTypeExtension: checkValueUniqueness,
+  };
+
+  function checkValueUniqueness(node) {
+    const typeName = node.name.value;
+
+    if (!knownValueNames[typeName]) {
+      knownValueNames[typeName] = Object.create(null);
+    }
+
+    const valueNames = knownValueNames[typeName];
+    if (node.values) {
+      for (const valueDef of node.values) {
+        const valueName = valueDef.name.value;
+
+        const existingType = existingTypeMap[typeName];
+        if (isEnumType(existingType) && existingType.getValue(valueName)) {
+          context.reportError(
+            new GraphQLError(
+              existedEnumValueNameMessage(typeName, valueName),
+              valueDef.name,
+            ),
+          );
+          continue;
+        }
+
+        if (valueNames[valueName]) {
+          context.reportError(
+            new GraphQLError(
+              duplicateEnumValueNameMessage(typeName, valueName),
+              [valueNames[valueName], valueDef.name],
+            ),
+          );
+        } else {
+          valueNames[valueName] = valueDef.name;
+        }
+      }
+    }
+
+    return false;
+  }
+}

package/validation/rules/UniqueEnumValueNames.mjs

@@ -0,0 +1,81 @@
+/**
+ * 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 { isEnumType } from '../../type/definition';
+export function duplicateEnumValueNameMessage(typeName, valueName) {
+  return "Enum value \"".concat(typeName, ".").concat(valueName, "\" can only be defined once.");
+}
+export function existedEnumValueNameMessage(typeName, valueName) {
+  return "Enum value \"".concat(typeName, ".").concat(valueName, "\" already exists in the schema. ") + 'It cannot also be defined in this type extension.';
+}
+/**
+ * Unique enum value names
+ *
+ * A GraphQL enum type is only valid if all its values are uniquely named.
+ */
+
+export function UniqueEnumValueNames(context) {
+  var schema = context.getSchema();
+  var existingTypeMap = schema ? schema.getTypeMap() : Object.create(null);
+  var knownValueNames = Object.create(null);
+  return {
+    EnumTypeDefinition: checkValueUniqueness,
+    EnumTypeExtension: checkValueUniqueness
+  };
+
+  function checkValueUniqueness(node) {
+    var typeName = node.name.value;
+
+    if (!knownValueNames[typeName]) {
+      knownValueNames[typeName] = Object.create(null);
+    }
+
+    var valueNames = knownValueNames[typeName];
+
+    if (node.values) {
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = node.values[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var valueDef = _step.value;
+          var valueName = valueDef.name.value;
+          var existingType = existingTypeMap[typeName];
+
+          if (isEnumType(existingType) && existingType.getValue(valueName)) {
+            context.reportError(new GraphQLError(existedEnumValueNameMessage(typeName, valueName), valueDef.name));
+            continue;
+          }
+
+          if (valueNames[valueName]) {
+            context.reportError(new GraphQLError(duplicateEnumValueNameMessage(typeName, valueName), [valueNames[valueName], valueDef.name]));
+          } else {
+            valueNames[valueName] = valueDef.name;
+          }
+        }
+      } 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/UniqueFieldDefinitionNames.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.duplicateFieldDefinitionNameMessage = duplicateFieldDefinitionNameMessage;
+exports.existedFieldDefinitionNameMessage = existedFieldDefinitionNameMessage;
+exports.UniqueFieldDefinitionNames = UniqueFieldDefinitionNames;
+
+var _GraphQLError = require("../../error/GraphQLError");
+
+var _definition = require("../../type/definition");
+
+/**
+ * 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 duplicateFieldDefinitionNameMessage(typeName, fieldName) {
+  return "Field \"".concat(typeName, ".").concat(fieldName, "\" can only be defined once.");
+}
+
+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.
+ */
+
+
+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.GraphQLError(existedFieldDefinitionNameMessage(typeName, fieldName), fieldDef.name));
+            continue;
+          }
+
+          if (fieldNames[fieldName]) {
+            context.reportError(new _GraphQLError.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 ((0, _definition.isObjectType)(type) || (0, _definition.isInterfaceType)(type) || (0, _definition.isInputObjectType)(type)) {
+    return type.getFields()[fieldName];
+  }
+
+  return false;
+}

package/validation/rules/UniqueFieldDefinitionNames.js.flow

@@ -0,0 +1,101 @@
+/**
+ * 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 {
+  isObjectType,
+  isInterfaceType,
+  isInputObjectType,
+} from '../../type/definition';
+
+export function duplicateFieldDefinitionNameMessage(
+  typeName: string,
+  fieldName: string,
+): string {
+  return `Field "${typeName}.${fieldName}" can only be defined once.`;
+}
+
+export function existedFieldDefinitionNameMessage(
+  typeName: string,
+  fieldName: string,
+): string {
+  return (
+    `Field "${typeName}.${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: SDLValidationContext,
+): ASTVisitor {
+  const schema = context.getSchema();
+  const existingTypeMap = schema ? schema.getTypeMap() : Object.create(null);
+  const knownFieldNames = Object.create(null);
+
+  return {
+    InputObjectTypeDefinition: checkFieldUniqueness,
+    InputObjectTypeExtension: checkFieldUniqueness,
+    InterfaceTypeDefinition: checkFieldUniqueness,
+    InterfaceTypeExtension: checkFieldUniqueness,
+    ObjectTypeDefinition: checkFieldUniqueness,
+    ObjectTypeExtension: checkFieldUniqueness,
+  };
+
+  function checkFieldUniqueness(node) {
+    const typeName = node.name.value;
+
+    if (!knownFieldNames[typeName]) {
+      knownFieldNames[typeName] = Object.create(null);
+    }
+
+    const fieldNames = knownFieldNames[typeName];
+    if (node.fields) {
+      for (const fieldDef of node.fields) {
+        const 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;
+        }
+      }
+    }
+
+    return false;
+  }
+}
+
+function hasField(type, fieldName) {
+  if (isObjectType(type) || isInterfaceType(type) || isInputObjectType(type)) {
+    return type.getFields()[fieldName];
+  }
+  return false;
+}