graphql 0.0.1-test.1

package/validation/rules/KnownDirectivesRule.mjs

@@ -0,0 +1,146 @@
+import { inspect } from '../../jsutils/inspect.mjs';
+import { invariant } from '../../jsutils/invariant.mjs';
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+import { OperationTypeNode } from '../../language/ast.mjs';
+import { DirectiveLocation } from '../../language/directiveLocation.mjs';
+import { Kind } from '../../language/kinds.mjs';
+import { specifiedDirectives } from '../../type/directives.mjs';
+
+/**
+ * Known directives
+ *
+ * A GraphQL document is only valid if all `@directives` are known by the
+ * schema and legally positioned.
+ *
+ * See https://spec.graphql.org/draft/#sec-Directives-Are-Defined
+ */
+export function KnownDirectivesRule(context) {
+  const locationsMap = Object.create(null);
+  const schema = context.getSchema();
+  const definedDirectives = schema
+    ? schema.getDirectives()
+    : specifiedDirectives;
+
+  for (const directive of definedDirectives) {
+    locationsMap[directive.name] = directive.locations;
+  }
+
+  const astDefinitions = context.getDocument().definitions;
+
+  for (const def of astDefinitions) {
+    if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+      locationsMap[def.name.value] = def.locations.map((name) => name.value);
+    }
+  }
+
+  return {
+    Directive(node, _key, _parent, _path, ancestors) {
+      const name = node.name.value;
+      const locations = locationsMap[name];
+
+      if (!locations) {
+        context.reportError(
+          new GraphQLError(`Unknown directive "@${name}".`, node),
+        );
+        return;
+      }
+
+      const candidateLocation = getDirectiveLocationForASTPath(ancestors);
+
+      if (candidateLocation && !locations.includes(candidateLocation)) {
+        context.reportError(
+          new GraphQLError(
+            `Directive "@${name}" may not be used on ${candidateLocation}.`,
+            node,
+          ),
+        );
+      }
+    },
+  };
+}
+
+function getDirectiveLocationForASTPath(ancestors) {
+  const appliedTo = ancestors[ancestors.length - 1];
+  'kind' in appliedTo || invariant(false);
+
+  switch (appliedTo.kind) {
+    case Kind.OPERATION_DEFINITION:
+      return getDirectiveLocationForOperation(appliedTo.operation);
+
+    case Kind.FIELD:
+      return DirectiveLocation.FIELD;
+
+    case Kind.FRAGMENT_SPREAD:
+      return DirectiveLocation.FRAGMENT_SPREAD;
+
+    case Kind.INLINE_FRAGMENT:
+      return DirectiveLocation.INLINE_FRAGMENT;
+
+    case Kind.FRAGMENT_DEFINITION:
+      return DirectiveLocation.FRAGMENT_DEFINITION;
+
+    case Kind.VARIABLE_DEFINITION:
+      return DirectiveLocation.VARIABLE_DEFINITION;
+
+    case Kind.SCHEMA_DEFINITION:
+    case Kind.SCHEMA_EXTENSION:
+      return DirectiveLocation.SCHEMA;
+
+    case Kind.SCALAR_TYPE_DEFINITION:
+    case Kind.SCALAR_TYPE_EXTENSION:
+      return DirectiveLocation.SCALAR;
+
+    case Kind.OBJECT_TYPE_DEFINITION:
+    case Kind.OBJECT_TYPE_EXTENSION:
+      return DirectiveLocation.OBJECT;
+
+    case Kind.FIELD_DEFINITION:
+      return DirectiveLocation.FIELD_DEFINITION;
+
+    case Kind.INTERFACE_TYPE_DEFINITION:
+    case Kind.INTERFACE_TYPE_EXTENSION:
+      return DirectiveLocation.INTERFACE;
+
+    case Kind.UNION_TYPE_DEFINITION:
+    case Kind.UNION_TYPE_EXTENSION:
+      return DirectiveLocation.UNION;
+
+    case Kind.ENUM_TYPE_DEFINITION:
+    case Kind.ENUM_TYPE_EXTENSION:
+      return DirectiveLocation.ENUM;
+
+    case Kind.ENUM_VALUE_DEFINITION:
+      return DirectiveLocation.ENUM_VALUE;
+
+    case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+    case Kind.INPUT_OBJECT_TYPE_EXTENSION:
+      return DirectiveLocation.INPUT_OBJECT;
+
+    case Kind.INPUT_VALUE_DEFINITION: {
+      const parentNode = ancestors[ancestors.length - 3];
+      'kind' in parentNode || invariant(false);
+      return parentNode.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION
+        ? DirectiveLocation.INPUT_FIELD_DEFINITION
+        : DirectiveLocation.ARGUMENT_DEFINITION;
+    }
+    // Not reachable, all possible types have been considered.
+
+    /* c8 ignore next */
+
+    default:
+      false || invariant(false, 'Unexpected kind: ' + inspect(appliedTo.kind));
+  }
+}
+
+function getDirectiveLocationForOperation(operation) {
+  switch (operation) {
+    case OperationTypeNode.QUERY:
+      return DirectiveLocation.QUERY;
+
+    case OperationTypeNode.MUTATION:
+      return DirectiveLocation.MUTATION;
+
+    case OperationTypeNode.SUBSCRIPTION:
+      return DirectiveLocation.SUBSCRIPTION;
+  }
+}

