@graphql-tools/merge 6.2.9-alpha-3e5e5d87.0 → 6.2.11

package/es5/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@graphql-tools/merge/es5",
-  "version": "6.2.9-alpha-3e5e5d87.0",
+  "version": "6.2.11",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0"
   },
   "dependencies": {
-    "@graphql-tools/schema": "7.1.4-alpha-3e5e5d87.0",
-    "@graphql-tools/utils": "7.5.0-alpha-3e5e5d87.0",
+    "@graphql-tools/schema": "^7.0.0",
+    "@graphql-tools/utils": "^7.7.0",
     "tslib": "~2.1.0"
   },
   "repository": {

package/es5/typedefs-mergers/comments.d.ts

@@ -1,9 +1,8 @@
-import { StringValueNode, TypeDefinitionNode, ASTNode } from 'graphql';
+import { ASTNode } from 'graphql';
+import { NamedDefinitionNode } from './merge-nodes';
 export declare function resetComments(): void;
-export declare function collectComment(node: TypeDefinitionNode): void;
-export declare function pushComment(node: {
-    readonly description?: StringValueNode;
-}, entity: string, field?: string, argument?: string): void;
+export declare function collectComment(node: NamedDefinitionNode): void;
+export declare function pushComment(node: any, entity: string, field?: string, argument?: string): void;
 export declare function printComment(comment: string): string;
 /**
  * Converts an AST into a string, using one set of reasonable

package/es5/typedefs-mergers/fields.d.ts

@@ -2,4 +2,4 @@ import { Config } from './merge-typedefs';
 import { FieldDefinitionNode, InputValueDefinitionNode, NameNode } from 'graphql';
 export declare function mergeFields<T extends FieldDefinitionNode | InputValueDefinitionNode>(type: {
     name: NameNode;
-}, f1: ReadonlyArray<T>, f2: ReadonlyArray<T>, config: Config): T[];
+}, f1: ReadonlyArray<T>, f2: ReadonlyArray<T>, config?: Config): T[];

package/es5/typedefs-mergers/merge-nodes.d.ts

@@ -1,6 +1,11 @@
 import { Config } from './merge-typedefs';
-import { DefinitionNode } from 'graphql';
-export declare type MergedResultMap = {
-    [name: string]: DefinitionNode;
+import { DefinitionNode, NameNode, SchemaDefinitionNode, SchemaExtensionNode } from 'graphql';
+export declare type MergedResultMap = Record<string, NamedDefinitionNode> & {
+    [schemaDefSymbol]: SchemaDefinitionNode | SchemaExtensionNode;
 };
+export declare type NamedDefinitionNode = DefinitionNode & {
+    name?: NameNode;
+};
+export declare function isNamedDefinitionNode(definitionNode: DefinitionNode): definitionNode is NamedDefinitionNode;
+export declare const schemaDefSymbol: unique symbol;
 export declare function mergeGraphQLNodes(nodes: ReadonlyArray<DefinitionNode>, config?: Config): MergedResultMap;

package/es5/typedefs-mergers/merge-typedefs.d.ts

@@ -1,6 +1,6 @@
 import { DefinitionNode, DocumentNode, GraphQLSchema, Source } from 'graphql';
+import { CompareFn } from './utils';
 declare type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
-declare type CompareFn<T> = (a: T, b: T) => number;
 export interface Config {
     /**
      * Produces `schema { query: ..., mutation: ..., subscription: ... }`
@@ -52,6 +52,7 @@ export interface Config {
     sort?: boolean | CompareFn<string>;
     convertExtensions?: boolean;
     consistentEnumMerge?: boolean;
+    ignoreFieldConflicts?: boolean;
 }
 /**
  * Merges multiple type definitions into a single `DocumentNode`

package/es5/typedefs-mergers/schema-def.d.ts

@@ -0,0 +1,8 @@
+import { SchemaDefinitionNode, SchemaExtensionNode } from 'graphql';
+import { Config } from './merge-typedefs';
+export declare const operationTypeDefinitionNodeTypeRootTypeMap: {
+    readonly query: "Query";
+    readonly mutation: "Mutation";
+    readonly subscription: "Subscription";
+};
+export declare function mergeSchemaDefs(node: SchemaDefinitionNode | SchemaExtensionNode, existingNode: SchemaDefinitionNode | SchemaExtensionNode, config?: Config): SchemaDefinitionNode | SchemaExtensionNode;

package/es5/typedefs-mergers/utils.d.ts

@@ -1,22 +1,15 @@
-import { TypeNode, DefinitionNode, EnumTypeDefinitionNode, NamedTypeNode, ListTypeNode, NonNullTypeNode, ObjectTypeDefinitionNode, Source, UnionTypeDefinitionNode, ScalarTypeDefinitionNode, InputObjectTypeDefinitionNode, InterfaceTypeDefinitionNode, DirectiveDefinitionNode, SchemaDefinitionNode, ObjectTypeExtensionNode, InputObjectTypeExtensionNode, EnumTypeExtensionNode, UnionTypeExtensionNode, ScalarTypeExtensionNode, InterfaceTypeExtensionNode } from 'graphql';
+import { TypeNode, NamedTypeNode, ListTypeNode, NonNullTypeNode, Source } from 'graphql';
 export declare function isStringTypes(types: any): types is string;
 export declare function isSourceTypes(types: any): types is Source;
-export declare function isGraphQLType(definition: DefinitionNode): definition is ObjectTypeDefinitionNode;
-export declare function isGraphQLTypeExtension(definition: DefinitionNode): definition is ObjectTypeExtensionNode;
-export declare function isGraphQLEnum(definition: DefinitionNode): definition is EnumTypeDefinitionNode;
-export declare function isGraphQLEnumExtension(definition: DefinitionNode): definition is EnumTypeExtensionNode;
-export declare function isGraphQLUnion(definition: DefinitionNode): definition is UnionTypeDefinitionNode;
-export declare function isGraphQLUnionExtension(definition: DefinitionNode): definition is UnionTypeExtensionNode;
-export declare function isGraphQLScalar(definition: DefinitionNode): definition is ScalarTypeDefinitionNode;
-export declare function isGraphQLScalarExtension(definition: DefinitionNode): definition is ScalarTypeExtensionNode;
-export declare function isGraphQLInputType(definition: DefinitionNode): definition is InputObjectTypeDefinitionNode;
-export declare function isGraphQLInputTypeExtension(definition: DefinitionNode): definition is InputObjectTypeExtensionNode;
-export declare function isGraphQLInterface(definition: DefinitionNode): definition is InterfaceTypeDefinitionNode;
-export declare function isGraphQLInterfaceExtension(definition: DefinitionNode): definition is InterfaceTypeExtensionNode;
-export declare function isGraphQLDirective(definition: DefinitionNode): definition is DirectiveDefinitionNode;
 export declare function extractType(type: TypeNode): NamedTypeNode;
-export declare function isSchemaDefinition(node: DefinitionNode): node is SchemaDefinitionNode;
 export declare function isWrappingTypeNode(type: TypeNode): type is ListTypeNode | NonNullTypeNode;
 export declare function isListTypeNode(type: TypeNode): type is ListTypeNode;
 export declare function isNonNullTypeNode(type: TypeNode): type is NonNullTypeNode;
 export declare function printTypeNode(type: TypeNode): string;
+export declare enum CompareVal {
+    A_SMALLER_THAN_B = -1,
+    A_EQUALS_B = 0,
+    A_GREATER_THAN_B = 1
+}
+export declare type CompareFn<T> = (a: T, b: T) => -1 | 0 | 1;
+export declare function defaultStringComparator(a: string, b: string): CompareVal;

package/index.cjs.js

@@ -416,55 +416,13 @@ function isStringTypes(types) {
 function isSourceTypes(types) {
     return types instanceof graphql.Source;
 }
-function isGraphQLType(definition) {
-    return definition.kind === 'ObjectTypeDefinition';
-}
-function isGraphQLTypeExtension(definition) {
-    return definition.kind === 'ObjectTypeExtension';
-}
-function isGraphQLEnum(definition) {
-    return definition.kind === 'EnumTypeDefinition';
-}
-function isGraphQLEnumExtension(definition) {
-    return definition.kind === 'EnumTypeExtension';
-}
-function isGraphQLUnion(definition) {
-    return definition.kind === 'UnionTypeDefinition';
-}
-function isGraphQLUnionExtension(definition) {
-    return definition.kind === 'UnionTypeExtension';
-}
-function isGraphQLScalar(definition) {
-    return definition.kind === 'ScalarTypeDefinition';
-}
-function isGraphQLScalarExtension(definition) {
-    return definition.kind === 'ScalarTypeExtension';
-}
-function isGraphQLInputType(definition) {
-    return definition.kind === 'InputObjectTypeDefinition';
-}
-function isGraphQLInputTypeExtension(definition) {
-    return definition.kind === 'InputObjectTypeExtension';
-}
-function isGraphQLInterface(definition) {
-    return definition.kind === 'InterfaceTypeDefinition';
-}
-function isGraphQLInterfaceExtension(definition) {
-    return definition.kind === 'InterfaceTypeExtension';
-}
-function isGraphQLDirective(definition) {
-    return definition.kind === 'DirectiveDefinition';
-}
 function extractType(type) {
     let visitedType = type;
-    while (visitedType.kind === 'ListType' || visitedType.kind === 'NonNullType') {
+    while (visitedType.kind === graphql.Kind.LIST_TYPE || visitedType.kind === 'NonNullType') {
         visitedType = visitedType.type;
     }
     return visitedType;
 }
-function isSchemaDefinition(node) {
-    return node.kind === 'SchemaDefinition';
-}
 function isWrappingTypeNode(type) {
     return type.kind !== graphql.Kind.NAMED_TYPE;
 }
@@ -483,10 +441,22 @@ function printTypeNode(type) {
     }
     return type.name.value;
 }
+(function (CompareVal) {
+    CompareVal[CompareVal["A_SMALLER_THAN_B"] = -1] = "A_SMALLER_THAN_B";
+    CompareVal[CompareVal["A_EQUALS_B"] = 0] = "A_EQUALS_B";
+    CompareVal[CompareVal["A_GREATER_THAN_B"] = 1] = "A_GREATER_THAN_B";
+})(exports.CompareVal || (exports.CompareVal = {}));
+function defaultStringComparator(a, b) {
+    if (a < b)
+        return exports.CompareVal.A_SMALLER_THAN_B;
+    if (a > b)
+        return exports.CompareVal.A_GREATER_THAN_B;
+    return exports.CompareVal.A_EQUALS_B;
+}
 
-function fieldAlreadyExists(fieldsArr, otherField) {
+function fieldAlreadyExists(fieldsArr, otherField, config) {
     const result = fieldsArr.find(field => field.name.value === otherField.name.value);
-    if (result) {
+    if (result && !(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) {
         const t1 = extractType(result.type);
         const t2 = extractType(otherField.type);
         if (t1.name.value !== t2.name.value) {
@@ -498,16 +468,18 @@ function fieldAlreadyExists(fieldsArr, otherField) {
 function mergeFields(type, f1, f2, config) {
     const result = [...f2];
     for (const field of f1) {
-        if (fieldAlreadyExists(result, field)) {
+        if (fieldAlreadyExists(result, field, config)) {
             const existing = result.find((f) => f.name.value === field.name.value);
-            if (config && config.throwOnConflict) {
-                preventConflicts(type, existing, field, false);
-            }
-            else {
-                preventConflicts(type, existing, field, true);
-            }
-            if (isNonNullTypeNode(field.type) && !isNonNullTypeNode(existing.type)) {
-                existing.type = field.type;
+            if (!(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) {
+                if (config === null || config === void 0 ? void 0 : config.throwOnConflict) {
+                    preventConflicts(type, existing, field, false);
+                }
+                else {
+                    preventConflicts(type, existing, field, true);
+                }
+                if (isNonNullTypeNode(field.type) && !isNonNullTypeNode(existing.type)) {
+                    existing.type = field.type;
+                }
             }
             existing.arguments = mergeArguments(field['arguments'] || [], existing.arguments || [], config);
             existing.directives = mergeDirectives(field.directives, existing.directives, config);
@@ -697,43 +669,95 @@ function mergeUnion(first, second, config) {
         : first;
 }
 
+const operationTypeDefinitionNodeTypeRootTypeMap = {
+    query: 'Query',
+    mutation: 'Mutation',
+    subscription: 'Subscription',
+};
+function mergeOperationTypes(opNodeList = [], existingOpNodeList = []) {
+    const finalOpNodeList = [];
+    for (const opNodeType in operationTypeDefinitionNodeTypeRootTypeMap) {
+        const opNode = opNodeList.find(n => n.operation === opNodeType) || existingOpNodeList.find(n => n.operation === opNodeType);
+        if (opNode) {
+            finalOpNodeList.push(opNode);
+        }
+    }
+    return finalOpNodeList;
+}
+function mergeSchemaDefs(node, existingNode, config) {
+    if (existingNode) {
+        return {
+            kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) ||
+                node.kind === graphql.Kind.SCHEMA_DEFINITION ||
+                existingNode.kind === graphql.Kind.SCHEMA_DEFINITION
+                ? graphql.Kind.SCHEMA_DEFINITION
+                : graphql.Kind.SCHEMA_EXTENSION,
+            description: node['description'] || existingNode['description'],
+            directives: mergeDirectives(node.directives, existingNode.directives, config),
+            operationTypes: mergeOperationTypes(node.operationTypes, existingNode.operationTypes),
+        };
+    }
+    return ((config === null || config === void 0 ? void 0 : config.convertExtensions)
+        ? {
+            ...node,
+            kind: graphql.Kind.SCHEMA_EXTENSION,
+        }
+        : node);
+}
+
+function isNamedDefinitionNode(definitionNode) {
+    return 'name' in definitionNode;
+}
+const schemaDefSymbol = Symbol('schemaDefSymbol');
 function mergeGraphQLNodes(nodes, config) {
-    return nodes.reduce((prev, nodeDefinition) => {
-        const node = nodeDefinition;
-        if (node && node.name && node.name.value) {
-            const name = node.name.value;
-            if (config && config.commentDescriptions) {
-                collectComment(node);
+    var _a, _b;
+    const mergedResultMap = {};
+    for (const nodeDefinition of nodes) {
+        if (isNamedDefinitionNode(nodeDefinition)) {
+            const name = nodeDefinition.name.value;
+            if (config === null || config === void 0 ? void 0 : config.commentDescriptions) {
+                collectComment(nodeDefinition);
             }
-            if (config &&
-                config.exclusions &&
-                (config.exclusions.includes(name + '.*') || config.exclusions.includes(name))) {
-                delete prev[name];
+            if (((_a = config === null || config === void 0 ? void 0 : config.exclusions) === null || _a === void 0 ? void 0 : _a.includes(name + '.*')) || ((_b = config === null || config === void 0 ? void 0 : config.exclusions) === null || _b === void 0 ? void 0 : _b.includes(name))) {
+                delete mergedResultMap[name];
             }
-            else if (isGraphQLType(nodeDefinition) || isGraphQLTypeExtension(nodeDefinition)) {
-                prev[name] = mergeType(nodeDefinition, prev[name], config);
-            }
-            else if (isGraphQLEnum(nodeDefinition) || isGraphQLEnumExtension(nodeDefinition)) {
-                prev[name] = mergeEnum(nodeDefinition, prev[name], config);
-            }
-            else if (isGraphQLUnion(nodeDefinition) || isGraphQLUnionExtension(nodeDefinition)) {
-                prev[name] = mergeUnion(nodeDefinition, prev[name], config);
-            }
-            else if (isGraphQLScalar(nodeDefinition) || isGraphQLScalarExtension(nodeDefinition)) {
-                prev[name] = mergeScalar(nodeDefinition, prev[name], config);
-            }
-            else if (isGraphQLInputType(nodeDefinition) || isGraphQLInputTypeExtension(nodeDefinition)) {
-                prev[name] = mergeInputType(nodeDefinition, prev[name], config);
-            }
-            else if (isGraphQLInterface(nodeDefinition) || isGraphQLInterfaceExtension(nodeDefinition)) {
-                prev[name] = mergeInterface(nodeDefinition, prev[name], config);
-            }
-            else if (isGraphQLDirective(nodeDefinition)) {
-                prev[name] = mergeDirective(nodeDefinition, prev[name]);
+            else {
+                switch (nodeDefinition.kind) {
+                    case graphql.Kind.OBJECT_TYPE_DEFINITION:
+                    case graphql.Kind.OBJECT_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeType(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case graphql.Kind.ENUM_TYPE_DEFINITION:
+                    case graphql.Kind.ENUM_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeEnum(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case graphql.Kind.UNION_TYPE_DEFINITION:
+                    case graphql.Kind.UNION_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeUnion(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case graphql.Kind.SCALAR_TYPE_DEFINITION:
+                    case graphql.Kind.SCALAR_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeScalar(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                    case graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeInputType(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case graphql.Kind.INTERFACE_TYPE_DEFINITION:
+                    case graphql.Kind.INTERFACE_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeInterface(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case graphql.Kind.DIRECTIVE_DEFINITION:
+                        mergedResultMap[name] = mergeDirective(nodeDefinition, mergedResultMap[name]);
+                        break;
+                }
             }
         }
-        return prev;
-    }, {});
+        else if (nodeDefinition.kind === graphql.Kind.SCHEMA_DEFINITION || nodeDefinition.kind === graphql.Kind.SCHEMA_EXTENSION) {
+            mergedResultMap[schemaDefSymbol] = mergeSchemaDefs(nodeDefinition, mergedResultMap[schemaDefSymbol], config);
+        }
+    }
+    return mergedResultMap;
 }
 
 function mergeTypeDefs(types, config) {
@@ -758,58 +782,86 @@ function mergeTypeDefs(types, config) {
     resetComments();
     return result;
 }
+function visitTypeSources(types, allNodes) {
+    for (const type of types) {
+        if (type) {
+            if (Array.isArray(type)) {
+                visitTypeSources(types, allNodes);
+            }
+            else if (graphql.isSchema(type)) {
+                const documentNode = utils.getDocumentNodeFromSchema(type);
+                visitTypeSources(documentNode.definitions, allNodes);
+            }
+            else if (isStringTypes(type) || isSourceTypes(type)) {
+                const documentNode = graphql.parse(type);
+                visitTypeSources(documentNode.definitions, allNodes);
+            }
+            else if (graphql.isDefinitionNode(type)) {
+                allNodes.push(type);
+            }
+            else {
+                visitTypeSources(type.definitions, allNodes);
+            }
+        }
+    }
+}
 function mergeGraphQLTypes(types, config) {
+    var _a, _b;
     resetComments();
-    const allNodes = types
-        .map(type => {
-        if (Array.isArray(type)) {
-            type = mergeTypeDefs(type);
-        }
-        if (graphql.isSchema(type)) {
-            return utils.getDocumentNodeFromSchema(type);
-        }
-        else if (isStringTypes(type) || isSourceTypes(type)) {
-            return graphql.parse(type);
-        }
-        return type;
-    })
-        .map(ast => ast.definitions)
-        .reduce((defs, newDef = []) => [...defs, ...newDef], []);
-    // XXX: right now we don't handle multiple schema definitions
-    let schemaDef = allNodes.filter(isSchemaDefinition).reduce((def, node) => {
-        node.operationTypes
-            .filter(op => op.type.name.value)
-            .forEach(op => {
-            def[op.operation] = op.type.name.value;
-        });
-        return def;
-    }, {
-        query: null,
-        mutation: null,
-        subscription: null,
-    });
+    const allNodes = [];
+    visitTypeSources(types, allNodes);
     const mergedNodes = mergeGraphQLNodes(allNodes, config);
-    const allTypes = Object.keys(mergedNodes);
-    if (config && config.sort) {
-        allTypes.sort(typeof config.sort === 'function' ? config.sort : undefined);
+    // XXX: right now we don't handle multiple schema definitions
+    let schemaDef = mergedNodes[schemaDefSymbol] || {
+        kind: graphql.Kind.SCHEMA_DEFINITION,
+        operationTypes: [],
+    };
+    if (config === null || config === void 0 ? void 0 : config.useSchemaDefinition) {
+        const operationTypes = schemaDef.operationTypes;
+        for (const opTypeDefNodeType in operationTypeDefinitionNodeTypeRootTypeMap) {
+            const opTypeDefNode = operationTypes.find(operationType => operationType.operation === opTypeDefNodeType);
+            if (!opTypeDefNode) {
+                const existingPossibleRootType = mergedNodes[operationTypeDefinitionNodeTypeRootTypeMap[opTypeDefNodeType]];
+                if (existingPossibleRootType) {
+                    operationTypes.push({
+                        kind: graphql.Kind.OPERATION_TYPE_DEFINITION,
+                        type: {
+                            kind: graphql.Kind.NAMED_TYPE,
+                            name: existingPossibleRootType.name,
+                        },
+                        operation: opTypeDefNodeType,
+                    });
+                }
+            }
+        }
     }
-    if (config && config.useSchemaDefinition) {
-        const queryType = schemaDef.query ? schemaDef.query : allTypes.find(t => t === 'Query');
-        const mutationType = schemaDef.mutation ? schemaDef.mutation : allTypes.find(t => t === 'Mutation');
-        const subscriptionType = schemaDef.subscription ? schemaDef.subscription : allTypes.find(t => t === 'Subscription');
+    if ((config === null || config === void 0 ? void 0 : config.forceSchemaDefinition) && !((_a = schemaDef === null || schemaDef === void 0 ? void 0 : schemaDef.operationTypes) === null || _a === void 0 ? void 0 : _a.length)) {
         schemaDef = {
-            query: queryType,
-            mutation: mutationType,
-            subscription: subscriptionType,
+            kind: graphql.Kind.SCHEMA_DEFINITION,
+            operationTypes: [
+                {
+                    kind: graphql.Kind.OPERATION_TYPE_DEFINITION,
+                    operation: 'query',
+                    type: {
+                        kind: graphql.Kind.NAMED_TYPE,
+                        name: {
+                            kind: graphql.Kind.NAME,
+                            value: 'Query',
+                        },
+                    },
+                },
+            ],
         };
     }
-    const schemaDefinition = utils.createSchemaDefinition(schemaDef, {
-        force: config.forceSchemaDefinition,
-    });
-    if (!schemaDefinition) {
-        return Object.values(mergedNodes);
+    const mergedNodeDefinitions = Object.values(mergedNodes);
+    if ((_b = schemaDef.operationTypes) === null || _b === void 0 ? void 0 : _b.length) {
+        mergedNodeDefinitions.push(schemaDef);
+    }
+    if (config === null || config === void 0 ? void 0 : config.sort) {
+        const sortFn = typeof config.sort === 'function' ? config.sort : defaultStringComparator;
+        mergedNodeDefinitions.sort((a, b) => { var _a, _b; return sortFn((_a = a.name) === null || _a === void 0 ? void 0 : _a.value, (_b = b.name) === null || _b === void 0 ? void 0 : _b.value); });
     }
-    return [...Object.values(mergedNodes), graphql.parse(schemaDefinition).definitions[0]];
+    return mergedNodeDefinitions;
 }
 
 function travelSchemaPossibleExtensions(schema, hooks) {
@@ -1006,24 +1058,12 @@ function makeSchema({ resolvers, typeDefs, extensions, }, config) {
 
 exports.applyExtensions = applyExtensions;
 exports.collectComment = collectComment;
+exports.defaultStringComparator = defaultStringComparator;
 exports.extractExtensionsFromSchema = extractExtensionsFromSchema;
 exports.extractType = extractType;
-exports.isGraphQLDirective = isGraphQLDirective;
-exports.isGraphQLEnum = isGraphQLEnum;
-exports.isGraphQLEnumExtension = isGraphQLEnumExtension;
-exports.isGraphQLInputType = isGraphQLInputType;
-exports.isGraphQLInputTypeExtension = isGraphQLInputTypeExtension;
-exports.isGraphQLInterface = isGraphQLInterface;
-exports.isGraphQLInterfaceExtension = isGraphQLInterfaceExtension;
-exports.isGraphQLScalar = isGraphQLScalar;
-exports.isGraphQLScalarExtension = isGraphQLScalarExtension;
-exports.isGraphQLType = isGraphQLType;
-exports.isGraphQLTypeExtension = isGraphQLTypeExtension;
-exports.isGraphQLUnion = isGraphQLUnion;
-exports.isGraphQLUnionExtension = isGraphQLUnionExtension;
 exports.isListTypeNode = isListTypeNode;
+exports.isNamedDefinitionNode = isNamedDefinitionNode;
 exports.isNonNullTypeNode = isNonNullTypeNode;
-exports.isSchemaDefinition = isSchemaDefinition;
 exports.isSourceTypes = isSourceTypes;
 exports.isStringTypes = isStringTypes;
 exports.isWrappingTypeNode = isWrappingTypeNode;
@@ -1051,5 +1091,6 @@ exports.printTypeNode = printTypeNode;
 exports.printWithComments = printWithComments;
 exports.pushComment = pushComment;
 exports.resetComments = resetComments;
+exports.schemaDefSymbol = schemaDefSymbol;
 exports.travelSchemaPossibleExtensions = travelSchemaPossibleExtensions;
 //# sourceMappingURL=index.cjs.js.map