@quantiya/codevibe-claude-plugin 1.0.0 → 1.0.2

package/node_modules/graphql/validation/specifiedRules.js

@@ -0,0 +1,176 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.specifiedSDLRules =
+  exports.specifiedRules =
+  exports.recommendedRules =
+    void 0;
+
+var _ExecutableDefinitionsRule = require('./rules/ExecutableDefinitionsRule.js');
+
+var _FieldsOnCorrectTypeRule = require('./rules/FieldsOnCorrectTypeRule.js');
+
+var _FragmentsOnCompositeTypesRule = require('./rules/FragmentsOnCompositeTypesRule.js');
+
+var _KnownArgumentNamesRule = require('./rules/KnownArgumentNamesRule.js');
+
+var _KnownDirectivesRule = require('./rules/KnownDirectivesRule.js');
+
+var _KnownFragmentNamesRule = require('./rules/KnownFragmentNamesRule.js');
+
+var _KnownTypeNamesRule = require('./rules/KnownTypeNamesRule.js');
+
+var _LoneAnonymousOperationRule = require('./rules/LoneAnonymousOperationRule.js');
+
+var _LoneSchemaDefinitionRule = require('./rules/LoneSchemaDefinitionRule.js');
+
+var _MaxIntrospectionDepthRule = require('./rules/MaxIntrospectionDepthRule.js');
+
+var _NoFragmentCyclesRule = require('./rules/NoFragmentCyclesRule.js');
+
+var _NoUndefinedVariablesRule = require('./rules/NoUndefinedVariablesRule.js');
+
+var _NoUnusedFragmentsRule = require('./rules/NoUnusedFragmentsRule.js');
+
+var _NoUnusedVariablesRule = require('./rules/NoUnusedVariablesRule.js');
+
+var _OverlappingFieldsCanBeMergedRule = require('./rules/OverlappingFieldsCanBeMergedRule.js');
+
+var _PossibleFragmentSpreadsRule = require('./rules/PossibleFragmentSpreadsRule.js');
+
+var _PossibleTypeExtensionsRule = require('./rules/PossibleTypeExtensionsRule.js');
+
+var _ProvidedRequiredArgumentsRule = require('./rules/ProvidedRequiredArgumentsRule.js');
+
+var _ScalarLeafsRule = require('./rules/ScalarLeafsRule.js');
+
+var _SingleFieldSubscriptionsRule = require('./rules/SingleFieldSubscriptionsRule.js');
+
+var _UniqueArgumentDefinitionNamesRule = require('./rules/UniqueArgumentDefinitionNamesRule.js');
+
+var _UniqueArgumentNamesRule = require('./rules/UniqueArgumentNamesRule.js');
+
+var _UniqueDirectiveNamesRule = require('./rules/UniqueDirectiveNamesRule.js');
+
+var _UniqueDirectivesPerLocationRule = require('./rules/UniqueDirectivesPerLocationRule.js');
+
+var _UniqueEnumValueNamesRule = require('./rules/UniqueEnumValueNamesRule.js');
+
+var _UniqueFieldDefinitionNamesRule = require('./rules/UniqueFieldDefinitionNamesRule.js');
+
+var _UniqueFragmentNamesRule = require('./rules/UniqueFragmentNamesRule.js');
+
+var _UniqueInputFieldNamesRule = require('./rules/UniqueInputFieldNamesRule.js');
+
+var _UniqueOperationNamesRule = require('./rules/UniqueOperationNamesRule.js');
+
+var _UniqueOperationTypesRule = require('./rules/UniqueOperationTypesRule.js');
+
+var _UniqueTypeNamesRule = require('./rules/UniqueTypeNamesRule.js');
+
+var _UniqueVariableNamesRule = require('./rules/UniqueVariableNamesRule.js');
+
+var _ValuesOfCorrectTypeRule = require('./rules/ValuesOfCorrectTypeRule.js');
+
+var _VariablesAreInputTypesRule = require('./rules/VariablesAreInputTypesRule.js');
+
+var _VariablesInAllowedPositionRule = require('./rules/VariablesInAllowedPositionRule.js');
+
+// Spec Section: "Executable Definitions"
+// Spec Section: "Field Selections on Objects, Interfaces, and Unions Types"
+// Spec Section: "Fragments on Composite Types"
+// Spec Section: "Argument Names"
+// Spec Section: "Directives Are Defined"
+// Spec Section: "Fragment spread target defined"
+// Spec Section: "Fragment Spread Type Existence"
+// Spec Section: "Lone Anonymous Operation"
+// SDL-specific validation rules
+// TODO: Spec Section
+// Spec Section: "Fragments must not form cycles"
+// Spec Section: "All Variable Used Defined"
+// Spec Section: "Fragments must be used"
+// Spec Section: "All Variables Used"
+// Spec Section: "Field Selection Merging"
+// Spec Section: "Fragment spread is possible"
+// Spec Section: "Argument Optionality"
+// Spec Section: "Leaf Field Selections"
+// Spec Section: "Subscriptions with Single Root Field"
+// Spec Section: "Argument Uniqueness"
+// Spec Section: "Directives Are Unique Per Location"
+// Spec Section: "Fragment Name Uniqueness"
+// Spec Section: "Input Object Field Uniqueness"
+// Spec Section: "Operation Name Uniqueness"
+// Spec Section: "Variable Uniqueness"
+// Spec Section: "Value Type Correctness"
+// Spec Section: "Variables are Input Types"
+// Spec Section: "All Variable Usages Are Allowed"
+
+/**
+ * Technically these aren't part of the spec but they are strongly encouraged
+ * validation rules.
+ */
+const recommendedRules = Object.freeze([
+  _MaxIntrospectionDepthRule.MaxIntrospectionDepthRule,
+]);
+/**
+ * This set includes all validation rules defined by the GraphQL spec.
+ *
+ * The order of the rules in this list has been adjusted to lead to the
+ * most clear output when encountering multiple validation errors.
+ */
+
+exports.recommendedRules = recommendedRules;
+const specifiedRules = Object.freeze([
+  _ExecutableDefinitionsRule.ExecutableDefinitionsRule,
+  _UniqueOperationNamesRule.UniqueOperationNamesRule,
+  _LoneAnonymousOperationRule.LoneAnonymousOperationRule,
+  _SingleFieldSubscriptionsRule.SingleFieldSubscriptionsRule,
+  _KnownTypeNamesRule.KnownTypeNamesRule,
+  _FragmentsOnCompositeTypesRule.FragmentsOnCompositeTypesRule,
+  _VariablesAreInputTypesRule.VariablesAreInputTypesRule,
+  _ScalarLeafsRule.ScalarLeafsRule,
+  _FieldsOnCorrectTypeRule.FieldsOnCorrectTypeRule,
+  _UniqueFragmentNamesRule.UniqueFragmentNamesRule,
+  _KnownFragmentNamesRule.KnownFragmentNamesRule,
+  _NoUnusedFragmentsRule.NoUnusedFragmentsRule,
+  _PossibleFragmentSpreadsRule.PossibleFragmentSpreadsRule,
+  _NoFragmentCyclesRule.NoFragmentCyclesRule,
+  _UniqueVariableNamesRule.UniqueVariableNamesRule,
+  _NoUndefinedVariablesRule.NoUndefinedVariablesRule,
+  _NoUnusedVariablesRule.NoUnusedVariablesRule,
+  _KnownDirectivesRule.KnownDirectivesRule,
+  _UniqueDirectivesPerLocationRule.UniqueDirectivesPerLocationRule,
+  _KnownArgumentNamesRule.KnownArgumentNamesRule,
+  _UniqueArgumentNamesRule.UniqueArgumentNamesRule,
+  _ValuesOfCorrectTypeRule.ValuesOfCorrectTypeRule,
+  _ProvidedRequiredArgumentsRule.ProvidedRequiredArgumentsRule,
+  _VariablesInAllowedPositionRule.VariablesInAllowedPositionRule,
+  _OverlappingFieldsCanBeMergedRule.OverlappingFieldsCanBeMergedRule,
+  _UniqueInputFieldNamesRule.UniqueInputFieldNamesRule,
+  ...recommendedRules,
+]);
+/**
+ * @internal
+ */
+
+exports.specifiedRules = specifiedRules;
+const specifiedSDLRules = Object.freeze([
+  _LoneSchemaDefinitionRule.LoneSchemaDefinitionRule,
+  _UniqueOperationTypesRule.UniqueOperationTypesRule,
+  _UniqueTypeNamesRule.UniqueTypeNamesRule,
+  _UniqueEnumValueNamesRule.UniqueEnumValueNamesRule,
+  _UniqueFieldDefinitionNamesRule.UniqueFieldDefinitionNamesRule,
+  _UniqueArgumentDefinitionNamesRule.UniqueArgumentDefinitionNamesRule,
+  _UniqueDirectiveNamesRule.UniqueDirectiveNamesRule,
+  _KnownTypeNamesRule.KnownTypeNamesRule,
+  _KnownDirectivesRule.KnownDirectivesRule,
+  _UniqueDirectivesPerLocationRule.UniqueDirectivesPerLocationRule,
+  _PossibleTypeExtensionsRule.PossibleTypeExtensionsRule,
+  _KnownArgumentNamesRule.KnownArgumentNamesOnDirectivesRule,
+  _UniqueArgumentNamesRule.UniqueArgumentNamesRule,
+  _UniqueInputFieldNamesRule.UniqueInputFieldNamesRule,
+  _ProvidedRequiredArgumentsRule.ProvidedRequiredArgumentsOnDirectivesRule,
+]);
+exports.specifiedSDLRules = specifiedSDLRules;