package/validation/rules/KnownFragmentNamesRule.d.ts

@@ -0,0 +1,13 @@
+import type { ASTVisitor } from '../../language/visitor';
+import type { ValidationContext } from '../ValidationContext';
+/**
+ * Known fragment names
+ *
+ * A GraphQL document is only valid if all `...Fragment` fragment spreads refer
+ * to fragments defined in the same document.
+ *
+ * See https://spec.graphql.org/draft/#sec-Fragment-spread-target-defined
+ */
+export declare function KnownFragmentNamesRule(
+  context: ValidationContext,
+): ASTVisitor;

package/validation/rules/KnownFragmentNamesRule.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.KnownFragmentNamesRule = KnownFragmentNamesRule;
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+/**
+ * Known fragment names
+ *
+ * A GraphQL document is only valid if all `...Fragment` fragment spreads refer
+ * to fragments defined in the same document.
+ *
+ * See https://spec.graphql.org/draft/#sec-Fragment-spread-target-defined
+ */
+function KnownFragmentNamesRule(context) {
+  return {
+    FragmentSpread(node) {
+      const fragmentName = node.name.value;
+      const fragment = context.getFragment(fragmentName);
+
+      if (!fragment) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `Unknown fragment "${fragmentName}".`,
+            node.name,
+          ),
+        );
+      }
+    },
+  };
+}

package/validation/rules/KnownFragmentNamesRule.mjs

@@ -0,0 +1,24 @@
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+
+/**
+ * Known fragment names
+ *
+ * A GraphQL document is only valid if all `...Fragment` fragment spreads refer
+ * to fragments defined in the same document.
+ *
+ * See https://spec.graphql.org/draft/#sec-Fragment-spread-target-defined
+ */
+export function KnownFragmentNamesRule(context) {
+  return {
+    FragmentSpread(node) {
+      const fragmentName = node.name.value;
+      const fragment = context.getFragment(fragmentName);
+
+      if (!fragment) {
+        context.reportError(
+          new GraphQLError(`Unknown fragment "${fragmentName}".`, node.name),
+        );
+      }
+    },
+  };
+}

package/validation/rules/KnownTypeNamesRule.d.ts

@@ -0,0 +1,16 @@
+import type { ASTVisitor } from '../../language/visitor';
+import type {
+  SDLValidationContext,
+  ValidationContext,
+} from '../ValidationContext';
+/**
+ * Known type names
+ *
+ * A GraphQL document is only valid if referenced types (specifically
+ * variable definitions and fragment conditions) are defined by the type schema.
+ *
+ * See https://spec.graphql.org/draft/#sec-Fragment-Spread-Type-Existence
+ */
+export declare function KnownTypeNamesRule(
+  context: ValidationContext | SDLValidationContext,
+): ASTVisitor;

package/validation/rules/KnownTypeNamesRule.js

