graphql 0.0.1-test.1

package/validation/rules/UniqueFragmentNamesRule.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.UniqueFragmentNamesRule = UniqueFragmentNamesRule;
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+/**
+ * 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
+ */
+function UniqueFragmentNamesRule(context) {
+  const knownFragmentNames = Object.create(null);
+  return {
+    OperationDefinition: () => false,
+
+    FragmentDefinition(node) {
+      const fragmentName = node.name.value;
+
+      if (knownFragmentNames[fragmentName]) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `There can be only one fragment named "${fragmentName}".`,
+            [knownFragmentNames[fragmentName], node.name],
+          ),
+        );
+      } else {
+        knownFragmentNames[fragmentName] = node.name;
+      }
+
+      return false;
+    },
+  };
+}

package/validation/rules/UniqueFragmentNamesRule.mjs

@@ -0,0 +1,32 @@
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+
+/**
+ * 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 function UniqueFragmentNamesRule(context) {
+  const knownFragmentNames = Object.create(null);
+  return {
+    OperationDefinition: () => false,
+
+    FragmentDefinition(node) {
+      const fragmentName = node.name.value;
+
+      if (knownFragmentNames[fragmentName]) {
+        context.reportError(
+          new GraphQLError(
+            `There can be only one fragment named "${fragmentName}".`,
+            [knownFragmentNames[fragmentName], node.name],
+          ),
+        );
+      } else {
+        knownFragmentNames[fragmentName] = node.name;
+      }
+
+      return false;
+    },
+  };
+}

package/validation/rules/UniqueInputFieldNamesRule.d.ts

@@ -0,0 +1,13 @@
+import type { ASTVisitor } from '../../language/visitor';
+import type { ASTValidationContext } from '../ValidationContext';
+/**
+ * Unique input field names
+ *
+ * A GraphQL input object value is only valid if all supplied fields are
+ * uniquely named.
+ *
+ * See https://spec.graphql.org/draft/#sec-Input-Object-Field-Uniqueness
+ */
+export declare function UniqueInputFieldNamesRule(
+  context: ASTValidationContext,
+): ASTVisitor;

package/validation/rules/UniqueInputFieldNamesRule.js

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.UniqueInputFieldNamesRule = UniqueInputFieldNamesRule;
+
+var _invariant = require('../../jsutils/invariant.js');
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+/**
+ * Unique input field names
+ *
+ * A GraphQL input object value is only valid if all supplied fields are
+ * uniquely named.
+ *
+ * See https://spec.graphql.org/draft/#sec-Input-Object-Field-Uniqueness
+ */
+function UniqueInputFieldNamesRule(context) {
+  const knownNameStack = [];
+  let knownNames = Object.create(null);
+  return {
+    ObjectValue: {
+      enter() {
+        knownNameStack.push(knownNames);
+        knownNames = Object.create(null);
+      },
+
+      leave() {
+        const prevKnownNames = knownNameStack.pop();
+        prevKnownNames || (0, _invariant.invariant)(false);
+        knownNames = prevKnownNames;
+      },
+    },
+
+    ObjectField(node) {
+      const fieldName = node.name.value;
+
+      if (knownNames[fieldName]) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `There can be only one input field named "${fieldName}".`,
+            [knownNames[fieldName], node.name],
+          ),
+        );
+      } else {
+        knownNames[fieldName] = node.name;
+      }
+    },
+  };
+}

package/validation/rules/UniqueInputFieldNamesRule.mjs

@@ -0,0 +1,44 @@
+import { invariant } from '../../jsutils/invariant.mjs';
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+
+/**
+ * Unique input field names
+ *
+ * A GraphQL input object value is only valid if all supplied fields are
+ * uniquely named.
+ *
+ * See https://spec.graphql.org/draft/#sec-Input-Object-Field-Uniqueness
+ */
+export function UniqueInputFieldNamesRule(context) {
+  const knownNameStack = [];
+  let knownNames = Object.create(null);
+  return {
+    ObjectValue: {
+      enter() {
+        knownNameStack.push(knownNames);
+        knownNames = Object.create(null);
+      },
+
+      leave() {
+        const prevKnownNames = knownNameStack.pop();
+        prevKnownNames || invariant(false);
+        knownNames = prevKnownNames;
+      },
+    },
+
+    ObjectField(node) {
+      const fieldName = node.name.value;
+
+      if (knownNames[fieldName]) {
+        context.reportError(
+          new GraphQLError(
+            `There can be only one input field named "${fieldName}".`,
+            [knownNames[fieldName], node.name],
+          ),
+        );
+      } else {
+        knownNames[fieldName] = node.name;
+      }
+    },
+  };
+}

package/validation/rules/UniqueOperationNamesRule.d.ts

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