package/node_modules/graphql/validation/specifiedRules.mjs

@@ -0,0 +1,132 @@
+// Spec Section: "Executable Definitions"
+import { ExecutableDefinitionsRule } from './rules/ExecutableDefinitionsRule.mjs'; // Spec Section: "Field Selections on Objects, Interfaces, and Unions Types"
+
+import { FieldsOnCorrectTypeRule } from './rules/FieldsOnCorrectTypeRule.mjs'; // Spec Section: "Fragments on Composite Types"
+
+import { FragmentsOnCompositeTypesRule } from './rules/FragmentsOnCompositeTypesRule.mjs'; // Spec Section: "Argument Names"
+
+import {
+  KnownArgumentNamesOnDirectivesRule,
+  KnownArgumentNamesRule,
+} from './rules/KnownArgumentNamesRule.mjs'; // Spec Section: "Directives Are Defined"
+
+import { KnownDirectivesRule } from './rules/KnownDirectivesRule.mjs'; // Spec Section: "Fragment spread target defined"
+
+import { KnownFragmentNamesRule } from './rules/KnownFragmentNamesRule.mjs'; // Spec Section: "Fragment Spread Type Existence"
+
+import { KnownTypeNamesRule } from './rules/KnownTypeNamesRule.mjs'; // Spec Section: "Lone Anonymous Operation"
+
+import { LoneAnonymousOperationRule } from './rules/LoneAnonymousOperationRule.mjs'; // SDL-specific validation rules
+
+import { LoneSchemaDefinitionRule } from './rules/LoneSchemaDefinitionRule.mjs'; // TODO: Spec Section
+
+import { MaxIntrospectionDepthRule } from './rules/MaxIntrospectionDepthRule.mjs'; // Spec Section: "Fragments must not form cycles"
+
+import { NoFragmentCyclesRule } from './rules/NoFragmentCyclesRule.mjs'; // Spec Section: "All Variable Used Defined"
+
+import { NoUndefinedVariablesRule } from './rules/NoUndefinedVariablesRule.mjs'; // Spec Section: "Fragments must be used"
+
+import { NoUnusedFragmentsRule } from './rules/NoUnusedFragmentsRule.mjs'; // Spec Section: "All Variables Used"
+
+import { NoUnusedVariablesRule } from './rules/NoUnusedVariablesRule.mjs'; // Spec Section: "Field Selection Merging"
+
+import { OverlappingFieldsCanBeMergedRule } from './rules/OverlappingFieldsCanBeMergedRule.mjs'; // Spec Section: "Fragment spread is possible"
+
+import { PossibleFragmentSpreadsRule } from './rules/PossibleFragmentSpreadsRule.mjs';
+import { PossibleTypeExtensionsRule } from './rules/PossibleTypeExtensionsRule.mjs'; // Spec Section: "Argument Optionality"
+
+import {
+  ProvidedRequiredArgumentsOnDirectivesRule,
+  ProvidedRequiredArgumentsRule,
+} from './rules/ProvidedRequiredArgumentsRule.mjs'; // Spec Section: "Leaf Field Selections"
+
+import { ScalarLeafsRule } from './rules/ScalarLeafsRule.mjs'; // Spec Section: "Subscriptions with Single Root Field"
+
+import { SingleFieldSubscriptionsRule } from './rules/SingleFieldSubscriptionsRule.mjs';
+import { UniqueArgumentDefinitionNamesRule } from './rules/UniqueArgumentDefinitionNamesRule.mjs'; // Spec Section: "Argument Uniqueness"
+
+import { UniqueArgumentNamesRule } from './rules/UniqueArgumentNamesRule.mjs';
+import { UniqueDirectiveNamesRule } from './rules/UniqueDirectiveNamesRule.mjs'; // Spec Section: "Directives Are Unique Per Location"
+
+import { UniqueDirectivesPerLocationRule } from './rules/UniqueDirectivesPerLocationRule.mjs';
+import { UniqueEnumValueNamesRule } from './rules/UniqueEnumValueNamesRule.mjs';
+import { UniqueFieldDefinitionNamesRule } from './rules/UniqueFieldDefinitionNamesRule.mjs'; // Spec Section: "Fragment Name Uniqueness"
+
+import { UniqueFragmentNamesRule } from './rules/UniqueFragmentNamesRule.mjs'; // Spec Section: "Input Object Field Uniqueness"
+
+import { UniqueInputFieldNamesRule } from './rules/UniqueInputFieldNamesRule.mjs'; // Spec Section: "Operation Name Uniqueness"
+
+import { UniqueOperationNamesRule } from './rules/UniqueOperationNamesRule.mjs';
+import { UniqueOperationTypesRule } from './rules/UniqueOperationTypesRule.mjs';
+import { UniqueTypeNamesRule } from './rules/UniqueTypeNamesRule.mjs'; // Spec Section: "Variable Uniqueness"
+
+import { UniqueVariableNamesRule } from './rules/UniqueVariableNamesRule.mjs'; // Spec Section: "Value Type Correctness"
+
+import { ValuesOfCorrectTypeRule } from './rules/ValuesOfCorrectTypeRule.mjs'; // Spec Section: "Variables are Input Types"
+
+import { VariablesAreInputTypesRule } from './rules/VariablesAreInputTypesRule.mjs'; // Spec Section: "All Variable Usages Are Allowed"
+
+import { VariablesInAllowedPositionRule } from './rules/VariablesInAllowedPositionRule.mjs';
+
+/**
+ * Technically these aren't part of the spec but they are strongly encouraged
+ * validation rules.
+ */
+export const recommendedRules = Object.freeze([MaxIntrospectionDepthRule]);
+/**
+ * This set includes all validation rules defined by the GraphQL spec.
+ *
+ * The order of the rules in this list has been adjusted to lead to the
+ * most clear output when encountering multiple validation errors.
+ */
+
+export const specifiedRules = Object.freeze([
+  ExecutableDefinitionsRule,
+  UniqueOperationNamesRule,
+  LoneAnonymousOperationRule,
+  SingleFieldSubscriptionsRule,
+  KnownTypeNamesRule,
+  FragmentsOnCompositeTypesRule,
+  VariablesAreInputTypesRule,
+  ScalarLeafsRule,
+  FieldsOnCorrectTypeRule,
+  UniqueFragmentNamesRule,
+  KnownFragmentNamesRule,
+  NoUnusedFragmentsRule,
+  PossibleFragmentSpreadsRule,
+  NoFragmentCyclesRule,
+  UniqueVariableNamesRule,
+  NoUndefinedVariablesRule,
+  NoUnusedVariablesRule,
+  KnownDirectivesRule,
+  UniqueDirectivesPerLocationRule,
+  KnownArgumentNamesRule,
+  UniqueArgumentNamesRule,
+  ValuesOfCorrectTypeRule,
+  ProvidedRequiredArgumentsRule,
+  VariablesInAllowedPositionRule,
+  OverlappingFieldsCanBeMergedRule,
+  UniqueInputFieldNamesRule,
+  ...recommendedRules,
+]);
+/**
+ * @internal
+ */
+
+export const specifiedSDLRules = Object.freeze([
+  LoneSchemaDefinitionRule,
+  UniqueOperationTypesRule,
+  UniqueTypeNamesRule,
+  UniqueEnumValueNamesRule,
+  UniqueFieldDefinitionNamesRule,
+  UniqueArgumentDefinitionNamesRule,
+  UniqueDirectiveNamesRule,
+  KnownTypeNamesRule,
+  KnownDirectivesRule,
+  UniqueDirectivesPerLocationRule,
+  PossibleTypeExtensionsRule,
+  KnownArgumentNamesOnDirectivesRule,
+  UniqueArgumentNamesRule,
+  UniqueInputFieldNamesRule,
+  ProvidedRequiredArgumentsOnDirectivesRule,
+]);