@@ -0,0 +1,87 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.KnownTypeNamesRule = KnownTypeNamesRule;
+
+var _didYouMean = require('../../jsutils/didYouMean.js');
+
+var _suggestionList = require('../../jsutils/suggestionList.js');
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+var _predicates = require('../../language/predicates.js');
+
+var _introspection = require('../../type/introspection.js');
+
+var _scalars = require('../../type/scalars.js');
+
+/**
+ * Known type names
+ *
+ * A GraphQL document is only valid if referenced types (specifically
+ * variable definitions and fragment conditions) are defined by the type schema.
+ *
+ * See https://spec.graphql.org/draft/#sec-Fragment-Spread-Type-Existence
+ */
+function KnownTypeNamesRule(context) {
+  const schema = context.getSchema();
+  const existingTypesMap = schema ? schema.getTypeMap() : Object.create(null);
+  const definedTypes = Object.create(null);
+
+  for (const def of context.getDocument().definitions) {
+    if ((0, _predicates.isTypeDefinitionNode)(def)) {
+      definedTypes[def.name.value] = true;
+    }
+  }
+
+  const typeNames = [
+    ...Object.keys(existingTypesMap),
+    ...Object.keys(definedTypes),
+  ];
+  return {
+    NamedType(node, _1, parent, _2, ancestors) {
+      const typeName = node.name.value;
+
+      if (!existingTypesMap[typeName] && !definedTypes[typeName]) {
+        var _ancestors$;
+
+        const definitionNode =
+          (_ancestors$ = ancestors[2]) !== null && _ancestors$ !== void 0
+            ? _ancestors$
+            : parent;
+        const isSDL = definitionNode != null && isSDLNode(definitionNode);
+
+        if (isSDL && standardTypeNames.includes(typeName)) {
+          return;
+        }
+
+        const suggestedTypes = (0, _suggestionList.suggestionList)(
+          typeName,
+          isSDL ? standardTypeNames.concat(typeNames) : typeNames,
+        );
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `Unknown type "${typeName}".` +
+              (0, _didYouMean.didYouMean)(suggestedTypes),
+            node,
+          ),
+        );
+      }
+    },
+  };
+}
+
+const standardTypeNames = [
+  ..._scalars.specifiedScalarTypes,
+  ..._introspection.introspectionTypes,
+].map((type) => type.name);
+
+function isSDLNode(value) {
+  return (
+    'kind' in value &&
+    ((0, _predicates.isTypeSystemDefinitionNode)(value) ||
+      (0, _predicates.isTypeSystemExtensionNode)(value))
+  );
+}

package/validation/rules/KnownTypeNamesRule.mjs

@@ -0,0 +1,75 @@
+import { didYouMean } from '../../jsutils/didYouMean.mjs';
+import { suggestionList } from '../../jsutils/suggestionList.mjs';
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+import {
+  isTypeDefinitionNode,
+  isTypeSystemDefinitionNode,
+  isTypeSystemExtensionNode,
+} from '../../language/predicates.mjs';
+import { introspectionTypes } from '../../type/introspection.mjs';
+import { specifiedScalarTypes } from '../../type/scalars.mjs';
+
+/**
+ * Known type names
+ *
+ * A GraphQL document is only valid if referenced types (specifically
+ * variable definitions and fragment conditions) are defined by the type schema.
+ *
+ * See https://spec.graphql.org/draft/#sec-Fragment-Spread-Type-Existence
+ */
+export function KnownTypeNamesRule(context) {
+  const schema = context.getSchema();
+  const existingTypesMap = schema ? schema.getTypeMap() : Object.create(null);
+  const definedTypes = Object.create(null);
+
+  for (const def of context.getDocument().definitions) {
+    if (isTypeDefinitionNode(def)) {
+      definedTypes[def.name.value] = true;
+    }
+  }
+
+  const typeNames = [
+    ...Object.keys(existingTypesMap),
+    ...Object.keys(definedTypes),
+  ];
+  return {
+    NamedType(node, _1, parent, _2, ancestors) {
+      const typeName = node.name.value;
+
+      if (!existingTypesMap[typeName] && !definedTypes[typeName]) {
+        var _ancestors$;
+
+        const definitionNode =
+          (_ancestors$ = ancestors[2]) !== null && _ancestors$ !== void 0
+            ? _ancestors$
+            : parent;
+        const isSDL = definitionNode != null && isSDLNode(definitionNode);
+
+        if (isSDL && standardTypeNames.includes(typeName)) {
+          return;
+        }
+
+        const suggestedTypes = suggestionList(
+          typeName,
+          isSDL ? standardTypeNames.concat(typeNames) : typeNames,
+        );
+        context.reportError(
+          new GraphQLError(
+            `Unknown type "${typeName}".` + didYouMean(suggestedTypes),
+            node,
+          ),
+        );
+      }
+    },
+  };
+}
+const standardTypeNames = [...specifiedScalarTypes, ...introspectionTypes].map(
+  (type) => type.name,
+);
+
+function isSDLNode(value) {
+  return (
+    'kind' in value &&
+    (isTypeSystemDefinitionNode(value) || isTypeSystemExtensionNode(value))
+  );
+}

