graphql 16.14.0 → 16.14.1

package/validation/rules/UniqueOperationNamesRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { ASTValidationContext } from '../ValidationContext';
 /**
@@ -6,6 +7,33 @@ import type { ASTValidationContext } from '../ValidationContext';
  * A GraphQL document is only valid if all defined operations have unique names.
  *
  * See https://spec.graphql.org/draft/#sec-Operation-Name-Uniqueness
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { UniqueOperationNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query Same { name } query Same { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueOperationNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query One { name } query Two { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueOperationNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function UniqueOperationNamesRule(
   context: ASTValidationContext,

package/validation/rules/UniqueOperationNamesRule.js

@@ -7,12 +7,41 @@ exports.UniqueOperationNamesRule = UniqueOperationNamesRule;
 
 var _GraphQLError = require('../../error/GraphQLError.js');
 
+/** @category Validation Rules */
+
 /**
  * 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
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { UniqueOperationNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query Same { name } query Same { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueOperationNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query One { name } query Two { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueOperationNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function UniqueOperationNamesRule(context) {
   const knownOperationNames = Object.create(null);

package/validation/rules/UniqueOperationNamesRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 
 /**
@@ -6,6 +7,33 @@ import { GraphQLError } from '../../error/GraphQLError.mjs';
  * A GraphQL document is only valid if all defined operations have unique names.
  *
  * See https://spec.graphql.org/draft/#sec-Operation-Name-Uniqueness
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { UniqueOperationNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query Same { name } query Same { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueOperationNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query One { name } query Two { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueOperationNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export function UniqueOperationNamesRule(context) {
   const knownOperationNames = Object.create(null);

package/validation/rules/UniqueOperationTypesRule.d.ts

@@ -1,9 +1,30 @@
+/** @category Validation Rules */
 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.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueOperationTypesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   schema { query: Query query: Other } type Query { name: String } type Other { name: String }
+ * `;
+ *
+ * UniqueOperationTypesRule.name; // => 'UniqueOperationTypesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   schema { query: Query } type Query { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 export declare function UniqueOperationTypesRule(
   context: SDLValidationContext,

package/validation/rules/UniqueOperationTypesRule.js

@@ -7,10 +7,32 @@ exports.UniqueOperationTypesRule = UniqueOperationTypesRule;
 
 var _GraphQLError = require('../../error/GraphQLError.js');
 
+/** @category Validation Rules */
+
 /**
  * Unique operation types
  *
  * A GraphQL document is only valid if it has only one type per operation.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueOperationTypesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   schema { query: Query query: Other } type Query { name: String } type Other { name: String }
+ * `;
+ *
+ * UniqueOperationTypesRule.name; // => 'UniqueOperationTypesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   schema { query: Query } type Query { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 function UniqueOperationTypesRule(context) {
   const schema = context.getSchema();

package/validation/rules/UniqueOperationTypesRule.mjs

@@ -1,9 +1,30 @@
+/** @category Validation Rules */
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 
 /**
  * Unique operation types
  *
  * A GraphQL document is only valid if it has only one type per operation.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueOperationTypesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   schema { query: Query query: Other } type Query { name: String } type Other { name: String }
+ * `;
+ *
+ * UniqueOperationTypesRule.name; // => 'UniqueOperationTypesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   schema { query: Query } type Query { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 export function UniqueOperationTypesRule(context) {
   const schema = context.getSchema();

package/validation/rules/UniqueTypeNamesRule.d.ts

@@ -1,9 +1,30 @@
+/** @category Validation Rules */
 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.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueTypeNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   type Query { name: String } type Query { other: String }
+ * `;
+ *
+ * UniqueTypeNamesRule.name; // => 'UniqueTypeNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   type Query { name: String } type Other { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 export declare function UniqueTypeNamesRule(
   context: SDLValidationContext,

package/validation/rules/UniqueTypeNamesRule.js

@@ -7,10 +7,32 @@ exports.UniqueTypeNamesRule = UniqueTypeNamesRule;
 
 var _GraphQLError = require('../../error/GraphQLError.js');
 
+/** @category Validation Rules */
+
 /**
  * Unique type names
  *
  * A GraphQL document is only valid if all defined types have unique names.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueTypeNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   type Query { name: String } type Query { other: String }
+ * `;
+ *
+ * UniqueTypeNamesRule.name; // => 'UniqueTypeNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   type Query { name: String } type Other { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 function UniqueTypeNamesRule(context) {
   const knownTypeNames = Object.create(null);

package/validation/rules/UniqueTypeNamesRule.mjs

