graphql 17.0.0-beta.1 → 17.0.0-beta.2

package/validation/rules/ValuesOfCorrectTypeRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from "../../language/visitor.js";
 import type { ValidationContext } from "../ValidationContext.js";
 /**
@@ -7,5 +8,32 @@ import type { ValidationContext } from "../ValidationContext.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; // => []
+ * ```
  */
 export declare function ValuesOfCorrectTypeRule(context: ValidationContext): ASTVisitor;

package/validation/rules/ValuesOfCorrectTypeRule.js

@@ -2,38 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValuesOfCorrectTypeRule = ValuesOfCorrectTypeRule;
 const validateInputValue_ts_1 = require("../../utilities/validateInputValue.js");
-/**
- * Value literals of correct type
- *
- * A GraphQL document is only valid if all value literals are of the type
- * expected at their position.
- *
- * See https://spec.graphql.org/draft/#sec-Values-of-Correct-Type
- */
 function ValuesOfCorrectTypeRule(context) {
     return {
         NullValue: (node) => isValidValueNode(context, node, context.getInputType()),
-        ListValue: (node) => 
-        // Note: TypeInfo will traverse into a list's item type, so look to the
-        // parent input type to check if it is a list.
-        isValidValueNode(context, node, context.getParentInputType()),
+        ListValue: (node) => isValidValueNode(context, node, context.getParentInputType()),
         ObjectValue: (node) => isValidValueNode(context, node, context.getInputType()),
         EnumValue: (node) => isValidValueNode(context, node, context.getInputType()),
         IntValue: (node) => isValidValueNode(context, node, context.getInputType()),
         FloatValue: (node) => isValidValueNode(context, node, context.getInputType()),
-        // Descriptions are string values that would not validate according
-        // to the below logic, but since (per the specification) descriptions must
-        // not affect validation, they are ignored entirely when visiting the AST
-        // and do not require special handling.
-        // See https://spec.graphql.org/draft/#sec-Descriptions
         StringValue: (node) => isValidValueNode(context, node, context.getInputType()),
         BooleanValue: (node) => isValidValueNode(context, node, context.getInputType()),
     };
 }