package/validation/rules/LoneAnonymousOperationRule.d.ts

@@ -0,0 +1,13 @@
+import type { ASTVisitor } from '../../language/visitor';
+import type { ASTValidationContext } from '../ValidationContext';
+/**
+ * Lone anonymous operation
+ *
+ * A GraphQL document is only valid if when it contains an anonymous operation
+ * (the query short-hand) that it contains only that one operation definition.
+ *
+ * See https://spec.graphql.org/draft/#sec-Lone-Anonymous-Operation
+ */
+export declare function LoneAnonymousOperationRule(
+  context: ASTValidationContext,
+): ASTVisitor;

package/validation/rules/LoneAnonymousOperationRule.js

@@ -0,0 +1,40 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.LoneAnonymousOperationRule = LoneAnonymousOperationRule;
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+var _kinds = require('../../language/kinds.js');
+
+/**
+ * Lone anonymous operation
+ *
+ * A GraphQL document is only valid if when it contains an anonymous operation
+ * (the query short-hand) that it contains only that one operation definition.
+ *
+ * See https://spec.graphql.org/draft/#sec-Lone-Anonymous-Operation
+ */
+function LoneAnonymousOperationRule(context) {
+  let operationCount = 0;
+  return {
+    Document(node) {
+      operationCount = node.definitions.filter(
+        (definition) => definition.kind === _kinds.Kind.OPERATION_DEFINITION,
+      ).length;
+    },
+
+    OperationDefinition(node) {
+      if (!node.name && operationCount > 1) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            'This anonymous operation must be the only defined operation.',
+            node,
+          ),
+        );
+      }
+    },
+  };
+}

package/validation/rules/LoneAnonymousOperationRule.mjs

@@ -0,0 +1,32 @@
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+import { Kind } from '../../language/kinds.mjs';
+
+/**
+ * Lone anonymous operation
+ *
+ * A GraphQL document is only valid if when it contains an anonymous operation
+ * (the query short-hand) that it contains only that one operation definition.
+ *
+ * See https://spec.graphql.org/draft/#sec-Lone-Anonymous-Operation
+ */
+export function LoneAnonymousOperationRule(context) {
+  let operationCount = 0;
+  return {
+    Document(node) {
+      operationCount = node.definitions.filter(
+        (definition) => definition.kind === Kind.OPERATION_DEFINITION,
+      ).length;
+    },
+
+    OperationDefinition(node) {
+      if (!node.name && operationCount > 1) {
+        context.reportError(
+          new GraphQLError(
+            'This anonymous operation must be the only defined operation.',
+            node,
+          ),
+        );
+      }
+    },
+  };
+}

package/validation/rules/LoneSchemaDefinitionRule.d.ts

@@ -0,0 +1,10 @@
+import type { ASTVisitor } from '../../language/visitor';
+import type { SDLValidationContext } from '../ValidationContext';
+/**
+ * Lone Schema definition
+ *
+ * A GraphQL document is only valid if it contains only one schema definition.
+ */
+export declare function LoneSchemaDefinitionRule(
+  context: SDLValidationContext,
+): ASTVisitor;

