@graphql-tools/utils 8.7.0 → 8.8.0-alpha-b76ec274.0

package/esm/visitResult.js

@@ -0,0 +1,213 @@
+import { getOperationASTFromRequest } from './getOperationASTFromRequest.js';
+import { Kind, isListType, getNullableType, isAbstractType, isObjectType, TypeNameMetaFieldDef, } from 'graphql';
+import { collectFields, collectSubFields } from './collectFields.js';
+export function visitData(data, enter, leave) {
+    if (Array.isArray(data)) {
+        return data.map(value => visitData(value, enter, leave));
+    }
+    else if (typeof data === 'object') {
+        const newData = enter != null ? enter(data) : data;
+        if (newData != null) {
+            for (const key in newData) {
+                const value = newData[key];
+                Object.defineProperty(newData, key, {
+                    value: visitData(value, enter, leave),
+                });
+            }
+        }
+        return leave != null ? leave(newData) : newData;
+    }
+    return data;
+}
+export function visitErrors(errors, visitor) {
+    return errors.map(error => visitor(error));
+}
+export function visitResult(result, request, schema, resultVisitorMap, errorVisitorMap) {
+    const fragments = request.document.definitions.reduce((acc, def) => {
+        if (def.kind === Kind.FRAGMENT_DEFINITION) {
+            acc[def.name.value] = def;
+        }
+        return acc;
+    }, {});
+    const variableValues = request.variables || {};
+    const errorInfo = {
+        segmentInfoMap: new Map(),
+        unpathedErrors: new Set(),
+    };
+    const data = result.data;
+    const errors = result.errors;
+    const visitingErrors = errors != null && errorVisitorMap != null;
+    const operationDocumentNode = getOperationASTFromRequest(request);
+    if (data != null && operationDocumentNode != null) {
+        result.data = visitRoot(data, operationDocumentNode, schema, fragments, variableValues, resultVisitorMap, visitingErrors ? errors : undefined, errorInfo);
+    }
+    if (errors != null && errorVisitorMap) {
+        result.errors = visitErrorsByType(errors, errorVisitorMap, errorInfo);
+    }
+    return result;
+}
+function visitErrorsByType(errors, errorVisitorMap, errorInfo) {
+    const segmentInfoMap = errorInfo.segmentInfoMap;
+    const unpathedErrors = errorInfo.unpathedErrors;
+    const unpathedErrorVisitor = errorVisitorMap['__unpathed'];
+    return errors.map(originalError => {
+        const pathSegmentsInfo = segmentInfoMap.get(originalError);
+        const newError = pathSegmentsInfo == null
+            ? originalError
+            : pathSegmentsInfo.reduceRight((acc, segmentInfo) => {
+                const typeName = segmentInfo.type.name;
+                const typeVisitorMap = errorVisitorMap[typeName];
+                if (typeVisitorMap == null) {
+                    return acc;
+                }
+                const errorVisitor = typeVisitorMap[segmentInfo.fieldName];
+                return errorVisitor == null ? acc : errorVisitor(acc, segmentInfo.pathIndex);
+            }, originalError);
+        if (unpathedErrorVisitor && unpathedErrors.has(originalError)) {
+            return unpathedErrorVisitor(newError);
+        }
+        return newError;
+    });
+}
+function getOperationRootType(schema, operationDef) {
+    switch (operationDef.operation) {
+        case 'query':
+            return schema.getQueryType();
+        case 'mutation':
+            return schema.getMutationType();
+        case 'subscription':
+            return schema.getSubscriptionType();
+    }
+}
+function visitRoot(root, operation, schema, fragments, variableValues, resultVisitorMap, errors, errorInfo) {
+    const operationRootType = getOperationRootType(schema, operation);
+    const collectedFields = collectFields(schema, fragments, variableValues, operationRootType, operation.selectionSet, new Map(), new Set());
+    return visitObjectValue(root, operationRootType, collectedFields, schema, fragments, variableValues, resultVisitorMap, 0, errors, errorInfo);
+}
+function visitObjectValue(object, type, fieldNodeMap, schema, fragments, variableValues, resultVisitorMap, pathIndex, errors, errorInfo) {
+    var _a;
+    const fieldMap = type.getFields();
+    const typeVisitorMap = resultVisitorMap === null || resultVisitorMap === void 0 ? void 0 : resultVisitorMap[type.name];
+    const enterObject = typeVisitorMap === null || typeVisitorMap === void 0 ? void 0 : typeVisitorMap.__enter;
+    const newObject = enterObject != null ? enterObject(object) : object;
+    let sortedErrors;
+    let errorMap = null;
+    if (errors != null) {
+        sortedErrors = sortErrorsByPathSegment(errors, pathIndex);
+        errorMap = sortedErrors.errorMap;
+        for (const error of sortedErrors.unpathedErrors) {
+            errorInfo.unpathedErrors.add(error);
+        }
+    }
+    for (const [responseKey, subFieldNodes] of fieldNodeMap) {
+        const fieldName = subFieldNodes[0].name.value;
+        const fieldType = fieldName === '__typename' ? TypeNameMetaFieldDef.type : (_a = fieldMap[fieldName]) === null || _a === void 0 ? void 0 : _a.type;
+        const newPathIndex = pathIndex + 1;
+        let fieldErrors;
+        if (errorMap) {
+            fieldErrors = errorMap[responseKey];
+            if (fieldErrors != null) {
+                delete errorMap[responseKey];
+            }
+            addPathSegmentInfo(type, fieldName, newPathIndex, fieldErrors, errorInfo);
+        }
+        const newValue = visitFieldValue(object[responseKey], fieldType, subFieldNodes, schema, fragments, variableValues, resultVisitorMap, newPathIndex, fieldErrors, errorInfo);
+        updateObject(newObject, responseKey, newValue, typeVisitorMap, fieldName);
+    }
+    const oldTypename = newObject.__typename;
+    if (oldTypename != null) {
+        updateObject(newObject, '__typename', oldTypename, typeVisitorMap, '__typename');
+    }
+    if (errorMap) {
+        for (const errorsKey in errorMap) {
+            const errors = errorMap[errorsKey];
+            for (const error of errors) {
+                errorInfo.unpathedErrors.add(error);
+            }
+        }
+    }
+    const leaveObject = typeVisitorMap === null || typeVisitorMap === void 0 ? void 0 : typeVisitorMap.__leave;
+    return leaveObject != null ? leaveObject(newObject) : newObject;
+}
+function updateObject(object, responseKey, newValue, typeVisitorMap, fieldName) {
+    if (typeVisitorMap == null) {
+        object[responseKey] = newValue;
+        return;
+    }
+    const fieldVisitor = typeVisitorMap[fieldName];
+    if (fieldVisitor == null) {
+        object[responseKey] = newValue;
+        return;
+    }
+    const visitedValue = fieldVisitor(newValue);
+    if (visitedValue === undefined) {
+        delete object[responseKey];
+        return;
+    }
+    object[responseKey] = visitedValue;
+}
+function visitListValue(list, returnType, fieldNodes, schema, fragments, variableValues, resultVisitorMap, pathIndex, errors, errorInfo) {
+    return list.map(listMember => visitFieldValue(listMember, returnType, fieldNodes, schema, fragments, variableValues, resultVisitorMap, pathIndex + 1, errors, errorInfo));
+}
+function visitFieldValue(value, returnType, fieldNodes, schema, fragments, variableValues, resultVisitorMap, pathIndex, errors = [], errorInfo) {
+    if (value == null) {
+        return value;
+    }
+    const nullableType = getNullableType(returnType);
+    if (isListType(nullableType)) {
+        return visitListValue(value, nullableType.ofType, fieldNodes, schema, fragments, variableValues, resultVisitorMap, pathIndex, errors, errorInfo);
+    }
+    else if (isAbstractType(nullableType)) {
+        const finalType = schema.getType(value.__typename);
+        const collectedFields = collectSubFields(schema, fragments, variableValues, finalType, fieldNodes);
+        return visitObjectValue(value, finalType, collectedFields, schema, fragments, variableValues, resultVisitorMap, pathIndex, errors, errorInfo);
+    }
+    else if (isObjectType(nullableType)) {
+        const collectedFields = collectSubFields(schema, fragments, variableValues, nullableType, fieldNodes);
+        return visitObjectValue(value, nullableType, collectedFields, schema, fragments, variableValues, resultVisitorMap, pathIndex, errors, errorInfo);
+    }
+    const typeVisitorMap = resultVisitorMap === null || resultVisitorMap === void 0 ? void 0 : resultVisitorMap[nullableType.name];
+    if (typeVisitorMap == null) {
+        return value;
+    }
+    const visitedValue = typeVisitorMap(value);
+    return visitedValue === undefined ? value : visitedValue;
+}
+function sortErrorsByPathSegment(errors, pathIndex) {
+    var _a;
+    const errorMap = Object.create(null);
+    const unpathedErrors = new Set();
+    for (const error of errors) {
+        const pathSegment = (_a = error.path) === null || _a === void 0 ? void 0 : _a[pathIndex];
+        if (pathSegment == null) {
+            unpathedErrors.add(error);
+            continue;
+        }
+        if (pathSegment in errorMap) {
+            errorMap[pathSegment].push(error);
+        }
+        else {
+            errorMap[pathSegment] = [error];
+        }
+    }
+    return {
+        errorMap,
+        unpathedErrors,
+    };
+}
+function addPathSegmentInfo(type, fieldName, pathIndex, errors = [], errorInfo) {
+    for (const error of errors) {
+        const segmentInfo = {
+            type,
+            fieldName,
+            pathIndex,
+        };
+        const pathSegmentsInfo = errorInfo.segmentInfoMap.get(error);
+        if (pathSegmentsInfo == null) {
+            errorInfo.segmentInfoMap.set(error, [segmentInfo]);
+        }
+        else {
+            pathSegmentsInfo.push(segmentInfo);
+        }
+    }
+}

