graphql 0.0.1-test.1

package/validation/rules/UniqueArgumentNamesRule.mjs

@@ -0,0 +1,42 @@
+import { groupBy } from '../../jsutils/groupBy.mjs';
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+
+/**
+ * Unique argument names
+ *
+ * A GraphQL field or directive is only valid if all supplied arguments are
+ * uniquely named.
+ *
+ * See https://spec.graphql.org/draft/#sec-Argument-Names
+ */
+export function UniqueArgumentNamesRule(context) {
+  return {
+    Field: checkArgUniqueness,
+    Directive: checkArgUniqueness,
+  };
+
+  function checkArgUniqueness(parentNode) {
+    var _parentNode$arguments;
+
+    // FIXME: https://github.com/graphql/graphql-js/issues/2203
+
+    /* c8 ignore next */
+    const argumentNodes =
+      (_parentNode$arguments = parentNode.arguments) !== null &&
+      _parentNode$arguments !== void 0
+        ? _parentNode$arguments
+        : [];
+    const seenArgs = groupBy(argumentNodes, (arg) => arg.name.value);
+
+    for (const [argName, argNodes] of seenArgs) {
+      if (argNodes.length > 1) {
+        context.reportError(
+          new GraphQLError(
+            `There can be only one argument named "${argName}".`,
+            argNodes.map((node) => node.name),
+          ),
+        );
+      }
+    }
+  }
+}

package/validation/rules/UniqueDirectiveNamesRule.d.ts

@@ -0,0 +1,10 @@
+import type { ASTVisitor } from '../../language/visitor';
+import type { SDLValidationContext } from '../ValidationContext';
+/**
+ * Unique directive names
+ *
+ * A GraphQL document is only valid if all defined directives have unique names.
+ */
+export declare function UniqueDirectiveNamesRule(
+  context: SDLValidationContext,
+): ASTVisitor;

package/validation/rules/UniqueDirectiveNamesRule.js

@@ -0,0 +1,50 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.UniqueDirectiveNamesRule = UniqueDirectiveNamesRule;
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+/**
+ * Unique directive names
+ *
+ * A GraphQL document is only valid if all defined directives have unique names.
+ */
+function UniqueDirectiveNamesRule(context) {
+  const knownDirectiveNames = Object.create(null);
+  const schema = context.getSchema();
+  return {
+    DirectiveDefinition(node) {
+      const directiveName = node.name.value;
+
+      if (
+        schema !== null &&
+        schema !== void 0 &&
+        schema.getDirective(directiveName)
+      ) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `Directive "@${directiveName}" already exists in the schema. It cannot be redefined.`,
+            node.name,
+          ),
+        );
+        return;
+      }
+
+      if (knownDirectiveNames[directiveName]) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `There can be only one directive named "@${directiveName}".`,
+            [knownDirectiveNames[directiveName], node.name],
+          ),
+        );
+      } else {
+        knownDirectiveNames[directiveName] = node.name;
+      }
+
+      return false;
+    },
+  };
+}

package/validation/rules/UniqueDirectiveNamesRule.mjs

@@ -0,0 +1,43 @@
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+
+/**
+ * Unique directive names
+ *
+ * A GraphQL document is only valid if all defined directives have unique names.
+ */
+export function UniqueDirectiveNamesRule(context) {
+  const knownDirectiveNames = Object.create(null);
+  const schema = context.getSchema();
+  return {
+    DirectiveDefinition(node) {
+      const directiveName = node.name.value;
+
+      if (
+        schema !== null &&
+        schema !== void 0 &&
+        schema.getDirective(directiveName)
+      ) {
+        context.reportError(
+          new GraphQLError(
+            `Directive "@${directiveName}" already exists in the schema. It cannot be redefined.`,
+            node.name,
+          ),
+        );
+        return;
+      }
+
+      if (knownDirectiveNames[directiveName]) {
+        context.reportError(
+          new GraphQLError(
+            `There can be only one directive named "@${directiveName}".`,
+            [knownDirectiveNames[directiveName], node.name],
+          ),
+        );
+      } else {
+        knownDirectiveNames[directiveName] = node.name;
+      }
+
+      return false;
+    },
+  };
+}

package/validation/rules/UniqueDirectivesPerLocationRule.d.ts

@@ -0,0 +1,16 @@
+import type { ASTVisitor } from '../../language/visitor';
+import type {
+  SDLValidationContext,
+  ValidationContext,
+} from '../ValidationContext';
+/**
+ * Unique directive names per location
+ *
+ * A GraphQL document is only valid if all non-repeatable directives at
+ * a given location are uniquely named.
+ *
+ * See https://spec.graphql.org/draft/#sec-Directives-Are-Unique-Per-Location
+ */
+export declare function UniqueDirectivesPerLocationRule(
+  context: ValidationContext | SDLValidationContext,
+): ASTVisitor;