package/node_modules/graphql/validation/validate.d.ts

@@ -0,0 +1,61 @@
+import type { Maybe } from '../jsutils/Maybe';
+import { GraphQLError } from '../error/GraphQLError';
+import type { DocumentNode } from '../language/ast';
+import type { GraphQLSchema } from '../type/schema';
+import { TypeInfo } from '../utilities/TypeInfo';
+import type { SDLValidationRule, ValidationRule } from './ValidationContext';
+/**
+ * Implements the "Validation" section of the spec.
+ *
+ * Validation runs synchronously, returning an array of encountered errors, or
+ * an empty array if no errors were encountered and the document is valid.
+ *
+ * A list of specific validation rules may be provided. If not provided, the
+ * default list of rules defined by the GraphQL specification will be used.
+ *
+ * Each validation rules is a function which returns a visitor
+ * (see the language/visitor API). Visitor methods are expected to return
+ * GraphQLErrors, or Arrays of GraphQLErrors when invalid.
+ *
+ * Validate will stop validation after a `maxErrors` limit has been reached.
+ * Attackers can send pathologically invalid queries to induce a DoS attack,
+ * so by default `maxErrors` set to 100 errors.
+ *
+ * Optionally a custom TypeInfo instance may be provided. If not provided, one
+ * will be created from the provided schema.
+ */
+export declare function validate(
+  schema: GraphQLSchema,
+  documentAST: DocumentNode,
+  rules?: ReadonlyArray<ValidationRule>,
+  options?: {
+    maxErrors?: number;
+  },
+  /** @deprecated will be removed in 17.0.0 */
+  typeInfo?: TypeInfo,
+): ReadonlyArray<GraphQLError>;
+/**
+ * @internal
+ */
+export declare function validateSDL(
+  documentAST: DocumentNode,
+  schemaToExtend?: Maybe<GraphQLSchema>,
+  rules?: ReadonlyArray<SDLValidationRule>,
+): ReadonlyArray<GraphQLError>;
+/**
+ * Utility function which asserts a SDL document is valid by throwing an error
+ * if it is invalid.
+ *
+ * @internal
+ */
+export declare function assertValidSDL(documentAST: DocumentNode): void;
+/**
+ * Utility function which asserts a SDL document is valid by throwing an error
+ * if it is invalid.
+ *
+ * @internal
+ */
+export declare function assertValidSDLExtension(
+  documentAST: DocumentNode,
+  schema: GraphQLSchema,
+): void;