package/validation/rules/UniqueOperationNamesRule.js

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.UniqueOperationNamesRule = UniqueOperationNamesRule;
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+/**
+ * Unique operation names
+ *
+ * A GraphQL document is only valid if all defined operations have unique names.
+ *
+ * See https://spec.graphql.org/draft/#sec-Operation-Name-Uniqueness
+ */
+function UniqueOperationNamesRule(context) {
+  const knownOperationNames = Object.create(null);
+  return {
+    OperationDefinition(node) {
+      const operationName = node.name;
+
+      if (operationName) {
+        if (knownOperationNames[operationName.value]) {
+          context.reportError(
+            new _GraphQLError.GraphQLError(
+              `There can be only one operation named "${operationName.value}".`,
+              [knownOperationNames[operationName.value], operationName],
+            ),
+          );
+        } else {
+          knownOperationNames[operationName.value] = operationName;
+        }
+      }
+
+      return false;
+    },
+
+    FragmentDefinition: () => false,
+  };
+}

package/validation/rules/UniqueOperationNamesRule.mjs

@@ -0,0 +1,34 @@
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+
+/**
+ * Unique operation names
+ *
+ * A GraphQL document is only valid if all defined operations have unique names.
+ *
+ * See https://spec.graphql.org/draft/#sec-Operation-Name-Uniqueness
+ */
+export function UniqueOperationNamesRule(context) {
+  const knownOperationNames = Object.create(null);
+  return {
+    OperationDefinition(node) {
+      const operationName = node.name;
+
+      if (operationName) {
+        if (knownOperationNames[operationName.value]) {
+          context.reportError(
+            new GraphQLError(
+              `There can be only one operation named "${operationName.value}".`,
+              [knownOperationNames[operationName.value], operationName],
+            ),
+          );
+        } else {
+          knownOperationNames[operationName.value] = operationName;
+        }
+      }
+
+      return false;
+    },
+
+    FragmentDefinition: () => false,
+  };
+}

package/validation/rules/UniqueOperationTypesRule.d.ts

@@ -0,0 +1,10 @@
+import type { ASTVisitor } from '../../language/visitor';
+import type { SDLValidationContext } from '../ValidationContext';
+/**
+ * Unique operation types
+ *
+ * A GraphQL document is only valid if it has only one type per operation.
+ */
+export declare function UniqueOperationTypesRule(
+  context: SDLValidationContext,
+): ASTVisitor;

package/validation/rules/UniqueOperationTypesRule.js

@@ -0,0 +1,67 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.UniqueOperationTypesRule = UniqueOperationTypesRule;
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+/**
+ * Unique operation types
+ *
+ * A GraphQL document is only valid if it has only one type per operation.
+ */
+function UniqueOperationTypesRule(context) {
+  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) {
+    var _node$operationTypes;
+
+    // See: https://github.com/graphql/graphql-js/issues/2203
+
+    /* c8 ignore next */
+    const operationTypesNodes =
+      (_node$operationTypes = node.operationTypes) !== null &&
+      _node$operationTypes !== void 0
+        ? _node$operationTypes
+        : [];
+
+    for (const operationType of operationTypesNodes) {
+      const operation = operationType.operation;
+      const alreadyDefinedOperationType = definedOperationTypes[operation];
+
+      if (existingOperationTypes[operation]) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `Type for ${operation} already defined in the schema. It cannot be redefined.`,
+            operationType,
+          ),
+        );
+      } else if (alreadyDefinedOperationType) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `There can be only one ${operation} type in schema.`,
+            [alreadyDefinedOperationType, operationType],
+          ),
+        );
+      } else {
+        definedOperationTypes[operation] = operationType;
+      }
+    }
+
+    return false;
+  }
+}

package/validation/rules/UniqueOperationTypesRule.mjs

@@ -0,0 +1,60 @@
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+
+/**
+ * Unique operation types
+ *
+ * A GraphQL document is only valid if it has only one type per operation.
+ */
+export function UniqueOperationTypesRule(context) {
+  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) {
+    var _node$operationTypes;
+
+    // See: https://github.com/graphql/graphql-js/issues/2203
+
+    /* c8 ignore next */
+    const operationTypesNodes =
+      (_node$operationTypes = node.operationTypes) !== null &&
+      _node$operationTypes !== void 0
+        ? _node$operationTypes
+        : [];
+
+    for (const operationType of operationTypesNodes) {
+      const operation = operationType.operation;
+      const alreadyDefinedOperationType = definedOperationTypes[operation];
+
+      if (existingOperationTypes[operation]) {
+        context.reportError(
+          new GraphQLError(
+            `Type for ${operation} already defined in the schema. It cannot be redefined.`,
+            operationType,
+          ),
+        );
+      } else if (alreadyDefinedOperationType) {
+        context.reportError(
+          new GraphQLError(
+            `There can be only one ${operation} type in schema.`,
+            [alreadyDefinedOperationType, operationType],
+          ),
+        );
+      } else {
+        definedOperationTypes[operation] = operationType;
+      }
+    }
+
+    return false;
+  }
+}

package/validation/rules/UniqueTypeNamesRule.d.ts

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

package/validation/rules/UniqueTypeNamesRule.js