package/validation/rules/UniqueDirectivesPerLocationRule.js

@@ -0,0 +1,93 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.UniqueDirectivesPerLocationRule = UniqueDirectivesPerLocationRule;
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+var _kinds = require('../../language/kinds.js');
+
+var _predicates = require('../../language/predicates.js');
+
+var _directives = require('../../type/directives.js');
+
+/**
+ * Unique directive names per location
+ *
+ * A GraphQL document is only valid if all non-repeatable directives at
+ * a given location are uniquely named.
+ *
+ * See https://spec.graphql.org/draft/#sec-Directives-Are-Unique-Per-Location
+ */
+function UniqueDirectivesPerLocationRule(context) {
+  const uniqueDirectiveMap = Object.create(null);
+  const schema = context.getSchema();
+  const definedDirectives = schema
+    ? schema.getDirectives()
+    : _directives.specifiedDirectives;
+
+  for (const directive of definedDirectives) {
+    uniqueDirectiveMap[directive.name] = !directive.isRepeatable;
+  }
+
+  const astDefinitions = context.getDocument().definitions;
+
+  for (const def of astDefinitions) {
+    if (def.kind === _kinds.Kind.DIRECTIVE_DEFINITION) {
+      uniqueDirectiveMap[def.name.value] = !def.repeatable;
+    }
+  }
+
+  const schemaDirectives = Object.create(null);
+  const typeDirectivesMap = Object.create(null);
+  return {
+    // Many different AST nodes may contain directives. Rather than listing
+    // them all, just listen for entering any node, and check to see if it
+    // defines any directives.
+    enter(node) {
+      if (!('directives' in node) || !node.directives) {
+        return;
+      }
+
+      let seenDirectives;
+
+      if (
+        node.kind === _kinds.Kind.SCHEMA_DEFINITION ||
+        node.kind === _kinds.Kind.SCHEMA_EXTENSION
+      ) {
+        seenDirectives = schemaDirectives;
+      } else if (
+        (0, _predicates.isTypeDefinitionNode)(node) ||
+        (0, _predicates.isTypeExtensionNode)(node)
+      ) {
+        const typeName = node.name.value;
+        seenDirectives = typeDirectivesMap[typeName];
+
+        if (seenDirectives === undefined) {
+          typeDirectivesMap[typeName] = seenDirectives = Object.create(null);
+        }
+      } else {
+        seenDirectives = Object.create(null);
+      }
+
+      for (const directive of node.directives) {
+        const directiveName = directive.name.value;
+
+        if (uniqueDirectiveMap[directiveName]) {
+          if (seenDirectives[directiveName]) {
+            context.reportError(
+              new _GraphQLError.GraphQLError(
+                `The directive "@${directiveName}" can only be used once at this location.`,
+                [seenDirectives[directiveName], directive],
+              ),
+            );
+          } else {
+            seenDirectives[directiveName] = directive;
+          }
+        }
+      }
+    },
+  };
+}

package/validation/rules/UniqueDirectivesPerLocationRule.mjs

@@ -0,0 +1,83 @@
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+import { Kind } from '../../language/kinds.mjs';
+import {
+  isTypeDefinitionNode,
+  isTypeExtensionNode,
+} from '../../language/predicates.mjs';
+import { specifiedDirectives } from '../../type/directives.mjs';
+
+/**
+ * Unique directive names per location
+ *
+ * A GraphQL document is only valid if all non-repeatable directives at
+ * a given location are uniquely named.
+ *
+ * See https://spec.graphql.org/draft/#sec-Directives-Are-Unique-Per-Location
+ */
+export function UniqueDirectivesPerLocationRule(context) {
+  const uniqueDirectiveMap = Object.create(null);
+  const schema = context.getSchema();
+  const definedDirectives = schema
+    ? schema.getDirectives()
+    : specifiedDirectives;
+
+  for (const directive of definedDirectives) {
+    uniqueDirectiveMap[directive.name] = !directive.isRepeatable;
+  }
+
+  const astDefinitions = context.getDocument().definitions;
+
+  for (const def of astDefinitions) {
+    if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+      uniqueDirectiveMap[def.name.value] = !def.repeatable;
+    }
+  }
+
+  const schemaDirectives = Object.create(null);
+  const typeDirectivesMap = Object.create(null);
+  return {
+    // Many different AST nodes may contain directives. Rather than listing
+    // them all, just listen for entering any node, and check to see if it
+    // defines any directives.
+    enter(node) {
+      if (!('directives' in node) || !node.directives) {
+        return;
+      }
+
+      let seenDirectives;
+
+      if (
+        node.kind === Kind.SCHEMA_DEFINITION ||
+        node.kind === Kind.SCHEMA_EXTENSION
+      ) {
+        seenDirectives = schemaDirectives;
+      } else if (isTypeDefinitionNode(node) || isTypeExtensionNode(node)) {
+        const typeName = node.name.value;
+        seenDirectives = typeDirectivesMap[typeName];
+
+        if (seenDirectives === undefined) {
+          typeDirectivesMap[typeName] = seenDirectives = Object.create(null);
+        }
+      } else {
+        seenDirectives = Object.create(null);
+      }
+
+      for (const directive of node.directives) {
+        const directiveName = directive.name.value;
+
+        if (uniqueDirectiveMap[directiveName]) {
+          if (seenDirectives[directiveName]) {
+            context.reportError(
+              new GraphQLError(
+                `The directive "@${directiveName}" can only be used once at this location.`,
+                [seenDirectives[directiveName], directive],
+              ),
+            );
+          } else {
+            seenDirectives[directiveName] = directive;
+          }
+        }
+      }
+    },
+  };
+}