-/**
- * Any value literal may be a valid representation of a Scalar, depending on
- * that scalar type.
- */
 function isValidValueNode(context, node, inputType) {
     if (inputType) {
         (0, validateInputValue_ts_1.validateInputLiteral)(node, inputType, (error) => {

package/validation/rules/ValuesOfCorrectTypeRule.js.map

@@ -1 +1 @@
-{"version":3,"file":"ValuesOfCorrectTypeRule.js","sourceRoot":"","sources":["../../../src/validation/rules/ValuesOfCorrectTypeRule.ts"],"names":[],"mappings":";;AAmBA,0DA2BC;AAvCD,iFAA6E;AAI7E;;;;;;;GAOG;AACH,SAAgB,uBAAuB,CACrC,OAA0B;IAE1B,OAAO;QACL,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAClB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE;QAClB,uEAAuE;QACvE,8CAA8C;QAC9C,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,kBAAkB,EAAE,CAAC;QAC/D,WAAW,EAAE,CAAC,IAAI,EAAE,EAAE,CACpB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAClB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QAC3E,UAAU,EAAE,CAAC,IAAI,EAAE,EAAE,CACnB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,mEAAmE;QACnE,0EAA0E;QAC1E,yEAAyE;QACzE,uCAAuC;QACvC,uDAAuD;QACvD,WAAW,EAAE,CAAC,IAAI,EAAE,EAAE,CACpB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,YAAY,EAAE,CAAC,IAAI,EAAE,EAAE,CACrB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;KAC1D,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAS,gBAAgB,CACvB,OAA0B,EAC1B,IAAe,EACf,SAAkC;IAElC,IAAI,SAAS,EAAE,CAAC;QACd,IAAA,4CAAoB,EAClB,IAAI,EACJ,SAAS,EACT,CAAC,KAAK,EAAE,EAAE;YACR,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC,EACD,SAAS,EACT,SAAS,EACT,OAAO,CAAC,eAAe,CACxB,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["import type { Maybe } from '../../jsutils/Maybe.ts';\n\nimport type { ValueNode } from '../../language/ast.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport type { GraphQLInputType } from '../../type/index.ts';\n\nimport { validateInputLiteral } from '../../utilities/validateInputValue.ts';\n\nimport type { ValidationContext } from '../ValidationContext.ts';\n\n/**\n * Value literals of correct type\n *\n * A GraphQL document is only valid if all value literals are of the type\n * expected at their position.\n *\n * See https://spec.graphql.org/draft/#sec-Values-of-Correct-Type\n */\nexport function ValuesOfCorrectTypeRule(\n  context: ValidationContext,\n): ASTVisitor {\n  return {\n    NullValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    ListValue: (node) =>\n      // Note: TypeInfo will traverse into a list's item type, so look to the\n      // parent input type to check if it is a list.\n      isValidValueNode(context, node, context.getParentInputType()),\n    ObjectValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    EnumValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    IntValue: (node) => isValidValueNode(context, node, context.getInputType()),\n    FloatValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    // Descriptions are string values that would not validate according\n    // to the below logic, but since (per the specification) descriptions must\n    // not affect validation, they are ignored entirely when visiting the AST\n    // and do not require special handling.\n    // See https://spec.graphql.org/draft/#sec-Descriptions\n    StringValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    BooleanValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n  };\n}\n\n/**\n * Any value literal may be a valid representation of a Scalar, depending on\n * that scalar type.\n */\nfunction isValidValueNode(\n  context: ValidationContext,\n  node: ValueNode,\n  inputType: Maybe<GraphQLInputType>,\n): false {\n  if (inputType) {\n    validateInputLiteral(\n      node,\n      inputType,\n      (error) => {\n        context.reportError(error);\n      },\n      undefined,\n      undefined,\n      context.hideSuggestions,\n    );\n  }\n  return false;\n}\n"]}
+{"version":3,"file":"ValuesOfCorrectTypeRule.js","sourceRoot":"","sources":["../../../src/validation/rules/ValuesOfCorrectTypeRule.ts"],"names":[],"mappings":";;AAgDA,0DA2BC;AAlED,iFAA6E;AAuC7E,SAAgB,uBAAuB,CACrC,OAA0B;IAE1B,OAAO;QACL,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAClB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAGlB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,kBAAkB,EAAE,CAAC;QAC/D,WAAW,EAAE,CAAC,IAAI,EAAE,EAAE,CACpB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAClB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QAC3E,UAAU,EAAE,CAAC,IAAI,EAAE,EAAE,CACnB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QAMzD,WAAW,EAAE,CAAC,IAAI,EAAE,EAAE,CACpB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,YAAY,EAAE,CAAC,IAAI,EAAE,EAAE,CACrB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;KAC1D,CAAC;AACJ,CAAC;AAQD,SAAS,gBAAgB,CACvB,OAA0B,EAC1B,IAAe,EACf,SAAkC;IAElC,IAAI,SAAS,EAAE,CAAC;QACd,IAAA,4CAAoB,EAClB,IAAI,EACJ,SAAS,EACT,CAAC,KAAK,EAAE,EAAE;YACR,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC,EACD,SAAS,EACT,SAAS,EACT,OAAO,CAAC,eAAe,CACxB,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["/** @category Validation Rules */\n\nimport type { Maybe } from '../../jsutils/Maybe.ts';\n\nimport type { ValueNode } from '../../language/ast.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport type { GraphQLInputType } from '../../type/index.ts';\n\nimport { validateInputLiteral } from '../../utilities/validateInputValue.ts';\n\nimport type { ValidationContext } from '../ValidationContext.ts';\n\n/**\n * Value literals of correct type\n *\n * A GraphQL document is only valid if all value literals are of the type\n * expected at their position.\n *\n * See https://spec.graphql.org/draft/#sec-Values-of-Correct-Type\n * @param context - The validation context used while checking the document.\n * @returns A visitor that reports validation errors for this rule.\n * @example\n * ```ts\n * import { buildSchema, parse, validate } from 'graphql';\n * import { ValuesOfCorrectTypeRule } from 'graphql/validation';\n *\n * const schema = buildSchema(`\n *   type Query {\n *     count(limit: Int): Int\n *   }\n * `);\n *\n * const invalidDocument = parse(`\n *   { count(limit: \"many\") }\n * `);\n * const invalidErrors = validate(schema, invalidDocument, [ValuesOfCorrectTypeRule]);\n *\n * invalidErrors.length; // => 1\n *\n * const validDocument = parse(`\n *   { count(limit: 1) }\n * `);\n * const validErrors = validate(schema, validDocument, [ValuesOfCorrectTypeRule]);\n *\n * validErrors; // => []\n * ```\n */\nexport function ValuesOfCorrectTypeRule(\n  context: ValidationContext,\n): ASTVisitor {\n  return {\n    NullValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    ListValue: (node) =>\n      // Note: TypeInfo will traverse into a list's item type, so look to the\n      // parent input type to check if it is a list.\n      isValidValueNode(context, node, context.getParentInputType()),\n    ObjectValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    EnumValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    IntValue: (node) => isValidValueNode(context, node, context.getInputType()),\n    FloatValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    // Descriptions are string values that would not validate according\n    // to the below logic, but since (per the specification) descriptions must\n    // not affect validation, they are ignored entirely when visiting the AST\n    // and do not require special handling.\n    // See https://spec.graphql.org/draft/#sec-Descriptions\n    StringValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    BooleanValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n  };\n}\n\n/**\n * Any value literal may be a valid representation of a Scalar, depending on\n * that scalar type.\n *\n * @internal\n */\nfunction isValidValueNode(\n  context: ValidationContext,\n  node: ValueNode,\n  inputType: Maybe<GraphQLInputType>,\n): false {\n  if (inputType) {\n    validateInputLiteral(\n      node,\n      inputType,\n      (error) => {\n        context.reportError(error);\n      },\n      undefined,\n      undefined,\n      context.hideSuggestions,\n    );\n  }\n  return false;\n}\n"]}

package/validation/rules/ValuesOfCorrectTypeRule.mjs

@@ -1,36 +1,16 @@
 import { validateInputLiteral } from "../../utilities/validateInputValue.mjs";
-/**
- * Value literals of correct type
- *
- * A GraphQL document is only valid if all value literals are of the type
- * expected at their position.
- *
- * See https://spec.graphql.org/draft/#sec-Values-of-Correct-Type
- */
 export function ValuesOfCorrectTypeRule(context) {
     return {
         NullValue: (node) => isValidValueNode(context, node, context.getInputType()),
-        ListValue: (node) => 
-        // Note: TypeInfo will traverse into a list's item type, so look to the
-        // parent input type to check if it is a list.
-        isValidValueNode(context, node, context.getParentInputType()),
+        ListValue: (node) => isValidValueNode(context, node, context.getParentInputType()),
         ObjectValue: (node) => isValidValueNode(context, node, context.getInputType()),
         EnumValue: (node) => isValidValueNode(context, node, context.getInputType()),
         IntValue: (node) => isValidValueNode(context, node, context.getInputType()),
         FloatValue: (node) => isValidValueNode(context, node, context.getInputType()),
-        // Descriptions are string values that would not validate according
-        // to the below logic, but since (per the specification) descriptions must
-        // not affect validation, they are ignored entirely when visiting the AST
-        // and do not require special handling.
-        // See https://spec.graphql.org/draft/#sec-Descriptions
         StringValue: (node) => isValidValueNode(context, node, context.getInputType()),
         BooleanValue: (node) => isValidValueNode(context, node, context.getInputType()),
     };
 }
-/**
- * Any value literal may be a valid representation of a Scalar, depending on
- * that scalar type.
- */
 function isValidValueNode(context, node, inputType) {
     if (inputType) {
         validateInputLiteral(node, inputType, (error) => {

package/validation/rules/ValuesOfCorrectTypeRule.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ValuesOfCorrectTypeRule.js","sourceRoot":"","sources":["../../../src/validation/rules/ValuesOfCorrectTypeRule.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,oBAAoB,EAAE,+CAA8C;AAI7E;;;;;;;GAOG;AACH,MAAM,UAAU,uBAAuB,CACrC,OAA0B;IAE1B,OAAO;QACL,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAClB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE;QAClB,uEAAuE;QACvE,8CAA8C;QAC9C,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,kBAAkB,EAAE,CAAC;QAC/D,WAAW,EAAE,CAAC,IAAI,EAAE,EAAE,CACpB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAClB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QAC3E,UAAU,EAAE,CAAC,IAAI,EAAE,EAAE,CACnB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,mEAAmE;QACnE,0EAA0E;QAC1E,yEAAyE;QACzE,uCAAuC;QACvC,uDAAuD;QACvD,WAAW,EAAE,CAAC,IAAI,EAAE,EAAE,CACpB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,YAAY,EAAE,CAAC,IAAI,EAAE,EAAE,CACrB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;KAC1D,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAS,gBAAgB,CACvB,OAA0B,EAC1B,IAAe,EACf,SAAkC;IAElC,IAAI,SAAS,EAAE,CAAC;QACd,oBAAoB,CAClB,IAAI,EACJ,SAAS,EACT,CAAC,KAAK,EAAE,EAAE;YACR,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC,EACD,SAAS,EACT,SAAS,EACT,OAAO,CAAC,eAAe,CACxB,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["import type { Maybe } from '../../jsutils/Maybe.ts';\n\nimport type { ValueNode } from '../../language/ast.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport type { GraphQLInputType } from '../../type/index.ts';\n\nimport { validateInputLiteral } from '../../utilities/validateInputValue.ts';\n\nimport type { ValidationContext } from '../ValidationContext.ts';\n\n/**\n * Value literals of correct type\n *\n * A GraphQL document is only valid if all value literals are of the type\n * expected at their position.\n *\n * See https://spec.graphql.org/draft/#sec-Values-of-Correct-Type\n */\nexport function ValuesOfCorrectTypeRule(\n  context: ValidationContext,\n): ASTVisitor {\n  return {\n    NullValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    ListValue: (node) =>\n      // Note: TypeInfo will traverse into a list's item type, so look to the\n      // parent input type to check if it is a list.\n      isValidValueNode(context, node, context.getParentInputType()),\n    ObjectValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    EnumValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    IntValue: (node) => isValidValueNode(context, node, context.getInputType()),\n    FloatValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    // Descriptions are string values that would not validate according\n    // to the below logic, but since (per the specification) descriptions must\n    // not affect validation, they are ignored entirely when visiting the AST\n    // and do not require special handling.\n    // See https://spec.graphql.org/draft/#sec-Descriptions\n    StringValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    BooleanValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n  };\n}\n\n/**\n * Any value literal may be a valid representation of a Scalar, depending on\n * that scalar type.\n */\nfunction isValidValueNode(\n  context: ValidationContext,\n  node: ValueNode,\n  inputType: Maybe<GraphQLInputType>,\n): false {\n  if (inputType) {\n    validateInputLiteral(\n      node,\n      inputType,\n      (error) => {\n        context.reportError(error);\n      },\n      undefined,\n      undefined,\n      context.hideSuggestions,\n    );\n  }\n  return false;\n}\n"]}
+{"version":3,"file":"ValuesOfCorrectTypeRule.js","sourceRoot":"","sources":["../../../src/validation/rules/ValuesOfCorrectTypeRule.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,oBAAoB,EAAE,+CAA8C;AAuC7E,MAAM,UAAU,uBAAuB,CACrC,OAA0B;IAE1B,OAAO;QACL,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAClB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAGlB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,kBAAkB,EAAE,CAAC;QAC/D,WAAW,EAAE,CAAC,IAAI,EAAE,EAAE,CACpB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAClB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QAC3E,UAAU,EAAE,CAAC,IAAI,EAAE,EAAE,CACnB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QAMzD,WAAW,EAAE,CAAC,IAAI,EAAE,EAAE,CACpB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;QACzD,YAAY,EAAE,CAAC,IAAI,EAAE,EAAE,CACrB,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC;KAC1D,CAAC;AACJ,CAAC;AAQD,SAAS,gBAAgB,CACvB,OAA0B,EAC1B,IAAe,EACf,SAAkC;IAElC,IAAI,SAAS,EAAE,CAAC;QACd,oBAAoB,CAClB,IAAI,EACJ,SAAS,EACT,CAAC,KAAK,EAAE,EAAE;YACR,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC,EACD,SAAS,EACT,SAAS,EACT,OAAO,CAAC,eAAe,CACxB,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["/** @category Validation Rules */\n\nimport type { Maybe } from '../../jsutils/Maybe.ts';\n\nimport type { ValueNode } from '../../language/ast.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport type { GraphQLInputType } from '../../type/index.ts';\n\nimport { validateInputLiteral } from '../../utilities/validateInputValue.ts';\n\nimport type { ValidationContext } from '../ValidationContext.ts';\n\n/**\n * Value literals of correct type\n *\n * A GraphQL document is only valid if all value literals are of the type\n * expected at their position.\n *\n * See https://spec.graphql.org/draft/#sec-Values-of-Correct-Type\n * @param context - The validation context used while checking the document.\n * @returns A visitor that reports validation errors for this rule.\n * @example\n * ```ts\n * import { buildSchema, parse, validate } from 'graphql';\n * import { ValuesOfCorrectTypeRule } from 'graphql/validation';\n *\n * const schema = buildSchema(`\n *   type Query {\n *     count(limit: Int): Int\n *   }\n * `);\n *\n * const invalidDocument = parse(`\n *   { count(limit: \"many\") }\n * `);\n * const invalidErrors = validate(schema, invalidDocument, [ValuesOfCorrectTypeRule]);\n *\n * invalidErrors.length; // => 1\n *\n * const validDocument = parse(`\n *   { count(limit: 1) }\n * `);\n * const validErrors = validate(schema, validDocument, [ValuesOfCorrectTypeRule]);\n *\n * validErrors; // => []\n * ```\n */\nexport function ValuesOfCorrectTypeRule(\n  context: ValidationContext,\n): ASTVisitor {\n  return {\n    NullValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    ListValue: (node) =>\n      // Note: TypeInfo will traverse into a list's item type, so look to the\n      // parent input type to check if it is a list.\n      isValidValueNode(context, node, context.getParentInputType()),\n    ObjectValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    EnumValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    IntValue: (node) => isValidValueNode(context, node, context.getInputType()),\n    FloatValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    // Descriptions are string values that would not validate according\n    // to the below logic, but since (per the specification) descriptions must\n    // not affect validation, they are ignored entirely when visiting the AST\n    // and do not require special handling.\n    // See https://spec.graphql.org/draft/#sec-Descriptions\n    StringValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n    BooleanValue: (node) =>\n      isValidValueNode(context, node, context.getInputType()),\n  };\n}\n\n/**\n * Any value literal may be a valid representation of a Scalar, depending on\n * that scalar type.\n *\n * @internal\n */\nfunction isValidValueNode(\n  context: ValidationContext,\n  node: ValueNode,\n  inputType: Maybe<GraphQLInputType>,\n): false {\n  if (inputType) {\n    validateInputLiteral(\n      node,\n      inputType,\n      (error) => {\n        context.reportError(error);\n      },\n      undefined,\n      undefined,\n      context.hideSuggestions,\n    );\n  }\n  return false;\n}\n"]}

package/validation/rules/VariablesAreInputTypesRule.d.mts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from "../../language/visitor.mjs";
 import type { ValidationContext } from "../ValidationContext.mjs";
 /**
@@ -7,5 +8,36 @@ import type { ValidationContext } from "../ValidationContext.mjs";
  * 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): ASTVisitor;

package/validation/rules/VariablesAreInputTypesRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from "../../language/visitor.js";
 import type { ValidationContext } from "../ValidationContext.js";
 /**
@@ -7,5 +8,36 @@ import type { ValidationContext } from "../ValidationContext.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; // => []
+ * ```
  */
 export declare function VariablesAreInputTypesRule(context: ValidationContext): ASTVisitor;

package/validation/rules/VariablesAreInputTypesRule.js

@@ -5,14 +5,6 @@ const GraphQLError_ts_1 = require("../../error/GraphQLError.js");
 const printer_ts_1 = require("../../language/printer.js");
 const definition_ts_1 = require("../../type/definition.js");
 const typeFromAST_ts_1 = require("../../utilities/typeFromAST.js");
-/**
- * Variables are input types
- *
- * A GraphQL operation is only valid if all the variables it defines are of
- * input types (scalar, enum, or input object).
- *
- * See https://spec.graphql.org/draft/#sec-Variables-Are-Input-Types
- */
 function VariablesAreInputTypesRule(context) {
     return {
         VariableDefinition(node) {

package/validation/rules/VariablesAreInputTypesRule.js.map

@@ -1 +1 @@
-{"version":3,"file":"VariablesAreInputTypesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/VariablesAreInputTypesRule.ts"],"names":[],"mappings":";;AAoBA,gEAoBC;AAxCD,iEAA2D;AAG3D,0DAAkD;AAGlD,4DAAuD;AAEvD,mEAA6D;AAI7D;;;;;;;GAOG;AACH,SAAgB,0BAA0B,CACxC,OAA0B;IAE1B,OAAO;QACL,kBAAkB,CAAC,IAA4B;YAC7C,MAAM,IAAI,GAAG,IAAA,4BAAW,EAAC,OAAO,CAAC,SAAS,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YAEzD,IAAI,IAAI,KAAK,SAAS,IAAI,CAAC,IAAA,2BAAW,EAAC,IAAI,CAAC,EAAE,CAAC;gBAC7C,MAAM,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC;gBAC9C,MAAM,QAAQ,GAAG,IAAA,kBAAK,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAElC,OAAO,CAAC,WAAW,CACjB,IAAI,8BAAY,CACd,cAAc,YAAY,+BAA+B,QAAQ,IAAI,EACrE,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,CACrB,CACF,CAAC;YACJ,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.ts';\n\nimport type { VariableDefinitionNode } from '../../language/ast.ts';\nimport { print } from '../../language/printer.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport { isInputType } from '../../type/definition.ts';\n\nimport { typeFromAST } from '../../utilities/typeFromAST.ts';\n\nimport type { ValidationContext } from '../ValidationContext.ts';\n\n/**\n * Variables are input types\n *\n * A GraphQL operation is only valid if all the variables it defines are of\n * input types (scalar, enum, or input object).\n *\n * See https://spec.graphql.org/draft/#sec-Variables-Are-Input-Types\n */\nexport function VariablesAreInputTypesRule(\n  context: ValidationContext,\n): ASTVisitor {\n  return {\n    VariableDefinition(node: VariableDefinitionNode) {\n      const type = typeFromAST(context.getSchema(), node.type);\n\n      if (type !== undefined && !isInputType(type)) {\n        const variableName = node.variable.name.value;\n        const typeName = print(node.type);\n\n        context.reportError(\n          new GraphQLError(\n            `Variable \"$${variableName}\" cannot be non-input type \"${typeName}\".`,\n            { nodes: node.type },\n          ),\n        );\n      }\n    },\n  };\n}\n"]}
+{"version":3,"file":"VariablesAreInputTypesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/VariablesAreInputTypesRule.ts"],"names":[],"mappings":";;AAqDA,gEAoBC;AAvED,iEAA2D;AAG3D,0DAAkD;AAGlD,4DAAuD;AAEvD,mEAA6D;AA2C7D,SAAgB,0BAA0B,CACxC,OAA0B;IAE1B,OAAO;QACL,kBAAkB,CAAC,IAA4B;YAC7C,MAAM,IAAI,GAAG,IAAA,4BAAW,EAAC,OAAO,CAAC,SAAS,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YAEzD,IAAI,IAAI,KAAK,SAAS,IAAI,CAAC,IAAA,2BAAW,EAAC,IAAI,CAAC,EAAE,CAAC;gBAC7C,MAAM,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC;gBAC9C,MAAM,QAAQ,GAAG,IAAA,kBAAK,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAElC,OAAO,CAAC,WAAW,CACjB,IAAI,8BAAY,CACd,cAAc,YAAY,+BAA+B,QAAQ,IAAI,EACrE,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,CACrB,CACF,CAAC;YACJ,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["/** @category Validation Rules */\n\nimport { GraphQLError } from '../../error/GraphQLError.ts';\n\nimport type { VariableDefinitionNode } from '../../language/ast.ts';\nimport { print } from '../../language/printer.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport { isInputType } from '../../type/definition.ts';\n\nimport { typeFromAST } from '../../utilities/typeFromAST.ts';\n\nimport type { ValidationContext } from '../ValidationContext.ts';\n\n/**\n * Variables are input types\n *\n * A GraphQL operation is only valid if all the variables it defines are of\n * input types (scalar, enum, or input object).\n *\n * See https://spec.graphql.org/draft/#sec-Variables-Are-Input-Types\n * @param context - The validation context used while checking the document.\n * @returns A visitor that reports validation errors for this rule.\n * @example\n * ```ts\n * import { buildSchema, parse, validate } from 'graphql';\n * import { VariablesAreInputTypesRule } from 'graphql/validation';\n *\n * const schema = buildSchema(`\n *   type Query {\n *     field(arg: ID): String\n *   }\n *\n *   type User {\n *     name: String\n *   }\n * `);\n *\n * const invalidDocument = parse(`\n *   query ($user: User) { field(arg: \"1\") }\n * `);\n * const invalidErrors = validate(schema, invalidDocument, [VariablesAreInputTypesRule]);\n *\n * invalidErrors.length; // => 1\n *\n * const validDocument = parse(`\n *   query ($id: ID) { field(arg: $id) }\n * `);\n * const validErrors = validate(schema, validDocument, [VariablesAreInputTypesRule]);\n *\n * validErrors; // => []\n * ```\n */\nexport function VariablesAreInputTypesRule(\n  context: ValidationContext,\n): ASTVisitor {\n  return {\n    VariableDefinition(node: VariableDefinitionNode) {\n      const type = typeFromAST(context.getSchema(), node.type);\n\n      if (type !== undefined && !isInputType(type)) {\n        const variableName = node.variable.name.value;\n        const typeName = print(node.type);\n\n        context.reportError(\n          new GraphQLError(\n            `Variable \"$${variableName}\" cannot be non-input type \"${typeName}\".`,\n            { nodes: node.type },\n          ),\n        );\n      }\n    },\n  };\n}\n"]}

package/validation/rules/VariablesAreInputTypesRule.mjs

@@ -2,14 +2,6 @@ import { GraphQLError } from "../../error/GraphQLError.mjs";
 import { print } from "../../language/printer.mjs";
 import { isInputType } from "../../type/definition.mjs";
 import { typeFromAST } from "../../utilities/typeFromAST.mjs";
-/**
- * Variables are input types
- *
- * A GraphQL operation is only valid if all the variables it defines are of
- * input types (scalar, enum, or input object).
- *
- * See https://spec.graphql.org/draft/#sec-Variables-Are-Input-Types
- */
 export function VariablesAreInputTypesRule(context) {
     return {
         VariableDefinition(node) {

package/validation/rules/VariablesAreInputTypesRule.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"VariablesAreInputTypesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/VariablesAreInputTypesRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,qCAAoC;AAG3D,OAAO,EAAE,KAAK,EAAE,mCAAkC;AAGlD,OAAO,EAAE,WAAW,EAAE,kCAAiC;AAEvD,OAAO,EAAE,WAAW,EAAE,wCAAuC;AAI7D;;;;;;;GAOG;AACH,MAAM,UAAU,0BAA0B,CACxC,OAA0B;IAE1B,OAAO;QACL,kBAAkB,CAAC,IAA4B;YAC7C,MAAM,IAAI,GAAG,WAAW,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YAEzD,IAAI,IAAI,KAAK,SAAS,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC7C,MAAM,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC;gBAC9C,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAElC,OAAO,CAAC,WAAW,CACjB,IAAI,YAAY,CACd,cAAc,YAAY,+BAA+B,QAAQ,IAAI,EACrE,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,CACrB,CACF,CAAC;YACJ,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.ts';\n\nimport type { VariableDefinitionNode } from '../../language/ast.ts';\nimport { print } from '../../language/printer.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport { isInputType } from '../../type/definition.ts';\n\nimport { typeFromAST } from '../../utilities/typeFromAST.ts';\n\nimport type { ValidationContext } from '../ValidationContext.ts';\n\n/**\n * Variables are input types\n *\n * A GraphQL operation is only valid if all the variables it defines are of\n * input types (scalar, enum, or input object).\n *\n * See https://spec.graphql.org/draft/#sec-Variables-Are-Input-Types\n */\nexport function VariablesAreInputTypesRule(\n  context: ValidationContext,\n): ASTVisitor {\n  return {\n    VariableDefinition(node: VariableDefinitionNode) {\n      const type = typeFromAST(context.getSchema(), node.type);\n\n      if (type !== undefined && !isInputType(type)) {\n        const variableName = node.variable.name.value;\n        const typeName = print(node.type);\n\n        context.reportError(\n          new GraphQLError(\n            `Variable \"$${variableName}\" cannot be non-input type \"${typeName}\".`,\n            { nodes: node.type },\n          ),\n        );\n      }\n    },\n  };\n}\n"]}
+{"version":3,"file":"VariablesAreInputTypesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/VariablesAreInputTypesRule.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,qCAAoC;AAG3D,OAAO,EAAE,KAAK,EAAE,mCAAkC;AAGlD,OAAO,EAAE,WAAW,EAAE,kCAAiC;AAEvD,OAAO,EAAE,WAAW,EAAE,wCAAuC;AA2C7D,MAAM,UAAU,0BAA0B,CACxC,OAA0B;IAE1B,OAAO;QACL,kBAAkB,CAAC,IAA4B;YAC7C,MAAM,IAAI,GAAG,WAAW,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YAEzD,IAAI,IAAI,KAAK,SAAS,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC7C,MAAM,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC;gBAC9C,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAElC,OAAO,CAAC,WAAW,CACjB,IAAI,YAAY,CACd,cAAc,YAAY,+BAA+B,QAAQ,IAAI,EACrE,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,CACrB,CACF,CAAC;YACJ,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["/** @category Validation Rules */\n\nimport { GraphQLError } from '../../error/GraphQLError.ts';\n\nimport type { VariableDefinitionNode } from '../../language/ast.ts';\nimport { print } from '../../language/printer.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport { isInputType } from '../../type/definition.ts';\n\nimport { typeFromAST } from '../../utilities/typeFromAST.ts';\n\nimport type { ValidationContext } from '../ValidationContext.ts';\n\n/**\n * Variables are input types\n *\n * A GraphQL operation is only valid if all the variables it defines are of\n * input types (scalar, enum, or input object).\n *\n * See https://spec.graphql.org/draft/#sec-Variables-Are-Input-Types\n * @param context - The validation context used while checking the document.\n * @returns A visitor that reports validation errors for this rule.\n * @example\n * ```ts\n * import { buildSchema, parse, validate } from 'graphql';\n * import { VariablesAreInputTypesRule } from 'graphql/validation';\n *\n * const schema = buildSchema(`\n *   type Query {\n *     field(arg: ID): String\n *   }\n *\n *   type User {\n *     name: String\n *   }\n * `);\n *\n * const invalidDocument = parse(`\n *   query ($user: User) { field(arg: \"1\") }\n * `);\n * const invalidErrors = validate(schema, invalidDocument, [VariablesAreInputTypesRule]);\n *\n * invalidErrors.length; // => 1\n *\n * const validDocument = parse(`\n *   query ($id: ID) { field(arg: $id) }\n * `);\n * const validErrors = validate(schema, validDocument, [VariablesAreInputTypesRule]);\n *\n * validErrors; // => []\n * ```\n */\nexport function VariablesAreInputTypesRule(\n  context: ValidationContext,\n): ASTVisitor {\n  return {\n    VariableDefinition(node: VariableDefinitionNode) {\n      const type = typeFromAST(context.getSchema(), node.type);\n\n      if (type !== undefined && !isInputType(type)) {\n        const variableName = node.variable.name.value;\n        const typeName = print(node.type);\n\n        context.reportError(\n          new GraphQLError(\n            `Variable \"$${variableName}\" cannot be non-input type \"${typeName}\".`,\n            { nodes: node.type },\n          ),\n        );\n      }\n    },\n  };\n}\n"]}

package/validation/rules/VariablesInAllowedPositionRule.d.mts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from "../../language/visitor.mjs";
 import type { ValidationContext } from "../ValidationContext.mjs";
 /**
@@ -6,5 +7,32 @@ import type { ValidationContext } from "../ValidationContext.mjs";
  * Variable usages must be compatible with the arguments they are passed to.
  *
  * See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed
+ * @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 { VariablesInAllowedPositionRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID!): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($id: String) { field(arg: $id) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [VariablesInAllowedPositionRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID!) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [VariablesInAllowedPositionRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function VariablesInAllowedPositionRule(context: ValidationContext): ASTVisitor;

package/validation/rules/VariablesInAllowedPositionRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from "../../language/visitor.js";
 import type { ValidationContext } from "../ValidationContext.js";
 /**
@@ -6,5 +7,32 @@ import type { ValidationContext } from "../ValidationContext.js";
  * Variable usages must be compatible with the arguments they are passed to.
  *
  * See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed
+ * @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 { VariablesInAllowedPositionRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID!): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($id: String) { field(arg: $id) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [VariablesInAllowedPositionRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID!) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [VariablesInAllowedPositionRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function VariablesInAllowedPositionRule(context: ValidationContext): ASTVisitor;

package/validation/rules/VariablesInAllowedPositionRule.js

@@ -6,13 +6,6 @@ const kinds_ts_1 = require("../../language/kinds.js");
 const definition_ts_1 = require("../../type/definition.js");
 const typeComparators_ts_1 = require("../../utilities/typeComparators.js");
 const typeFromAST_ts_1 = require("../../utilities/typeFromAST.js");
-/**
- * Variables in allowed position
- *
- * Variable usages must be compatible with the arguments they are passed to.
- *
- * See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed
- */
 function VariablesInAllowedPositionRule(context) {
     let varDefMap;
     return {
@@ -27,11 +20,6 @@ function VariablesInAllowedPositionRule(context) {
                     let varDef = fragmentVariableDefinition;
                     varDef ??= varDefMap.get(varName);
                     if (varDef && type) {
-                        // A var type is allowed if it is the same or more strict (e.g. is
-                        // a subtype of) than the expected type. It can be more strict if
-                        // the variable type is non-null when the expected type is nullable.
-                        // If both are list types, the variable item type can be more strict
-                        // than the expected item type (contravariant).
                         const schema = context.getSchema();
                         const varType = (0, typeFromAST_ts_1.typeFromAST)(schema, varDef.type);
                         if (varType &&
@@ -52,14 +40,6 @@ function VariablesInAllowedPositionRule(context) {
         },
     };
 }
-/**
- * Returns true if the variable is allowed in the location it was found,
- * including considering if default values exist for either the variable
- * or the location at which it is located.
- *
- * OneOf Input Object Type fields are considered separately above to
- * provide a more descriptive error message.
- */
 function allowedVariableUsage(schema, varType, varDefaultValue, locationType, locationDefaultValue) {
     if ((0, definition_ts_1.isNonNullType)(locationType) && !(0, definition_ts_1.isNonNullType)(varType)) {
         const hasNonNullVariableDefaultValue = varDefaultValue != null && varDefaultValue.kind !== kinds_ts_1.Kind.NULL;

package/validation/rules/VariablesInAllowedPositionRule.js.map

@@ -1 +1 @@
-{"version":3,"file":"VariablesInAllowedPositionRule.js","sourceRoot":"","sources":["../../../src/validation/rules/VariablesInAllowedPositionRule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Maybe } from '../../jsutils/Maybe.ts';\n\nimport { GraphQLError } from '../../error/GraphQLError.ts';\n\nimport type { ValueNode, VariableDefinitionNode } from '../../language/ast.ts';\nimport { Kind } from '../../language/kinds.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport type { GraphQLType } from '../../type/definition.ts';\nimport {\n  isInputObjectType,\n  isNonNullType,\n  isNullableType,\n} from '../../type/definition.ts';\nimport type { GraphQLSchema } from '../../type/schema.ts';\n\nimport { isTypeSubTypeOf } from '../../utilities/typeComparators.ts';\nimport { typeFromAST } from '../../utilities/typeFromAST.ts';\n\nimport type { ValidationContext } from '../ValidationContext.ts';\n\n/**\n * Variables in allowed position\n *\n * Variable usages must be compatible with the arguments they are passed to.\n *\n * See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed\n */\nexport function VariablesInAllowedPositionRule(\n  context: ValidationContext,\n): ASTVisitor {\n  let varDefMap: Map<string, VariableDefinitionNode>;\n\n  return {\n    OperationDefinition: {\n      enter() {\n        varDefMap = new Map();\n      },\n      leave(operation) {\n        const usages = context.getRecursiveVariableUsages(operation);\n\n        for (const {\n          node,\n          type,\n          parentType,\n          defaultValue,\n          fragmentVariableDefinition,\n        } of usages) {\n          const varName = node.name.value;\n\n          let varDef = fragmentVariableDefinition;\n          varDef ??= varDefMap.get(varName);\n          if (varDef && type) {\n            // A var type is allowed if it is the same or more strict (e.g. is\n            // a subtype of) than the expected type. It can be more strict if\n            // the variable type is non-null when the expected type is nullable.\n            // If both are list types, the variable item type can be more strict\n            // than the expected item type (contravariant).\n            const schema = context.getSchema();\n            const varType = typeFromAST(schema, varDef.type);\n            if (\n              varType &&\n              !allowedVariableUsage(\n                schema,\n                varType,\n                varDef.defaultValue,\n                type,\n                defaultValue,\n              )\n            ) {\n              context.reportError(\n                new GraphQLError(\n                  `Variable \"$${varName}\" of type \"${varType}\" used in position expecting type \"${type}\".`,\n                  { nodes: [varDef, node] },\n                ),\n              );\n            }\n\n            if (\n              isInputObjectType(parentType) &&\n              parentType.isOneOf &&\n              isNullableType(varType)\n            ) {\n              context.reportError(\n                new GraphQLError(\n                  `Variable \"$${varName}\" is of type \"${varType}\" but must be non-nullable to be used for OneOf Input Object \"${parentType}\".`,\n                  { nodes: [varDef, node] },\n                ),\n              );\n            }\n          }\n        }\n      },\n    },\n    VariableDefinition(node) {\n      varDefMap.set(node.variable.name.value, node);\n    },\n  };\n}\n\n/**\n * Returns true if the variable is allowed in the location it was found,\n * including considering if default values exist for either the variable\n * or the location at which it is located.\n *\n * OneOf Input Object Type fields are considered separately above to\n * provide a more descriptive error message.\n */\nfunction allowedVariableUsage(\n  schema: GraphQLSchema,\n  varType: GraphQLType,\n  varDefaultValue: Maybe<ValueNode>,\n  locationType: GraphQLType,\n  locationDefaultValue: unknown,\n): boolean {\n  if (isNonNullType(locationType) && !isNonNullType(varType)) {\n    const hasNonNullVariableDefaultValue =\n      varDefaultValue != null && varDefaultValue.kind !== Kind.NULL;\n    const hasLocationDefaultValue = locationDefaultValue !== undefined;\n    if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) {\n      return false;\n    }\n    const nullableLocationType = locationType.ofType;\n    return isTypeSubTypeOf(schema, varType, nullableLocationType);\n  }\n  return isTypeSubTypeOf(schema, varType, locationType);\n}\n"]}
+{"version":3,"file":"VariablesInAllowedPositionRule.js","sourceRoot":"","sources":["../../../src/validation/rules/VariablesInAllowedPositionRule.ts"],"names":[],"mappings":";;AAyDA,wEAsEC;AA3HD,iEAA2D;AAG3D,sDAA+C;AAI/C,4DAIkC;AAGlC,2EAAqE;AACrE,mEAA6D;AAsC7D,SAAgB,8BAA8B,CAC5C,OAA0B;IAE1B,IAAI,SAA8C,CAAC;IAEnD,OAAO;QACL,mBAAmB,EAAE;YACnB,KAAK;gBACH,SAAS,GAAG,IAAI,GAAG,EAAE,CAAC;YACxB,CAAC;YACD,KAAK,CAAC,SAAS;gBACb,MAAM,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC,SAAS,CAAC,CAAC;gBAE7D,KAAK,MAAM,EACT,IAAI,EACJ,IAAI,EACJ,UAAU,EACV,YAAY,EACZ,0BAA0B,GAC3B,IAAI,MAAM,EAAE,CAAC;oBACZ,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;oBAEhC,IAAI,MAAM,GAAG,0BAA0B,CAAC;oBACxC,MAAM,KAAK,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;oBAClC,IAAI,MAAM,IAAI,IAAI,EAAE,CAAC;wBAMnB,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;wBACnC,MAAM,OAAO,GAAG,IAAA,4BAAW,EAAC,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;wBACjD,IACE,OAAO;4BACP,CAAC,oBAAoB,CACnB,MAAM,EACN,OAAO,EACP,MAAM,CAAC,YAAY,EACnB,IAAI,EACJ,YAAY,CACb,EACD,CAAC;4BACD,OAAO,CAAC,WAAW,CACjB,IAAI,8BAAY,CACd,cAAc,OAAO,cAAc,OAAO,sCAAsC,IAAI,IAAI,EACxF,EAAE,KAAK,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,CAC1B,CACF,CAAC;wBACJ,CAAC;wBAED,IACE,IAAA,iCAAiB,EAAC,UAAU,CAAC;4BAC7B,UAAU,CAAC,OAAO;4BAClB,IAAA,8BAAc,EAAC,OAAO,CAAC,EACvB,CAAC;4BACD,OAAO,CAAC,WAAW,CACjB,IAAI,8BAAY,CACd,cAAc,OAAO,iBAAiB,OAAO,iEAAiE,UAAU,IAAI,EAC5H,EAAE,KAAK,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,CAC1B,CACF,CAAC;wBACJ,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;SACF;QACD,kBAAkB,CAAC,IAAI;YACrB,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAChD,CAAC;KACF,CAAC;AACJ,CAAC;AAYD,SAAS,oBAAoB,CAC3B,MAAqB,EACrB,OAAoB,EACpB,eAAiC,EACjC,YAAyB,EACzB,oBAA6B;IAE7B,IAAI,IAAA,6BAAa,EAAC,YAAY,CAAC,IAAI,CAAC,IAAA,6BAAa,EAAC,OAAO,CAAC,EAAE,CAAC;QAC3D,MAAM,8BAA8B,GAClC,eAAe,IAAI,IAAI,IAAI,eAAe,CAAC,IAAI,KAAK,eAAI,CAAC,IAAI,CAAC;QAChE,MAAM,uBAAuB,GAAG,oBAAoB,KAAK,SAAS,CAAC;QACnE,IAAI,CAAC,8BAA8B,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAChE,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,oBAAoB,GAAG,YAAY,CAAC,MAAM,CAAC;QACjD,OAAO,IAAA,oCAAe,EAAC,MAAM,EAAE,OAAO,EAAE,oBAAoB,CAAC,CAAC;IAChE,CAAC;IACD,OAAO,IAAA,oCAAe,EAAC,MAAM,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;AACxD,CAAC","sourcesContent":["/** @category Validation Rules */\n\nimport type { Maybe } from '../../jsutils/Maybe.ts';\n\nimport { GraphQLError } from '../../error/GraphQLError.ts';\n\nimport type { ValueNode, VariableDefinitionNode } from '../../language/ast.ts';\nimport { Kind } from '../../language/kinds.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport type { GraphQLType } from '../../type/definition.ts';\nimport {\n  isInputObjectType,\n  isNonNullType,\n  isNullableType,\n} from '../../type/definition.ts';\nimport type { GraphQLSchema } from '../../type/schema.ts';\n\nimport { isTypeSubTypeOf } from '../../utilities/typeComparators.ts';\nimport { typeFromAST } from '../../utilities/typeFromAST.ts';\n\nimport type { ValidationContext } from '../ValidationContext.ts';\n\n/**\n * Variables in allowed position\n *\n * Variable usages must be compatible with the arguments they are passed to.\n *\n * See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed\n * @param context - The validation context used while checking the document.\n * @returns A visitor that reports validation errors for this rule.\n * @example\n * ```ts\n * import { buildSchema, parse, validate } from 'graphql';\n * import { VariablesInAllowedPositionRule } from 'graphql/validation';\n *\n * const schema = buildSchema(`\n *   type Query {\n *     field(arg: ID!): String\n *   }\n * `);\n *\n * const invalidDocument = parse(`\n *   query ($id: String) { field(arg: $id) }\n * `);\n * const invalidErrors = validate(schema, invalidDocument, [VariablesInAllowedPositionRule]);\n *\n * invalidErrors.length; // => 1\n *\n * const validDocument = parse(`\n *   query ($id: ID!) { field(arg: $id) }\n * `);\n * const validErrors = validate(schema, validDocument, [VariablesInAllowedPositionRule]);\n *\n * validErrors; // => []\n * ```\n */\nexport function VariablesInAllowedPositionRule(\n  context: ValidationContext,\n): ASTVisitor {\n  let varDefMap: Map<string, VariableDefinitionNode>;\n\n  return {\n    OperationDefinition: {\n      enter() {\n        varDefMap = new Map();\n      },\n      leave(operation) {\n        const usages = context.getRecursiveVariableUsages(operation);\n\n        for (const {\n          node,\n          type,\n          parentType,\n          defaultValue,\n          fragmentVariableDefinition,\n        } of usages) {\n          const varName = node.name.value;\n\n          let varDef = fragmentVariableDefinition;\n          varDef ??= varDefMap.get(varName);\n          if (varDef && type) {\n            // A var type is allowed if it is the same or more strict (e.g. is\n            // a subtype of) than the expected type. It can be more strict if\n            // the variable type is non-null when the expected type is nullable.\n            // If both are list types, the variable item type can be more strict\n            // than the expected item type (contravariant).\n            const schema = context.getSchema();\n            const varType = typeFromAST(schema, varDef.type);\n            if (\n              varType &&\n              !allowedVariableUsage(\n                schema,\n                varType,\n                varDef.defaultValue,\n                type,\n                defaultValue,\n              )\n            ) {\n              context.reportError(\n                new GraphQLError(\n                  `Variable \"$${varName}\" of type \"${varType}\" used in position expecting type \"${type}\".`,\n                  { nodes: [varDef, node] },\n                ),\n              );\n            }\n\n            if (\n              isInputObjectType(parentType) &&\n              parentType.isOneOf &&\n              isNullableType(varType)\n            ) {\n              context.reportError(\n                new GraphQLError(\n                  `Variable \"$${varName}\" is of type \"${varType}\" but must be non-nullable to be used for OneOf Input Object \"${parentType}\".`,\n                  { nodes: [varDef, node] },\n                ),\n              );\n            }\n          }\n        }\n      },\n    },\n    VariableDefinition(node) {\n      varDefMap.set(node.variable.name.value, node);\n    },\n  };\n}\n\n/**\n * Returns true if the variable is allowed in the location it was found,\n * including considering if default values exist for either the variable\n * or the location at which it is located.\n *\n * OneOf Input Object Type fields are considered separately above to\n * provide a more descriptive error message.\n *\n * @internal\n */\nfunction allowedVariableUsage(\n  schema: GraphQLSchema,\n  varType: GraphQLType,\n  varDefaultValue: Maybe<ValueNode>,\n  locationType: GraphQLType,\n  locationDefaultValue: unknown,\n): boolean {\n  if (isNonNullType(locationType) && !isNonNullType(varType)) {\n    const hasNonNullVariableDefaultValue =\n      varDefaultValue != null && varDefaultValue.kind !== Kind.NULL;\n    const hasLocationDefaultValue = locationDefaultValue !== undefined;\n    if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) {\n      return false;\n    }\n    const nullableLocationType = locationType.ofType;\n    return isTypeSubTypeOf(schema, varType, nullableLocationType);\n  }\n  return isTypeSubTypeOf(schema, varType, locationType);\n}\n"]}

package/validation/rules/VariablesInAllowedPositionRule.mjs

@@ -3,13 +3,6 @@ import { Kind } from "../../language/kinds.mjs";
 import { isInputObjectType, isNonNullType, isNullableType, } from "../../type/definition.mjs";
 import { isTypeSubTypeOf } from "../../utilities/typeComparators.mjs";
 import { typeFromAST } from "../../utilities/typeFromAST.mjs";
-/**
- * Variables in allowed position
- *
- * Variable usages must be compatible with the arguments they are passed to.
- *
- * See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed
- */
 export function VariablesInAllowedPositionRule(context) {
     let varDefMap;
     return {
@@ -24,11 +17,6 @@ export function VariablesInAllowedPositionRule(context) {
                     let varDef = fragmentVariableDefinition;
                     varDef ??= varDefMap.get(varName);
                     if (varDef && type) {
-                        // A var type is allowed if it is the same or more strict (e.g. is
-                        // a subtype of) than the expected type. It can be more strict if
-                        // the variable type is non-null when the expected type is nullable.
-                        // If both are list types, the variable item type can be more strict
-                        // than the expected item type (contravariant).
                         const schema = context.getSchema();
                         const varType = typeFromAST(schema, varDef.type);
                         if (varType &&
@@ -49,14 +37,6 @@ export function VariablesInAllowedPositionRule(context) {
         },
     };
 }
-/**
- * Returns true if the variable is allowed in the location it was found,
- * including considering if default values exist for either the variable
- * or the location at which it is located.
- *
- * OneOf Input Object Type fields are considered separately above to
- * provide a more descriptive error message.
- */
 function allowedVariableUsage(schema, varType, varDefaultValue, locationType, locationDefaultValue) {
     if (isNonNullType(locationType) && !isNonNullType(varType)) {
         const hasNonNullVariableDefaultValue = varDefaultValue != null && varDefaultValue.kind !== Kind.NULL;

package/validation/rules/VariablesInAllowedPositionRule.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"VariablesInAllowedPositionRule.js","sourceRoot":"","sources":["../../../src/validation/rules/VariablesInAllowedPositionRule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Maybe } from '../../jsutils/Maybe.ts';\n\nimport { GraphQLError } from '../../error/GraphQLError.ts';\n\nimport type { ValueNode, VariableDefinitionNode } from '../../language/ast.ts';\nimport { Kind } from '../../language/kinds.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport type { GraphQLType } from '../../type/definition.ts';\nimport {\n  isInputObjectType,\n  isNonNullType,\n  isNullableType,\n} from '../../type/definition.ts';\nimport type { GraphQLSchema } from '../../type/schema.ts';\n\nimport { isTypeSubTypeOf } from '../../utilities/typeComparators.ts';\nimport { typeFromAST } from '../../utilities/typeFromAST.ts';\n\nimport type { ValidationContext } from '../ValidationContext.ts';\n\n/**\n * Variables in allowed position\n *\n * Variable usages must be compatible with the arguments they are passed to.\n *\n * See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed\n */\nexport function VariablesInAllowedPositionRule(\n  context: ValidationContext,\n): ASTVisitor {\n  let varDefMap: Map<string, VariableDefinitionNode>;\n\n  return {\n    OperationDefinition: {\n      enter() {\n        varDefMap = new Map();\n      },\n      leave(operation) {\n        const usages = context.getRecursiveVariableUsages(operation);\n\n        for (const {\n          node,\n          type,\n          parentType,\n          defaultValue,\n          fragmentVariableDefinition,\n        } of usages) {\n          const varName = node.name.value;\n\n          let varDef = fragmentVariableDefinition;\n          varDef ??= varDefMap.get(varName);\n          if (varDef && type) {\n            // A var type is allowed if it is the same or more strict (e.g. is\n            // a subtype of) than the expected type. It can be more strict if\n            // the variable type is non-null when the expected type is nullable.\n            // If both are list types, the variable item type can be more strict\n            // than the expected item type (contravariant).\n            const schema = context.getSchema();\n            const varType = typeFromAST(schema, varDef.type);\n            if (\n              varType &&\n              !allowedVariableUsage(\n                schema,\n                varType,\n                varDef.defaultValue,\n                type,\n                defaultValue,\n              )\n            ) {\n              context.reportError(\n                new GraphQLError(\n                  `Variable \"$${varName}\" of type \"${varType}\" used in position expecting type \"${type}\".`,\n                  { nodes: [varDef, node] },\n                ),\n              );\n            }\n\n            if (\n              isInputObjectType(parentType) &&\n              parentType.isOneOf &&\n              isNullableType(varType)\n            ) {\n              context.reportError(\n                new GraphQLError(\n                  `Variable \"$${varName}\" is of type \"${varType}\" but must be non-nullable to be used for OneOf Input Object \"${parentType}\".`,\n                  { nodes: [varDef, node] },\n                ),\n              );\n            }\n          }\n        }\n      },\n    },\n    VariableDefinition(node) {\n      varDefMap.set(node.variable.name.value, node);\n    },\n  };\n}\n\n/**\n * Returns true if the variable is allowed in the location it was found,\n * including considering if default values exist for either the variable\n * or the location at which it is located.\n *\n * OneOf Input Object Type fields are considered separately above to\n * provide a more descriptive error message.\n */\nfunction allowedVariableUsage(\n  schema: GraphQLSchema,\n  varType: GraphQLType,\n  varDefaultValue: Maybe<ValueNode>,\n  locationType: GraphQLType,\n  locationDefaultValue: unknown,\n): boolean {\n  if (isNonNullType(locationType) && !isNonNullType(varType)) {\n    const hasNonNullVariableDefaultValue =\n      varDefaultValue != null && varDefaultValue.kind !== Kind.NULL;\n    const hasLocationDefaultValue = locationDefaultValue !== undefined;\n    if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) {\n      return false;\n    }\n    const nullableLocationType = locationType.ofType;\n    return isTypeSubTypeOf(schema, varType, nullableLocationType);\n  }\n  return isTypeSubTypeOf(schema, varType, locationType);\n}\n"]}
+{"version":3,"file":"VariablesInAllowedPositionRule.js","sourceRoot":"","sources":["../../../src/validation/rules/VariablesInAllowedPositionRule.ts"],"names":[],"mappings":"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","sourcesContent":["/** @category Validation Rules */\n\nimport type { Maybe } from '../../jsutils/Maybe.ts';\n\nimport { GraphQLError } from '../../error/GraphQLError.ts';\n\nimport type { ValueNode, VariableDefinitionNode } from '../../language/ast.ts';\nimport { Kind } from '../../language/kinds.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport type { GraphQLType } from '../../type/definition.ts';\nimport {\n  isInputObjectType,\n  isNonNullType,\n  isNullableType,\n} from '../../type/definition.ts';\nimport type { GraphQLSchema } from '../../type/schema.ts';\n\nimport { isTypeSubTypeOf } from '../../utilities/typeComparators.ts';\nimport { typeFromAST } from '../../utilities/typeFromAST.ts';\n\nimport type { ValidationContext } from '../ValidationContext.ts';\n\n/**\n * Variables in allowed position\n *\n * Variable usages must be compatible with the arguments they are passed to.\n *\n * See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed\n * @param context - The validation context used while checking the document.\n * @returns A visitor that reports validation errors for this rule.\n * @example\n * ```ts\n * import { buildSchema, parse, validate } from 'graphql';\n * import { VariablesInAllowedPositionRule } from 'graphql/validation';\n *\n * const schema = buildSchema(`\n *   type Query {\n *     field(arg: ID!): String\n *   }\n * `);\n *\n * const invalidDocument = parse(`\n *   query ($id: String) { field(arg: $id) }\n * `);\n * const invalidErrors = validate(schema, invalidDocument, [VariablesInAllowedPositionRule]);\n *\n * invalidErrors.length; // => 1\n *\n * const validDocument = parse(`\n *   query ($id: ID!) { field(arg: $id) }\n * `);\n * const validErrors = validate(schema, validDocument, [VariablesInAllowedPositionRule]);\n *\n * validErrors; // => []\n * ```\n */\nexport function VariablesInAllowedPositionRule(\n  context: ValidationContext,\n): ASTVisitor {\n  let varDefMap: Map<string, VariableDefinitionNode>;\n\n  return {\n    OperationDefinition: {\n      enter() {\n        varDefMap = new Map();\n      },\n      leave(operation) {\n        const usages = context.getRecursiveVariableUsages(operation);\n\n        for (const {\n          node,\n          type,\n          parentType,\n          defaultValue,\n          fragmentVariableDefinition,\n        } of usages) {\n          const varName = node.name.value;\n\n          let varDef = fragmentVariableDefinition;\n          varDef ??= varDefMap.get(varName);\n          if (varDef && type) {\n            // A var type is allowed if it is the same or more strict (e.g. is\n            // a subtype of) than the expected type. It can be more strict if\n            // the variable type is non-null when the expected type is nullable.\n            // If both are list types, the variable item type can be more strict\n            // than the expected item type (contravariant).\n            const schema = context.getSchema();\n            const varType = typeFromAST(schema, varDef.type);\n            if (\n              varType &&\n              !allowedVariableUsage(\n                schema,\n                varType,\n                varDef.defaultValue,\n                type,\n                defaultValue,\n              )\n            ) {\n              context.reportError(\n                new GraphQLError(\n                  `Variable \"$${varName}\" of type \"${varType}\" used in position expecting type \"${type}\".`,\n                  { nodes: [varDef, node] },\n                ),\n              );\n            }\n\n            if (\n              isInputObjectType(parentType) &&\n              parentType.isOneOf &&\n              isNullableType(varType)\n            ) {\n              context.reportError(\n                new GraphQLError(\n                  `Variable \"$${varName}\" is of type \"${varType}\" but must be non-nullable to be used for OneOf Input Object \"${parentType}\".`,\n                  { nodes: [varDef, node] },\n                ),\n              );\n            }\n          }\n        }\n      },\n    },\n    VariableDefinition(node) {\n      varDefMap.set(node.variable.name.value, node);\n    },\n  };\n}\n\n/**\n * Returns true if the variable is allowed in the location it was found,\n * including considering if default values exist for either the variable\n * or the location at which it is located.\n *\n * OneOf Input Object Type fields are considered separately above to\n * provide a more descriptive error message.\n *\n * @internal\n */\nfunction allowedVariableUsage(\n  schema: GraphQLSchema,\n  varType: GraphQLType,\n  varDefaultValue: Maybe<ValueNode>,\n  locationType: GraphQLType,\n  locationDefaultValue: unknown,\n): boolean {\n  if (isNonNullType(locationType) && !isNonNullType(varType)) {\n    const hasNonNullVariableDefaultValue =\n      varDefaultValue != null && varDefaultValue.kind !== Kind.NULL;\n    const hasLocationDefaultValue = locationDefaultValue !== undefined;\n    if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) {\n      return false;\n    }\n    const nullableLocationType = locationType.ofType;\n    return isTypeSubTypeOf(schema, varType, nullableLocationType);\n  }\n  return isTypeSubTypeOf(schema, varType, locationType);\n}\n"]}

package/validation/rules/custom/NoDeprecatedCustomRule.d.mts

@@ -1,3 +1,4 @@
+/** @category Custom Rules */
 import type { ASTVisitor } from "../../../language/visitor.mjs";
 import type { ValidationContext } from "../../ValidationContext.mjs";
 /**
@@ -9,5 +10,45 @@ import type { ValidationContext } from "../../ValidationContext.mjs";
  * Note: This rule is optional and is not part of the Validation section of the GraphQL
  * Specification. The main purpose of this rule is detection of deprecated usages and not
  * necessarily to forbid their use when querying a service.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import {
+ *   GraphQLObjectType,
+ *   GraphQLSchema,
+ *   GraphQLString,
+ *   parse,
+ *   validate,
+ * } from 'graphql';
+ * import { NoDeprecatedCustomRule } from 'graphql/validation';
+ *
+ * const schema = new GraphQLSchema({
+ *   query: new GraphQLObjectType({
+ *     name: 'Query',
+ *     fields: {
+ *       name: { type: GraphQLString },
+ *       oldName: {
+ *         type: GraphQLString,
+ *         deprecationReason: 'Use name instead.',
+ *       },
+ *     },
+ *   }),
+ * });
+ *
+ * const invalidDocument = parse(`
+ *   { oldName }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoDeprecatedCustomRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoDeprecatedCustomRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function NoDeprecatedCustomRule(context: ValidationContext): ASTVisitor;