package/validation/rules/LoneSchemaDefinitionRule.js

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.LoneSchemaDefinitionRule = LoneSchemaDefinitionRule;
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+/**
+ * Lone Schema definition
+ *
+ * A GraphQL document is only valid if it contains only one schema definition.
+ */
+function LoneSchemaDefinitionRule(context) {
+  var _ref, _ref2, _oldSchema$astNode;
+
+  const oldSchema = context.getSchema();
+  const alreadyDefined =
+    (_ref =
+      (_ref2 =
+        (_oldSchema$astNode =
+          oldSchema === null || oldSchema === void 0
+            ? void 0
+            : oldSchema.astNode) !== null && _oldSchema$astNode !== void 0
+          ? _oldSchema$astNode
+          : oldSchema === null || oldSchema === void 0
+          ? void 0
+          : oldSchema.getQueryType()) !== null && _ref2 !== void 0
+        ? _ref2
+        : oldSchema === null || oldSchema === void 0
+        ? void 0
+        : oldSchema.getMutationType()) !== null && _ref !== void 0
+      ? _ref
+      : oldSchema === null || oldSchema === void 0
+      ? void 0
+      : oldSchema.getSubscriptionType();
+  let schemaDefinitionsCount = 0;
+  return {
+    SchemaDefinition(node) {
+      if (alreadyDefined) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            'Cannot define a new schema within a schema extension.',
+            node,
+          ),
+        );
+        return;
+      }
+
+      if (schemaDefinitionsCount > 0) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            'Must provide only one schema definition.',
+            node,
+          ),
+        );
+      }
+
+      ++schemaDefinitionsCount;
+    },
+  };
+}

package/validation/rules/LoneSchemaDefinitionRule.mjs

@@ -0,0 +1,53 @@
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+
+/**
+ * Lone Schema definition
+ *
+ * A GraphQL document is only valid if it contains only one schema definition.
+ */
+export function LoneSchemaDefinitionRule(context) {
+  var _ref, _ref2, _oldSchema$astNode;
+
+  const oldSchema = context.getSchema();
+  const alreadyDefined =
+    (_ref =
+      (_ref2 =
+        (_oldSchema$astNode =
+          oldSchema === null || oldSchema === void 0
+            ? void 0
+            : oldSchema.astNode) !== null && _oldSchema$astNode !== void 0
+          ? _oldSchema$astNode
+          : oldSchema === null || oldSchema === void 0
+          ? void 0
+          : oldSchema.getQueryType()) !== null && _ref2 !== void 0
+        ? _ref2
+        : oldSchema === null || oldSchema === void 0
+        ? void 0
+        : oldSchema.getMutationType()) !== null && _ref !== void 0
+      ? _ref
+      : oldSchema === null || oldSchema === void 0
+      ? void 0
+      : oldSchema.getSubscriptionType();
+  let schemaDefinitionsCount = 0;
+  return {
+    SchemaDefinition(node) {
+      if (alreadyDefined) {
+        context.reportError(
+          new GraphQLError(
+            'Cannot define a new schema within a schema extension.',
+            node,
+          ),
+        );
+        return;
+      }
+
+      if (schemaDefinitionsCount > 0) {
+        context.reportError(
+          new GraphQLError('Must provide only one schema definition.', node),
+        );
+      }
+
+      ++schemaDefinitionsCount;
+    },
+  };
+}

package/validation/rules/NoFragmentCyclesRule.d.ts

@@ -0,0 +1,13 @@
+import type { ASTVisitor } from '../../language/visitor';
+import type { ASTValidationContext } from '../ValidationContext';
+/**
+ * No fragment cycles
+ *
+ * The graph of fragment spreads must not form any cycles including spreading itself.
+ * Otherwise an operation could infinitely spread or infinitely execute on cycles in the underlying data.
+ *
+ * See https://spec.graphql.org/draft/#sec-Fragment-spreads-must-not-form-cycles
+ */
+export declare function NoFragmentCyclesRule(
+  context: ASTValidationContext,
+): ASTVisitor;