graphql 16.14.0 → 16.14.1

package/validation/rules/PossibleTypeExtensionsRule.js

@@ -21,10 +21,32 @@ var _predicates = require('../../language/predicates.js');
 
 var _definition = require('../../type/definition.js');
 
+/** @category Validation Rules */
+
 /**
  * Possible type extension
  *
  * A type extension is only valid if the type is defined and has the same kind.
+ * @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 { PossibleTypeExtensionsRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   extend type Missing { name: String } type Query { name: String }
+ * `;
+ *
+ * PossibleTypeExtensionsRule.name; // => 'PossibleTypeExtensionsRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   type Query { name: String } extend type Query { other: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 function PossibleTypeExtensionsRule(context) {
   const schema = context.getSchema();

package/validation/rules/PossibleTypeExtensionsRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { didYouMean } from '../../jsutils/didYouMean.mjs';
 import { inspect } from '../../jsutils/inspect.mjs';
 import { invariant } from '../../jsutils/invariant.mjs';
@@ -18,6 +19,26 @@ import {
  * Possible type extension
  *
  * A type extension is only valid if the type is defined and has the same kind.
+ * @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 { PossibleTypeExtensionsRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   extend type Missing { name: String } type Query { name: String }
+ * `;
+ *
+ * PossibleTypeExtensionsRule.name; // => 'PossibleTypeExtensionsRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   type Query { name: String } extend type Query { other: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 export function PossibleTypeExtensionsRule(context) {
   const schema = context.getSchema();

package/validation/rules/ProvidedRequiredArgumentsRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type {
   SDLValidationContext,
@@ -8,13 +9,38 @@ import type {
  *
  * A field or directive is only valid if all required (non-null without a
  * default value) field arguments have been provided.
+ * @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 { ProvidedRequiredArgumentsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(required: String!): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { field }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [ProvidedRequiredArgumentsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { field(required: "x") }
+ * `);
+ * const validErrors = validate(schema, validDocument, [ProvidedRequiredArgumentsRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function ProvidedRequiredArgumentsRule(
   context: ValidationContext,
 ): ASTVisitor;
-/**
- * @internal
- */
+/** @internal */
 export declare function ProvidedRequiredArgumentsOnDirectivesRule(
   context: ValidationContext | SDLValidationContext,
 ): ASTVisitor;

package/validation/rules/ProvidedRequiredArgumentsRule.js

@@ -21,11 +21,40 @@ var _definition = require('../../type/definition.js');
 
 var _directives = require('../../type/directives.js');
 
