@graphql-tools/utils 8.2.1 → 8.2.5

package/comments.d.ts

@@ -17,8 +17,10 @@ export declare function getDescription(node: {
 }, options?: {
     commentDescriptions?: boolean;
 }): string | undefined;
+export declare function getComment(node: {
+    loc?: Location;
+}): undefined | string;
 export declare function getLeadingCommentBlock(node: {
-    description?: StringValueNode;
     loc?: Location;
 }): void | string;
 export declare function dedentBlockStringValue(rawString: string): string;

package/implementsAbstractType.d.ts

@@ -1,3 +1,3 @@
 import { GraphQLType, GraphQLSchema } from 'graphql';
-import { Maybe } from '@graphql-tools/utils';
+import { Maybe } from './types';
 export declare function implementsAbstractType(schema: GraphQLSchema, typeA: Maybe<GraphQLType>, typeB: Maybe<GraphQLType>): boolean;

package/index.js

@@ -1324,7 +1324,7 @@ function collectComment(node) {
     }
 }
 function pushComment(node, entity, field, argument) {
-    const comment = getDescription(node, { commentDescriptions: true });
+    const comment = getComment(node);
     if (typeof comment !== 'string' || comment.length === 0) {
         return;
     }
@@ -1460,7 +1460,12 @@ const printDocASTReducer = {
     IntValue: { leave: ({ value }) => value },
     FloatValue: { leave: ({ value }) => value },
     StringValue: {
-        leave: ({ value, block: isBlockString }) => (isBlockString ? printBlockString(value) : JSON.stringify(value)),
+        leave: ({ value, block: isBlockString }) => {
+            if (isBlockString) {
+                return printBlockString(value);
+            }
+            return JSON.stringify(value);
+        },
     },
     BooleanValue: { leave: ({ value }) => (value ? 'true' : 'false') },
     NullValue: { leave: () => 'null' },
@@ -1478,21 +1483,19 @@ const printDocASTReducer = {
     NonNullType: { leave: ({ type }) => type + '!' },
     // Type System Definitions
     SchemaDefinition: {
-        leave: ({ description, directives, operationTypes }) => wrap('', description, '\n') + join(['schema', join(directives, ' '), block(operationTypes)], ' '),
+        leave: ({ directives, operationTypes }) => join(['schema', join(directives, ' '), block(operationTypes)], ' '),
     },
     OperationTypeDefinition: {
         leave: ({ operation, type }) => operation + ': ' + type,
     },
     ScalarTypeDefinition: {
-        leave: ({ description, name, directives }) => wrap('', description, '\n') + join(['scalar', name, join(directives, ' ')], ' '),
+        leave: ({ name, directives }) => join(['scalar', name, join(directives, ' ')], ' '),
     },
     ObjectTypeDefinition: {
-        leave: ({ description, name, interfaces, directives, fields }) => wrap('', description, '\n') +
-            join(['type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
+        leave: ({ name, interfaces, directives, fields }) => join(['type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
     },
     FieldDefinition: {
-        leave: ({ description, name, arguments: args, type, directives }) => wrap('', description, '\n') +
-            name +
+        leave: ({ name, arguments: args, type, directives }) => name +
             (hasMultilineItems(args)
                 ? wrap('(\n', indent(join(args, '\n')), '\n)')
                 : wrap('(', join(args, ', '), ')')) +
@@ -1501,27 +1504,25 @@ const printDocASTReducer = {
             wrap(' ', join(directives, ' ')),
     },
     InputValueDefinition: {
-        leave: ({ description, name, type, defaultValue, directives }) => wrap('', description, '\n') + join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' '),
+        leave: ({ name, type, defaultValue, directives }) => join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' '),
     },
     InterfaceTypeDefinition: {
-        leave: ({ description, name, interfaces, directives, fields }) => wrap('', description, '\n') +
-            join(['interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
+        leave: ({ name, interfaces, directives, fields }) => join(['interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
     },
     UnionTypeDefinition: {
-        leave: ({ description, name, directives, types }) => wrap('', description, '\n') + join(['union', name, join(directives, ' '), wrap('= ', join(types, ' | '))], ' '),
+        leave: ({ name, directives, types }) => join(['union', name, join(directives, ' '), wrap('= ', join(types, ' | '))], ' '),
     },
     EnumTypeDefinition: {
-        leave: ({ description, name, directives, values }) => wrap('', description, '\n') + join(['enum', name, join(directives, ' '), block(values)], ' '),
+        leave: ({ name, directives, values }) => join(['enum', name, join(directives, ' '), block(values)], ' '),
     },
     EnumValueDefinition: {
-        leave: ({ description, name, directives }) => wrap('', description, '\n') + join([name, join(directives, ' ')], ' '),
+        leave: ({ name, directives }) => join([name, join(directives, ' ')], ' '),
     },
     InputObjectTypeDefinition: {
-        leave: ({ description, name, directives, fields }) => wrap('', description, '\n') + join(['input', name, join(directives, ' '), block(fields)], ' '),
+        leave: ({ name, directives, fields }) => join(['input', name, join(directives, ' '), block(fields)], ' '),
     },
     DirectiveDefinition: {
-        leave: ({ description, name, arguments: args, repeatable, locations }) => wrap('', description, '\n') +
-            'directive @' +
+        leave: ({ name, arguments: args, repeatable, locations }) => 'directive @' +
             name +
             (hasMultilineItems(args)
                 ? wrap('(\n', indent(join(args, '\n')), '\n)')
@@ -1574,10 +1575,13 @@ function getDescription(node, options) {
         return node.description.value;
     }
     if (options === null || options === void 0 ? void 0 : options.commentDescriptions) {
-        const rawValue = getLeadingCommentBlock(node);
-        if (rawValue !== undefined) {
-            return dedentBlockStringValue(`\n${rawValue}`);
-        }
+        return getComment(node);
+    }
+}
+function getComment(node) {
+    const rawValue = getLeadingCommentBlock(node);
+    if (rawValue !== undefined) {
+        return dedentBlockStringValue(`\n${rawValue}`);
     }
 }
 function getLeadingCommentBlock(node) {
@@ -3926,7 +3930,9 @@ function visitData(data, enter, leave) {
         if (newData != null) {
             for (const key in newData) {
                 const value = newData[key];
-                newData[key] = visitData(value, enter, leave);
+                Object.defineProperty(newData, key, {
+                    value: visitData(value, enter, leave),
+                });
             }
         }
         return leave != null ? leave(newData) : newData;
@@ -4211,6 +4217,7 @@ exports.forEachField = forEachField;
 exports.getArgumentValues = getArgumentValues;
 exports.getBlockStringIndentation = getBlockStringIndentation;
 exports.getBuiltInForStub = getBuiltInForStub;
+exports.getComment = getComment;
 exports.getDefinedRootType = getDefinedRootType;
 exports.getDeprecatableDirectiveNodes = getDeprecatableDirectiveNodes;
 exports.getDescription = getDescription;

package/index.mjs

@@ -1320,7 +1320,7 @@ function collectComment(node) {
     }
 }
 function pushComment(node, entity, field, argument) {
-    const comment = getDescription(node, { commentDescriptions: true });
+    const comment = getComment(node);
     if (typeof comment !== 'string' || comment.length === 0) {
         return;
     }
@@ -1456,7 +1456,12 @@ const printDocASTReducer = {
     IntValue: { leave: ({ value }) => value },
     FloatValue: { leave: ({ value }) => value },
     StringValue: {
-        leave: ({ value, block: isBlockString }) => (isBlockString ? printBlockString(value) : JSON.stringify(value)),
+        leave: ({ value, block: isBlockString }) => {
+            if (isBlockString) {
+                return printBlockString(value);
+            }
+            return JSON.stringify(value);
+        },
     },
     BooleanValue: { leave: ({ value }) => (value ? 'true' : 'false') },
     NullValue: { leave: () => 'null' },
@@ -1474,21 +1479,19 @@ const printDocASTReducer = {
     NonNullType: { leave: ({ type }) => type + '!' },
     // Type System Definitions
     SchemaDefinition: {
-        leave: ({ description, directives, operationTypes }) => wrap('', description, '\n') + join(['schema', join(directives, ' '), block(operationTypes)], ' '),
+        leave: ({ directives, operationTypes }) => join(['schema', join(directives, ' '), block(operationTypes)], ' '),
     },
     OperationTypeDefinition: {
         leave: ({ operation, type }) => operation + ': ' + type,
     },
     ScalarTypeDefinition: {
-        leave: ({ description, name, directives }) => wrap('', description, '\n') + join(['scalar', name, join(directives, ' ')], ' '),
+        leave: ({ name, directives }) => join(['scalar', name, join(directives, ' ')], ' '),
     },
     ObjectTypeDefinition: {
-        leave: ({ description, name, interfaces, directives, fields }) => wrap('', description, '\n') +
-            join(['type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
+        leave: ({ name, interfaces, directives, fields }) => join(['type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
     },
     FieldDefinition: {
-        leave: ({ description, name, arguments: args, type, directives }) => wrap('', description, '\n') +
-            name +
+        leave: ({ name, arguments: args, type, directives }) => name +
             (hasMultilineItems(args)
                 ? wrap('(\n', indent(join(args, '\n')), '\n)')
                 : wrap('(', join(args, ', '), ')')) +
@@ -1497,27 +1500,25 @@ const printDocASTReducer = {
             wrap(' ', join(directives, ' ')),
     },
     InputValueDefinition: {
-        leave: ({ description, name, type, defaultValue, directives }) => wrap('', description, '\n') + join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' '),
+        leave: ({ name, type, defaultValue, directives }) => join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' '),
     },
     InterfaceTypeDefinition: {
-        leave: ({ description, name, interfaces, directives, fields }) => wrap('', description, '\n') +
-            join(['interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
+        leave: ({ name, interfaces, directives, fields }) => join(['interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
     },
     UnionTypeDefinition: {
-        leave: ({ description, name, directives, types }) => wrap('', description, '\n') + join(['union', name, join(directives, ' '), wrap('= ', join(types, ' | '))], ' '),
+        leave: ({ name, directives, types }) => join(['union', name, join(directives, ' '), wrap('= ', join(types, ' | '))], ' '),
     },
     EnumTypeDefinition: {
-        leave: ({ description, name, directives, values }) => wrap('', description, '\n') + join(['enum', name, join(directives, ' '), block(values)], ' '),
+        leave: ({ name, directives, values }) => join(['enum', name, join(directives, ' '), block(values)], ' '),
     },
     EnumValueDefinition: {
-        leave: ({ description, name, directives }) => wrap('', description, '\n') + join([name, join(directives, ' ')], ' '),
+        leave: ({ name, directives }) => join([name, join(directives, ' ')], ' '),
     },
     InputObjectTypeDefinition: {
-        leave: ({ description, name, directives, fields }) => wrap('', description, '\n') + join(['input', name, join(directives, ' '), block(fields)], ' '),
+        leave: ({ name, directives, fields }) => join(['input', name, join(directives, ' '), block(fields)], ' '),
     },
     DirectiveDefinition: {
-        leave: ({ description, name, arguments: args, repeatable, locations }) => wrap('', description, '\n') +
-            'directive @' +
+        leave: ({ name, arguments: args, repeatable, locations }) => 'directive @' +
             name +
             (hasMultilineItems(args)
                 ? wrap('(\n', indent(join(args, '\n')), '\n)')
@@ -1570,10 +1571,13 @@ function getDescription(node, options) {
         return node.description.value;
     }
     if (options === null || options === void 0 ? void 0 : options.commentDescriptions) {
-        const rawValue = getLeadingCommentBlock(node);
-        if (rawValue !== undefined) {
-            return dedentBlockStringValue(`\n${rawValue}`);
-        }
+        return getComment(node);
+    }
+}
+function getComment(node) {
+    const rawValue = getLeadingCommentBlock(node);
+    if (rawValue !== undefined) {
+        return dedentBlockStringValue(`\n${rawValue}`);
     }
 }
 function getLeadingCommentBlock(node) {
@@ -3923,7 +3927,9 @@ function visitData(data, enter, leave) {
         if (newData != null) {
             for (const key in newData) {
                 const value = newData[key];
-                newData[key] = visitData(value, enter, leave);
+                Object.defineProperty(newData, key, {
+                    value: visitData(value, enter, leave),
+                });
             }
         }
         return leave != null ? leave(newData) : newData;
@@ -4172,4 +4178,4 @@ function fixSchemaAst(schema, options) {
     return schema;
 }
 
-export { AggregateErrorImpl as AggregateError, MapperKind, addTypes, appendObjectFields, asArray, assertSome, astFromArg, astFromDirective, astFromEnumType, astFromEnumValue, astFromField, astFromInputField, astFromInputObjectType, astFromInterfaceType, astFromObjectType, astFromScalarType, astFromSchema, astFromUnionType, astFromValueUntyped, buildOperationNodeForField, checkValidationErrors, collectComment, collectFields, collectSubFields, compareNodes, compareStrings, correctASTNodes, createNamedStub, createStub, createVariableNameGenerator, dedentBlockStringValue, filterSchema, fixSchemaAst, forEachDefaultValue, forEachField, getArgumentValues, getBlockStringIndentation, getBuiltInForStub, getDefinedRootType, getDeprecatableDirectiveNodes, getDescription, getDirective, getDirectiveInExtensions, getDirectiveNodes, getDirectives, getDirectivesInExtensions, getDocumentNodeFromSchema, getFieldsWithDirectives, getImplementingTypes, getLeadingCommentBlock, getResolversFromSchema, getResponseKeyFromInfo, getRootTypeMap, getRootTypeNames, getRootTypes, healSchema, healTypes, implementsAbstractType, inspect, isAsyncIterable, isDescribable, isDocumentNode, isDocumentString, isNamedStub, isSome, isValidPath, makeDeprecatedDirective, makeDirectiveNode, makeDirectiveNodes, mapAsyncIterator, mapSchema, memoize1, memoize2, memoize2of4, memoize3, memoize4, memoize5, mergeDeep, modifyObjectFields, nodeToString, observableToAsyncIterable, parseGraphQLJSON, parseGraphQLSDL, parseInputValue, parseInputValueLiteral, parseSelectionSet, printComment, printSchemaWithDirectives, printWithComments, pruneSchema, pushComment, relocatedError, removeObjectFields, renameType, resetComments, rewireTypes, selectObjectFields, serializeInputValue, transformCommentsToDescriptions, transformInputValue, updateArgument, validateGraphQlDocuments, valueMatchesCriteria, visitData, visitErrors, visitResult, withCancel };
+export { AggregateErrorImpl as AggregateError, MapperKind, addTypes, appendObjectFields, asArray, assertSome, astFromArg, astFromDirective, astFromEnumType, astFromEnumValue, astFromField, astFromInputField, astFromInputObjectType, astFromInterfaceType, astFromObjectType, astFromScalarType, astFromSchema, astFromUnionType, astFromValueUntyped, buildOperationNodeForField, checkValidationErrors, collectComment, collectFields, collectSubFields, compareNodes, compareStrings, correctASTNodes, createNamedStub, createStub, createVariableNameGenerator, dedentBlockStringValue, filterSchema, fixSchemaAst, forEachDefaultValue, forEachField, getArgumentValues, getBlockStringIndentation, getBuiltInForStub, getComment, getDefinedRootType, getDeprecatableDirectiveNodes, getDescription, getDirective, getDirectiveInExtensions, getDirectiveNodes, getDirectives, getDirectivesInExtensions, getDocumentNodeFromSchema, getFieldsWithDirectives, getImplementingTypes, getLeadingCommentBlock, getResolversFromSchema, getResponseKeyFromInfo, getRootTypeMap, getRootTypeNames, getRootTypes, healSchema, healTypes, implementsAbstractType, inspect, isAsyncIterable, isDescribable, isDocumentNode, isDocumentString, isNamedStub, isSome, isValidPath, makeDeprecatedDirective, makeDirectiveNode, makeDirectiveNodes, mapAsyncIterator, mapSchema, memoize1, memoize2, memoize2of4, memoize3, memoize4, memoize5, mergeDeep, modifyObjectFields, nodeToString, observableToAsyncIterable, parseGraphQLJSON, parseGraphQLSDL, parseInputValue, parseInputValueLiteral, parseSelectionSet, printComment, printSchemaWithDirectives, printWithComments, pruneSchema, pushComment, relocatedError, removeObjectFields, renameType, resetComments, rewireTypes, selectObjectFields, serializeInputValue, transformCommentsToDescriptions, transformInputValue, updateArgument, validateGraphQlDocuments, valueMatchesCriteria, visitData, visitErrors, visitResult, withCancel };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/utils",
-  "version": "8.2.1",
+  "version": "8.2.5",
   "description": "Common package containing utils and types for GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {

package/es5/AggregateError.d.ts

@@ -1,10 +0,0 @@
-interface AggregateError extends Error {
-    errors: any[];
-}
-interface AggregateErrorConstructor {
-    new (errors: Iterable<any>, message?: string): AggregateError;
-    (errors: Iterable<any>, message?: string): AggregateError;
-    readonly prototype: AggregateError;
-}
-declare let AggregateErrorImpl: AggregateErrorConstructor;
-export { AggregateErrorImpl as AggregateError };

package/es5/Interfaces.d.ts

@@ -1,242 +0,0 @@
-import { GraphQLSchema, GraphQLField, GraphQLInputType, GraphQLNamedType, GraphQLResolveInfo, GraphQLScalarType, DocumentNode, FieldNode, GraphQLEnumValue, GraphQLEnumType, GraphQLUnionType, GraphQLArgument, GraphQLInputField, GraphQLInputObjectType, GraphQLInterfaceType, GraphQLObjectType, GraphQLDirective, FragmentDefinitionNode, SelectionNode, ExecutionResult as GraphQLExecutionResult, GraphQLOutputType, FieldDefinitionNode, GraphQLFieldConfig, GraphQLInputFieldConfig, GraphQLArgumentConfig, GraphQLEnumValueConfig, GraphQLScalarSerializer, GraphQLScalarValueParser, GraphQLScalarLiteralParser, ScalarTypeDefinitionNode, ScalarTypeExtensionNode, EnumTypeDefinitionNode, EnumTypeExtensionNode, GraphQLIsTypeOfFn, ObjectTypeDefinitionNode, ObjectTypeExtensionNode, InterfaceTypeExtensionNode, InterfaceTypeDefinitionNode, GraphQLTypeResolver, UnionTypeDefinitionNode, UnionTypeExtensionNode, InputObjectTypeExtensionNode, InputObjectTypeDefinitionNode, GraphQLType, Source, DefinitionNode, OperationTypeNode } from 'graphql';
-export declare type ExecutionResult<TData = Record<string, any>> = GraphQLExecutionResult & {
-    data?: TData | null;
-    extensions?: Record<string, any>;
-};
-export interface ExecutionRequest<TArgs extends Record<string, any> = Record<string, any>, TContext = any, TRootValue = any, TExtensions = Record<string, any>> {
-    document: DocumentNode;
-    operationType: OperationTypeNode;
-    variables?: TArgs;
-    operationName?: string;
-    extensions?: TExtensions;
-    rootValue?: TRootValue;
-    context?: TContext;
-    info?: GraphQLResolveInfo;
-}
-export interface GraphQLParseOptions {
-    noLocation?: boolean;
-    allowLegacySDLEmptyFields?: boolean;
-    allowLegacySDLImplementsInterfaces?: boolean;
-    experimentalFragmentVariables?: boolean;
-    /**
-     * Set to `true` in order to convert all GraphQL comments (marked with # sign) to descriptions (""")
-     * GraphQL has built-in support for transforming descriptions to comments (with `print`), but not while
-     * parsing. Turning the flag on will support the other way as well (`parse`)
-     */
-    commentDescriptions?: boolean;
-}
-export declare type ValidatorBehavior = 'error' | 'warn' | 'ignore';
-/**
- * Options for validating resolvers
- */
-export interface IResolverValidationOptions {
-    /**
-     * Enable to require a resolver to be defined for any field that has
-     * arguments. Defaults to `ignore`.
-     */
-    requireResolversForArgs?: ValidatorBehavior;
-    /**
-     * Enable to require a resolver to be defined for any field which has
-     * a return type that isn't a scalar. Defaults to `ignore`.
-     */
-    requireResolversForNonScalar?: ValidatorBehavior;
-    /**
-     * Enable to require a resolver for be defined for all fields defined
-     * in the schema. Defaults to `ignore`.
-     */
-    requireResolversForAllFields?: ValidatorBehavior;
-    /**
-     * Enable to require a `resolveType()` for Interface and Union types.
-     * Defaults to `ignore`.
-     */
-    requireResolversForResolveType?: ValidatorBehavior;
-    /**
-     * Enable to require all defined resolvers to match fields that
-     * actually exist in the schema. Defaults to `error` to catch common errors.
-     */
-    requireResolversToMatchSchema?: ValidatorBehavior;
-}
-/**
- * Configuration object for adding resolvers to a schema
- */
-export interface IAddResolversToSchemaOptions {
-    /**
-     * The schema to which to add resolvers
-     */
-    schema: GraphQLSchema;
-    /**
-     * Object describing the field resolvers to add to the provided schema
-     */
-    resolvers: IResolvers;
-    /**
-     * Override the default field resolver provided by `graphql-js`
-     */
-    defaultFieldResolver?: IFieldResolver<any, any>;
-    /**
-     * Additional options for validating the provided resolvers
-     */
-    resolverValidationOptions?: IResolverValidationOptions;
-    /**
-     * GraphQL object types that implement interfaces will inherit any missing
-     * resolvers from their interface types defined in the `resolvers` object
-     */
-    inheritResolversFromInterfaces?: boolean;
-    /**
-     * Set to `true` to modify the existing schema instead of creating a new one
-     */
-    updateResolversInPlace?: boolean;
-}
-export declare type IScalarTypeResolver = GraphQLScalarType & {
-    __name?: string;
-    __description?: string;
-    __serialize?: GraphQLScalarSerializer<any>;
-    __parseValue?: GraphQLScalarValueParser<any>;
-    __parseLiteral?: GraphQLScalarLiteralParser<any>;
-    __extensions?: Record<string, any>;
-    __astNode?: ScalarTypeDefinitionNode;
-    __extensionASTNodes?: Array<ScalarTypeExtensionNode>;
-};
-export declare type IEnumTypeResolver = Record<string, any> & {
-    __name?: string;
-    __description?: string;
-    __extensions?: Record<string, any>;
-    __astNode?: EnumTypeDefinitionNode;
-    __extensionASTNodes?: Array<EnumTypeExtensionNode>;
-};
-export interface IFieldResolverOptions<TSource = any, TContext = any, TArgs = any> {
-    name?: string;
-    description?: string;
-    type?: GraphQLOutputType;
-    args?: Array<GraphQLArgument>;
-    resolve?: IFieldResolver<TSource, TContext, TArgs>;
-    subscribe?: IFieldResolver<TSource, TContext, TArgs>;
-    isDeprecated?: boolean;
-    deprecationReason?: string;
-    extensions?: Record<string, any>;
-    astNode?: FieldDefinitionNode;
-}
-export declare type FieldNodeMapper = (fieldNode: FieldNode, fragments: Record<string, FragmentDefinitionNode>, transformationContext: Record<string, any>) => SelectionNode | Array<SelectionNode>;
-export declare type FieldNodeMappers = Record<string, Record<string, FieldNodeMapper>>;
-export declare type InputFieldFilter = (typeName?: string, fieldName?: string, inputFieldConfig?: GraphQLInputFieldConfig) => boolean;
-export declare type FieldFilter = (typeName: string, fieldName: string, fieldConfig: GraphQLFieldConfig<any, any> | GraphQLInputFieldConfig) => boolean;
-export declare type ObjectFieldFilter = (typeName: string, fieldName: string, fieldConfig: GraphQLFieldConfig<any, any>) => boolean;
-export declare type RootFieldFilter = (operation: 'Query' | 'Mutation' | 'Subscription', rootFieldName: string, fieldConfig: GraphQLFieldConfig<any, any>) => boolean;
-export declare type TypeFilter = (typeName: string, type: GraphQLType) => boolean;
-export declare type ArgumentFilter = (typeName?: string, fieldName?: string, argName?: string, argConfig?: GraphQLArgumentConfig) => boolean;
-export declare type RenameTypesOptions = {
-    renameBuiltins: boolean;
-    renameScalars: boolean;
-};
-export declare type IFieldResolver<TSource, TContext, TArgs = Record<string, any>, TReturn = any> = (source: TSource, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TReturn;
-export declare type TypeSource = string | Source | DocumentNode | GraphQLSchema | DefinitionNode | Array<TypeSource> | (() => TypeSource);
-export declare type IObjectTypeResolver<TSource = any, TContext = any, TArgs = any> = {
-    [key: string]: IFieldResolver<TSource, TContext, TArgs> | IFieldResolverOptions<TSource, TContext>;
-} & {
-    __name?: string;
-    __description?: string;
-    __isTypeOf?: GraphQLIsTypeOfFn<TSource, TContext>;
-    __extensions?: Record<string, any>;
-    __astNode?: ObjectTypeDefinitionNode;
-    __extensionASTNodes?: ObjectTypeExtensionNode;
-};
-export declare type IInterfaceTypeResolver<TSource = any, TContext = any, TArgs = any> = {
-    [key: string]: IFieldResolver<TSource, TContext, TArgs> | IFieldResolverOptions<TSource, TContext>;
-} & {
-    __name?: string;
-    __description?: string;
-    __resolveType?: GraphQLTypeResolver<any, any>;
-    __extensions?: Record<string, any>;
-    __astNode?: InterfaceTypeDefinitionNode;
-    __extensionASTNodes?: Array<InterfaceTypeExtensionNode>;
-};
-export declare type IUnionTypeResolver = {
-    __name?: string;
-    __description?: string;
-    __resolveType?: GraphQLTypeResolver<any, any>;
-    __extensions?: Record<string, any>;
-    __astNode?: UnionTypeDefinitionNode;
-    __extensionASTNodes?: Array<UnionTypeExtensionNode>;
-};
-export declare type IInputObjectTypeResolver = {
-    __name?: string;
-    __description?: string;
-    __extensions?: Record<string, any>;
-    __astNode?: InputObjectTypeDefinitionNode;
-    __extensionASTNodes?: Array<InputObjectTypeExtensionNode>;
-};
-export declare type ISchemaLevelResolver<TSource, TContext, TArgs = Record<string, any>, TReturn = any> = IFieldResolver<TSource, TContext, TArgs, TReturn>;
-export declare type IResolvers<TSource = any, TContext = any, TArgs = Record<string, any>, TReturn = any> = Record<string, ISchemaLevelResolver<TSource, TContext, TArgs, TReturn> | IObjectTypeResolver<TSource, TContext> | IInterfaceTypeResolver<TSource, TContext> | IUnionTypeResolver | IScalarTypeResolver | IEnumTypeResolver | IInputObjectTypeResolver>;
-export declare type IFieldIteratorFn = (fieldDef: GraphQLField<any, any>, typeName: string, fieldName: string) => void;
-export declare type IDefaultValueIteratorFn = (type: GraphQLInputType, value: any) => void;
-export declare type NextResolverFn = () => Promise<any>;
-export declare type VisitableSchemaType = GraphQLSchema | GraphQLObjectType | GraphQLInterfaceType | GraphQLInputObjectType | GraphQLNamedType | GraphQLScalarType | GraphQLField<any, any> | GraphQLInputField | GraphQLArgument | GraphQLUnionType | GraphQLEnumType | GraphQLEnumValue;
-export declare enum MapperKind {
-    TYPE = "MapperKind.TYPE",
-    SCALAR_TYPE = "MapperKind.SCALAR_TYPE",
-    ENUM_TYPE = "MapperKind.ENUM_TYPE",
-    COMPOSITE_TYPE = "MapperKind.COMPOSITE_TYPE",
-    OBJECT_TYPE = "MapperKind.OBJECT_TYPE",
-    INPUT_OBJECT_TYPE = "MapperKind.INPUT_OBJECT_TYPE",
-    ABSTRACT_TYPE = "MapperKind.ABSTRACT_TYPE",
-    UNION_TYPE = "MapperKind.UNION_TYPE",
-    INTERFACE_TYPE = "MapperKind.INTERFACE_TYPE",
-    ROOT_OBJECT = "MapperKind.ROOT_OBJECT",
-    QUERY = "MapperKind.QUERY",
-    MUTATION = "MapperKind.MUTATION",
-    SUBSCRIPTION = "MapperKind.SUBSCRIPTION",
-    DIRECTIVE = "MapperKind.DIRECTIVE",
-    FIELD = "MapperKind.FIELD",
-    COMPOSITE_FIELD = "MapperKind.COMPOSITE_FIELD",
-    OBJECT_FIELD = "MapperKind.OBJECT_FIELD",
-    ROOT_FIELD = "MapperKind.ROOT_FIELD",
-    QUERY_ROOT_FIELD = "MapperKind.QUERY_ROOT_FIELD",
-    MUTATION_ROOT_FIELD = "MapperKind.MUTATION_ROOT_FIELD",
-    SUBSCRIPTION_ROOT_FIELD = "MapperKind.SUBSCRIPTION_ROOT_FIELD",
-    INTERFACE_FIELD = "MapperKind.INTERFACE_FIELD",
-    INPUT_OBJECT_FIELD = "MapperKind.INPUT_OBJECT_FIELD",
-    ARGUMENT = "MapperKind.ARGUMENT",
-    ENUM_VALUE = "MapperKind.ENUM_VALUE"
-}
-export interface SchemaMapper {
-    [MapperKind.TYPE]?: NamedTypeMapper;
-    [MapperKind.SCALAR_TYPE]?: ScalarTypeMapper;
-    [MapperKind.ENUM_TYPE]?: EnumTypeMapper;
-    [MapperKind.COMPOSITE_TYPE]?: CompositeTypeMapper;
-    [MapperKind.OBJECT_TYPE]?: ObjectTypeMapper;
-    [MapperKind.INPUT_OBJECT_TYPE]?: InputObjectTypeMapper;
-    [MapperKind.ABSTRACT_TYPE]?: AbstractTypeMapper;
-    [MapperKind.UNION_TYPE]?: UnionTypeMapper;
-    [MapperKind.INTERFACE_TYPE]?: InterfaceTypeMapper;
-    [MapperKind.ROOT_OBJECT]?: ObjectTypeMapper;
-    [MapperKind.QUERY]?: ObjectTypeMapper;
-    [MapperKind.MUTATION]?: ObjectTypeMapper;
-    [MapperKind.SUBSCRIPTION]?: ObjectTypeMapper;
-    [MapperKind.ENUM_VALUE]?: EnumValueMapper;
-    [MapperKind.FIELD]?: GenericFieldMapper<GraphQLFieldConfig<any, any> | GraphQLInputFieldConfig>;
-    [MapperKind.OBJECT_FIELD]?: FieldMapper;
-    [MapperKind.ROOT_FIELD]?: FieldMapper;
-    [MapperKind.QUERY_ROOT_FIELD]?: FieldMapper;
-    [MapperKind.MUTATION_ROOT_FIELD]?: FieldMapper;
-    [MapperKind.SUBSCRIPTION_ROOT_FIELD]?: FieldMapper;
-    [MapperKind.INTERFACE_FIELD]?: FieldMapper;
-    [MapperKind.COMPOSITE_FIELD]?: FieldMapper;
-    [MapperKind.ARGUMENT]?: ArgumentMapper;
-    [MapperKind.INPUT_OBJECT_FIELD]?: InputFieldMapper;
-    [MapperKind.DIRECTIVE]?: DirectiveMapper;
-}
-export declare type SchemaFieldMapperTypes = Array<MapperKind.FIELD | MapperKind.COMPOSITE_FIELD | MapperKind.OBJECT_FIELD | MapperKind.ROOT_FIELD | MapperKind.QUERY_ROOT_FIELD | MapperKind.MUTATION_ROOT_FIELD | MapperKind.SUBSCRIPTION_ROOT_FIELD | MapperKind.INTERFACE_FIELD | MapperKind.INPUT_OBJECT_FIELD>;
-export declare type NamedTypeMapper = (type: GraphQLNamedType, schema: GraphQLSchema) => GraphQLNamedType | null | undefined;
-export declare type ScalarTypeMapper = (type: GraphQLScalarType, schema: GraphQLSchema) => GraphQLScalarType | null | undefined;
-export declare type EnumTypeMapper = (type: GraphQLEnumType, schema: GraphQLSchema) => GraphQLEnumType | null | undefined;
-export declare type EnumValueMapper = (valueConfig: GraphQLEnumValueConfig, typeName: string, schema: GraphQLSchema, externalValue: string) => GraphQLEnumValueConfig | [string, GraphQLEnumValueConfig] | null | undefined;
-export declare type CompositeTypeMapper = (type: GraphQLObjectType | GraphQLInterfaceType | GraphQLUnionType, schema: GraphQLSchema) => GraphQLObjectType | GraphQLInterfaceType | GraphQLUnionType | null | undefined;
-export declare type ObjectTypeMapper = (type: GraphQLObjectType, schema: GraphQLSchema) => GraphQLObjectType | null | undefined;
-export declare type InputObjectTypeMapper = (type: GraphQLInputObjectType, schema: GraphQLSchema) => GraphQLInputObjectType | null | undefined;
-export declare type AbstractTypeMapper = (type: GraphQLInterfaceType | GraphQLUnionType, schema: GraphQLSchema) => GraphQLInterfaceType | GraphQLUnionType | null | undefined;
-export declare type UnionTypeMapper = (type: GraphQLUnionType, schema: GraphQLSchema) => GraphQLUnionType | null | undefined;
-export declare type InterfaceTypeMapper = (type: GraphQLInterfaceType, schema: GraphQLSchema) => GraphQLInterfaceType | null | undefined;
-export declare type DirectiveMapper = (directive: GraphQLDirective, schema: GraphQLSchema) => GraphQLDirective | null | undefined;
-export declare type GenericFieldMapper<F extends GraphQLFieldConfig<any, any> | GraphQLInputFieldConfig> = (fieldConfig: F, fieldName: string, typeName: string, schema: GraphQLSchema) => F | [string, F] | null | undefined;
-export declare type FieldMapper = GenericFieldMapper<GraphQLFieldConfig<any, any>>;
-export declare type ArgumentMapper = (argumentConfig: GraphQLArgumentConfig, fieldName: string, typeName: string, schema: GraphQLSchema) => GraphQLArgumentConfig | [string, GraphQLArgumentConfig] | null | undefined;
-export declare type InputFieldMapper = GenericFieldMapper<GraphQLInputFieldConfig>;

package/es5/addTypes.d.ts

@@ -1,2 +0,0 @@
-import { GraphQLSchema, GraphQLNamedType, GraphQLDirective } from 'graphql';
-export declare function addTypes(schema: GraphQLSchema, newTypesOrDirectives: Array<GraphQLNamedType | GraphQLDirective>): GraphQLSchema;

package/es5/astFromType.d.ts

@@ -1,2 +0,0 @@
-import { GraphQLType, TypeNode } from 'graphql';
-export declare function astFromType(type: GraphQLType): TypeNode;

package/es5/astFromValueUntyped.d.ts

@@ -1,17 +0,0 @@
-import { ValueNode } from 'graphql';
-/**
- * Produces a GraphQL Value AST given a JavaScript object.
- * Function will match JavaScript/JSON values to GraphQL AST schema format
- * by using the following mapping.
- *
- * | JSON Value    | GraphQL Value        |
- * | ------------- | -------------------- |
- * | Object        | Input Object         |
- * | Array         | List                 |
- * | Boolean       | Boolean              |
- * | String        | String               |
- * | Number        | Int / Float          |
- * | null          | NullValue            |
- *
- */
-export declare function astFromValueUntyped(value: any): ValueNode | null;

package/es5/build-operation-for-field.d.ts

@@ -1,18 +0,0 @@
-import { GraphQLSchema, OperationDefinitionNode, OperationTypeNode } from 'graphql';
-export declare type Skip = string[];
-export declare type Force = string[];
-export declare type Ignore = string[];
-export declare type SelectedFields = {
-    [key: string]: SelectedFields;
-} | boolean;
-export declare function buildOperationNodeForField({ schema, kind, field, models, ignore, depthLimit, circularReferenceDepth, argNames, selectedFields, }: {
-    schema: GraphQLSchema;
-    kind: OperationTypeNode;
-    field: string;
-    models?: string[];
-    ignore?: Ignore;
-    depthLimit?: number;
-    circularReferenceDepth?: number;
-    argNames?: string[];
-    selectedFields?: SelectedFields;
-}): OperationDefinitionNode;

package/es5/collectFields.d.ts

@@ -1,5 +0,0 @@
-import { GraphQLSchema, FragmentDefinitionNode, GraphQLObjectType, SelectionSetNode, FieldNode } from 'graphql';
-export declare function collectFields(schema: GraphQLSchema, fragments: Record<string, FragmentDefinitionNode>, variableValues: {
-    [variable: string]: unknown;
-}, runtimeType: GraphQLObjectType, selectionSet: SelectionSetNode, fields: Map<string, Array<FieldNode>>, visitedFragmentNames: Set<string>): Map<string, Array<FieldNode>>;
-export declare const collectSubFields: (schema: GraphQLSchema, fragments: Record<string, FragmentDefinitionNode>, variableValues: Record<string, any>, type: GraphQLObjectType, fieldNodes: Array<FieldNode>) => Map<string, Array<FieldNode>>;

package/es5/comments.d.ts

@@ -1,28 +0,0 @@
-import { StringValueNode, ASTNode, NameNode, DefinitionNode, Location } from 'graphql';
-export declare type NamedDefinitionNode = DefinitionNode & {
-    name?: NameNode;
-};
-export declare function resetComments(): 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
- * formatting rules.
- */
-export declare function printWithComments(ast: ASTNode): string;
-export declare function getDescription(node: {
-    description?: StringValueNode;
-    loc?: Location;
-}, options?: {
-    commentDescriptions?: boolean;
-}): string | undefined;
-export declare function getLeadingCommentBlock(node: {
-    description?: StringValueNode;
-    loc?: Location;
-}): void | string;
-export declare function dedentBlockStringValue(rawString: string): string;
-/**
- * @internal
- */
-export declare function getBlockStringIndentation(lines: ReadonlyArray<string>): number;

package/es5/errors.d.ts

@@ -1,2 +0,0 @@
-import { GraphQLError } from 'graphql';
-export declare function relocatedError(originalError: GraphQLError, path?: ReadonlyArray<string | number>): GraphQLError;

package/es5/executor.d.ts

@@ -1,7 +0,0 @@
-import { ExecutionResult, ExecutionRequest } from './Interfaces';
-declare type MaybePromise<T> = Promise<T> | T;
-declare type MaybeAsyncIterableIterator<T> = AsyncIterableIterator<T> | T;
-export declare type AsyncExecutor<TBaseContext = Record<string, any>, TBaseExtensions = Record<string, any>> = <TReturn = any, TArgs = Record<string, any>, TContext extends TBaseContext = TBaseContext, TRoot = any, TExtensions extends TBaseExtensions = TBaseExtensions>(request: ExecutionRequest<TArgs, TContext, TRoot, TExtensions>) => Promise<MaybeAsyncIterableIterator<ExecutionResult<TReturn>>>;
-export declare type SyncExecutor<TBaseContext = Record<string, any>, TBaseExtensions = Record<string, any>> = <TReturn = any, TArgs = Record<string, any>, TContext extends TBaseContext = TBaseContext, TRoot = any, TExtensions extends TBaseExtensions = TBaseExtensions>(request: ExecutionRequest<TArgs, TContext, TRoot, TExtensions>) => ExecutionResult<TReturn>;
-export declare type Executor<TBaseContext = Record<string, any>, TBaseExtensions = Record<string, any>> = <TReturn = any, TArgs = Record<string, any>, TContext extends TBaseContext = TBaseContext, TRoot = any, TExtensions extends TBaseExtensions = TBaseExtensions>(request: ExecutionRequest<TArgs, TContext, TRoot, TExtensions>) => MaybePromise<MaybeAsyncIterableIterator<ExecutionResult<TReturn>>>;
-export {};

package/es5/fields.d.ts

@@ -1,5 +0,0 @@
-import { GraphQLFieldConfigMap, GraphQLFieldConfig, GraphQLSchema } from 'graphql';
-export declare function appendObjectFields(schema: GraphQLSchema, typeName: string, additionalFields: GraphQLFieldConfigMap<any, any>): GraphQLSchema;
-export declare function removeObjectFields(schema: GraphQLSchema, typeName: string, testFn: (fieldName: string, field: GraphQLFieldConfig<any, any>) => boolean): [GraphQLSchema, GraphQLFieldConfigMap<any, any>];
-export declare function selectObjectFields(schema: GraphQLSchema, typeName: string, testFn: (fieldName: string, field: GraphQLFieldConfig<any, any>) => boolean): GraphQLFieldConfigMap<any, any>;
-export declare function modifyObjectFields(schema: GraphQLSchema, typeName: string, testFn: (fieldName: string, field: GraphQLFieldConfig<any, any>) => boolean, newFields: GraphQLFieldConfigMap<any, any>): [GraphQLSchema, GraphQLFieldConfigMap<any, any>];