graphql 17.0.0-beta.0 → 17.0.0-beta.2

package/validation/rules/UniqueInputFieldNamesRule.d.ts

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

package/validation/rules/UniqueInputFieldNamesRule.js

@@ -1,16 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniqueInputFieldNamesRule = UniqueInputFieldNamesRule;
-const invariant_js_1 = require("../../jsutils/invariant.js");
-const GraphQLError_js_1 = require("../../error/GraphQLError.js");
-/**
- * Unique input field names
- *
- * A GraphQL input object value is only valid if all supplied fields are
- * uniquely named.
- *
- * See https://spec.graphql.org/draft/#sec-Input-Object-Field-Uniqueness
- */
+const invariant_ts_1 = require("../../jsutils/invariant.js");
+const GraphQLError_ts_1 = require("../../error/GraphQLError.js");
 function UniqueInputFieldNamesRule(context) {
     const knownNameStack = [];
     let knownNames = new Map();
@@ -23,7 +15,7 @@ function UniqueInputFieldNamesRule(context) {
             leave() {
                 const prevKnownNames = knownNameStack.pop();
                 if (!(prevKnownNames != null))
-                    (0, invariant_js_1.invariant)(false);
+                    (0, invariant_ts_1.invariant)(false);
                 knownNames = prevKnownNames;
             },
         },
@@ -31,7 +23,7 @@ function UniqueInputFieldNamesRule(context) {
             const fieldName = node.name.value;
             const knownName = knownNames.get(fieldName);
             if (knownName != null) {
-                context.reportError(new GraphQLError_js_1.GraphQLError(`There can be only one input field named "${fieldName}".`, { nodes: [knownName, node.name] }));
+                context.reportError(new GraphQLError_ts_1.GraphQLError(`There can be only one input field named "${fieldName}".`, { nodes: [knownName, node.name] }));
             }
             else {
                 knownNames.set(fieldName, node.name);

package/validation/rules/UniqueInputFieldNamesRule.js.map

@@ -1 +1 @@
-{"version":3,"file":"UniqueInputFieldNamesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/UniqueInputFieldNamesRule.ts"],"names":[],"mappings":";;AAiBA,8DAiCC;AAlDD,6DAAuD;AAEvD,iEAA2D;AAO3D;;;;;;;GAOG;AACH,SAAgB,yBAAyB,CACvC,OAA6B;IAE7B,MAAM,cAAc,GAAiC,EAAE,CAAC;IACxD,IAAI,UAAU,GAAG,IAAI,GAAG,EAAoB,CAAC;IAE7C,OAAO;QACL,WAAW,EAAE;YACX,KAAK;gBACH,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;gBAChC,UAAU,GAAG,IAAI,GAAG,EAAE,CAAC;YACzB,CAAC;YACD,KAAK;gBACH,MAAM,cAAc,GAAG,cAAc,CAAC,GAAG,EAAE,CAAC;sBAClC,cAAc,IAAI,IAAI;wBAAhC,wBAAS;gBACT,UAAU,GAAG,cAAc,CAAC;YAC9B,CAAC;SACF;QACD,WAAW,CAAC,IAAI;YACd,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;YAClC,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAC5C,IAAI,SAAS,IAAI,IAAI,EAAE,CAAC;gBACtB,OAAO,CAAC,WAAW,CACjB,IAAI,8BAAY,CACd,4CAA4C,SAAS,IAAI,EACzD,EAAE,KAAK,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,CAClC,CACF,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,UAAU,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YACvC,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import { invariant } from '../../jsutils/invariant.js';\n\nimport { GraphQLError } from '../../error/GraphQLError.js';\n\nimport type { NameNode } from '../../language/ast.js';\nimport type { ASTVisitor } from '../../language/visitor.js';\n\nimport type { ASTValidationContext } from '../ValidationContext.js';\n\n/**\n * Unique input field names\n *\n * A GraphQL input object value is only valid if all supplied fields are\n * uniquely named.\n *\n * See https://spec.graphql.org/draft/#sec-Input-Object-Field-Uniqueness\n */\nexport function UniqueInputFieldNamesRule(\n  context: ASTValidationContext,\n): ASTVisitor {\n  const knownNameStack: Array<Map<string, NameNode>> = [];\n  let knownNames = new Map<string, NameNode>();\n\n  return {\n    ObjectValue: {\n      enter() {\n        knownNameStack.push(knownNames);\n        knownNames = new Map();\n      },\n      leave() {\n        const prevKnownNames = knownNameStack.pop();\n        invariant(prevKnownNames != null);\n        knownNames = prevKnownNames;\n      },\n    },\n    ObjectField(node) {\n      const fieldName = node.name.value;\n      const knownName = knownNames.get(fieldName);\n      if (knownName != null) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one input field named \"${fieldName}\".`,\n            { nodes: [knownName, node.name] },\n          ),\n        );\n      } else {\n        knownNames.set(fieldName, node.name);\n      }\n    },\n  };\n}\n"]}
+{"version":3,"file":"UniqueInputFieldNamesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/UniqueInputFieldNamesRule.ts"],"names":[],"mappings":";;AAkDA,8DAiCC;AAjFD,6DAAuD;AAEvD,iEAA2D;AA8C3D,SAAgB,yBAAyB,CACvC,OAA6B;IAE7B,MAAM,cAAc,GAAiC,EAAE,CAAC;IACxD,IAAI,UAAU,GAAG,IAAI,GAAG,EAAoB,CAAC;IAE7C,OAAO;QACL,WAAW,EAAE;YACX,KAAK;gBACH,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;gBAChC,UAAU,GAAG,IAAI,GAAG,EAAE,CAAC;YACzB,CAAC;YACD,KAAK;gBACH,MAAM,cAAc,GAAG,cAAc,CAAC,GAAG,EAAE,CAAC;sBAClC,cAAc,IAAI,IAAI;wBAAhC,wBAAS;gBACT,UAAU,GAAG,cAAc,CAAC;YAC9B,CAAC;SACF;QACD,WAAW,CAAC,IAAI;YACd,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;YAClC,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAC5C,IAAI,SAAS,IAAI,IAAI,EAAE,CAAC;gBACtB,OAAO,CAAC,WAAW,CACjB,IAAI,8BAAY,CACd,4CAA4C,SAAS,IAAI,EACzD,EAAE,KAAK,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,CAClC,CACF,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,UAAU,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YACvC,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["/** @category Validation Rules */\n\nimport { invariant } from '../../jsutils/invariant.ts';\n\nimport { GraphQLError } from '../../error/GraphQLError.ts';\n\nimport type { NameNode } from '../../language/ast.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport type { ASTValidationContext } from '../ValidationContext.ts';\n\n/**\n * Unique input field names\n *\n * A GraphQL input object value is only valid if all supplied fields are\n * uniquely named.\n *\n * See https://spec.graphql.org/draft/#sec-Input-Object-Field-Uniqueness\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 { UniqueInputFieldNamesRule } from 'graphql/validation';\n *\n * const schema = buildSchema(`\n *   input Filter {\n *     name: String\n *   }\n *\n *   type Query {\n *     search(filter: Filter): String\n *   }\n * `);\n *\n * const invalidDocument = parse(`\n *   { search(filter: { name: \"a\", name: \"b\" }) }\n * `);\n * const invalidErrors = validate(schema, invalidDocument, [UniqueInputFieldNamesRule]);\n *\n * invalidErrors.length; // => 1\n *\n * const validDocument = parse(`\n *   { search(filter: { name: \"a\" }) }\n * `);\n * const validErrors = validate(schema, validDocument, [UniqueInputFieldNamesRule]);\n *\n * validErrors; // => []\n * ```\n */\nexport function UniqueInputFieldNamesRule(\n  context: ASTValidationContext,\n): ASTVisitor {\n  const knownNameStack: Array<Map<string, NameNode>> = [];\n  let knownNames = new Map<string, NameNode>();\n\n  return {\n    ObjectValue: {\n      enter() {\n        knownNameStack.push(knownNames);\n        knownNames = new Map();\n      },\n      leave() {\n        const prevKnownNames = knownNameStack.pop();\n        invariant(prevKnownNames != null);\n        knownNames = prevKnownNames;\n      },\n    },\n    ObjectField(node) {\n      const fieldName = node.name.value;\n      const knownName = knownNames.get(fieldName);\n      if (knownName != null) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one input field named \"${fieldName}\".`,\n            { nodes: [knownName, node.name] },\n          ),\n        );\n      } else {\n        knownNames.set(fieldName, node.name);\n      }\n    },\n  };\n}\n"]}

package/validation/rules/UniqueInputFieldNamesRule.mjs

@@ -1,13 +1,5 @@
 import { invariant } from "../../jsutils/invariant.mjs";
 import { GraphQLError } from "../../error/GraphQLError.mjs";
-/**
- * Unique input field names
- *
- * A GraphQL input object value is only valid if all supplied fields are
- * uniquely named.
- *
- * See https://spec.graphql.org/draft/#sec-Input-Object-Field-Uniqueness
- */
 export function UniqueInputFieldNamesRule(context) {
     const knownNameStack = [];
     let knownNames = new Map();

package/validation/rules/UniqueInputFieldNamesRule.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"UniqueInputFieldNamesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/UniqueInputFieldNamesRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,oCAAmC;AAEvD,OAAO,EAAE,YAAY,EAAE,qCAAoC;AAO3D;;;;;;;GAOG;AACH,MAAM,UAAU,yBAAyB,CACvC,OAA6B;IAE7B,MAAM,cAAc,GAAiC,EAAE,CAAC;IACxD,IAAI,UAAU,GAAG,IAAI,GAAG,EAAoB,CAAC;IAE7C,OAAO;QACL,WAAW,EAAE;YACX,KAAK;gBACH,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;gBAChC,UAAU,GAAG,IAAI,GAAG,EAAE,CAAC;YACzB,CAAC;YACD,KAAK;gBACH,MAAM,cAAc,GAAG,cAAc,CAAC,GAAG,EAAE,CAAC;sBAClC,cAAc,IAAI,IAAI;oBAAhC,SAAS;gBACT,UAAU,GAAG,cAAc,CAAC;YAC9B,CAAC;SACF;QACD,WAAW,CAAC,IAAI;YACd,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;YAClC,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAC5C,IAAI,SAAS,IAAI,IAAI,EAAE,CAAC;gBACtB,OAAO,CAAC,WAAW,CACjB,IAAI,YAAY,CACd,4CAA4C,SAAS,IAAI,EACzD,EAAE,KAAK,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,CAClC,CACF,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,UAAU,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YACvC,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import { invariant } from '../../jsutils/invariant.js';\n\nimport { GraphQLError } from '../../error/GraphQLError.js';\n\nimport type { NameNode } from '../../language/ast.js';\nimport type { ASTVisitor } from '../../language/visitor.js';\n\nimport type { ASTValidationContext } from '../ValidationContext.js';\n\n/**\n * Unique input field names\n *\n * A GraphQL input object value is only valid if all supplied fields are\n * uniquely named.\n *\n * See https://spec.graphql.org/draft/#sec-Input-Object-Field-Uniqueness\n */\nexport function UniqueInputFieldNamesRule(\n  context: ASTValidationContext,\n): ASTVisitor {\n  const knownNameStack: Array<Map<string, NameNode>> = [];\n  let knownNames = new Map<string, NameNode>();\n\n  return {\n    ObjectValue: {\n      enter() {\n        knownNameStack.push(knownNames);\n        knownNames = new Map();\n      },\n      leave() {\n        const prevKnownNames = knownNameStack.pop();\n        invariant(prevKnownNames != null);\n        knownNames = prevKnownNames;\n      },\n    },\n    ObjectField(node) {\n      const fieldName = node.name.value;\n      const knownName = knownNames.get(fieldName);\n      if (knownName != null) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one input field named \"${fieldName}\".`,\n            { nodes: [knownName, node.name] },\n          ),\n        );\n      } else {\n        knownNames.set(fieldName, node.name);\n      }\n    },\n  };\n}\n"]}
+{"version":3,"file":"UniqueInputFieldNamesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/UniqueInputFieldNamesRule.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,oCAAmC;AAEvD,OAAO,EAAE,YAAY,EAAE,qCAAoC;AA8C3D,MAAM,UAAU,yBAAyB,CACvC,OAA6B;IAE7B,MAAM,cAAc,GAAiC,EAAE,CAAC;IACxD,IAAI,UAAU,GAAG,IAAI,GAAG,EAAoB,CAAC;IAE7C,OAAO;QACL,WAAW,EAAE;YACX,KAAK;gBACH,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;gBAChC,UAAU,GAAG,IAAI,GAAG,EAAE,CAAC;YACzB,CAAC;YACD,KAAK;gBACH,MAAM,cAAc,GAAG,cAAc,CAAC,GAAG,EAAE,CAAC;sBAClC,cAAc,IAAI,IAAI;oBAAhC,SAAS;gBACT,UAAU,GAAG,cAAc,CAAC;YAC9B,CAAC;SACF;QACD,WAAW,CAAC,IAAI;YACd,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;YAClC,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAC5C,IAAI,SAAS,IAAI,IAAI,EAAE,CAAC;gBACtB,OAAO,CAAC,WAAW,CACjB,IAAI,YAAY,CACd,4CAA4C,SAAS,IAAI,EACzD,EAAE,KAAK,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,CAClC,CACF,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,UAAU,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YACvC,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["/** @category Validation Rules */\n\nimport { invariant } from '../../jsutils/invariant.ts';\n\nimport { GraphQLError } from '../../error/GraphQLError.ts';\n\nimport type { NameNode } from '../../language/ast.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport type { ASTValidationContext } from '../ValidationContext.ts';\n\n/**\n * Unique input field names\n *\n * A GraphQL input object value is only valid if all supplied fields are\n * uniquely named.\n *\n * See https://spec.graphql.org/draft/#sec-Input-Object-Field-Uniqueness\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 { UniqueInputFieldNamesRule } from 'graphql/validation';\n *\n * const schema = buildSchema(`\n *   input Filter {\n *     name: String\n *   }\n *\n *   type Query {\n *     search(filter: Filter): String\n *   }\n * `);\n *\n * const invalidDocument = parse(`\n *   { search(filter: { name: \"a\", name: \"b\" }) }\n * `);\n * const invalidErrors = validate(schema, invalidDocument, [UniqueInputFieldNamesRule]);\n *\n * invalidErrors.length; // => 1\n *\n * const validDocument = parse(`\n *   { search(filter: { name: \"a\" }) }\n * `);\n * const validErrors = validate(schema, validDocument, [UniqueInputFieldNamesRule]);\n *\n * validErrors; // => []\n * ```\n */\nexport function UniqueInputFieldNamesRule(\n  context: ASTValidationContext,\n): ASTVisitor {\n  const knownNameStack: Array<Map<string, NameNode>> = [];\n  let knownNames = new Map<string, NameNode>();\n\n  return {\n    ObjectValue: {\n      enter() {\n        knownNameStack.push(knownNames);\n        knownNames = new Map();\n      },\n      leave() {\n        const prevKnownNames = knownNameStack.pop();\n        invariant(prevKnownNames != null);\n        knownNames = prevKnownNames;\n      },\n    },\n    ObjectField(node) {\n      const fieldName = node.name.value;\n      const knownName = knownNames.get(fieldName);\n      if (knownName != null) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one input field named \"${fieldName}\".`,\n            { nodes: [knownName, node.name] },\n          ),\n        );\n      } else {\n        knownNames.set(fieldName, node.name);\n      }\n    },\n  };\n}\n"]}

package/validation/rules/UniqueOperationNamesRule.d.mts

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

package/validation/rules/UniqueOperationNamesRule.d.ts

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

package/validation/rules/UniqueOperationNamesRule.js

@@ -1,14 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniqueOperationNamesRule = UniqueOperationNamesRule;
-const GraphQLError_js_1 = require("../../error/GraphQLError.js");
-/**
- * Unique operation names
- *
- * A GraphQL document is only valid if all defined operations have unique names.
- *
- * See https://spec.graphql.org/draft/#sec-Operation-Name-Uniqueness
- */
+const GraphQLError_ts_1 = require("../../error/GraphQLError.js");
 function UniqueOperationNamesRule(context) {
     const knownOperationNames = new Map();
     return {
@@ -17,7 +10,7 @@ function UniqueOperationNamesRule(context) {
             if (operationName != null) {
                 const knownOperationName = knownOperationNames.get(operationName.value);
                 if (knownOperationName != null) {
-                    context.reportError(new GraphQLError_js_1.GraphQLError(`There can be only one operation named "${operationName.value}".`, { nodes: [knownOperationName, operationName] }));
+                    context.reportError(new GraphQLError_ts_1.GraphQLError(`There can be only one operation named "${operationName.value}".`, { nodes: [knownOperationName, operationName] }));
                 }
                 else {
                     knownOperationNames.set(operationName.value, operationName);

package/validation/rules/UniqueOperationNamesRule.js.map

@@ -1 +1 @@
-{"version":3,"file":"UniqueOperationNamesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/UniqueOperationNamesRule.ts"],"names":[],"mappings":";;AAcA,4DAwBC;AAtCD,iEAA2D;AAO3D;;;;;;GAMG;AACH,SAAgB,wBAAwB,CACtC,OAA6B;IAE7B,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAAoB,CAAC;IACxD,OAAO;QACL,mBAAmB,CAAC,IAAI;YACtB,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC;YAChC,IAAI,aAAa,IAAI,IAAI,EAAE,CAAC;gBAC1B,MAAM,kBAAkB,GAAG,mBAAmB,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;gBACxE,IAAI,kBAAkB,IAAI,IAAI,EAAE,CAAC;oBAC/B,OAAO,CAAC,WAAW,CACjB,IAAI,8BAAY,CACd,0CAA0C,aAAa,CAAC,KAAK,IAAI,EACjE,EAAE,KAAK,EAAE,CAAC,kBAAkB,EAAE,aAAa,CAAC,EAAE,CAC/C,CACF,CAAC;gBACJ,CAAC;qBAAM,CAAC;oBACN,mBAAmB,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;gBAC9D,CAAC;YACH,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QACD,kBAAkB,EAAE,GAAG,EAAE,CAAC,KAAK;KAChC,CAAC;AACJ,CAAC","sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.js';\n\nimport type { NameNode } from '../../language/ast.js';\nimport type { ASTVisitor } from '../../language/visitor.js';\n\nimport type { ASTValidationContext } from '../ValidationContext.js';\n\n/**\n * Unique operation names\n *\n * A GraphQL document is only valid if all defined operations have unique names.\n *\n * See https://spec.graphql.org/draft/#sec-Operation-Name-Uniqueness\n */\nexport function UniqueOperationNamesRule(\n  context: ASTValidationContext,\n): ASTVisitor {\n  const knownOperationNames = new Map<string, NameNode>();\n  return {\n    OperationDefinition(node) {\n      const operationName = node.name;\n      if (operationName != null) {\n        const knownOperationName = knownOperationNames.get(operationName.value);\n        if (knownOperationName != null) {\n          context.reportError(\n            new GraphQLError(\n              `There can be only one operation named \"${operationName.value}\".`,\n              { nodes: [knownOperationName, operationName] },\n            ),\n          );\n        } else {\n          knownOperationNames.set(operationName.value, operationName);\n        }\n      }\n      return false;\n    },\n    FragmentDefinition: () => false,\n  };\n}\n"]}
+{"version":3,"file":"UniqueOperationNamesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/UniqueOperationNamesRule.ts"],"names":[],"mappings":";;AA2CA,4DAwBC;AAjED,iEAA2D;AAyC3D,SAAgB,wBAAwB,CACtC,OAA6B;IAE7B,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAAoB,CAAC;IACxD,OAAO;QACL,mBAAmB,CAAC,IAAI;YACtB,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC;YAChC,IAAI,aAAa,IAAI,IAAI,EAAE,CAAC;gBAC1B,MAAM,kBAAkB,GAAG,mBAAmB,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;gBACxE,IAAI,kBAAkB,IAAI,IAAI,EAAE,CAAC;oBAC/B,OAAO,CAAC,WAAW,CACjB,IAAI,8BAAY,CACd,0CAA0C,aAAa,CAAC,KAAK,IAAI,EACjE,EAAE,KAAK,EAAE,CAAC,kBAAkB,EAAE,aAAa,CAAC,EAAE,CAC/C,CACF,CAAC;gBACJ,CAAC;qBAAM,CAAC;oBACN,mBAAmB,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;gBAC9D,CAAC;YACH,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QACD,kBAAkB,EAAE,GAAG,EAAE,CAAC,KAAK;KAChC,CAAC;AACJ,CAAC","sourcesContent":["/** @category Validation Rules */\n\nimport { GraphQLError } from '../../error/GraphQLError.ts';\n\nimport type { NameNode } from '../../language/ast.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport type { ASTValidationContext } from '../ValidationContext.ts';\n\n/**\n * Unique operation names\n *\n * A GraphQL document is only valid if all defined operations have unique names.\n *\n * See https://spec.graphql.org/draft/#sec-Operation-Name-Uniqueness\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 { UniqueOperationNamesRule } from 'graphql/validation';\n *\n * const schema = buildSchema(`\n *   type Query {\n *     name: String\n *   }\n * `);\n *\n * const invalidDocument = parse(`\n *   query Same { name } query Same { name }\n * `);\n * const invalidErrors = validate(schema, invalidDocument, [UniqueOperationNamesRule]);\n *\n * invalidErrors.length; // => 1\n *\n * const validDocument = parse(`\n *   query One { name } query Two { name }\n * `);\n * const validErrors = validate(schema, validDocument, [UniqueOperationNamesRule]);\n *\n * validErrors; // => []\n * ```\n */\nexport function UniqueOperationNamesRule(\n  context: ASTValidationContext,\n): ASTVisitor {\n  const knownOperationNames = new Map<string, NameNode>();\n  return {\n    OperationDefinition(node) {\n      const operationName = node.name;\n      if (operationName != null) {\n        const knownOperationName = knownOperationNames.get(operationName.value);\n        if (knownOperationName != null) {\n          context.reportError(\n            new GraphQLError(\n              `There can be only one operation named \"${operationName.value}\".`,\n              { nodes: [knownOperationName, operationName] },\n            ),\n          );\n        } else {\n          knownOperationNames.set(operationName.value, operationName);\n        }\n      }\n      return false;\n    },\n    FragmentDefinition: () => false,\n  };\n}\n"]}

package/validation/rules/UniqueOperationNamesRule.mjs

@@ -1,11 +1,4 @@
 import { GraphQLError } from "../../error/GraphQLError.mjs";
-/**
- * Unique operation names
- *
- * A GraphQL document is only valid if all defined operations have unique names.
- *
- * See https://spec.graphql.org/draft/#sec-Operation-Name-Uniqueness
- */
 export function UniqueOperationNamesRule(context) {
     const knownOperationNames = new Map();
     return {

package/validation/rules/UniqueOperationNamesRule.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"UniqueOperationNamesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/UniqueOperationNamesRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,qCAAoC;AAO3D;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CACtC,OAA6B;IAE7B,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAAoB,CAAC;IACxD,OAAO;QACL,mBAAmB,CAAC,IAAI;YACtB,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC;YAChC,IAAI,aAAa,IAAI,IAAI,EAAE,CAAC;gBAC1B,MAAM,kBAAkB,GAAG,mBAAmB,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;gBACxE,IAAI,kBAAkB,IAAI,IAAI,EAAE,CAAC;oBAC/B,OAAO,CAAC,WAAW,CACjB,IAAI,YAAY,CACd,0CAA0C,aAAa,CAAC,KAAK,IAAI,EACjE,EAAE,KAAK,EAAE,CAAC,kBAAkB,EAAE,aAAa,CAAC,EAAE,CAC/C,CACF,CAAC;gBACJ,CAAC;qBAAM,CAAC;oBACN,mBAAmB,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;gBAC9D,CAAC;YACH,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QACD,kBAAkB,EAAE,GAAG,EAAE,CAAC,KAAK;KAChC,CAAC;AACJ,CAAC","sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.js';\n\nimport type { NameNode } from '../../language/ast.js';\nimport type { ASTVisitor } from '../../language/visitor.js';\n\nimport type { ASTValidationContext } from '../ValidationContext.js';\n\n/**\n * Unique operation names\n *\n * A GraphQL document is only valid if all defined operations have unique names.\n *\n * See https://spec.graphql.org/draft/#sec-Operation-Name-Uniqueness\n */\nexport function UniqueOperationNamesRule(\n  context: ASTValidationContext,\n): ASTVisitor {\n  const knownOperationNames = new Map<string, NameNode>();\n  return {\n    OperationDefinition(node) {\n      const operationName = node.name;\n      if (operationName != null) {\n        const knownOperationName = knownOperationNames.get(operationName.value);\n        if (knownOperationName != null) {\n          context.reportError(\n            new GraphQLError(\n              `There can be only one operation named \"${operationName.value}\".`,\n              { nodes: [knownOperationName, operationName] },\n            ),\n          );\n        } else {\n          knownOperationNames.set(operationName.value, operationName);\n        }\n      }\n      return false;\n    },\n    FragmentDefinition: () => false,\n  };\n}\n"]}
+{"version":3,"file":"UniqueOperationNamesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/UniqueOperationNamesRule.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,qCAAoC;AAyC3D,MAAM,UAAU,wBAAwB,CACtC,OAA6B;IAE7B,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAAoB,CAAC;IACxD,OAAO;QACL,mBAAmB,CAAC,IAAI;YACtB,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC;YAChC,IAAI,aAAa,IAAI,IAAI,EAAE,CAAC;gBAC1B,MAAM,kBAAkB,GAAG,mBAAmB,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;gBACxE,IAAI,kBAAkB,IAAI,IAAI,EAAE,CAAC;oBAC/B,OAAO,CAAC,WAAW,CACjB,IAAI,YAAY,CACd,0CAA0C,aAAa,CAAC,KAAK,IAAI,EACjE,EAAE,KAAK,EAAE,CAAC,kBAAkB,EAAE,aAAa,CAAC,EAAE,CAC/C,CACF,CAAC;gBACJ,CAAC;qBAAM,CAAC;oBACN,mBAAmB,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;gBAC9D,CAAC;YACH,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QACD,kBAAkB,EAAE,GAAG,EAAE,CAAC,KAAK;KAChC,CAAC;AACJ,CAAC","sourcesContent":["/** @category Validation Rules */\n\nimport { GraphQLError } from '../../error/GraphQLError.ts';\n\nimport type { NameNode } from '../../language/ast.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport type { ASTValidationContext } from '../ValidationContext.ts';\n\n/**\n * Unique operation names\n *\n * A GraphQL document is only valid if all defined operations have unique names.\n *\n * See https://spec.graphql.org/draft/#sec-Operation-Name-Uniqueness\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 { UniqueOperationNamesRule } from 'graphql/validation';\n *\n * const schema = buildSchema(`\n *   type Query {\n *     name: String\n *   }\n * `);\n *\n * const invalidDocument = parse(`\n *   query Same { name } query Same { name }\n * `);\n * const invalidErrors = validate(schema, invalidDocument, [UniqueOperationNamesRule]);\n *\n * invalidErrors.length; // => 1\n *\n * const validDocument = parse(`\n *   query One { name } query Two { name }\n * `);\n * const validErrors = validate(schema, validDocument, [UniqueOperationNamesRule]);\n *\n * validErrors; // => []\n * ```\n */\nexport function UniqueOperationNamesRule(\n  context: ASTValidationContext,\n): ASTVisitor {\n  const knownOperationNames = new Map<string, NameNode>();\n  return {\n    OperationDefinition(node) {\n      const operationName = node.name;\n      if (operationName != null) {\n        const knownOperationName = knownOperationNames.get(operationName.value);\n        if (knownOperationName != null) {\n          context.reportError(\n            new GraphQLError(\n              `There can be only one operation named \"${operationName.value}\".`,\n              { nodes: [knownOperationName, operationName] },\n            ),\n          );\n        } else {\n          knownOperationNames.set(operationName.value, operationName);\n        }\n      }\n      return false;\n    },\n    FragmentDefinition: () => false,\n  };\n}\n"]}

package/validation/rules/UniqueOperationTypesRule.d.mts

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

package/validation/rules/UniqueOperationTypesRule.d.ts

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

package/validation/rules/UniqueOperationTypesRule.js

@@ -1,12 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniqueOperationTypesRule = UniqueOperationTypesRule;
-const GraphQLError_js_1 = require("../../error/GraphQLError.js");
-/**
- * Unique operation types
- *
- * A GraphQL document is only valid if it has only one type per operation.
- */
+const GraphQLError_ts_1 = require("../../error/GraphQLError.js");
 function UniqueOperationTypesRule(context) {
     const schema = context.getSchema();
     const definedOperationTypes = new Map();
@@ -27,10 +22,10 @@ function UniqueOperationTypesRule(context) {
             const operation = operationType.operation;
             const alreadyDefinedOperationType = definedOperationTypes.get(operation);
             if (existingOperationTypes[operation]) {
-                context.reportError(new GraphQLError_js_1.GraphQLError(`Type for ${operation} already defined in the schema. It cannot be redefined.`, { nodes: operationType }));
+                context.reportError(new GraphQLError_ts_1.GraphQLError(`Type for ${operation} already defined in the schema. It cannot be redefined.`, { nodes: operationType }));
             }
             else if (alreadyDefinedOperationType) {
-                context.reportError(new GraphQLError_js_1.GraphQLError(`There can be only one ${operation} type in schema.`, { nodes: [alreadyDefinedOperationType, operationType] }));
+                context.reportError(new GraphQLError_ts_1.GraphQLError(`There can be only one ${operation} type in schema.`, { nodes: [alreadyDefinedOperationType, operationType] }));
             }
             else {
                 definedOperationTypes.set(operation, operationType);

package/validation/rules/UniqueOperationTypesRule.js.map

@@ -1 +1 @@
-{"version":3,"file":"UniqueOperationTypesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/UniqueOperationTypesRule.ts"],"names":[],"mappings":";;AAgBA,4DAgDC;AAhED,iEAA2D;AAW3D;;;;GAIG;AACH,SAAgB,wBAAwB,CACtC,OAA6B;IAE7B,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IACnC,MAAM,qBAAqB,GAAG,IAAI,GAAG,EAAuC,CAAC;IAC7E,MAAM,sBAAsB,GAAG,MAAM;QACnC,CAAC,CAAC;YACE,KAAK,EAAE,MAAM,CAAC,YAAY,EAAE;YAC5B,QAAQ,EAAE,MAAM,CAAC,eAAe,EAAE;YAClC,YAAY,EAAE,MAAM,CAAC,mBAAmB,EAAE;SAC3C;QACH,CAAC,CAAC,EAAE,CAAC;IAEP,OAAO;QACL,gBAAgB,EAAE,mBAAmB;QACrC,eAAe,EAAE,mBAAmB;KACrC,CAAC;IAEF,SAAS,mBAAmB,CAC1B,IAAgD;QAEhD,MAAM,mBAAmB,GAAG,IAAI,CAAC,cAAc,IAAI,EAAE,CAAC;QAEtD,KAAK,MAAM,aAAa,IAAI,mBAAmB,EAAE,CAAC;YAChD,MAAM,SAAS,GAAG,aAAa,CAAC,SAAS,CAAC;YAC1C,MAAM,2BAA2B,GAAG,qBAAqB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAEzE,IAAI,sBAAsB,CAAC,SAAS,CAAC,EAAE,CAAC;gBACtC,OAAO,CAAC,WAAW,CACjB,IAAI,8BAAY,CACd,YAAY,SAAS,yDAAyD,EAC9E,EAAE,KAAK,EAAE,aAAa,EAAE,CACzB,CACF,CAAC;YACJ,CAAC;iBAAM,IAAI,2BAA2B,EAAE,CAAC;gBACvC,OAAO,CAAC,WAAW,CACjB,IAAI,8BAAY,CACd,yBAAyB,SAAS,kBAAkB,EACpD,EAAE,KAAK,EAAE,CAAC,2BAA2B,EAAE,aAAa,CAAC,EAAE,CACxD,CACF,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,qBAAqB,CAAC,GAAG,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;YACtD,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC","sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.js';\n\nimport type {\n  OperationTypeDefinitionNode,\n  SchemaDefinitionNode,\n  SchemaExtensionNode,\n} from '../../language/ast.js';\nimport type { ASTVisitor } from '../../language/visitor.js';\n\nimport type { SDLValidationContext } from '../ValidationContext.js';\n\n/**\n * Unique operation types\n *\n * A GraphQL document is only valid if it has only one type per operation.\n */\nexport function UniqueOperationTypesRule(\n  context: SDLValidationContext,\n): ASTVisitor {\n  const schema = context.getSchema();\n  const definedOperationTypes = new Map<string, OperationTypeDefinitionNode>();\n  const existingOperationTypes = schema\n    ? {\n        query: schema.getQueryType(),\n        mutation: schema.getMutationType(),\n        subscription: schema.getSubscriptionType(),\n      }\n    : {};\n\n  return {\n    SchemaDefinition: checkOperationTypes,\n    SchemaExtension: checkOperationTypes,\n  };\n\n  function checkOperationTypes(\n    node: SchemaDefinitionNode | SchemaExtensionNode,\n  ) {\n    const operationTypesNodes = node.operationTypes ?? [];\n\n    for (const operationType of operationTypesNodes) {\n      const operation = operationType.operation;\n      const alreadyDefinedOperationType = definedOperationTypes.get(operation);\n\n      if (existingOperationTypes[operation]) {\n        context.reportError(\n          new GraphQLError(\n            `Type for ${operation} already defined in the schema. It cannot be redefined.`,\n            { nodes: operationType },\n          ),\n        );\n      } else if (alreadyDefinedOperationType) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one ${operation} type in schema.`,\n            { nodes: [alreadyDefinedOperationType, operationType] },\n          ),\n        );\n      } else {\n        definedOperationTypes.set(operation, operationType);\n      }\n    }\n\n    return false;\n  }\n}\n"]}
+{"version":3,"file":"UniqueOperationTypesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/UniqueOperationTypesRule.ts"],"names":[],"mappings":";;AAsCA,4DAgDC;AApFD,iEAA2D;AAoC3D,SAAgB,wBAAwB,CACtC,OAA6B;IAE7B,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IACnC,MAAM,qBAAqB,GAAG,IAAI,GAAG,EAAuC,CAAC;IAC7E,MAAM,sBAAsB,GAAG,MAAM;QACnC,CAAC,CAAC;YACE,KAAK,EAAE,MAAM,CAAC,YAAY,EAAE;YAC5B,QAAQ,EAAE,MAAM,CAAC,eAAe,EAAE;YAClC,YAAY,EAAE,MAAM,CAAC,mBAAmB,EAAE;SAC3C;QACH,CAAC,CAAC,EAAE,CAAC;IAEP,OAAO;QACL,gBAAgB,EAAE,mBAAmB;QACrC,eAAe,EAAE,mBAAmB;KACrC,CAAC;IAEF,SAAS,mBAAmB,CAC1B,IAAgD;QAEhD,MAAM,mBAAmB,GAAG,IAAI,CAAC,cAAc,IAAI,EAAE,CAAC;QAEtD,KAAK,MAAM,aAAa,IAAI,mBAAmB,EAAE,CAAC;YAChD,MAAM,SAAS,GAAG,aAAa,CAAC,SAAS,CAAC;YAC1C,MAAM,2BAA2B,GAAG,qBAAqB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAEzE,IAAI,sBAAsB,CAAC,SAAS,CAAC,EAAE,CAAC;gBACtC,OAAO,CAAC,WAAW,CACjB,IAAI,8BAAY,CACd,YAAY,SAAS,yDAAyD,EAC9E,EAAE,KAAK,EAAE,aAAa,EAAE,CACzB,CACF,CAAC;YACJ,CAAC;iBAAM,IAAI,2BAA2B,EAAE,CAAC;gBACvC,OAAO,CAAC,WAAW,CACjB,IAAI,8BAAY,CACd,yBAAyB,SAAS,kBAAkB,EACpD,EAAE,KAAK,EAAE,CAAC,2BAA2B,EAAE,aAAa,CAAC,EAAE,CACxD,CACF,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,qBAAqB,CAAC,GAAG,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;YACtD,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC","sourcesContent":["/** @category Validation Rules */\n\nimport { GraphQLError } from '../../error/GraphQLError.ts';\n\nimport type {\n  OperationTypeDefinitionNode,\n  SchemaDefinitionNode,\n  SchemaExtensionNode,\n} from '../../language/ast.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport type { SDLValidationContext } from '../ValidationContext.ts';\n\n/**\n * Unique operation types\n *\n * A GraphQL document is only valid if it has only one type per operation.\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 } from 'graphql';\n * import { UniqueOperationTypesRule } from 'graphql/validation';\n *\n * const invalidSDL = `\n *   schema { query: Query query: Other } type Query { name: String } type Other { name: String }\n * `;\n *\n * UniqueOperationTypesRule.name; // => 'UniqueOperationTypesRule'\n * buildSchema(invalidSDL); // throws an error\n *\n * const validSDL = `\n *   schema { query: Query } type Query { name: String }\n * `;\n *\n * buildSchema(validSDL); // does not throw\n * ```\n */\nexport function UniqueOperationTypesRule(\n  context: SDLValidationContext,\n): ASTVisitor {\n  const schema = context.getSchema();\n  const definedOperationTypes = new Map<string, OperationTypeDefinitionNode>();\n  const existingOperationTypes = schema\n    ? {\n        query: schema.getQueryType(),\n        mutation: schema.getMutationType(),\n        subscription: schema.getSubscriptionType(),\n      }\n    : {};\n\n  return {\n    SchemaDefinition: checkOperationTypes,\n    SchemaExtension: checkOperationTypes,\n  };\n\n  function checkOperationTypes(\n    node: SchemaDefinitionNode | SchemaExtensionNode,\n  ) {\n    const operationTypesNodes = node.operationTypes ?? [];\n\n    for (const operationType of operationTypesNodes) {\n      const operation = operationType.operation;\n      const alreadyDefinedOperationType = definedOperationTypes.get(operation);\n\n      if (existingOperationTypes[operation]) {\n        context.reportError(\n          new GraphQLError(\n            `Type for ${operation} already defined in the schema. It cannot be redefined.`,\n            { nodes: operationType },\n          ),\n        );\n      } else if (alreadyDefinedOperationType) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one ${operation} type in schema.`,\n            { nodes: [alreadyDefinedOperationType, operationType] },\n          ),\n        );\n      } else {\n        definedOperationTypes.set(operation, operationType);\n      }\n    }\n\n    return false;\n  }\n}\n"]}

package/validation/rules/UniqueOperationTypesRule.mjs

@@ -1,9 +1,4 @@
 import { GraphQLError } from "../../error/GraphQLError.mjs";
-/**
- * Unique operation types
- *
- * A GraphQL document is only valid if it has only one type per operation.
- */
 export function UniqueOperationTypesRule(context) {
     const schema = context.getSchema();
     const definedOperationTypes = new Map();

package/validation/rules/UniqueOperationTypesRule.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"UniqueOperationTypesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/UniqueOperationTypesRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,qCAAoC;AAW3D;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CACtC,OAA6B;IAE7B,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IACnC,MAAM,qBAAqB,GAAG,IAAI,GAAG,EAAuC,CAAC;IAC7E,MAAM,sBAAsB,GAAG,MAAM;QACnC,CAAC,CAAC;YACE,KAAK,EAAE,MAAM,CAAC,YAAY,EAAE;YAC5B,QAAQ,EAAE,MAAM,CAAC,eAAe,EAAE;YAClC,YAAY,EAAE,MAAM,CAAC,mBAAmB,EAAE;SAC3C;QACH,CAAC,CAAC,EAAE,CAAC;IAEP,OAAO;QACL,gBAAgB,EAAE,mBAAmB;QACrC,eAAe,EAAE,mBAAmB;KACrC,CAAC;IAEF,SAAS,mBAAmB,CAC1B,IAAgD;QAEhD,MAAM,mBAAmB,GAAG,IAAI,CAAC,cAAc,IAAI,EAAE,CAAC;QAEtD,KAAK,MAAM,aAAa,IAAI,mBAAmB,EAAE,CAAC;YAChD,MAAM,SAAS,GAAG,aAAa,CAAC,SAAS,CAAC;YAC1C,MAAM,2BAA2B,GAAG,qBAAqB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAEzE,IAAI,sBAAsB,CAAC,SAAS,CAAC,EAAE,CAAC;gBACtC,OAAO,CAAC,WAAW,CACjB,IAAI,YAAY,CACd,YAAY,SAAS,yDAAyD,EAC9E,EAAE,KAAK,EAAE,aAAa,EAAE,CACzB,CACF,CAAC;YACJ,CAAC;iBAAM,IAAI,2BAA2B,EAAE,CAAC;gBACvC,OAAO,CAAC,WAAW,CACjB,IAAI,YAAY,CACd,yBAAyB,SAAS,kBAAkB,EACpD,EAAE,KAAK,EAAE,CAAC,2BAA2B,EAAE,aAAa,CAAC,EAAE,CACxD,CACF,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,qBAAqB,CAAC,GAAG,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;YACtD,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC","sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.js';\n\nimport type {\n  OperationTypeDefinitionNode,\n  SchemaDefinitionNode,\n  SchemaExtensionNode,\n} from '../../language/ast.js';\nimport type { ASTVisitor } from '../../language/visitor.js';\n\nimport type { SDLValidationContext } from '../ValidationContext.js';\n\n/**\n * Unique operation types\n *\n * A GraphQL document is only valid if it has only one type per operation.\n */\nexport function UniqueOperationTypesRule(\n  context: SDLValidationContext,\n): ASTVisitor {\n  const schema = context.getSchema();\n  const definedOperationTypes = new Map<string, OperationTypeDefinitionNode>();\n  const existingOperationTypes = schema\n    ? {\n        query: schema.getQueryType(),\n        mutation: schema.getMutationType(),\n        subscription: schema.getSubscriptionType(),\n      }\n    : {};\n\n  return {\n    SchemaDefinition: checkOperationTypes,\n    SchemaExtension: checkOperationTypes,\n  };\n\n  function checkOperationTypes(\n    node: SchemaDefinitionNode | SchemaExtensionNode,\n  ) {\n    const operationTypesNodes = node.operationTypes ?? [];\n\n    for (const operationType of operationTypesNodes) {\n      const operation = operationType.operation;\n      const alreadyDefinedOperationType = definedOperationTypes.get(operation);\n\n      if (existingOperationTypes[operation]) {\n        context.reportError(\n          new GraphQLError(\n            `Type for ${operation} already defined in the schema. It cannot be redefined.`,\n            { nodes: operationType },\n          ),\n        );\n      } else if (alreadyDefinedOperationType) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one ${operation} type in schema.`,\n            { nodes: [alreadyDefinedOperationType, operationType] },\n          ),\n        );\n      } else {\n        definedOperationTypes.set(operation, operationType);\n      }\n    }\n\n    return false;\n  }\n}\n"]}
+{"version":3,"file":"UniqueOperationTypesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/UniqueOperationTypesRule.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,qCAAoC;AAoC3D,MAAM,UAAU,wBAAwB,CACtC,OAA6B;IAE7B,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IACnC,MAAM,qBAAqB,GAAG,IAAI,GAAG,EAAuC,CAAC;IAC7E,MAAM,sBAAsB,GAAG,MAAM;QACnC,CAAC,CAAC;YACE,KAAK,EAAE,MAAM,CAAC,YAAY,EAAE;YAC5B,QAAQ,EAAE,MAAM,CAAC,eAAe,EAAE;YAClC,YAAY,EAAE,MAAM,CAAC,mBAAmB,EAAE;SAC3C;QACH,CAAC,CAAC,EAAE,CAAC;IAEP,OAAO;QACL,gBAAgB,EAAE,mBAAmB;QACrC,eAAe,EAAE,mBAAmB;KACrC,CAAC;IAEF,SAAS,mBAAmB,CAC1B,IAAgD;QAEhD,MAAM,mBAAmB,GAAG,IAAI,CAAC,cAAc,IAAI,EAAE,CAAC;QAEtD,KAAK,MAAM,aAAa,IAAI,mBAAmB,EAAE,CAAC;YAChD,MAAM,SAAS,GAAG,aAAa,CAAC,SAAS,CAAC;YAC1C,MAAM,2BAA2B,GAAG,qBAAqB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAEzE,IAAI,sBAAsB,CAAC,SAAS,CAAC,EAAE,CAAC;gBACtC,OAAO,CAAC,WAAW,CACjB,IAAI,YAAY,CACd,YAAY,SAAS,yDAAyD,EAC9E,EAAE,KAAK,EAAE,aAAa,EAAE,CACzB,CACF,CAAC;YACJ,CAAC;iBAAM,IAAI,2BAA2B,EAAE,CAAC;gBACvC,OAAO,CAAC,WAAW,CACjB,IAAI,YAAY,CACd,yBAAyB,SAAS,kBAAkB,EACpD,EAAE,KAAK,EAAE,CAAC,2BAA2B,EAAE,aAAa,CAAC,EAAE,CACxD,CACF,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,qBAAqB,CAAC,GAAG,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;YACtD,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC","sourcesContent":["/** @category Validation Rules */\n\nimport { GraphQLError } from '../../error/GraphQLError.ts';\n\nimport type {\n  OperationTypeDefinitionNode,\n  SchemaDefinitionNode,\n  SchemaExtensionNode,\n} from '../../language/ast.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport type { SDLValidationContext } from '../ValidationContext.ts';\n\n/**\n * Unique operation types\n *\n * A GraphQL document is only valid if it has only one type per operation.\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 } from 'graphql';\n * import { UniqueOperationTypesRule } from 'graphql/validation';\n *\n * const invalidSDL = `\n *   schema { query: Query query: Other } type Query { name: String } type Other { name: String }\n * `;\n *\n * UniqueOperationTypesRule.name; // => 'UniqueOperationTypesRule'\n * buildSchema(invalidSDL); // throws an error\n *\n * const validSDL = `\n *   schema { query: Query } type Query { name: String }\n * `;\n *\n * buildSchema(validSDL); // does not throw\n * ```\n */\nexport function UniqueOperationTypesRule(\n  context: SDLValidationContext,\n): ASTVisitor {\n  const schema = context.getSchema();\n  const definedOperationTypes = new Map<string, OperationTypeDefinitionNode>();\n  const existingOperationTypes = schema\n    ? {\n        query: schema.getQueryType(),\n        mutation: schema.getMutationType(),\n        subscription: schema.getSubscriptionType(),\n      }\n    : {};\n\n  return {\n    SchemaDefinition: checkOperationTypes,\n    SchemaExtension: checkOperationTypes,\n  };\n\n  function checkOperationTypes(\n    node: SchemaDefinitionNode | SchemaExtensionNode,\n  ) {\n    const operationTypesNodes = node.operationTypes ?? [];\n\n    for (const operationType of operationTypesNodes) {\n      const operation = operationType.operation;\n      const alreadyDefinedOperationType = definedOperationTypes.get(operation);\n\n      if (existingOperationTypes[operation]) {\n        context.reportError(\n          new GraphQLError(\n            `Type for ${operation} already defined in the schema. It cannot be redefined.`,\n            { nodes: operationType },\n          ),\n        );\n      } else if (alreadyDefinedOperationType) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one ${operation} type in schema.`,\n            { nodes: [alreadyDefinedOperationType, operationType] },\n          ),\n        );\n      } else {\n        definedOperationTypes.set(operation, operationType);\n      }\n    }\n\n    return false;\n  }\n}\n"]}

package/validation/rules/UniqueTypeNamesRule.d.mts

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

package/validation/rules/UniqueTypeNamesRule.d.ts

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

package/validation/rules/UniqueTypeNamesRule.js

@@ -1,12 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniqueTypeNamesRule = UniqueTypeNamesRule;
-const GraphQLError_js_1 = require("../../error/GraphQLError.js");
-/**
- * Unique type names
- *
- * A GraphQL document is only valid if all defined types have unique names.
- */
+const GraphQLError_ts_1 = require("../../error/GraphQLError.js");
 function UniqueTypeNamesRule(context) {
     const knownTypeNames = new Map();
     const schema = context.getSchema();
@@ -21,12 +16,12 @@ function UniqueTypeNamesRule(context) {
     function checkTypeName(node) {
         const typeName = node.name.value;
         if (schema?.getType(typeName)) {
-            context.reportError(new GraphQLError_js_1.GraphQLError(`Type "${typeName}" already exists in the schema. It cannot also be defined in this type definition.`, { nodes: node.name }));
+            context.reportError(new GraphQLError_ts_1.GraphQLError(`Type "${typeName}" already exists in the schema. It cannot also be defined in this type definition.`, { nodes: node.name }));
             return;
         }
         const knownNameNode = knownTypeNames.get(typeName);
         if (knownNameNode != null) {
-            context.reportError(new GraphQLError_js_1.GraphQLError(`There can be only one type named "${typeName}".`, {
+            context.reportError(new GraphQLError_ts_1.GraphQLError(`There can be only one type named "${typeName}".`, {
                 nodes: [knownNameNode, node.name],
             }));
         }

package/validation/rules/UniqueTypeNamesRule.js.map

@@ -1 +1 @@
-{"version":3,"file":"UniqueTypeNamesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/UniqueTypeNamesRule.ts"],"names":[],"mappings":";;AAYA,kDAuCC;AAnDD,iEAA2D;AAO3D;;;;GAIG;AACH,SAAgB,mBAAmB,CAAC,OAA6B;IAC/D,MAAM,cAAc,GAAG,IAAI,GAAG,EAAoB,CAAC;IACnD,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAEnC,OAAO;QACL,oBAAoB,EAAE,aAAa;QACnC,oBAAoB,EAAE,aAAa;QACnC,uBAAuB,EAAE,aAAa;QACtC,mBAAmB,EAAE,aAAa;QAClC,kBAAkB,EAAE,aAAa;QACjC,yBAAyB,EAAE,aAAa;KACzC,CAAC;IAEF,SAAS,aAAa,CAAC,IAAwB;QAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;QAEjC,IAAI,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC9B,OAAO,CAAC,WAAW,CACjB,IAAI,8BAAY,CACd,SAAS,QAAQ,oFAAoF,EACrG,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,CACrB,CACF,CAAC;YACF,OAAO;QACT,CAAC;QAED,MAAM,aAAa,GAAG,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACnD,IAAI,aAAa,IAAI,IAAI,EAAE,CAAC;YAC1B,OAAO,CAAC,WAAW,CACjB,IAAI,8BAAY,CAAC,qCAAqC,QAAQ,IAAI,EAAE;gBAClE,KAAK,EAAE,CAAC,aAAa,EAAE,IAAI,CAAC,IAAI,CAAC;aAClC,CAAC,CACH,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,cAAc,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1C,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC","sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.js';\n\nimport type { NameNode, TypeDefinitionNode } from '../../language/ast.js';\nimport type { ASTVisitor } from '../../language/visitor.js';\n\nimport type { SDLValidationContext } from '../ValidationContext.js';\n\n/**\n * Unique type names\n *\n * A GraphQL document is only valid if all defined types have unique names.\n */\nexport function UniqueTypeNamesRule(context: SDLValidationContext): ASTVisitor {\n  const knownTypeNames = new Map<string, NameNode>();\n  const schema = context.getSchema();\n\n  return {\n    ScalarTypeDefinition: checkTypeName,\n    ObjectTypeDefinition: checkTypeName,\n    InterfaceTypeDefinition: checkTypeName,\n    UnionTypeDefinition: checkTypeName,\n    EnumTypeDefinition: checkTypeName,\n    InputObjectTypeDefinition: checkTypeName,\n  };\n\n  function checkTypeName(node: TypeDefinitionNode) {\n    const typeName = node.name.value;\n\n    if (schema?.getType(typeName)) {\n      context.reportError(\n        new GraphQLError(\n          `Type \"${typeName}\" already exists in the schema. It cannot also be defined in this type definition.`,\n          { nodes: node.name },\n        ),\n      );\n      return;\n    }\n\n    const knownNameNode = knownTypeNames.get(typeName);\n    if (knownNameNode != null) {\n      context.reportError(\n        new GraphQLError(`There can be only one type named \"${typeName}\".`, {\n          nodes: [knownNameNode, node.name],\n        }),\n      );\n    } else {\n      knownTypeNames.set(typeName, node.name);\n    }\n\n    return false;\n  }\n}\n"]}
+{"version":3,"file":"UniqueTypeNamesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/UniqueTypeNamesRule.ts"],"names":[],"mappings":";;AAkCA,kDAuCC;AAvED,iEAA2D;AAgC3D,SAAgB,mBAAmB,CAAC,OAA6B;IAC/D,MAAM,cAAc,GAAG,IAAI,GAAG,EAAoB,CAAC;IACnD,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAEnC,OAAO;QACL,oBAAoB,EAAE,aAAa;QACnC,oBAAoB,EAAE,aAAa;QACnC,uBAAuB,EAAE,aAAa;QACtC,mBAAmB,EAAE,aAAa;QAClC,kBAAkB,EAAE,aAAa;QACjC,yBAAyB,EAAE,aAAa;KACzC,CAAC;IAEF,SAAS,aAAa,CAAC,IAAwB;QAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;QAEjC,IAAI,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC9B,OAAO,CAAC,WAAW,CACjB,IAAI,8BAAY,CACd,SAAS,QAAQ,oFAAoF,EACrG,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,CACrB,CACF,CAAC;YACF,OAAO;QACT,CAAC;QAED,MAAM,aAAa,GAAG,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACnD,IAAI,aAAa,IAAI,IAAI,EAAE,CAAC;YAC1B,OAAO,CAAC,WAAW,CACjB,IAAI,8BAAY,CAAC,qCAAqC,QAAQ,IAAI,EAAE;gBAClE,KAAK,EAAE,CAAC,aAAa,EAAE,IAAI,CAAC,IAAI,CAAC;aAClC,CAAC,CACH,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,cAAc,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1C,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC","sourcesContent":["/** @category Validation Rules */\n\nimport { GraphQLError } from '../../error/GraphQLError.ts';\n\nimport type { NameNode, TypeDefinitionNode } from '../../language/ast.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport type { SDLValidationContext } from '../ValidationContext.ts';\n\n/**\n * Unique type names\n *\n * A GraphQL document is only valid if all defined types have unique names.\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 } from 'graphql';\n * import { UniqueTypeNamesRule } from 'graphql/validation';\n *\n * const invalidSDL = `\n *   type Query { name: String } type Query { other: String }\n * `;\n *\n * UniqueTypeNamesRule.name; // => 'UniqueTypeNamesRule'\n * buildSchema(invalidSDL); // throws an error\n *\n * const validSDL = `\n *   type Query { name: String } type Other { name: String }\n * `;\n *\n * buildSchema(validSDL); // does not throw\n * ```\n */\nexport function UniqueTypeNamesRule(context: SDLValidationContext): ASTVisitor {\n  const knownTypeNames = new Map<string, NameNode>();\n  const schema = context.getSchema();\n\n  return {\n    ScalarTypeDefinition: checkTypeName,\n    ObjectTypeDefinition: checkTypeName,\n    InterfaceTypeDefinition: checkTypeName,\n    UnionTypeDefinition: checkTypeName,\n    EnumTypeDefinition: checkTypeName,\n    InputObjectTypeDefinition: checkTypeName,\n  };\n\n  function checkTypeName(node: TypeDefinitionNode) {\n    const typeName = node.name.value;\n\n    if (schema?.getType(typeName)) {\n      context.reportError(\n        new GraphQLError(\n          `Type \"${typeName}\" already exists in the schema. It cannot also be defined in this type definition.`,\n          { nodes: node.name },\n        ),\n      );\n      return;\n    }\n\n    const knownNameNode = knownTypeNames.get(typeName);\n    if (knownNameNode != null) {\n      context.reportError(\n        new GraphQLError(`There can be only one type named \"${typeName}\".`, {\n          nodes: [knownNameNode, node.name],\n        }),\n      );\n    } else {\n      knownTypeNames.set(typeName, node.name);\n    }\n\n    return false;\n  }\n}\n"]}

package/validation/rules/UniqueTypeNamesRule.mjs

@@ -1,9 +1,4 @@
 import { GraphQLError } from "../../error/GraphQLError.mjs";
-/**
- * Unique type names
- *
- * A GraphQL document is only valid if all defined types have unique names.
- */
 export function UniqueTypeNamesRule(context) {
     const knownTypeNames = new Map();
     const schema = context.getSchema();

package/validation/rules/UniqueTypeNamesRule.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"UniqueTypeNamesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/UniqueTypeNamesRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,qCAAoC;AAO3D;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,OAA6B;IAC/D,MAAM,cAAc,GAAG,IAAI,GAAG,EAAoB,CAAC;IACnD,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAEnC,OAAO;QACL,oBAAoB,EAAE,aAAa;QACnC,oBAAoB,EAAE,aAAa;QACnC,uBAAuB,EAAE,aAAa;QACtC,mBAAmB,EAAE,aAAa;QAClC,kBAAkB,EAAE,aAAa;QACjC,yBAAyB,EAAE,aAAa;KACzC,CAAC;IAEF,SAAS,aAAa,CAAC,IAAwB;QAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;QAEjC,IAAI,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC9B,OAAO,CAAC,WAAW,CACjB,IAAI,YAAY,CACd,SAAS,QAAQ,oFAAoF,EACrG,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,CACrB,CACF,CAAC;YACF,OAAO;QACT,CAAC;QAED,MAAM,aAAa,GAAG,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACnD,IAAI,aAAa,IAAI,IAAI,EAAE,CAAC;YAC1B,OAAO,CAAC,WAAW,CACjB,IAAI,YAAY,CAAC,qCAAqC,QAAQ,IAAI,EAAE;gBAClE,KAAK,EAAE,CAAC,aAAa,EAAE,IAAI,CAAC,IAAI,CAAC;aAClC,CAAC,CACH,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,cAAc,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1C,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC","sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.js';\n\nimport type { NameNode, TypeDefinitionNode } from '../../language/ast.js';\nimport type { ASTVisitor } from '../../language/visitor.js';\n\nimport type { SDLValidationContext } from '../ValidationContext.js';\n\n/**\n * Unique type names\n *\n * A GraphQL document is only valid if all defined types have unique names.\n */\nexport function UniqueTypeNamesRule(context: SDLValidationContext): ASTVisitor {\n  const knownTypeNames = new Map<string, NameNode>();\n  const schema = context.getSchema();\n\n  return {\n    ScalarTypeDefinition: checkTypeName,\n    ObjectTypeDefinition: checkTypeName,\n    InterfaceTypeDefinition: checkTypeName,\n    UnionTypeDefinition: checkTypeName,\n    EnumTypeDefinition: checkTypeName,\n    InputObjectTypeDefinition: checkTypeName,\n  };\n\n  function checkTypeName(node: TypeDefinitionNode) {\n    const typeName = node.name.value;\n\n    if (schema?.getType(typeName)) {\n      context.reportError(\n        new GraphQLError(\n          `Type \"${typeName}\" already exists in the schema. It cannot also be defined in this type definition.`,\n          { nodes: node.name },\n        ),\n      );\n      return;\n    }\n\n    const knownNameNode = knownTypeNames.get(typeName);\n    if (knownNameNode != null) {\n      context.reportError(\n        new GraphQLError(`There can be only one type named \"${typeName}\".`, {\n          nodes: [knownNameNode, node.name],\n        }),\n      );\n    } else {\n      knownTypeNames.set(typeName, node.name);\n    }\n\n    return false;\n  }\n}\n"]}
+{"version":3,"file":"UniqueTypeNamesRule.js","sourceRoot":"","sources":["../../../src/validation/rules/UniqueTypeNamesRule.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,qCAAoC;AAgC3D,MAAM,UAAU,mBAAmB,CAAC,OAA6B;IAC/D,MAAM,cAAc,GAAG,IAAI,GAAG,EAAoB,CAAC;IACnD,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAEnC,OAAO;QACL,oBAAoB,EAAE,aAAa;QACnC,oBAAoB,EAAE,aAAa;QACnC,uBAAuB,EAAE,aAAa;QACtC,mBAAmB,EAAE,aAAa;QAClC,kBAAkB,EAAE,aAAa;QACjC,yBAAyB,EAAE,aAAa;KACzC,CAAC;IAEF,SAAS,aAAa,CAAC,IAAwB;QAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;QAEjC,IAAI,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC9B,OAAO,CAAC,WAAW,CACjB,IAAI,YAAY,CACd,SAAS,QAAQ,oFAAoF,EACrG,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,CACrB,CACF,CAAC;YACF,OAAO;QACT,CAAC;QAED,MAAM,aAAa,GAAG,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACnD,IAAI,aAAa,IAAI,IAAI,EAAE,CAAC;YAC1B,OAAO,CAAC,WAAW,CACjB,IAAI,YAAY,CAAC,qCAAqC,QAAQ,IAAI,EAAE;gBAClE,KAAK,EAAE,CAAC,aAAa,EAAE,IAAI,CAAC,IAAI,CAAC;aAClC,CAAC,CACH,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,cAAc,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1C,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC","sourcesContent":["/** @category Validation Rules */\n\nimport { GraphQLError } from '../../error/GraphQLError.ts';\n\nimport type { NameNode, TypeDefinitionNode } from '../../language/ast.ts';\nimport type { ASTVisitor } from '../../language/visitor.ts';\n\nimport type { SDLValidationContext } from '../ValidationContext.ts';\n\n/**\n * Unique type names\n *\n * A GraphQL document is only valid if all defined types have unique names.\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 } from 'graphql';\n * import { UniqueTypeNamesRule } from 'graphql/validation';\n *\n * const invalidSDL = `\n *   type Query { name: String } type Query { other: String }\n * `;\n *\n * UniqueTypeNamesRule.name; // => 'UniqueTypeNamesRule'\n * buildSchema(invalidSDL); // throws an error\n *\n * const validSDL = `\n *   type Query { name: String } type Other { name: String }\n * `;\n *\n * buildSchema(validSDL); // does not throw\n * ```\n */\nexport function UniqueTypeNamesRule(context: SDLValidationContext): ASTVisitor {\n  const knownTypeNames = new Map<string, NameNode>();\n  const schema = context.getSchema();\n\n  return {\n    ScalarTypeDefinition: checkTypeName,\n    ObjectTypeDefinition: checkTypeName,\n    InterfaceTypeDefinition: checkTypeName,\n    UnionTypeDefinition: checkTypeName,\n    EnumTypeDefinition: checkTypeName,\n    InputObjectTypeDefinition: checkTypeName,\n  };\n\n  function checkTypeName(node: TypeDefinitionNode) {\n    const typeName = node.name.value;\n\n    if (schema?.getType(typeName)) {\n      context.reportError(\n        new GraphQLError(\n          `Type \"${typeName}\" already exists in the schema. It cannot also be defined in this type definition.`,\n          { nodes: node.name },\n        ),\n      );\n      return;\n    }\n\n    const knownNameNode = knownTypeNames.get(typeName);\n    if (knownNameNode != null) {\n      context.reportError(\n        new GraphQLError(`There can be only one type named \"${typeName}\".`, {\n          nodes: [knownNameNode, node.name],\n        }),\n      );\n    } else {\n      knownTypeNames.set(typeName, node.name);\n    }\n\n    return false;\n  }\n}\n"]}

package/validation/rules/UniqueVariableNamesRule.d.mts

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