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

package/utilities/typeComparators.d.mts

@@ -1,12 +1,63 @@
-import type { GraphQLCompositeType, GraphQLType } from '../type/definition.js';
-import type { GraphQLSchema } from '../type/schema.js';
+/** @category Type Comparisons */
+import type { GraphQLCompositeType, GraphQLType } from "../type/definition.mjs";
+import type { GraphQLSchema } from "../type/schema.mjs";
 /**
  * Provided two types, return true if the types are equal (invariant).
+ * @param typeA - The first GraphQL type to compare.
+ * @param typeB - The second GraphQL type to compare.
+ * @returns True when both types are equal.
+ * @example
+ * ```ts
+ * import {
+ *   GraphQLList,
+ *   GraphQLNonNull,
+ *   GraphQLString,
+ * } from 'graphql/type';
+ * import { isEqualType } from 'graphql/utilities';
+ *
+ * isEqualType(GraphQLString, GraphQLString); // => true
+ * isEqualType(new GraphQLList(GraphQLString), new GraphQLList(GraphQLString)); // => true
+ * isEqualType(new GraphQLNonNull(GraphQLString), GraphQLString); // => false
+ * ```
  */
 export declare function isEqualType(typeA: GraphQLType, typeB: GraphQLType): boolean;
 /**
  * Provided a type and a super type, return true if the first type is either
  * equal or a subset of the second super type (covariant).
+ * @param schema - GraphQL schema to use.
+ * @param maybeSubType - The possible subtype to compare.
+ * @param superType - The possible supertype to compare.
+ * @returns True when `maybeSubType` is equal to or a subtype of `superType`.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   GraphQLNonNull,
+ *   assertInterfaceType,
+ *   assertObjectType,
+ * } from 'graphql/type';
+ * import { isTypeSubTypeOf } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   interface Node {
+ *     id: ID!
+ *   }
+ *
+ *   type User implements Node {
+ *     id: ID!
+ *   }
+ *
+ *   type Query {
+ *     node: Node
+ *   }
+ * `);
+ * const Node = assertInterfaceType(schema.getType('Node'));
+ * const User = assertObjectType(schema.getType('User'));
+ *
+ * isTypeSubTypeOf(schema, User, Node); // => true
+ * isTypeSubTypeOf(schema, new GraphQLNonNull(User), Node); // => true
+ * isTypeSubTypeOf(schema, Node, User); // => false
+ * ```
  */
 export declare function isTypeSubTypeOf(schema: GraphQLSchema, maybeSubType: GraphQLType, superType: GraphQLType): boolean;
 /**
@@ -17,5 +68,38 @@ export declare function isTypeSubTypeOf(schema: GraphQLSchema, maybeSubType: Gra
  * be visited in a context of another type.
  *
  * This function is commutative.
+ * @param schema - GraphQL schema to use.
+ * @param typeA - The first GraphQL type to compare.
+ * @param typeB - The second GraphQL type to compare.
+ * @returns True when the two composite types can apply to at least one common object type.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertObjectType, assertUnionType } from 'graphql/type';
+ * import { doTypesOverlap } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Photo {
+ *     url: String!
+ *   }
+ *
+ *   type Video {
+ *     url: String!
+ *   }
+ *
+ *   union Media = Photo | Video
+ *   union StillImage = Photo
+ *
+ *   type Query {
+ *     media: [Media]
+ *   }
+ * `);
+ * const Media = assertUnionType(schema.getType('Media'));
+ * const StillImage = assertUnionType(schema.getType('StillImage'));
+ * const Video = assertObjectType(schema.getType('Video'));
+ *
+ * doTypesOverlap(schema, Media, StillImage); // => true
+ * doTypesOverlap(schema, StillImage, Video); // => false
+ * ```
  */
 export declare function doTypesOverlap(schema: GraphQLSchema, typeA: GraphQLCompositeType, typeB: GraphQLCompositeType): boolean;

package/utilities/typeComparators.d.ts

@@ -1,12 +1,63 @@
-import type { GraphQLCompositeType, GraphQLType } from '../type/definition.js';
-import type { GraphQLSchema } from '../type/schema.js';
+/** @category Type Comparisons */
+import type { GraphQLCompositeType, GraphQLType } from "../type/definition.js";
+import type { GraphQLSchema } from "../type/schema.js";
 /**
  * Provided two types, return true if the types are equal (invariant).
+ * @param typeA - The first GraphQL type to compare.
+ * @param typeB - The second GraphQL type to compare.
+ * @returns True when both types are equal.
+ * @example
+ * ```ts
+ * import {
+ *   GraphQLList,
+ *   GraphQLNonNull,
+ *   GraphQLString,
+ * } from 'graphql/type';
+ * import { isEqualType } from 'graphql/utilities';
+ *
+ * isEqualType(GraphQLString, GraphQLString); // => true
+ * isEqualType(new GraphQLList(GraphQLString), new GraphQLList(GraphQLString)); // => true
+ * isEqualType(new GraphQLNonNull(GraphQLString), GraphQLString); // => false
+ * ```
  */
 export declare function isEqualType(typeA: GraphQLType, typeB: GraphQLType): boolean;
 /**
  * Provided a type and a super type, return true if the first type is either
  * equal or a subset of the second super type (covariant).
+ * @param schema - GraphQL schema to use.
+ * @param maybeSubType - The possible subtype to compare.
+ * @param superType - The possible supertype to compare.
+ * @returns True when `maybeSubType` is equal to or a subtype of `superType`.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   GraphQLNonNull,
+ *   assertInterfaceType,
+ *   assertObjectType,
+ * } from 'graphql/type';
+ * import { isTypeSubTypeOf } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   interface Node {
+ *     id: ID!
+ *   }
+ *
+ *   type User implements Node {
+ *     id: ID!
+ *   }
+ *
+ *   type Query {
+ *     node: Node
+ *   }
+ * `);
+ * const Node = assertInterfaceType(schema.getType('Node'));
+ * const User = assertObjectType(schema.getType('User'));
+ *
+ * isTypeSubTypeOf(schema, User, Node); // => true
+ * isTypeSubTypeOf(schema, new GraphQLNonNull(User), Node); // => true
+ * isTypeSubTypeOf(schema, Node, User); // => false
+ * ```
  */
 export declare function isTypeSubTypeOf(schema: GraphQLSchema, maybeSubType: GraphQLType, superType: GraphQLType): boolean;
 /**
@@ -17,5 +68,38 @@ export declare function isTypeSubTypeOf(schema: GraphQLSchema, maybeSubType: Gra
  * be visited in a context of another type.
  *
  * This function is commutative.
+ * @param schema - GraphQL schema to use.
+ * @param typeA - The first GraphQL type to compare.
+ * @param typeB - The second GraphQL type to compare.
+ * @returns True when the two composite types can apply to at least one common object type.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql/utilities';
+ * import { assertObjectType, assertUnionType } from 'graphql/type';
+ * import { doTypesOverlap } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Photo {
+ *     url: String!
+ *   }
+ *
+ *   type Video {
+ *     url: String!
+ *   }
+ *
+ *   union Media = Photo | Video
+ *   union StillImage = Photo
+ *
+ *   type Query {
+ *     media: [Media]
+ *   }
+ * `);
+ * const Media = assertUnionType(schema.getType('Media'));
+ * const StillImage = assertUnionType(schema.getType('StillImage'));
+ * const Video = assertObjectType(schema.getType('Video'));
+ *
+ * doTypesOverlap(schema, Media, StillImage); // => true
+ * doTypesOverlap(schema, StillImage, Video); // => false
+ * ```
  */
 export declare function doTypesOverlap(schema: GraphQLSchema, typeA: GraphQLCompositeType, typeB: GraphQLCompositeType): boolean;