+/** @category Validation Rules */
+
 /**
  * Provided required arguments
  *
  * A field or directive is only valid if all required (non-null without a
  * default value) field arguments have been provided.
+ * @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 { ProvidedRequiredArgumentsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(required: String!): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { field }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [ProvidedRequiredArgumentsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { field(required: "x") }
+ * `);
+ * const validErrors = validate(schema, validDocument, [ProvidedRequiredArgumentsRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function ProvidedRequiredArgumentsRule(context) {
   return {
@@ -70,9 +99,7 @@ function ProvidedRequiredArgumentsRule(context) {
     },
   };
 }
-/**
- * @internal
- */
+/** @internal */
 
 function ProvidedRequiredArgumentsOnDirectivesRule(context) {
   var _schema$getDirectives;

package/validation/rules/ProvidedRequiredArgumentsRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { inspect } from '../../jsutils/inspect.mjs';
 import { keyMap } from '../../jsutils/keyMap.mjs';
 import { GraphQLError } from '../../error/GraphQLError.mjs';
@@ -11,6 +12,33 @@ import { specifiedDirectives } from '../../type/directives.mjs';
  *
  * A field or directive is only valid if all required (non-null without a
  * default value) field arguments have been provided.
+ * @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 { ProvidedRequiredArgumentsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(required: String!): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { field }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [ProvidedRequiredArgumentsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { field(required: "x") }
+ * `);
+ * const validErrors = validate(schema, validDocument, [ProvidedRequiredArgumentsRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export function ProvidedRequiredArgumentsRule(context) {
   return {
@@ -52,9 +80,7 @@ export function ProvidedRequiredArgumentsRule(context) {
     },
   };
 }
-/**
- * @internal
- */
+/** @internal */
 
 export function ProvidedRequiredArgumentsOnDirectivesRule(context) {
   var _schema$getDirectives;

package/validation/rules/ScalarLeafsRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { ValidationContext } from '../ValidationContext';
 /**
@@ -5,5 +6,32 @@ import type { ValidationContext } from '../ValidationContext';
  *
  * A GraphQL document is valid only if all leaf fields (fields without
  * sub selections) are of scalar or enum 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 { ScalarLeafsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { name { length } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [ScalarLeafsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [ScalarLeafsRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function ScalarLeafsRule(context: ValidationContext): ASTVisitor;

package/validation/rules/ScalarLeafsRule.js

@@ -11,11 +11,40 @@ var _GraphQLError = require('../../error/GraphQLError.js');
 
 var _definition = require('../../type/definition.js');
 
+/** @category Validation Rules */
+
 /**
  * Scalar leafs
  *
  * A GraphQL document is valid only if all leaf fields (fields without
  * sub selections) are of scalar or enum 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 { ScalarLeafsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { name { length } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [ScalarLeafsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [ScalarLeafsRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function ScalarLeafsRule(context) {
   return {

package/validation/rules/ScalarLeafsRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { inspect } from '../../jsutils/inspect.mjs';
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 import { getNamedType, isLeafType } from '../../type/definition.mjs';
@@ -7,6 +8,33 @@ import { getNamedType, isLeafType } from '../../type/definition.mjs';
  *
  * A GraphQL document is valid only if all leaf fields (fields without
  * sub selections) are of scalar or enum 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 { ScalarLeafsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { name { length } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [ScalarLeafsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [ScalarLeafsRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export function ScalarLeafsRule(context) {
   return {

package/validation/rules/SingleFieldSubscriptionsRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { ValidationContext } from '../ValidationContext';
 /**
@@ -7,6 +8,38 @@ import type { ValidationContext } from '../ValidationContext';
  * that root field is not an introspection field.
  *
  * See https://spec.graphql.org/draft/#sec-Single-root-field
+ * @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 { SingleFieldSubscriptionsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ *
+ *   type Subscription {
+ *     a: String
+ *     b: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   subscription { a b }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [SingleFieldSubscriptionsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   subscription { a }
+ * `);
+ * const validErrors = validate(schema, validDocument, [SingleFieldSubscriptionsRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function SingleFieldSubscriptionsRule(
   context: ValidationContext,

package/validation/rules/SingleFieldSubscriptionsRule.js

@@ -11,6 +11,8 @@ var _kinds = require('../../language/kinds.js');
 
 var _collectFields = require('../../execution/collectFields.js');
 
+/** @category Validation Rules */
+
 /**
  * Subscriptions must only include a non-introspection field.
  *
@@ -18,6 +20,38 @@ var _collectFields = require('../../execution/collectFields.js');
  * that root field is not an introspection field.
  *
  * See https://spec.graphql.org/draft/#sec-Single-root-field
+ * @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 { SingleFieldSubscriptionsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ *
+ *   type Subscription {
+ *     a: String
+ *     b: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   subscription { a b }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [SingleFieldSubscriptionsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   subscription { a }
+ * `);
+ * const validErrors = validate(schema, validDocument, [SingleFieldSubscriptionsRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function SingleFieldSubscriptionsRule(context) {
   return {

package/validation/rules/SingleFieldSubscriptionsRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 import { Kind } from '../../language/kinds.mjs';
 import { collectFields } from '../../execution/collectFields.mjs';
@@ -9,6 +10,38 @@ import { collectFields } from '../../execution/collectFields.mjs';
  * that root field is not an introspection field.
  *
  * See https://spec.graphql.org/draft/#sec-Single-root-field
+ * @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 { SingleFieldSubscriptionsRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ *
+ *   type Subscription {
+ *     a: String
+ *     b: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   subscription { a b }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [SingleFieldSubscriptionsRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   subscription { a }
+ * `);
+ * const validErrors = validate(schema, validDocument, [SingleFieldSubscriptionsRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export function SingleFieldSubscriptionsRule(context) {
   return {

package/validation/rules/UniqueArgumentDefinitionNamesRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { SDLValidationContext } from '../ValidationContext';
 /**
@@ -5,6 +6,26 @@ import type { SDLValidationContext } from '../ValidationContext';
  *
  * A GraphQL Object or Interface type is only valid if all its fields have uniquely named arguments.
  * A GraphQL Directive is only valid if all its arguments 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 { UniqueArgumentDefinitionNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   type Query { field(arg: String, arg: Int): String }
+ * `;
+ *
+ * UniqueArgumentDefinitionNamesRule.name; // => 'UniqueArgumentDefinitionNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   type Query { field(arg: String): String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 export declare function UniqueArgumentDefinitionNamesRule(
   context: SDLValidationContext,

package/validation/rules/UniqueArgumentDefinitionNamesRule.js

@@ -9,11 +9,33 @@ var _groupBy = require('../../jsutils/groupBy.js');
 
 var _GraphQLError = require('../../error/GraphQLError.js');
 
+/** @category Validation Rules */
+
 /**
  * Unique argument definition names
  *
  * A GraphQL Object or Interface type is only valid if all its fields have uniquely named arguments.
  * A GraphQL Directive is only valid if all its arguments 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 { UniqueArgumentDefinitionNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   type Query { field(arg: String, arg: Int): String }
+ * `;
+ *
+ * UniqueArgumentDefinitionNamesRule.name; // => 'UniqueArgumentDefinitionNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   type Query { field(arg: String): String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 function UniqueArgumentDefinitionNamesRule(context) {
   return {

package/validation/rules/UniqueArgumentDefinitionNamesRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { groupBy } from '../../jsutils/groupBy.mjs';
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 
@@ -6,6 +7,26 @@ import { GraphQLError } from '../../error/GraphQLError.mjs';
  *
  * A GraphQL Object or Interface type is only valid if all its fields have uniquely named arguments.
  * A GraphQL Directive is only valid if all its arguments 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 { UniqueArgumentDefinitionNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   type Query { field(arg: String, arg: Int): String }
+ * `;
+ *
+ * UniqueArgumentDefinitionNamesRule.name; // => 'UniqueArgumentDefinitionNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   type Query { field(arg: String): String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 export function UniqueArgumentDefinitionNamesRule(context) {
   return {

package/validation/rules/UniqueArgumentNamesRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { ASTValidationContext } from '../ValidationContext';
 /**
@@ -7,6 +8,33 @@ import type { ASTValidationContext } from '../ValidationContext';
  * uniquely named.
  *
  * See https://spec.graphql.org/draft/#sec-Argument-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, parse, validate } from 'graphql';
+ * import { UniqueArgumentNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: String): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { field(arg: "1", arg: "2") }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueArgumentNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { field(arg: "1") }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueArgumentNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function UniqueArgumentNamesRule(
   context: ASTValidationContext,

package/validation/rules/UniqueArgumentNamesRule.js

@@ -9,6 +9,8 @@ var _groupBy = require('../../jsutils/groupBy.js');
 
 var _GraphQLError = require('../../error/GraphQLError.js');
 
+/** @category Validation Rules */
+
 /**
  * Unique argument names
  *
@@ -16,6 +18,33 @@ var _GraphQLError = require('../../error/GraphQLError.js');
  * uniquely named.
  *
  * See https://spec.graphql.org/draft/#sec-Argument-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, parse, validate } from 'graphql';
+ * import { UniqueArgumentNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: String): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { field(arg: "1", arg: "2") }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueArgumentNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { field(arg: "1") }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueArgumentNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function UniqueArgumentNamesRule(context) {
   return {

package/validation/rules/UniqueArgumentNamesRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { groupBy } from '../../jsutils/groupBy.mjs';
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 
@@ -8,6 +9,33 @@ import { GraphQLError } from '../../error/GraphQLError.mjs';
  * uniquely named.
  *
  * See https://spec.graphql.org/draft/#sec-Argument-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, parse, validate } from 'graphql';
+ * import { UniqueArgumentNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: String): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { field(arg: "1", arg: "2") }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueArgumentNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { field(arg: "1") }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueArgumentNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export function UniqueArgumentNamesRule(context) {
   return {