package/esm/withCancel.js

@@ -0,0 +1,51 @@
+import { memoize2 } from './memoize.js';
+async function defaultAsyncIteratorReturn(value) {
+    return { value, done: true };
+}
+const proxyMethodFactory = memoize2(function proxyMethodFactory(target, targetMethod) {
+    return function proxyMethod(...args) {
+        return Reflect.apply(targetMethod, target, args);
+    };
+});
+export function getAsyncIteratorWithCancel(asyncIterator, onCancel) {
+    return new Proxy(asyncIterator, {
+        has(asyncIterator, prop) {
+            if (prop === 'return') {
+                return true;
+            }
+            return Reflect.has(asyncIterator, prop);
+        },
+        get(asyncIterator, prop, receiver) {
+            const existingPropValue = Reflect.get(asyncIterator, prop, receiver);
+            if (prop === 'return') {
+                const existingReturn = existingPropValue || defaultAsyncIteratorReturn;
+                return async function returnWithCancel(value) {
+                    const returnValue = await onCancel(value);
+                    return Reflect.apply(existingReturn, asyncIterator, [returnValue]);
+                };
+            }
+            else if (typeof existingPropValue === 'function') {
+                return proxyMethodFactory(asyncIterator, existingPropValue);
+            }
+            return existingPropValue;
+        },
+    });
+}
+export function getAsyncIterableWithCancel(asyncIterable, onCancel) {
+    return new Proxy(asyncIterable, {
+        get(asyncIterable, prop, receiver) {
+            const existingPropValue = Reflect.get(asyncIterable, prop, receiver);
+            if (Symbol.asyncIterator === prop) {
+                return function asyncIteratorFactory() {
+                    const asyncIterator = Reflect.apply(existingPropValue, asyncIterable, []);
+                    return getAsyncIteratorWithCancel(asyncIterator, onCancel);
+                };
+            }
+            else if (typeof existingPropValue === 'function') {
+                return proxyMethodFactory(asyncIterable, existingPropValue);
+            }
+            return existingPropValue;
+        },
+    });
+}
+export { getAsyncIterableWithCancel as withCancel };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/utils",
-  "version": "8.7.0",
+  "version": "8.8.0-alpha-b76ec274.0",
   "description": "Common package containing utils and types for GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {
@@ -16,21 +16,42 @@
   },
   "author": "Dotan Simha <dotansimha@gmail.com>",
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
+      "require": {
+        "types": "./typings/index.d.ts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/*.d.ts",
+        "default": "./cjs/*.js"
+      },
+      "import": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "default": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/{errors.d.ts → typings/errors.d.ts}

@@ -1,5 +1,5 @@
 import { ASTNode, GraphQLError, Source } from 'graphql';
-import { Maybe } from './types';
+import { Maybe } from './types.js';
 interface GraphQLErrorOptions {
     nodes?: ReadonlyArray<ASTNode> | ASTNode | null;
     source?: Maybe<Source>;

package/{executor.d.ts → typings/executor.d.ts}

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

package/{filterSchema.d.ts → typings/filterSchema.d.ts}

@@ -1,5 +1,5 @@
 import { GraphQLSchema } from 'graphql';
-import { FieldFilter, RootFieldFilter, TypeFilter, ArgumentFilter } from './Interfaces';
+import { FieldFilter, RootFieldFilter, TypeFilter, ArgumentFilter } from './Interfaces.js';
 export declare function filterSchema({ schema, typeFilter, fieldFilter, rootFieldFilter, objectFieldFilter, interfaceFieldFilter, inputObjectFieldFilter, argumentFilter, }: {
     schema: GraphQLSchema;
     rootFieldFilter?: RootFieldFilter;

package/{fixSchemaAst.d.ts → typings/fixSchemaAst.d.ts}

@@ -1,3 +1,3 @@
 import { GraphQLSchema, BuildSchemaOptions } from 'graphql';
-import { SchemaPrintOptions } from './types';
+import { SchemaPrintOptions } from './types.js';
 export declare function fixSchemaAst(schema: GraphQLSchema, options: BuildSchemaOptions & SchemaPrintOptions): GraphQLSchema;

package/{forEachDefaultValue.d.ts → typings/forEachDefaultValue.d.ts}

@@ -1,3 +1,3 @@
 import { GraphQLSchema } from 'graphql';
-import { IDefaultValueIteratorFn } from './Interfaces';
+import { IDefaultValueIteratorFn } from './Interfaces.js';
 export declare function forEachDefaultValue(schema: GraphQLSchema, fn: IDefaultValueIteratorFn): void;

package/{forEachField.d.ts → typings/forEachField.d.ts}

@@ -1,3 +1,3 @@
 import { GraphQLSchema } from 'graphql';
-import { IFieldIteratorFn } from './Interfaces';
+import { IFieldIteratorFn } from './Interfaces.js';
 export declare function forEachField(schema: GraphQLSchema, fn: IFieldIteratorFn): void;

package/{getObjectTypeFromTypeMap.d.ts → typings/getObjectTypeFromTypeMap.d.ts}

@@ -1,3 +1,3 @@
 import { GraphQLNamedType, GraphQLObjectType } from 'graphql';
-import { Maybe } from './types';
+import { Maybe } from './types.js';
 export declare function getObjectTypeFromTypeMap(typeMap: Record<string, GraphQLNamedType>, type: Maybe<GraphQLObjectType>): GraphQLObjectType | undefined;

package/{getOperationASTFromRequest.d.ts → typings/getOperationASTFromRequest.d.ts}

@@ -1,4 +1,4 @@
 import { DocumentNode, OperationDefinitionNode } from 'graphql';
-import { ExecutionRequest } from './Interfaces';
+import { ExecutionRequest } from './Interfaces.js';
 export declare function getOperationASTFromDocument(documentNode: DocumentNode, operationName?: string): OperationDefinitionNode;
 export declare const getOperationASTFromRequest: (request: ExecutionRequest) => OperationDefinitionNode;

package/{getResolversFromSchema.d.ts → typings/getResolversFromSchema.d.ts}

@@ -1,3 +1,3 @@
 import { GraphQLSchema } from 'graphql';
-import { IResolvers } from './Interfaces';
+import { IResolvers } from './Interfaces.js';
 export declare function getResolversFromSchema(schema: GraphQLSchema, includeDefaultMergedResolver?: boolean): IResolvers;

package/{implementsAbstractType.d.ts → typings/implementsAbstractType.d.ts}

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

package/typings/index.d.ts

@@ -0,0 +1,50 @@
+export * from './loaders.js';
+export * from './helpers.js';
+export * from './get-directives.js';
+export * from './get-fields-with-directives.js';
+export * from './get-implementing-types.js';
+export * from './print-schema-with-directives.js';
+export * from './get-fields-with-directives.js';
+export * from './validate-documents.js';
+export * from './parse-graphql-json.js';
+export * from './parse-graphql-sdl.js';
+export * from './build-operation-for-field.js';
+export * from './types.js';
+export * from './filterSchema.js';
+export * from './heal.js';
+export * from './getResolversFromSchema.js';
+export * from './forEachField.js';
+export * from './forEachDefaultValue.js';
+export * from './mapSchema.js';
+export * from './addTypes.js';
+export * from './rewire.js';
+export * from './prune.js';
+export * from './mergeDeep.js';
+export * from './Interfaces.js';
+export * from './stub.js';
+export * from './selectionSets.js';
+export * from './getResponseKeyFromInfo.js';
+export * from './fields.js';
+export * from './renameType.js';
+export * from './transformInputValue.js';
+export * from './mapAsyncIterator.js';
+export * from './updateArgument.js';
+export * from './implementsAbstractType.js';
+export * from './errors.js';
+export * from './observableToAsyncIterable.js';
+export * from './visitResult.js';
+export * from './getArgumentValues.js';
+export * from './valueMatchesCriteria.js';
+export * from './isAsyncIterable.js';
+export * from './isDocumentNode.js';
+export * from './astFromValueUntyped.js';
+export * from './executor.js';
+export * from './withCancel.js';
+export * from './AggregateError.js';
+export * from './rootTypes.js';
+export * from './comments.js';
+export * from './collectFields.js';
+export * from './inspect.js';
+export * from './memoize.js';
+export * from './fixSchemaAst.js';
+export * from './getOperationASTFromRequest.js';

package/{loaders.d.ts → typings/loaders.d.ts}

@@ -1,5 +1,5 @@
 import { DocumentNode, GraphQLSchema, BuildSchemaOptions } from 'graphql';
-import { GraphQLParseOptions } from './Interfaces';
+import { GraphQLParseOptions } from './Interfaces.js';
 export interface Source {
     document?: DocumentNode;
     schema?: GraphQLSchema;

package/{mapSchema.d.ts → typings/mapSchema.d.ts}

@@ -1,5 +1,5 @@
 import { GraphQLObjectType, GraphQLSchema, GraphQLInputObjectType, GraphQLInterfaceType, GraphQLEnumType } from 'graphql';
-import { SchemaMapper } from './Interfaces';
+import { SchemaMapper } from './Interfaces.js';
 export declare function mapSchema(schema: GraphQLSchema, schemaMapper?: SchemaMapper): GraphQLSchema;
 export declare function correctASTNodes(type: GraphQLObjectType): GraphQLObjectType;
 export declare function correctASTNodes(type: GraphQLInterfaceType): GraphQLInterfaceType;

package/{parse-graphql-json.d.ts → typings/parse-graphql-json.d.ts}

@@ -1,4 +1,4 @@
 import { ParseOptions } from 'graphql';
-import { Source } from './loaders';
-import { SchemaPrintOptions } from './types';
+import { Source } from './loaders.js';
+import { SchemaPrintOptions } from './types.js';
 export declare function parseGraphQLJSON(location: string, jsonContent: string, options: SchemaPrintOptions & ParseOptions): Source;

package/{parse-graphql-sdl.d.ts → typings/parse-graphql-sdl.d.ts}

@@ -1,5 +1,5 @@
 import { DocumentNode, ASTNode, StringValueNode } from 'graphql';
-import { GraphQLParseOptions } from './Interfaces';
+import { GraphQLParseOptions } from './Interfaces.js';
 export declare function parseGraphQLSDL(location: string | undefined, rawSDL: string, options?: GraphQLParseOptions): {
     location: string | undefined;
     document: DocumentNode;

package/{print-schema-with-directives.d.ts → typings/print-schema-with-directives.d.ts}

@@ -1,5 +1,5 @@
 import { GraphQLSchema, GraphQLNamedType, DirectiveNode, FieldDefinitionNode, InputValueDefinitionNode, GraphQLArgument, EnumValueDefinitionNode, GraphQLDirective, DirectiveDefinitionNode, SchemaDefinitionNode, SchemaExtensionNode, GraphQLObjectType, ObjectTypeDefinitionNode, GraphQLField, GraphQLInterfaceType, InterfaceTypeDefinitionNode, UnionTypeDefinitionNode, GraphQLUnionType, GraphQLInputObjectType, InputObjectTypeDefinitionNode, GraphQLInputField, GraphQLEnumType, GraphQLEnumValue, EnumTypeDefinitionNode, GraphQLScalarType, ScalarTypeDefinitionNode, DocumentNode } from 'graphql';
-import { GetDocumentNodeFromSchemaOptions, PrintSchemaWithDirectivesOptions, Maybe } from './types';
+import { GetDocumentNodeFromSchemaOptions, PrintSchemaWithDirectivesOptions, Maybe } from './types.js';
 export declare function getDocumentNodeFromSchema(schema: GraphQLSchema, options?: GetDocumentNodeFromSchemaOptions): DocumentNode;
 export declare function printSchemaWithDirectives(schema: GraphQLSchema, options?: PrintSchemaWithDirectivesOptions): string;
 export declare function astFromSchema(schema: GraphQLSchema, pathToDirectivesInExtensions?: Array<string>): SchemaDefinitionNode | SchemaExtensionNode | null;

package/{prune.d.ts → typings/prune.d.ts}

@@ -1,5 +1,5 @@
 import { GraphQLSchema } from 'graphql';
-import { PruneSchemaOptions } from './types';
+import { PruneSchemaOptions } from './types.js';
 /**
  * Prunes the provided schema, removing unused and empty types
  * @param schema The schema to prune

package/{selectionSets.d.ts → typings/selectionSets.d.ts}

@@ -1,3 +1,3 @@
 import { SelectionSetNode } from 'graphql';
-import { GraphQLParseOptions } from './Interfaces';
+import { GraphQLParseOptions } from './Interfaces.js';
 export declare function parseSelectionSet(selectionSet: string, options?: GraphQLParseOptions): SelectionSetNode;

package/{transformInputValue.d.ts → typings/transformInputValue.d.ts}

@@ -1,5 +1,5 @@
 import { GraphQLInputType } from 'graphql';
-import { InputLeafValueTransformer, InputObjectValueTransformer, Maybe } from './types';
+import { InputLeafValueTransformer, InputObjectValueTransformer, Maybe } from './types.js';
 export declare function transformInputValue(type: GraphQLInputType, value: any, inputLeafValueTransformer?: Maybe<InputLeafValueTransformer>, inputObjectValueTransformer?: Maybe<InputObjectValueTransformer>): any;
 export declare function serializeInputValue(type: GraphQLInputType, value: any): any;
 export declare function parseInputValue(type: GraphQLInputType, value: any): any;

package/{validate-documents.d.ts → typings/validate-documents.d.ts}

@@ -1,5 +1,5 @@
 import { GraphQLSchema, GraphQLError, ValidationContext, ASTVisitor } from 'graphql';
-import { Source } from './loaders';
+import { Source } from './loaders.js';
 export declare type ValidationRule = (context: ValidationContext) => ASTVisitor;
 export interface LoadDocumentError {
     readonly filePath?: string;

package/{visitResult.d.ts → typings/visitResult.d.ts}

@@ -1,5 +1,5 @@
 import { GraphQLSchema, GraphQLError } from 'graphql';
-import { ExecutionRequest, ExecutionResult } from './Interfaces';
+import { ExecutionRequest, ExecutionResult } from './Interfaces.js';
 export declare type ValueVisitor = (value: any) => any;
 export declare type ObjectValueVisitor = {
     __enter?: ValueVisitor;