package/utilities/typeComparators.js

@@ -3,93 +3,60 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isEqualType = isEqualType;
 exports.isTypeSubTypeOf = isTypeSubTypeOf;
 exports.doTypesOverlap = doTypesOverlap;
-const definition_js_1 = require("../type/definition.js");
-/**
- * Provided two types, return true if the types are equal (invariant).
- */
+const definition_ts_1 = require("../type/definition.js");
 function isEqualType(typeA, typeB) {
-    // Equivalent types are equal.
     if (typeA === typeB) {
         return true;
     }
-    // If either type is non-null, the other must also be non-null.
-    if ((0, definition_js_1.isNonNullType)(typeA) && (0, definition_js_1.isNonNullType)(typeB)) {
+    if ((0, definition_ts_1.isNonNullType)(typeA) && (0, definition_ts_1.isNonNullType)(typeB)) {
         return isEqualType(typeA.ofType, typeB.ofType);
     }
-    // If either type is a list, the other must also be a list.
-    if ((0, definition_js_1.isListType)(typeA) && (0, definition_js_1.isListType)(typeB)) {
+    if ((0, definition_ts_1.isListType)(typeA) && (0, definition_ts_1.isListType)(typeB)) {
         return isEqualType(typeA.ofType, typeB.ofType);
     }
-    // Otherwise the types are not equal.
     return false;
 }
-/**
- * Provided a type and a super type, return true if the first type is either
- * equal or a subset of the second super type (covariant).
- */
 function isTypeSubTypeOf(schema, maybeSubType, superType) {
-    // Equivalent type is a valid subtype
     if (maybeSubType === superType) {
         return true;
     }
-    // If superType is non-null, maybeSubType must also be non-null.
-    if ((0, definition_js_1.isNonNullType)(superType)) {
-        if ((0, definition_js_1.isNonNullType)(maybeSubType)) {
+    if ((0, definition_ts_1.isNonNullType)(superType)) {
+        if ((0, definition_ts_1.isNonNullType)(maybeSubType)) {
             return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
         }
         return false;
     }
-    if ((0, definition_js_1.isNonNullType)(maybeSubType)) {
-        // If superType is nullable, maybeSubType may be non-null or nullable.
+    if ((0, definition_ts_1.isNonNullType)(maybeSubType)) {
         return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);
     }
-    // If superType type is a list, maybeSubType type must also be a list.
-    if ((0, definition_js_1.isListType)(superType)) {
-        if ((0, definition_js_1.isListType)(maybeSubType)) {
+    if ((0, definition_ts_1.isListType)(superType)) {
+        if ((0, definition_ts_1.isListType)(maybeSubType)) {
             return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
         }
         return false;
     }
-    if ((0, definition_js_1.isListType)(maybeSubType)) {
-        // If superType is not a list, maybeSubType must also be not a list.
+    if ((0, definition_ts_1.isListType)(maybeSubType)) {
         return false;
     }
-    // If superType type is an abstract type, check if it is super type of maybeSubType.
-    // Otherwise, the child type is not a valid subtype of the parent type.
-    return ((0, definition_js_1.isAbstractType)(superType) &&
-        ((0, definition_js_1.isInterfaceType)(maybeSubType) || (0, definition_js_1.isObjectType)(maybeSubType)) &&
+    return ((0, definition_ts_1.isAbstractType)(superType) &&
+        ((0, definition_ts_1.isInterfaceType)(maybeSubType) || (0, definition_ts_1.isObjectType)(maybeSubType)) &&
         schema.isSubType(superType, maybeSubType));
 }
-/**
- * Provided two composite types, determine if they "overlap". Two composite
- * types overlap when the Sets of possible concrete types for each intersect.
- *
- * This is often used to determine if a fragment of a given type could possibly
- * be visited in a context of another type.
- *
- * This function is commutative.
- */
 function doTypesOverlap(schema, typeA, typeB) {
-    // Equivalent types overlap
     if (typeA === typeB) {
         return true;
     }
-    if ((0, definition_js_1.isAbstractType)(typeA)) {
-        if ((0, definition_js_1.isAbstractType)(typeB)) {
-            // If both types are abstract, then determine if there is any intersection
-            // between possible concrete types of each.
+    if ((0, definition_ts_1.isAbstractType)(typeA)) {
+        if ((0, definition_ts_1.isAbstractType)(typeB)) {
             return schema
                 .getPossibleTypes(typeA)
                 .some((type) => schema.isSubType(typeB, type));
         }
-        // Determine if the latter type is a possible concrete type of the former.
         return schema.isSubType(typeA, typeB);
     }
-    if ((0, definition_js_1.isAbstractType)(typeB)) {
-        // Determine if the former type is a possible concrete type of the latter.
+    if ((0, definition_ts_1.isAbstractType)(typeB)) {
         return schema.isSubType(typeB, typeA);
     }
-    // Otherwise the types do not overlap.
     return false;
 }
 //# sourceMappingURL=typeComparators.js.map

package/utilities/typeComparators.js.map

@@ -1 +1 @@
-{"version":3,"file":"typeComparators.js","sourceRoot":"","sources":["../../src/utilities/typeComparators.ts"],"names":[],"mappings":"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","sourcesContent":["import type { GraphQLCompositeType, GraphQLType } from '../type/definition.js';\nimport {\n  isAbstractType,\n  isInterfaceType,\n  isListType,\n  isNonNullType,\n  isObjectType,\n} from '../type/definition.js';\nimport type { GraphQLSchema } from '../type/schema.js';\n\n/**\n * Provided two types, return true if the types are equal (invariant).\n */\nexport function isEqualType(typeA: GraphQLType, typeB: GraphQLType): boolean {\n  // Equivalent types are equal.\n  if (typeA === typeB) {\n    return true;\n  }\n\n  // If either type is non-null, the other must also be non-null.\n  if (isNonNullType(typeA) && isNonNullType(typeB)) {\n    return isEqualType(typeA.ofType, typeB.ofType);\n  }\n\n  // If either type is a list, the other must also be a list.\n  if (isListType(typeA) && isListType(typeB)) {\n    return isEqualType(typeA.ofType, typeB.ofType);\n  }\n\n  // Otherwise the types are not equal.\n  return false;\n}\n\n/**\n * Provided a type and a super type, return true if the first type is either\n * equal or a subset of the second super type (covariant).\n */\nexport function isTypeSubTypeOf(\n  schema: GraphQLSchema,\n  maybeSubType: GraphQLType,\n  superType: GraphQLType,\n): boolean {\n  // Equivalent type is a valid subtype\n  if (maybeSubType === superType) {\n    return true;\n  }\n\n  // If superType is non-null, maybeSubType must also be non-null.\n  if (isNonNullType(superType)) {\n    if (isNonNullType(maybeSubType)) {\n      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);\n    }\n    return false;\n  }\n  if (isNonNullType(maybeSubType)) {\n    // If superType is nullable, maybeSubType may be non-null or nullable.\n    return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);\n  }\n\n  // If superType type is a list, maybeSubType type must also be a list.\n  if (isListType(superType)) {\n    if (isListType(maybeSubType)) {\n      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);\n    }\n    return false;\n  }\n  if (isListType(maybeSubType)) {\n    // If superType is not a list, maybeSubType must also be not a list.\n    return false;\n  }\n\n  // If superType type is an abstract type, check if it is super type of maybeSubType.\n  // Otherwise, the child type is not a valid subtype of the parent type.\n  return (\n    isAbstractType(superType) &&\n    (isInterfaceType(maybeSubType) || isObjectType(maybeSubType)) &&\n    schema.isSubType(superType, maybeSubType)\n  );\n}\n\n/**\n * Provided two composite types, determine if they \"overlap\". Two composite\n * types overlap when the Sets of possible concrete types for each intersect.\n *\n * This is often used to determine if a fragment of a given type could possibly\n * be visited in a context of another type.\n *\n * This function is commutative.\n */\nexport function doTypesOverlap(\n  schema: GraphQLSchema,\n  typeA: GraphQLCompositeType,\n  typeB: GraphQLCompositeType,\n): boolean {\n  // Equivalent types overlap\n  if (typeA === typeB) {\n    return true;\n  }\n\n  if (isAbstractType(typeA)) {\n    if (isAbstractType(typeB)) {\n      // If both types are abstract, then determine if there is any intersection\n      // between possible concrete types of each.\n      return schema\n        .getPossibleTypes(typeA)\n        .some((type) => schema.isSubType(typeB, type));\n    }\n    // Determine if the latter type is a possible concrete type of the former.\n    return schema.isSubType(typeA, typeB);\n  }\n\n  if (isAbstractType(typeB)) {\n    // Determine if the former type is a possible concrete type of the latter.\n    return schema.isSubType(typeB, typeA);\n  }\n\n  // Otherwise the types do not overlap.\n  return false;\n}\n"]}
+{"version":3,"file":"typeComparators.js","sourceRoot":"","sources":["../../src/utilities/typeComparators.ts"],"names":[],"mappings":";;AA+BA,kCAkBC;AAwCD,0CAyCC;AA4CD,wCA6BC;AAxMD,yDAM+B;AAsB/B,SAAgB,WAAW,CAAC,KAAkB,EAAE,KAAkB;IAEhE,IAAI,KAAK,KAAK,KAAK,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC;IACd,CAAC;IAGD,IAAI,IAAA,6BAAa,EAAC,KAAK,CAAC,IAAI,IAAA,6BAAa,EAAC,KAAK,CAAC,EAAE,CAAC;QACjD,OAAO,WAAW,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACjD,CAAC;IAGD,IAAI,IAAA,0BAAU,EAAC,KAAK,CAAC,IAAI,IAAA,0BAAU,EAAC,KAAK,CAAC,EAAE,CAAC;QAC3C,OAAO,WAAW,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACjD,CAAC;IAGD,OAAO,KAAK,CAAC;AACf,CAAC;AAwCD,SAAgB,eAAe,CAC7B,MAAqB,EACrB,YAAyB,EACzB,SAAsB;IAGtB,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IAGD,IAAI,IAAA,6BAAa,EAAC,SAAS,CAAC,EAAE,CAAC;QAC7B,IAAI,IAAA,6BAAa,EAAC,YAAY,CAAC,EAAE,CAAC;YAChC,OAAO,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;QACxE,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,IAAA,6BAAa,EAAC,YAAY,CAAC,EAAE,CAAC;QAEhC,OAAO,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACjE,CAAC;IAGD,IAAI,IAAA,0BAAU,EAAC,SAAS,CAAC,EAAE,CAAC;QAC1B,IAAI,IAAA,0BAAU,EAAC,YAAY,CAAC,EAAE,CAAC;YAC7B,OAAO,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;QACxE,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,IAAA,0BAAU,EAAC,YAAY,CAAC,EAAE,CAAC;QAE7B,OAAO,KAAK,CAAC;IACf,CAAC;IAID,OAAO,CACL,IAAA,8BAAc,EAAC,SAAS,CAAC;QACzB,CAAC,IAAA,+BAAe,EAAC,YAAY,CAAC,IAAI,IAAA,4BAAY,EAAC,YAAY,CAAC,CAAC;QAC7D,MAAM,CAAC,SAAS,CAAC,SAAS,EAAE,YAAY,CAAC,CAC1C,CAAC;AACJ,CAAC;AA4CD,SAAgB,cAAc,CAC5B,MAAqB,EACrB,KAA2B,EAC3B,KAA2B;IAG3B,IAAI,KAAK,KAAK,KAAK,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,IAAA,8BAAc,EAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,IAAI,IAAA,8BAAc,EAAC,KAAK,CAAC,EAAE,CAAC;YAG1B,OAAO,MAAM;iBACV,gBAAgB,CAAC,KAAK,CAAC;iBACvB,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;QACnD,CAAC;QAED,OAAO,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACxC,CAAC;IAED,IAAI,IAAA,8BAAc,EAAC,KAAK,CAAC,EAAE,CAAC;QAE1B,OAAO,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACxC,CAAC;IAGD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["/** @category Type Comparisons */\n\nimport type { GraphQLCompositeType, GraphQLType } from '../type/definition.ts';\nimport {\n  isAbstractType,\n  isInterfaceType,\n  isListType,\n  isNonNullType,\n  isObjectType,\n} from '../type/definition.ts';\nimport type { GraphQLSchema } from '../type/schema.ts';\n\n/**\n * Provided two types, return true if the types are equal (invariant).\n * @param typeA - The first GraphQL type to compare.\n * @param typeB - The second GraphQL type to compare.\n * @returns True when both types are equal.\n * @example\n * ```ts\n * import {\n *   GraphQLList,\n *   GraphQLNonNull,\n *   GraphQLString,\n * } from 'graphql/type';\n * import { isEqualType } from 'graphql/utilities';\n *\n * isEqualType(GraphQLString, GraphQLString); // => true\n * isEqualType(new GraphQLList(GraphQLString), new GraphQLList(GraphQLString)); // => true\n * isEqualType(new GraphQLNonNull(GraphQLString), GraphQLString); // => false\n * ```\n */\nexport function isEqualType(typeA: GraphQLType, typeB: GraphQLType): boolean {\n  // Equivalent types are equal.\n  if (typeA === typeB) {\n    return true;\n  }\n\n  // If either type is non-null, the other must also be non-null.\n  if (isNonNullType(typeA) && isNonNullType(typeB)) {\n    return isEqualType(typeA.ofType, typeB.ofType);\n  }\n\n  // If either type is a list, the other must also be a list.\n  if (isListType(typeA) && isListType(typeB)) {\n    return isEqualType(typeA.ofType, typeB.ofType);\n  }\n\n  // Otherwise the types are not equal.\n  return false;\n}\n\n/**\n * Provided a type and a super type, return true if the first type is either\n * equal or a subset of the second super type (covariant).\n * @param schema - GraphQL schema to use.\n * @param maybeSubType - The possible subtype to compare.\n * @param superType - The possible supertype to compare.\n * @returns True when `maybeSubType` is equal to or a subtype of `superType`.\n * @example\n * ```ts\n * import { buildSchema } from 'graphql/utilities';\n * import {\n *   GraphQLNonNull,\n *   assertInterfaceType,\n *   assertObjectType,\n * } from 'graphql/type';\n * import { isTypeSubTypeOf } from 'graphql/utilities';\n *\n * const schema = buildSchema(`\n *   interface Node {\n *     id: ID!\n *   }\n *\n *   type User implements Node {\n *     id: ID!\n *   }\n *\n *   type Query {\n *     node: Node\n *   }\n * `);\n * const Node = assertInterfaceType(schema.getType('Node'));\n * const User = assertObjectType(schema.getType('User'));\n *\n * isTypeSubTypeOf(schema, User, Node); // => true\n * isTypeSubTypeOf(schema, new GraphQLNonNull(User), Node); // => true\n * isTypeSubTypeOf(schema, Node, User); // => false\n * ```\n */\nexport function isTypeSubTypeOf(\n  schema: GraphQLSchema,\n  maybeSubType: GraphQLType,\n  superType: GraphQLType,\n): boolean {\n  // Equivalent type is a valid subtype\n  if (maybeSubType === superType) {\n    return true;\n  }\n\n  // If superType is non-null, maybeSubType must also be non-null.\n  if (isNonNullType(superType)) {\n    if (isNonNullType(maybeSubType)) {\n      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);\n    }\n    return false;\n  }\n  if (isNonNullType(maybeSubType)) {\n    // If superType is nullable, maybeSubType may be non-null or nullable.\n    return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);\n  }\n\n  // If superType type is a list, maybeSubType type must also be a list.\n  if (isListType(superType)) {\n    if (isListType(maybeSubType)) {\n      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);\n    }\n    return false;\n  }\n  if (isListType(maybeSubType)) {\n    // If superType is not a list, maybeSubType must also be not a list.\n    return false;\n  }\n\n  // If superType type is an abstract type, check if it is super type of maybeSubType.\n  // Otherwise, the child type is not a valid subtype of the parent type.\n  return (\n    isAbstractType(superType) &&\n    (isInterfaceType(maybeSubType) || isObjectType(maybeSubType)) &&\n    schema.isSubType(superType, maybeSubType)\n  );\n}\n\n/**\n * Provided two composite types, determine if they \"overlap\". Two composite\n * types overlap when the Sets of possible concrete types for each intersect.\n *\n * This is often used to determine if a fragment of a given type could possibly\n * be visited in a context of another type.\n *\n * This function is commutative.\n * @param schema - GraphQL schema to use.\n * @param typeA - The first GraphQL type to compare.\n * @param typeB - The second GraphQL type to compare.\n * @returns True when the two composite types can apply to at least one common object type.\n * @example\n * ```ts\n * import { buildSchema } from 'graphql/utilities';\n * import { assertObjectType, assertUnionType } from 'graphql/type';\n * import { doTypesOverlap } from 'graphql/utilities';\n *\n * const schema = buildSchema(`\n *   type Photo {\n *     url: String!\n *   }\n *\n *   type Video {\n *     url: String!\n *   }\n *\n *   union Media = Photo | Video\n *   union StillImage = Photo\n *\n *   type Query {\n *     media: [Media]\n *   }\n * `);\n * const Media = assertUnionType(schema.getType('Media'));\n * const StillImage = assertUnionType(schema.getType('StillImage'));\n * const Video = assertObjectType(schema.getType('Video'));\n *\n * doTypesOverlap(schema, Media, StillImage); // => true\n * doTypesOverlap(schema, StillImage, Video); // => false\n * ```\n */\nexport function doTypesOverlap(\n  schema: GraphQLSchema,\n  typeA: GraphQLCompositeType,\n  typeB: GraphQLCompositeType,\n): boolean {\n  // Equivalent types overlap\n  if (typeA === typeB) {\n    return true;\n  }\n\n  if (isAbstractType(typeA)) {\n    if (isAbstractType(typeB)) {\n      // If both types are abstract, then determine if there is any intersection\n      // between possible concrete types of each.\n      return schema\n        .getPossibleTypes(typeA)\n        .some((type) => schema.isSubType(typeB, type));\n    }\n    // Determine if the latter type is a possible concrete type of the former.\n    return schema.isSubType(typeA, typeB);\n  }\n\n  if (isAbstractType(typeB)) {\n    // Determine if the former type is a possible concrete type of the latter.\n    return schema.isSubType(typeB, typeA);\n  }\n\n  // Otherwise the types do not overlap.\n  return false;\n}\n"]}

package/utilities/typeComparators.mjs

@@ -1,33 +1,20 @@
 import { isAbstractType, isInterfaceType, isListType, isNonNullType, isObjectType, } from "../type/definition.mjs";
-/**
- * Provided two types, return true if the types are equal (invariant).
- */
 export function isEqualType(typeA, typeB) {
-    // Equivalent types are equal.
     if (typeA === typeB) {
         return true;
     }
-    // If either type is non-null, the other must also be non-null.
     if (isNonNullType(typeA) && isNonNullType(typeB)) {
         return isEqualType(typeA.ofType, typeB.ofType);
     }
-    // If either type is a list, the other must also be a list.
     if (isListType(typeA) && isListType(typeB)) {
         return isEqualType(typeA.ofType, typeB.ofType);
     }
-    // Otherwise the types are not equal.
     return false;
 }
-/**
- * Provided a type and a super type, return true if the first type is either
- * equal or a subset of the second super type (covariant).
- */
 export function isTypeSubTypeOf(schema, maybeSubType, superType) {
-    // Equivalent type is a valid subtype
     if (maybeSubType === superType) {
         return true;
     }
-    // If superType is non-null, maybeSubType must also be non-null.
     if (isNonNullType(superType)) {
         if (isNonNullType(maybeSubType)) {
             return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
@@ -35,10 +22,8 @@ export function isTypeSubTypeOf(schema, maybeSubType, superType) {
         return false;
     }
     if (isNonNullType(maybeSubType)) {
-        // If superType is nullable, maybeSubType may be non-null or nullable.
         return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);
     }
-    // If superType type is a list, maybeSubType type must also be a list.
     if (isListType(superType)) {
         if (isListType(maybeSubType)) {
             return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
@@ -46,45 +31,27 @@ export function isTypeSubTypeOf(schema, maybeSubType, superType) {
         return false;
     }
     if (isListType(maybeSubType)) {
-        // If superType is not a list, maybeSubType must also be not a list.
         return false;
     }
-    // If superType type is an abstract type, check if it is super type of maybeSubType.
-    // Otherwise, the child type is not a valid subtype of the parent type.
     return (isAbstractType(superType) &&
         (isInterfaceType(maybeSubType) || isObjectType(maybeSubType)) &&
         schema.isSubType(superType, maybeSubType));
 }
-/**
- * Provided two composite types, determine if they "overlap". Two composite
- * types overlap when the Sets of possible concrete types for each intersect.
- *
- * This is often used to determine if a fragment of a given type could possibly
- * be visited in a context of another type.
- *
- * This function is commutative.
- */
 export function doTypesOverlap(schema, typeA, typeB) {
-    // Equivalent types overlap
     if (typeA === typeB) {
         return true;
     }
     if (isAbstractType(typeA)) {
         if (isAbstractType(typeB)) {
-            // If both types are abstract, then determine if there is any intersection
-            // between possible concrete types of each.
             return schema
                 .getPossibleTypes(typeA)
                 .some((type) => schema.isSubType(typeB, type));
         }
-        // Determine if the latter type is a possible concrete type of the former.
         return schema.isSubType(typeA, typeB);
     }
     if (isAbstractType(typeB)) {
-        // Determine if the former type is a possible concrete type of the latter.
         return schema.isSubType(typeB, typeA);
     }
-    // Otherwise the types do not overlap.
     return false;
 }
 //# sourceMappingURL=typeComparators.js.map

package/utilities/typeComparators.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"typeComparators.js","sourceRoot":"","sources":["../../src/utilities/typeComparators.ts"],"names":[],"mappings":"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","sourcesContent":["import type { GraphQLCompositeType, GraphQLType } from '../type/definition.js';\nimport {\n  isAbstractType,\n  isInterfaceType,\n  isListType,\n  isNonNullType,\n  isObjectType,\n} from '../type/definition.js';\nimport type { GraphQLSchema } from '../type/schema.js';\n\n/**\n * Provided two types, return true if the types are equal (invariant).\n */\nexport function isEqualType(typeA: GraphQLType, typeB: GraphQLType): boolean {\n  // Equivalent types are equal.\n  if (typeA === typeB) {\n    return true;\n  }\n\n  // If either type is non-null, the other must also be non-null.\n  if (isNonNullType(typeA) && isNonNullType(typeB)) {\n    return isEqualType(typeA.ofType, typeB.ofType);\n  }\n\n  // If either type is a list, the other must also be a list.\n  if (isListType(typeA) && isListType(typeB)) {\n    return isEqualType(typeA.ofType, typeB.ofType);\n  }\n\n  // Otherwise the types are not equal.\n  return false;\n}\n\n/**\n * Provided a type and a super type, return true if the first type is either\n * equal or a subset of the second super type (covariant).\n */\nexport function isTypeSubTypeOf(\n  schema: GraphQLSchema,\n  maybeSubType: GraphQLType,\n  superType: GraphQLType,\n): boolean {\n  // Equivalent type is a valid subtype\n  if (maybeSubType === superType) {\n    return true;\n  }\n\n  // If superType is non-null, maybeSubType must also be non-null.\n  if (isNonNullType(superType)) {\n    if (isNonNullType(maybeSubType)) {\n      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);\n    }\n    return false;\n  }\n  if (isNonNullType(maybeSubType)) {\n    // If superType is nullable, maybeSubType may be non-null or nullable.\n    return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);\n  }\n\n  // If superType type is a list, maybeSubType type must also be a list.\n  if (isListType(superType)) {\n    if (isListType(maybeSubType)) {\n      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);\n    }\n    return false;\n  }\n  if (isListType(maybeSubType)) {\n    // If superType is not a list, maybeSubType must also be not a list.\n    return false;\n  }\n\n  // If superType type is an abstract type, check if it is super type of maybeSubType.\n  // Otherwise, the child type is not a valid subtype of the parent type.\n  return (\n    isAbstractType(superType) &&\n    (isInterfaceType(maybeSubType) || isObjectType(maybeSubType)) &&\n    schema.isSubType(superType, maybeSubType)\n  );\n}\n\n/**\n * Provided two composite types, determine if they \"overlap\". Two composite\n * types overlap when the Sets of possible concrete types for each intersect.\n *\n * This is often used to determine if a fragment of a given type could possibly\n * be visited in a context of another type.\n *\n * This function is commutative.\n */\nexport function doTypesOverlap(\n  schema: GraphQLSchema,\n  typeA: GraphQLCompositeType,\n  typeB: GraphQLCompositeType,\n): boolean {\n  // Equivalent types overlap\n  if (typeA === typeB) {\n    return true;\n  }\n\n  if (isAbstractType(typeA)) {\n    if (isAbstractType(typeB)) {\n      // If both types are abstract, then determine if there is any intersection\n      // between possible concrete types of each.\n      return schema\n        .getPossibleTypes(typeA)\n        .some((type) => schema.isSubType(typeB, type));\n    }\n    // Determine if the latter type is a possible concrete type of the former.\n    return schema.isSubType(typeA, typeB);\n  }\n\n  if (isAbstractType(typeB)) {\n    // Determine if the former type is a possible concrete type of the latter.\n    return schema.isSubType(typeB, typeA);\n  }\n\n  // Otherwise the types do not overlap.\n  return false;\n}\n"]}
+{"version":3,"file":"typeComparators.js","sourceRoot":"","sources":["../../src/utilities/typeComparators.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,cAAc,EACd,eAAe,EACf,UAAU,EACV,aAAa,EACb,YAAY,GACb,+BAA8B;AAsB/B,MAAM,UAAU,WAAW,CAAC,KAAkB,EAAE,KAAkB;IAEhE,IAAI,KAAK,KAAK,KAAK,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC;IACd,CAAC;IAGD,IAAI,aAAa,CAAC,KAAK,CAAC,IAAI,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QACjD,OAAO,WAAW,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACjD,CAAC;IAGD,IAAI,UAAU,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3C,OAAO,WAAW,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACjD,CAAC;IAGD,OAAO,KAAK,CAAC;AACf,CAAC;AAwCD,MAAM,UAAU,eAAe,CAC7B,MAAqB,EACrB,YAAyB,EACzB,SAAsB;IAGtB,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IAGD,IAAI,aAAa,CAAC,SAAS,CAAC,EAAE,CAAC;QAC7B,IAAI,aAAa,CAAC,YAAY,CAAC,EAAE,CAAC;YAChC,OAAO,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;QACxE,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,aAAa,CAAC,YAAY,CAAC,EAAE,CAAC;QAEhC,OAAO,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACjE,CAAC;IAGD,IAAI,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;QAC1B,IAAI,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;YAC7B,OAAO,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;QACxE,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;QAE7B,OAAO,KAAK,CAAC;IACf,CAAC;IAID,OAAO,CACL,cAAc,CAAC,SAAS,CAAC;QACzB,CAAC,eAAe,CAAC,YAAY,CAAC,IAAI,YAAY,CAAC,YAAY,CAAC,CAAC;QAC7D,MAAM,CAAC,SAAS,CAAC,SAAS,EAAE,YAAY,CAAC,CAC1C,CAAC;AACJ,CAAC;AA4CD,MAAM,UAAU,cAAc,CAC5B,MAAqB,EACrB,KAA2B,EAC3B,KAA2B;IAG3B,IAAI,KAAK,KAAK,KAAK,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,IAAI,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;YAG1B,OAAO,MAAM;iBACV,gBAAgB,CAAC,KAAK,CAAC;iBACvB,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;QACnD,CAAC;QAED,OAAO,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACxC,CAAC;IAED,IAAI,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;QAE1B,OAAO,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACxC,CAAC;IAGD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["/** @category Type Comparisons */\n\nimport type { GraphQLCompositeType, GraphQLType } from '../type/definition.ts';\nimport {\n  isAbstractType,\n  isInterfaceType,\n  isListType,\n  isNonNullType,\n  isObjectType,\n} from '../type/definition.ts';\nimport type { GraphQLSchema } from '../type/schema.ts';\n\n/**\n * Provided two types, return true if the types are equal (invariant).\n * @param typeA - The first GraphQL type to compare.\n * @param typeB - The second GraphQL type to compare.\n * @returns True when both types are equal.\n * @example\n * ```ts\n * import {\n *   GraphQLList,\n *   GraphQLNonNull,\n *   GraphQLString,\n * } from 'graphql/type';\n * import { isEqualType } from 'graphql/utilities';\n *\n * isEqualType(GraphQLString, GraphQLString); // => true\n * isEqualType(new GraphQLList(GraphQLString), new GraphQLList(GraphQLString)); // => true\n * isEqualType(new GraphQLNonNull(GraphQLString), GraphQLString); // => false\n * ```\n */\nexport function isEqualType(typeA: GraphQLType, typeB: GraphQLType): boolean {\n  // Equivalent types are equal.\n  if (typeA === typeB) {\n    return true;\n  }\n\n  // If either type is non-null, the other must also be non-null.\n  if (isNonNullType(typeA) && isNonNullType(typeB)) {\n    return isEqualType(typeA.ofType, typeB.ofType);\n  }\n\n  // If either type is a list, the other must also be a list.\n  if (isListType(typeA) && isListType(typeB)) {\n    return isEqualType(typeA.ofType, typeB.ofType);\n  }\n\n  // Otherwise the types are not equal.\n  return false;\n}\n\n/**\n * Provided a type and a super type, return true if the first type is either\n * equal or a subset of the second super type (covariant).\n * @param schema - GraphQL schema to use.\n * @param maybeSubType - The possible subtype to compare.\n * @param superType - The possible supertype to compare.\n * @returns True when `maybeSubType` is equal to or a subtype of `superType`.\n * @example\n * ```ts\n * import { buildSchema } from 'graphql/utilities';\n * import {\n *   GraphQLNonNull,\n *   assertInterfaceType,\n *   assertObjectType,\n * } from 'graphql/type';\n * import { isTypeSubTypeOf } from 'graphql/utilities';\n *\n * const schema = buildSchema(`\n *   interface Node {\n *     id: ID!\n *   }\n *\n *   type User implements Node {\n *     id: ID!\n *   }\n *\n *   type Query {\n *     node: Node\n *   }\n * `);\n * const Node = assertInterfaceType(schema.getType('Node'));\n * const User = assertObjectType(schema.getType('User'));\n *\n * isTypeSubTypeOf(schema, User, Node); // => true\n * isTypeSubTypeOf(schema, new GraphQLNonNull(User), Node); // => true\n * isTypeSubTypeOf(schema, Node, User); // => false\n * ```\n */\nexport function isTypeSubTypeOf(\n  schema: GraphQLSchema,\n  maybeSubType: GraphQLType,\n  superType: GraphQLType,\n): boolean {\n  // Equivalent type is a valid subtype\n  if (maybeSubType === superType) {\n    return true;\n  }\n\n  // If superType is non-null, maybeSubType must also be non-null.\n  if (isNonNullType(superType)) {\n    if (isNonNullType(maybeSubType)) {\n      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);\n    }\n    return false;\n  }\n  if (isNonNullType(maybeSubType)) {\n    // If superType is nullable, maybeSubType may be non-null or nullable.\n    return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);\n  }\n\n  // If superType type is a list, maybeSubType type must also be a list.\n  if (isListType(superType)) {\n    if (isListType(maybeSubType)) {\n      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);\n    }\n    return false;\n  }\n  if (isListType(maybeSubType)) {\n    // If superType is not a list, maybeSubType must also be not a list.\n    return false;\n  }\n\n  // If superType type is an abstract type, check if it is super type of maybeSubType.\n  // Otherwise, the child type is not a valid subtype of the parent type.\n  return (\n    isAbstractType(superType) &&\n    (isInterfaceType(maybeSubType) || isObjectType(maybeSubType)) &&\n    schema.isSubType(superType, maybeSubType)\n  );\n}\n\n/**\n * Provided two composite types, determine if they \"overlap\". Two composite\n * types overlap when the Sets of possible concrete types for each intersect.\n *\n * This is often used to determine if a fragment of a given type could possibly\n * be visited in a context of another type.\n *\n * This function is commutative.\n * @param schema - GraphQL schema to use.\n * @param typeA - The first GraphQL type to compare.\n * @param typeB - The second GraphQL type to compare.\n * @returns True when the two composite types can apply to at least one common object type.\n * @example\n * ```ts\n * import { buildSchema } from 'graphql/utilities';\n * import { assertObjectType, assertUnionType } from 'graphql/type';\n * import { doTypesOverlap } from 'graphql/utilities';\n *\n * const schema = buildSchema(`\n *   type Photo {\n *     url: String!\n *   }\n *\n *   type Video {\n *     url: String!\n *   }\n *\n *   union Media = Photo | Video\n *   union StillImage = Photo\n *\n *   type Query {\n *     media: [Media]\n *   }\n * `);\n * const Media = assertUnionType(schema.getType('Media'));\n * const StillImage = assertUnionType(schema.getType('StillImage'));\n * const Video = assertObjectType(schema.getType('Video'));\n *\n * doTypesOverlap(schema, Media, StillImage); // => true\n * doTypesOverlap(schema, StillImage, Video); // => false\n * ```\n */\nexport function doTypesOverlap(\n  schema: GraphQLSchema,\n  typeA: GraphQLCompositeType,\n  typeB: GraphQLCompositeType,\n): boolean {\n  // Equivalent types overlap\n  if (typeA === typeB) {\n    return true;\n  }\n\n  if (isAbstractType(typeA)) {\n    if (isAbstractType(typeB)) {\n      // If both types are abstract, then determine if there is any intersection\n      // between possible concrete types of each.\n      return schema\n        .getPossibleTypes(typeA)\n        .some((type) => schema.isSubType(typeB, type));\n    }\n    // Determine if the latter type is a possible concrete type of the former.\n    return schema.isSubType(typeA, typeB);\n  }\n\n  if (isAbstractType(typeB)) {\n    // Determine if the former type is a possible concrete type of the latter.\n    return schema.isSubType(typeB, typeA);\n  }\n\n  // Otherwise the types do not overlap.\n  return false;\n}\n"]}

package/utilities/typeFromAST.d.mts

@@ -1,15 +1,101 @@
-import type { ListTypeNode, NamedTypeNode, NonNullTypeNode, TypeNode } from '../language/ast.js';
-import type { GraphQLNamedType, GraphQLType } from '../type/definition.js';
-import { GraphQLList, GraphQLNonNull } from '../type/definition.js';
-import type { GraphQLSchema } from '../type/schema.js';
+/** @category Values */
+import type { ListTypeNode, NamedTypeNode, NonNullTypeNode, TypeNode } from "../language/ast.mjs";
+import type { GraphQLNamedType, GraphQLType } from "../type/definition.mjs";
+import { GraphQLList, GraphQLNonNull } from "../type/definition.mjs";
+import type { GraphQLSchema } from "../type/schema.mjs";
 /**
  * Given a Schema and an AST node describing a type, return a GraphQLType
  * definition which applies to that type. For example, if provided the parsed
  * AST node for `[User]`, a GraphQLList instance will be returned, containing
  * the type called "User" found in the schema. If a type called "User" is not
  * found in the schema, then undefined will be returned.
+ * @param schema - GraphQL schema to use.
+ * @param typeNode - The GraphQL type AST node to resolve.
+ * @returns The GraphQL type referenced by the AST node, or undefined if it cannot be resolved.
+ * @example
+ * ```ts
+ * import { parseType } from 'graphql/language';
+ * import { buildSchema, typeFromAST } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * typeFromAST(schema, parseType('String'))?.toString(); // => 'String'
+ * typeFromAST(schema, parseType('Missing')); // => undefined
+ * ```
  */
 export declare function typeFromAST(schema: GraphQLSchema, typeNode: NamedTypeNode): GraphQLNamedType | undefined;
+/**
+ * Resolves a list type AST node against a schema.
+ * @param schema - GraphQL schema to use.
+ * @param typeNode - The list type AST node to resolve.
+ * @returns The GraphQL list type referenced by the AST node, or undefined if
+ * it cannot be resolved.
+ * @example
+ * ```ts
+ * import { parseType } from 'graphql/language';
+ * import { buildSchema, typeFromAST } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     tags: [String]
+ *   }
+ * `);
+ *
+ * typeFromAST(schema, parseType('[String]'))?.toString(); // => '[String]'
+ * typeFromAST(schema, parseType('[Missing]')); // => undefined
+ * ```
+ */
 export declare function typeFromAST(schema: GraphQLSchema, typeNode: ListTypeNode): GraphQLList<any> | undefined;
+/**
+ * Resolves a non-null type AST node against a schema.
+ * @param schema - GraphQL schema to use.
+ * @param typeNode - The non-null type AST node to resolve.
+ * @returns The GraphQL non-null type referenced by the AST node, or undefined
+ * if it cannot be resolved.
+ * @example
+ * ```ts
+ * import { parseType } from 'graphql/language';
+ * import { buildSchema, typeFromAST } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String!
+ *   }
+ * `);
+ *
+ * typeFromAST(schema, parseType('String!'))?.toString(); // => 'String!'
+ * typeFromAST(schema, parseType('[String!]!'))?.toString(); // => '[String!]!'
+ * ```
+ */
 export declare function typeFromAST(schema: GraphQLSchema, typeNode: NonNullTypeNode): GraphQLNonNull<any> | undefined;
+/**
+ * Resolves a type AST node against a schema.
+ * @param schema - GraphQL schema to use.
+ * @param typeNode - The GraphQL type AST node to resolve.
+ * @returns The GraphQL type referenced by the AST node, or undefined if it
+ * cannot be resolved.
+ * @example
+ * ```ts
+ * import { parseType } from 'graphql/language';
+ * import { buildSchema, typeFromAST } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type User {
+ *     name: String
+ *   }
+ *
+ *   type Query {
+ *     users: [User!]!
+ *   }
+ * `);
+ *
+ * typeFromAST(schema, parseType('User'))?.toString(); // => 'User'
+ * typeFromAST(schema, parseType('[User!]!'))?.toString(); // => '[User!]!'
+ * typeFromAST(schema, parseType('Missing')); // => undefined
+ * ```
+ */
 export declare function typeFromAST(schema: GraphQLSchema, typeNode: TypeNode): GraphQLType | undefined;