@@ -0,0 +1,53 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.UniqueTypeNamesRule = UniqueTypeNamesRule;
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+/**
+ * Unique type names
+ *
+ * A GraphQL document is only valid if all defined types have unique names.
+ */
+function UniqueTypeNamesRule(context) {
+  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) {
+    const typeName = node.name.value;
+
+    if (schema !== null && schema !== void 0 && schema.getType(typeName)) {
+      context.reportError(
+        new _GraphQLError.GraphQLError(
+          `Type "${typeName}" already exists in the schema. It cannot also be defined in this type definition.`,
+          node.name,
+        ),
+      );
+      return;
+    }
+
+    if (knownTypeNames[typeName]) {
+      context.reportError(
+        new _GraphQLError.GraphQLError(
+          `There can be only one type named "${typeName}".`,
+          [knownTypeNames[typeName], node.name],
+        ),
+      );
+    } else {
+      knownTypeNames[typeName] = node.name;
+    }
+
+    return false;
+  }
+}

package/validation/rules/UniqueTypeNamesRule.mjs

@@ -0,0 +1,46 @@
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+
+/**
+ * Unique type names
+ *
+ * A GraphQL document is only valid if all defined types have unique names.
+ */
+export function UniqueTypeNamesRule(context) {
+  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) {
+    const typeName = node.name.value;
+
+    if (schema !== null && schema !== void 0 && schema.getType(typeName)) {
+      context.reportError(
+        new GraphQLError(
+          `Type "${typeName}" already exists in the schema. It cannot also be defined in this type definition.`,
+          node.name,
+        ),
+      );
+      return;
+    }
+
+    if (knownTypeNames[typeName]) {
+      context.reportError(
+        new GraphQLError(`There can be only one type named "${typeName}".`, [
+          knownTypeNames[typeName],
+          node.name,
+        ]),
+      );
+    } else {
+      knownTypeNames[typeName] = node.name;
+    }
+
+    return false;
+  }
+}

package/validation/rules/UniqueVariableNamesRule.d.ts

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

package/validation/rules/UniqueVariableNamesRule.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.UniqueVariableNamesRule = UniqueVariableNamesRule;
+
+var _groupBy = require('../../jsutils/groupBy.js');
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+/**
+ * Unique variable names
+ *
+ * A GraphQL operation is only valid if all its variables are uniquely named.
+ */
+function UniqueVariableNamesRule(context) {
+  return {
+    OperationDefinition(operationNode) {
+      var _operationNode$variab;
+
+      // See: https://github.com/graphql/graphql-js/issues/2203
+
+      /* c8 ignore next */
+      const variableDefinitions =
+        (_operationNode$variab = operationNode.variableDefinitions) !== null &&
+        _operationNode$variab !== void 0
+          ? _operationNode$variab
+          : [];
+      const seenVariableDefinitions = (0, _groupBy.groupBy)(
+        variableDefinitions,
+        (node) => node.variable.name.value,
+      );
+
+      for (const [variableName, variableNodes] of seenVariableDefinitions) {
+        if (variableNodes.length > 1) {
+          context.reportError(
+            new _GraphQLError.GraphQLError(
+              `There can be only one variable named "$${variableName}".`,
+              variableNodes.map((node) => node.variable.name),
+            ),
+          );
+        }
+      }
+    },
+  };
+}

package/validation/rules/UniqueVariableNamesRule.mjs

@@ -0,0 +1,39 @@
+import { groupBy } from '../../jsutils/groupBy.mjs';
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+
+/**
+ * Unique variable names
+ *
+ * A GraphQL operation is only valid if all its variables are uniquely named.
+ */
+export function UniqueVariableNamesRule(context) {
+  return {
+    OperationDefinition(operationNode) {
+      var _operationNode$variab;
+
+      // See: https://github.com/graphql/graphql-js/issues/2203
+
+      /* c8 ignore next */
+      const variableDefinitions =
+        (_operationNode$variab = operationNode.variableDefinitions) !== null &&
+        _operationNode$variab !== void 0
+          ? _operationNode$variab
+          : [];
+      const seenVariableDefinitions = groupBy(
+        variableDefinitions,
+        (node) => node.variable.name.value,
+      );
+
+      for (const [variableName, variableNodes] of seenVariableDefinitions) {
+        if (variableNodes.length > 1) {
+          context.reportError(
+            new GraphQLError(
+              `There can be only one variable named "$${variableName}".`,
+              variableNodes.map((node) => node.variable.name),
+            ),
+          );
+        }
+      }
+    },
+  };
+}

package/validation/rules/ValuesOfCorrectTypeRule.d.ts

@@ -0,0 +1,13 @@
+import type { ASTVisitor } from '../../language/visitor';
+import type { ValidationContext } from '../ValidationContext';
+/**
+ * Value literals of correct type
+ *
+ * A GraphQL document is only valid if all value literals are of the type
+ * expected at their position.
+ *
+ * See https://spec.graphql.org/draft/#sec-Values-of-Correct-Type
+ */
+export declare function ValuesOfCorrectTypeRule(
+  context: ValidationContext,
+): ASTVisitor;