package/node_modules/graphql/validation/validate.js

@@ -0,0 +1,151 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.assertValidSDL = assertValidSDL;
+exports.assertValidSDLExtension = assertValidSDLExtension;
+exports.validate = validate;
+exports.validateSDL = validateSDL;
+
+var _devAssert = require('../jsutils/devAssert.js');
+
+var _GraphQLError = require('../error/GraphQLError.js');
+
+var _visitor = require('../language/visitor.js');
+
+var _validate = require('../type/validate.js');
+
+var _TypeInfo = require('../utilities/TypeInfo.js');
+
+var _specifiedRules = require('./specifiedRules.js');
+
+var _ValidationContext = require('./ValidationContext.js');
+
+/**
+ * Implements the "Validation" section of the spec.
+ *
+ * Validation runs synchronously, returning an array of encountered errors, or
+ * an empty array if no errors were encountered and the document is valid.
+ *
+ * A list of specific validation rules may be provided. If not provided, the
+ * default list of rules defined by the GraphQL specification will be used.
+ *
+ * Each validation rules is a function which returns a visitor
+ * (see the language/visitor API). Visitor methods are expected to return
+ * GraphQLErrors, or Arrays of GraphQLErrors when invalid.
+ *
+ * Validate will stop validation after a `maxErrors` limit has been reached.
+ * Attackers can send pathologically invalid queries to induce a DoS attack,
+ * so by default `maxErrors` set to 100 errors.
+ *
+ * Optionally a custom TypeInfo instance may be provided. If not provided, one
+ * will be created from the provided schema.
+ */
+function validate(
+  schema,
+  documentAST,
+  rules = _specifiedRules.specifiedRules,
+  options,
+  /** @deprecated will be removed in 17.0.0 */
+  typeInfo = new _TypeInfo.TypeInfo(schema),
+) {
+  var _options$maxErrors;
+
+  const maxErrors =
+    (_options$maxErrors =
+      options === null || options === void 0 ? void 0 : options.maxErrors) !==
+      null && _options$maxErrors !== void 0
+      ? _options$maxErrors
+      : 100;
+  documentAST || (0, _devAssert.devAssert)(false, 'Must provide document.'); // If the schema used for validation is invalid, throw an error.
+
+  (0, _validate.assertValidSchema)(schema);
+  const abortObj = Object.freeze({});
+  const errors = [];
+  const context = new _ValidationContext.ValidationContext(
+    schema,
+    documentAST,
+    typeInfo,
+    (error) => {
+      if (errors.length >= maxErrors) {
+        errors.push(
+          new _GraphQLError.GraphQLError(
+            'Too many validation errors, error limit reached. Validation aborted.',
+          ),
+        ); // eslint-disable-next-line @typescript-eslint/no-throw-literal
+
+        throw abortObj;
+      }
+
+      errors.push(error);
+    },
+  ); // This uses a specialized visitor which runs multiple visitors in parallel,
+  // while maintaining the visitor skip and break API.
+
+  const visitor = (0, _visitor.visitInParallel)(
+    rules.map((rule) => rule(context)),
+  ); // Visit the whole document with each instance of all provided rules.
+
+  try {
+    (0, _visitor.visit)(
+      documentAST,
+      (0, _TypeInfo.visitWithTypeInfo)(typeInfo, visitor),
+    );
+  } catch (e) {
+    if (e !== abortObj) {
+      throw e;
+    }
+  }
+
+  return errors;
+}
+/**
+ * @internal
+ */
+
+function validateSDL(
+  documentAST,
+  schemaToExtend,
+  rules = _specifiedRules.specifiedSDLRules,
+) {
+  const errors = [];
+  const context = new _ValidationContext.SDLValidationContext(
+    documentAST,
+    schemaToExtend,
+    (error) => {
+      errors.push(error);
+    },
+  );
+  const visitors = rules.map((rule) => rule(context));
+  (0, _visitor.visit)(documentAST, (0, _visitor.visitInParallel)(visitors));
+  return errors;
+}
+/**
+ * Utility function which asserts a SDL document is valid by throwing an error
+ * if it is invalid.
+ *
+ * @internal
+ */
+
+function assertValidSDL(documentAST) {
+  const errors = validateSDL(documentAST);
+
+  if (errors.length !== 0) {
+    throw new Error(errors.map((error) => error.message).join('\n\n'));
+  }
+}
+/**
+ * Utility function which asserts a SDL document is valid by throwing an error
+ * if it is invalid.
+ *
+ * @internal
+ */
+
+function assertValidSDLExtension(documentAST, schema) {
+  const errors = validateSDL(documentAST, schema);
+
+  if (errors.length !== 0) {
+    throw new Error(errors.map((error) => error.message).join('\n\n'));
+  }
+}