package/validation/rules/UniqueEnumValueNamesRule.d.ts

@@ -0,0 +1,10 @@
+import type { ASTVisitor } from '../../language/visitor';
+import type { SDLValidationContext } from '../ValidationContext';
+/**
+ * Unique enum value names
+ *
+ * A GraphQL enum type is only valid if all its values are uniquely named.
+ */
+export declare function UniqueEnumValueNamesRule(
+  context: SDLValidationContext,
+): ASTVisitor;

package/validation/rules/UniqueEnumValueNamesRule.js

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.UniqueEnumValueNamesRule = UniqueEnumValueNamesRule;
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+var _definition = require('../../type/definition.js');
+
+/**
+ * Unique enum value names
+ *
+ * A GraphQL enum type is only valid if all its values are uniquely named.
+ */
+function UniqueEnumValueNamesRule(context) {
+  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) {
+    var _node$values;
+
+    const typeName = node.name.value;
+
+    if (!knownValueNames[typeName]) {
+      knownValueNames[typeName] = Object.create(null);
+    } // FIXME: https://github.com/graphql/graphql-js/issues/2203
+
+    /* c8 ignore next */
+
+    const valueNodes =
+      (_node$values = node.values) !== null && _node$values !== void 0
+        ? _node$values
+        : [];
+    const valueNames = knownValueNames[typeName];
+
+    for (const valueDef of valueNodes) {
+      const valueName = valueDef.name.value;
+      const existingType = existingTypeMap[typeName];
+
+      if (
+        (0, _definition.isEnumType)(existingType) &&
+        existingType.getValue(valueName)
+      ) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `Enum value "${typeName}.${valueName}" already exists in the schema. It cannot also be defined in this type extension.`,
+            valueDef.name,
+          ),
+        );
+      } else if (valueNames[valueName]) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `Enum value "${typeName}.${valueName}" can only be defined once.`,
+            [valueNames[valueName], valueDef.name],
+          ),
+        );
+      } else {
+        valueNames[valueName] = valueDef.name;
+      }
+    }
+
+    return false;
+  }
+}

package/validation/rules/UniqueEnumValueNamesRule.mjs

@@ -0,0 +1,60 @@
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+import { isEnumType } from '../../type/definition.mjs';
+
+/**
+ * Unique enum value names
+ *
+ * A GraphQL enum type is only valid if all its values are uniquely named.
+ */
+export function UniqueEnumValueNamesRule(context) {
+  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) {
+    var _node$values;
+
+    const typeName = node.name.value;
+
+    if (!knownValueNames[typeName]) {
+      knownValueNames[typeName] = Object.create(null);
+    } // FIXME: https://github.com/graphql/graphql-js/issues/2203
+
+    /* c8 ignore next */
+
+    const valueNodes =
+      (_node$values = node.values) !== null && _node$values !== void 0
+        ? _node$values
+        : [];
+    const valueNames = knownValueNames[typeName];
+
+    for (const valueDef of valueNodes) {
+      const valueName = valueDef.name.value;
+      const existingType = existingTypeMap[typeName];
+
+      if (isEnumType(existingType) && existingType.getValue(valueName)) {
+        context.reportError(
+          new GraphQLError(
+            `Enum value "${typeName}.${valueName}" already exists in the schema. It cannot also be defined in this type extension.`,
+            valueDef.name,
+          ),
+        );
+      } else if (valueNames[valueName]) {
+        context.reportError(
+          new GraphQLError(
+            `Enum value "${typeName}.${valueName}" can only be defined once.`,
+            [valueNames[valueName], valueDef.name],
+          ),
+        );
+      } else {
+        valueNames[valueName] = valueDef.name;
+      }
+    }
+
+    return false;
+  }
+}