@@ -1,9 +1,30 @@
+/** @category Validation Rules */
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 
 /**
  * Unique type names
  *
  * A GraphQL document is only valid if all defined types have unique names.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueTypeNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   type Query { name: String } type Query { other: String }
+ * `;
+ *
+ * UniqueTypeNamesRule.name; // => 'UniqueTypeNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   type Query { name: String } type Other { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 export function UniqueTypeNamesRule(context) {
   const knownTypeNames = Object.create(null);

package/validation/rules/UniqueVariableNamesRule.d.ts

@@ -1,9 +1,37 @@
+/** @category Validation Rules */
 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.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { UniqueVariableNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($id: ID, $id: ID) { field(arg: $id) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueVariableNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueVariableNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function UniqueVariableNamesRule(
   context: ASTValidationContext,

package/validation/rules/UniqueVariableNamesRule.js

@@ -9,10 +9,39 @@ var _groupBy = require('../../jsutils/groupBy.js');
 
 var _GraphQLError = require('../../error/GraphQLError.js');
 
+/** @category Validation Rules */
+
 /**
  * Unique variable names
  *
  * A GraphQL operation is only valid if all its variables are uniquely named.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { UniqueVariableNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($id: ID, $id: ID) { field(arg: $id) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueVariableNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueVariableNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function UniqueVariableNamesRule(context) {
   return {

package/validation/rules/UniqueVariableNamesRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { groupBy } from '../../jsutils/groupBy.mjs';
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 
@@ -5,6 +6,33 @@ import { GraphQLError } from '../../error/GraphQLError.mjs';
  * Unique variable names
  *
  * A GraphQL operation is only valid if all its variables are uniquely named.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { UniqueVariableNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($id: ID, $id: ID) { field(arg: $id) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueVariableNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueVariableNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export function UniqueVariableNamesRule(context) {
   return {

package/validation/rules/ValuesOfCorrectTypeRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { ValidationContext } from '../ValidationContext';
 /**
@@ -7,6 +8,33 @@ import type { ValidationContext } from '../ValidationContext';
  * expected at their position.
  *
  * See https://spec.graphql.org/draft/#sec-Values-of-Correct-Type
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { ValuesOfCorrectTypeRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     count(limit: Int): Int
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { count(limit: "many") }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [ValuesOfCorrectTypeRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { count(limit: 1) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [ValuesOfCorrectTypeRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function ValuesOfCorrectTypeRule(
   context: ValidationContext,

package/validation/rules/ValuesOfCorrectTypeRule.js

@@ -21,6 +21,8 @@ var _printer = require('../../language/printer.js');
 
 var _definition = require('../../type/definition.js');
 
+/** @category Validation Rules */
+
 /**
  * Value literals of correct type
  *
@@ -28,6 +30,33 @@ var _definition = require('../../type/definition.js');
  * expected at their position.
  *
  * See https://spec.graphql.org/draft/#sec-Values-of-Correct-Type
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { ValuesOfCorrectTypeRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     count(limit: Int): Int
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { count(limit: "many") }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [ValuesOfCorrectTypeRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { count(limit: 1) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [ValuesOfCorrectTypeRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function ValuesOfCorrectTypeRule(context) {
   return {
@@ -133,6 +162,8 @@ function ValuesOfCorrectTypeRule(context) {
 /**
  * Any value literal may be a valid representation of a Scalar, depending on
  * that scalar type.
+ *
+ * @internal
  */
 
 function isValidValueNode(context, node) {

package/validation/rules/ValuesOfCorrectTypeRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { didYouMean } from '../../jsutils/didYouMean.mjs';
 import { inspect } from '../../jsutils/inspect.mjs';
 import { keyMap } from '../../jsutils/keyMap.mjs';
@@ -22,6 +23,33 @@ import {
  * expected at their position.
  *
  * See https://spec.graphql.org/draft/#sec-Values-of-Correct-Type
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { ValuesOfCorrectTypeRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     count(limit: Int): Int
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { count(limit: "many") }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [ValuesOfCorrectTypeRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { count(limit: 1) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [ValuesOfCorrectTypeRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export function ValuesOfCorrectTypeRule(context) {
   return {
@@ -118,6 +146,8 @@ export function ValuesOfCorrectTypeRule(context) {
 /**
  * Any value literal may be a valid representation of a Scalar, depending on
  * that scalar type.
+ *
+ * @internal
  */
 
 function isValidValueNode(context, node) {

package/validation/rules/VariablesAreInputTypesRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { ValidationContext } from '../ValidationContext';
 /**
@@ -7,6 +8,37 @@ import type { ValidationContext } from '../ValidationContext';
  * input types (scalar, enum, or input object).
  *
  * See https://spec.graphql.org/draft/#sec-Variables-Are-Input-Types
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { VariablesAreInputTypesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID): String
+ *   }
+ *
+ *   type User {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($user: User) { field(arg: "1") }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [VariablesAreInputTypesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [VariablesAreInputTypesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function VariablesAreInputTypesRule(
   context: ValidationContext,

package/validation/rules/VariablesAreInputTypesRule.js

@@ -13,6 +13,8 @@ var _definition = require('../../type/definition.js');
 
 var _typeFromAST = require('../../utilities/typeFromAST.js');
 
+/** @category Validation Rules */
+
 /**
  * Variables are input types
  *
@@ -20,6 +22,37 @@ var _typeFromAST = require('../../utilities/typeFromAST.js');
  * input types (scalar, enum, or input object).
  *
  * See https://spec.graphql.org/draft/#sec-Variables-Are-Input-Types
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { VariablesAreInputTypesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID): String
+ *   }
+ *
+ *   type User {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($user: User) { field(arg: "1") }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [VariablesAreInputTypesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [VariablesAreInputTypesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function VariablesAreInputTypesRule(context) {
   return {