graphql
Version:
A Query Language and Runtime which can target any service.
102 lines (101 loc) • 3.56 kB
TypeScript
/** @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;
/**
* 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.
* @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;