package/validation/rules/UniqueFieldDefinitionNamesRule.d.ts

@@ -0,0 +1,10 @@
+import type { ASTVisitor } from '../../language/visitor';
+import type { SDLValidationContext } from '../ValidationContext';
+/**
+ * Unique field definition names
+ *
+ * A GraphQL complex type is only valid if all its fields are uniquely named.
+ */
+export declare function UniqueFieldDefinitionNamesRule(
+  context: SDLValidationContext,
+): ASTVisitor;

package/validation/rules/UniqueFieldDefinitionNamesRule.js

@@ -0,0 +1,83 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.UniqueFieldDefinitionNamesRule = UniqueFieldDefinitionNamesRule;
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+var _definition = require('../../type/definition.js');
+
+/**
+ * Unique field definition names
+ *
+ * A GraphQL complex type is only valid if all its fields are uniquely named.
+ */
+function UniqueFieldDefinitionNamesRule(context) {
+  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) {
+    var _node$fields;
+
+    const typeName = node.name.value;
+
+    if (!knownFieldNames[typeName]) {
+      knownFieldNames[typeName] = Object.create(null);
+    } // FIXME: https://github.com/graphql/graphql-js/issues/2203
+
+    /* c8 ignore next */
+
+    const fieldNodes =
+      (_node$fields = node.fields) !== null && _node$fields !== void 0
+        ? _node$fields
+        : [];
+    const fieldNames = knownFieldNames[typeName];
+
+    for (const fieldDef of fieldNodes) {
+      const fieldName = fieldDef.name.value;
+
+      if (hasField(existingTypeMap[typeName], fieldName)) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `Field "${typeName}.${fieldName}" already exists in the schema. It cannot also be defined in this type extension.`,
+            fieldDef.name,
+          ),
+        );
+      } else if (fieldNames[fieldName]) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `Field "${typeName}.${fieldName}" can only be defined once.`,
+            [fieldNames[fieldName], fieldDef.name],
+          ),
+        );
+      } else {
+        fieldNames[fieldName] = fieldDef.name;
+      }
+    }
+
+    return false;
+  }
+}
+
+function hasField(type, fieldName) {
+  if (
+    (0, _definition.isObjectType)(type) ||
+    (0, _definition.isInterfaceType)(type) ||
+    (0, _definition.isInputObjectType)(type)
+  ) {
+    return type.getFields()[fieldName] != null;
+  }
+
+  return false;
+}

package/validation/rules/UniqueFieldDefinitionNamesRule.mjs

@@ -0,0 +1,75 @@
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+import {
+  isInputObjectType,
+  isInterfaceType,
+  isObjectType,
+} from '../../type/definition.mjs';
+
+/**
+ * Unique field definition names
+ *
+ * A GraphQL complex type is only valid if all its fields are uniquely named.
+ */
+export function UniqueFieldDefinitionNamesRule(context) {
+  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) {
+    var _node$fields;
+
+    const typeName = node.name.value;
+
+    if (!knownFieldNames[typeName]) {
+      knownFieldNames[typeName] = Object.create(null);
+    } // FIXME: https://github.com/graphql/graphql-js/issues/2203
+
+    /* c8 ignore next */
+
+    const fieldNodes =
+      (_node$fields = node.fields) !== null && _node$fields !== void 0
+        ? _node$fields
+        : [];
+    const fieldNames = knownFieldNames[typeName];
+
+    for (const fieldDef of fieldNodes) {
+      const fieldName = fieldDef.name.value;
+
+      if (hasField(existingTypeMap[typeName], fieldName)) {
+        context.reportError(
+          new GraphQLError(
+            `Field "${typeName}.${fieldName}" already exists in the schema. It cannot also be defined in this type extension.`,
+            fieldDef.name,
+          ),
+        );
+      } else if (fieldNames[fieldName]) {
+        context.reportError(
+          new GraphQLError(
+            `Field "${typeName}.${fieldName}" can only be defined once.`,
+            [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] != null;
+  }
+
+  return false;
+}

package/validation/rules/UniqueFragmentNamesRule.d.ts

@@ -0,0 +1,12 @@
+import type { ASTVisitor } from '../../language/visitor';
+import type { ASTValidationContext } from '../ValidationContext';
+/**
+ * Unique fragment names
+ *
+ * A GraphQL document is only valid if all defined fragments have unique names.
+ *
+ * See https://spec.graphql.org/draft/#sec-Fragment-Name-Uniqueness
+ */
+export declare function UniqueFragmentNamesRule(
+  context: ASTValidationContext,
+): ASTVisitor;