graphql 16.14.0 → 16.14.1

package/validation/rules/UniqueDirectiveNamesRule.d.ts

@@ -1,9 +1,30 @@
+/** @category Validation Rules */
 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.
+ * @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 { UniqueDirectiveNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   directive @tag on FIELD directive @tag on QUERY type Query { name: String }
+ * `;
+ *
+ * UniqueDirectiveNamesRule.name; // => 'UniqueDirectiveNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   directive @tag on FIELD type Query { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 export declare function UniqueDirectiveNamesRule(
   context: SDLValidationContext,

package/validation/rules/UniqueDirectiveNamesRule.js

@@ -7,10 +7,32 @@ exports.UniqueDirectiveNamesRule = UniqueDirectiveNamesRule;
 
 var _GraphQLError = require('../../error/GraphQLError.js');
 
+/** @category Validation Rules */
+
 /**
  * Unique directive names
  *
  * A GraphQL document is only valid if all defined directives 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 { UniqueDirectiveNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   directive @tag on FIELD directive @tag on QUERY type Query { name: String }
+ * `;
+ *
+ * UniqueDirectiveNamesRule.name; // => 'UniqueDirectiveNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   directive @tag on FIELD type Query { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 function UniqueDirectiveNamesRule(context) {
   const knownDirectiveNames = Object.create(null);

package/validation/rules/UniqueDirectiveNamesRule.mjs

@@ -1,9 +1,30 @@
+/** @category Validation Rules */
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 
 /**
  * Unique directive names
  *
  * A GraphQL document is only valid if all defined directives 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 { UniqueDirectiveNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   directive @tag on FIELD directive @tag on QUERY type Query { name: String }
+ * `;
+ *
+ * UniqueDirectiveNamesRule.name; // => 'UniqueDirectiveNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   directive @tag on FIELD type Query { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 export function UniqueDirectiveNamesRule(context) {
   const knownDirectiveNames = Object.create(null);

package/validation/rules/UniqueDirectivesPerLocationRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type {
   SDLValidationContext,
@@ -10,6 +11,33 @@ import type {
  * a given location are uniquely named.
  *
  * See https://spec.graphql.org/draft/#sec-Directives-Are-Unique-Per-Location
+ * @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 { UniqueDirectivesPerLocationRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { name @include(if: true) @include(if: false) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueDirectivesPerLocationRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name @include(if: true) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueDirectivesPerLocationRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function UniqueDirectivesPerLocationRule(
   context: ValidationContext | SDLValidationContext,

package/validation/rules/UniqueDirectivesPerLocationRule.js

@@ -13,6 +13,8 @@ var _predicates = require('../../language/predicates.js');
 
 var _directives = require('../../type/directives.js');
 
+/** @category Validation Rules */
+
 /**
  * Unique directive names per location
  *
@@ -20,6 +22,33 @@ var _directives = require('../../type/directives.js');
  * a given location are uniquely named.
  *
  * See https://spec.graphql.org/draft/#sec-Directives-Are-Unique-Per-Location
+ * @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 { UniqueDirectivesPerLocationRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { name @include(if: true) @include(if: false) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueDirectivesPerLocationRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name @include(if: true) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueDirectivesPerLocationRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function UniqueDirectivesPerLocationRule(context) {
   const uniqueDirectiveMap = Object.create(null);

package/validation/rules/UniqueDirectivesPerLocationRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 import { Kind } from '../../language/kinds.mjs';
 import {
@@ -13,6 +14,33 @@ import { specifiedDirectives } from '../../type/directives.mjs';
  * a given location are uniquely named.
  *
  * See https://spec.graphql.org/draft/#sec-Directives-Are-Unique-Per-Location
+ * @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 { UniqueDirectivesPerLocationRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { name @include(if: true) @include(if: false) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueDirectivesPerLocationRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name @include(if: true) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueDirectivesPerLocationRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export function UniqueDirectivesPerLocationRule(context) {
   const uniqueDirectiveMap = Object.create(null);

package/validation/rules/UniqueEnumValueNamesRule.d.ts

@@ -1,9 +1,30 @@
+/** @category Validation Rules */
 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.
+ * @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 { UniqueEnumValueNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   enum Status { ACTIVE ACTIVE } type Query { status: Status }
+ * `;
+ *
+ * UniqueEnumValueNamesRule.name; // => 'UniqueEnumValueNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   enum Status { ACTIVE INACTIVE } type Query { status: Status }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 export declare function UniqueEnumValueNamesRule(
   context: SDLValidationContext,

package/validation/rules/UniqueEnumValueNamesRule.js

@@ -9,10 +9,32 @@ var _GraphQLError = require('../../error/GraphQLError.js');
 
 var _definition = require('../../type/definition.js');
 
+/** @category Validation Rules */
+
 /**
  * Unique enum value names
  *
  * A GraphQL enum type is only valid if all its values 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 } from 'graphql';
+ * import { UniqueEnumValueNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   enum Status { ACTIVE ACTIVE } type Query { status: Status }
+ * `;
+ *
+ * UniqueEnumValueNamesRule.name; // => 'UniqueEnumValueNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   enum Status { ACTIVE INACTIVE } type Query { status: Status }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 function UniqueEnumValueNamesRule(context) {
   const schema = context.getSchema();

package/validation/rules/UniqueEnumValueNamesRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 import { isEnumType } from '../../type/definition.mjs';
 
@@ -5,6 +6,26 @@ import { isEnumType } from '../../type/definition.mjs';
  * Unique enum value names
  *
  * A GraphQL enum type is only valid if all its values 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 } from 'graphql';
+ * import { UniqueEnumValueNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   enum Status { ACTIVE ACTIVE } type Query { status: Status }
+ * `;
+ *
+ * UniqueEnumValueNamesRule.name; // => 'UniqueEnumValueNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   enum Status { ACTIVE INACTIVE } type Query { status: Status }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 export function UniqueEnumValueNamesRule(context) {
   const schema = context.getSchema();

package/validation/rules/UniqueFieldDefinitionNamesRule.d.ts

@@ -1,9 +1,30 @@
+/** @category Validation Rules */
 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.
+ * @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 { UniqueFieldDefinitionNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   type Query { name: String name: String }
+ * `;
+ *
+ * UniqueFieldDefinitionNamesRule.name; // => 'UniqueFieldDefinitionNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   type Query { name: String other: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 export declare function UniqueFieldDefinitionNamesRule(
   context: SDLValidationContext,

package/validation/rules/UniqueFieldDefinitionNamesRule.js

@@ -9,10 +9,32 @@ var _GraphQLError = require('../../error/GraphQLError.js');
 
 var _definition = require('../../type/definition.js');
 
+/** @category Validation Rules */
+
 /**
  * Unique field definition names
  *
  * A GraphQL complex type is only valid if all its fields 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 } from 'graphql';
+ * import { UniqueFieldDefinitionNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   type Query { name: String name: String }
+ * `;
+ *
+ * UniqueFieldDefinitionNamesRule.name; // => 'UniqueFieldDefinitionNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   type Query { name: String other: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 function UniqueFieldDefinitionNamesRule(context) {
   const schema = context.getSchema();

package/validation/rules/UniqueFieldDefinitionNamesRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 import {
   isInputObjectType,
@@ -9,6 +10,26 @@ import {
  * Unique field definition names
  *
  * A GraphQL complex type is only valid if all its fields 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 } from 'graphql';
+ * import { UniqueFieldDefinitionNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   type Query { name: String name: String }
+ * `;
+ *
+ * UniqueFieldDefinitionNamesRule.name; // => 'UniqueFieldDefinitionNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   type Query { name: String other: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 export function UniqueFieldDefinitionNamesRule(context) {
   const schema = context.getSchema();

package/validation/rules/UniqueFragmentNamesRule.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 fragments have unique names.
  *
  * See https://spec.graphql.org/draft/#sec-Fragment-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 { UniqueFragmentNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   fragment A on Query { name } fragment A on Query { name } query { ...A }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueFragmentNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   fragment A on Query { name } query { ...A }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueFragmentNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function UniqueFragmentNamesRule(
   context: ASTValidationContext,

package/validation/rules/UniqueFragmentNamesRule.js

@@ -7,12 +7,41 @@ exports.UniqueFragmentNamesRule = UniqueFragmentNamesRule;
 
 var _GraphQLError = require('../../error/GraphQLError.js');
 
+/** @category Validation Rules */
+
 /**
  * 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
+ * @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 { UniqueFragmentNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   fragment A on Query { name } fragment A on Query { name } query { ...A }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueFragmentNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   fragment A on Query { name } query { ...A }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueFragmentNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function UniqueFragmentNamesRule(context) {
   const knownFragmentNames = Object.create(null);

package/validation/rules/UniqueFragmentNamesRule.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 fragments have unique names.
  *
  * See https://spec.graphql.org/draft/#sec-Fragment-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 { UniqueFragmentNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   fragment A on Query { name } fragment A on Query { name } query { ...A }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueFragmentNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   fragment A on Query { name } query { ...A }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueFragmentNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export function UniqueFragmentNamesRule(context) {
   const knownFragmentNames = Object.create(null);

package/validation/rules/UniqueInputFieldNamesRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { ASTValidationContext } from '../ValidationContext';
 /**
@@ -7,6 +8,37 @@ import type { ASTValidationContext } from '../ValidationContext';
  * uniquely named.
  *
  * See https://spec.graphql.org/draft/#sec-Input-Object-Field-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 { UniqueInputFieldNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   input Filter {
+ *     name: String
+ *   }
+ *
+ *   type Query {
+ *     search(filter: Filter): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { search(filter: { name: "a", name: "b" }) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueInputFieldNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { search(filter: { name: "a" }) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueInputFieldNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function UniqueInputFieldNamesRule(
   context: ASTValidationContext,

package/validation/rules/UniqueInputFieldNamesRule.js

@@ -9,6 +9,8 @@ var _invariant = require('../../jsutils/invariant.js');
 
 var _GraphQLError = require('../../error/GraphQLError.js');
 
+/** @category Validation Rules */
+
 /**
  * Unique input field names
  *
@@ -16,6 +18,37 @@ var _GraphQLError = require('../../error/GraphQLError.js');
  * uniquely named.
  *
  * See https://spec.graphql.org/draft/#sec-Input-Object-Field-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 { UniqueInputFieldNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   input Filter {
+ *     name: String
+ *   }
+ *
+ *   type Query {
+ *     search(filter: Filter): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { search(filter: { name: "a", name: "b" }) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueInputFieldNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { search(filter: { name: "a" }) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueInputFieldNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function UniqueInputFieldNamesRule(context) {
   const knownNameStack = [];

package/validation/rules/UniqueInputFieldNamesRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { invariant } from '../../jsutils/invariant.mjs';
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 
@@ -8,6 +9,37 @@ import { GraphQLError } from '../../error/GraphQLError.mjs';
  * uniquely named.
  *
  * See https://spec.graphql.org/draft/#sec-Input-Object-Field-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 { UniqueInputFieldNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   input Filter {
+ *     name: String
+ *   }
+ *
+ *   type Query {
+ *     search(filter: Filter): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { search(filter: { name: "a", name: "b" }) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueInputFieldNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { search(filter: { name: "a" }) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueInputFieldNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export function UniqueInputFieldNamesRule(context) {
   const knownNameStack = [];