package/node_modules/graphql/validation/validate.mjs

@@ -0,0 +1,133 @@
+import { devAssert } from '../jsutils/devAssert.mjs';
+import { GraphQLError } from '../error/GraphQLError.mjs';
+import { visit, visitInParallel } from '../language/visitor.mjs';
+import { assertValidSchema } from '../type/validate.mjs';
+import { TypeInfo, visitWithTypeInfo } from '../utilities/TypeInfo.mjs';
+import { specifiedRules, specifiedSDLRules } from './specifiedRules.mjs';
+import {
+  SDLValidationContext,
+  ValidationContext,
+} from './ValidationContext.mjs';
+/**
+ * Implements the "Validation" section of the spec.
+ *
+ * Validation runs synchronously, returning an array of encountered errors, or
+ * an empty array if no errors were encountered and the document is valid.
+ *
+ * A list of specific validation rules may be provided. If not provided, the
+ * default list of rules defined by the GraphQL specification will be used.
+ *
+ * Each validation rules is a function which returns a visitor
+ * (see the language/visitor API). Visitor methods are expected to return
+ * GraphQLErrors, or Arrays of GraphQLErrors when invalid.
+ *
+ * Validate will stop validation after a `maxErrors` limit has been reached.
+ * Attackers can send pathologically invalid queries to induce a DoS attack,
+ * so by default `maxErrors` set to 100 errors.
+ *
+ * Optionally a custom TypeInfo instance may be provided. If not provided, one
+ * will be created from the provided schema.
+ */
+
+export function validate(
+  schema,
+  documentAST,
+  rules = specifiedRules,
+  options,
+  /** @deprecated will be removed in 17.0.0 */
+  typeInfo = new TypeInfo(schema),
+) {
+  var _options$maxErrors;
+
+  const maxErrors =
+    (_options$maxErrors =
+      options === null || options === void 0 ? void 0 : options.maxErrors) !==
+      null && _options$maxErrors !== void 0
+      ? _options$maxErrors
+      : 100;
+  documentAST || devAssert(false, 'Must provide document.'); // If the schema used for validation is invalid, throw an error.
+
+  assertValidSchema(schema);
+  const abortObj = Object.freeze({});
+  const errors = [];
+  const context = new ValidationContext(
+    schema,
+    documentAST,
+    typeInfo,
+    (error) => {
+      if (errors.length >= maxErrors) {
+        errors.push(
+          new GraphQLError(
+            'Too many validation errors, error limit reached. Validation aborted.',
+          ),
+        ); // eslint-disable-next-line @typescript-eslint/no-throw-literal
+
+        throw abortObj;
+      }
+
+      errors.push(error);
+    },
+  ); // This uses a specialized visitor which runs multiple visitors in parallel,
+  // while maintaining the visitor skip and break API.
+
+  const visitor = visitInParallel(rules.map((rule) => rule(context))); // Visit the whole document with each instance of all provided rules.
+
+  try {
+    visit(documentAST, visitWithTypeInfo(typeInfo, visitor));
+  } catch (e) {
+    if (e !== abortObj) {
+      throw e;
+    }
+  }
+
+  return errors;
+}
+/**
+ * @internal
+ */
+
+export function validateSDL(
+  documentAST,
+  schemaToExtend,
+  rules = specifiedSDLRules,
+) {
+  const errors = [];
+  const context = new SDLValidationContext(
+    documentAST,
+    schemaToExtend,
+    (error) => {
+      errors.push(error);
+    },
+  );
+  const visitors = rules.map((rule) => rule(context));
+  visit(documentAST, visitInParallel(visitors));
+  return errors;
+}
+/**
+ * Utility function which asserts a SDL document is valid by throwing an error
+ * if it is invalid.
+ *
+ * @internal
+ */
+
+export function assertValidSDL(documentAST) {
+  const errors = validateSDL(documentAST);
+
+  if (errors.length !== 0) {
+    throw new Error(errors.map((error) => error.message).join('\n\n'));
+  }
+}
+/**
+ * Utility function which asserts a SDL document is valid by throwing an error
+ * if it is invalid.
+ *
+ * @internal
+ */
+
+export function assertValidSDLExtension(documentAST, schema) {
+  const errors = validateSDL(documentAST, schema);
+
+  if (errors.length !== 0) {
+    throw new Error(errors.map((error) => error.message).join('\n\n'));
+  }
+}

package/node_modules/graphql/version.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A string containing the version of the GraphQL.js library
+ */
+export declare const version: string;
+/**
+ * An object containing the components of the GraphQL.js version string
+ */
+export declare const versionInfo: Readonly<{
+  major: number;
+  minor: number;
+  patch: number;
+  preReleaseTag: string | null;
+}>;

package/node_modules/graphql/version.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.versionInfo = exports.version = void 0;
+// Note: This file is autogenerated using "resources/gen-version.js" script and
+// automatically updated by "npm version" command.
+
+/**
+ * A string containing the version of the GraphQL.js library
+ */
+const version = '16.12.0';
+/**
+ * An object containing the components of the GraphQL.js version string
+ */
+
+exports.version = version;
+const versionInfo = Object.freeze({
+  major: 16,
+  minor: 12,
+  patch: 0,
+  preReleaseTag: null,
+});
+exports.versionInfo = versionInfo;