@graphql-tools/import 7.1.1-alpha-20250905084227-a20ed1fabf7f2c69761699dc9c4e0676cd9e8c28 → 7.1.1-alpha-20250905110939-465ce4b83eaffe7e8ad2d10538526654c551aeff

package/cjs/index.js

@@ -95,7 +95,7 @@ function visitFile(filePath, cwd, visitedFiles, predefinedImports, pathAliases)
                                 addDefinition(importedDefinition, fieldDefinitionName, definitionsWithDeps);
                             }
                         });
-                        const newDependencySet = new Set();
+                        const newDependencySet = new Map();
                         switch (field.kind) {
                             case graphql_1.Kind.FIELD_DEFINITION:
                                 visitFieldDefinitionNode(field, newDependencySet, dependenciesByDefinitionName);
@@ -104,7 +104,7 @@ function visitFile(filePath, cwd, visitedFiles, predefinedImports, pathAliases)
                                 visitInputValueDefinitionNode(field, newDependencySet, dependenciesByDefinitionName);
                                 break;
                         }
-                        newDependencySet.forEach(dependencyName => {
+                        Array.from(newDependencySet.keys()).forEach(dependencyName => {
                             const definitionsInCurrentFile = fileDefinitionMap.get(dependencyName);
                             definitionsInCurrentFile?.forEach(def => addDefinition(def, definitionName, definitionSet));
                             const definitionsFromImports = allImportedDefinitionsMap.get(dependencyName);
@@ -131,11 +131,11 @@ function visitFile(filePath, cwd, visitedFiles, predefinedImports, pathAliases)
                         });
                         const dependenciesOfDefinition = dependenciesByDefinitionName.get(definitionName);
                         if (dependenciesOfDefinition) {
-                            for (const dependencyName of dependenciesOfDefinition) {
+                            for (const [dependencyName, dependencyNodes] of dependenciesOfDefinition.entries()) {
                                 // If that dependency cannot be found both in imports and this file, throw an error
                                 if (!allImportedDefinitionsMap.has(dependencyName) &&
                                     !definitionsByName.has(dependencyName)) {
-                                    throw new Error(`Couldn't find type ${dependencyName} in any of the schemas.`);
+                                    throw (0, utils_1.createGraphQLError)(`Couldn't find type ${dependencyName} in any of the schemas.`, { nodes: Array.from(dependencyNodes) });
                                 }
                                 const dependencyDefinitionsFromImports = allImportedDefinitionsMap.get(dependencyName);
                                 dependencyDefinitionsFromImports?.forEach(dependencyDefinition => {
@@ -158,9 +158,7 @@ function visitFile(filePath, cwd, visitedFiles, predefinedImports, pathAliases)
 function extractDependencies(filePath, fileContents) {
     const definitionsByName = new Map();
     const dependenciesByDefinitionName = new Map();
-    const { document } = (0, utils_1.parseGraphQLSDL)(filePath, fileContents, {
-        noLocation: true,
-    });
+    const { document } = (0, utils_1.parseGraphQLSDL)(filePath, fileContents);
     for (const definition of document.definitions) {
         visitDefinition(definition, definitionsByName, dependenciesByDefinitionName);
     }
@@ -234,7 +232,7 @@ function visitDefinition(definition, definitionsByName, dependenciesByDefinition
         definitionsSet.add(definition);
         let dependencySet = dependenciesByDefinitionName.get(definitionName);
         if (!dependencySet) {
-            dependencySet = new Set();
+            dependencySet = new Map();
             dependenciesByDefinitionName.set(definitionName, dependencySet);
         }
         switch (definition.kind) {
@@ -304,7 +302,7 @@ function visitDefinition(definition, definitionsByName, dependenciesByDefinition
                 });
                 let dependencySet = dependenciesByDefinitionName.get(definitionName);
                 if (!dependencySet) {
-                    dependencySet = new Set();
+                    dependencySet = new Map();
                     dependenciesByDefinitionName.set(definitionName, dependencySet);
                 }
                 switch (field.kind) {
@@ -332,7 +330,7 @@ function getFileDefinitionMap(definitionsByName, dependenciesByDefinitionName) {
         }
         const dependenciesOfDefinition = dependenciesByDefinitionName.get(definitionName);
         if (dependenciesOfDefinition) {
-            for (const dependencyName of dependenciesOfDefinition) {
+            for (const dependencyName of dependenciesOfDefinition.keys()) {
                 const dependencyDefinitions = definitionsByName.get(dependencyName);
                 if (dependencyDefinitions != null) {
                     for (const dependencyDefinition of dependencyDefinitions) {
@@ -513,9 +511,17 @@ function applyPathAlias(prefixPattern, mapping, importFrom) {
     }
     return mapping;
 }
+function addToDependencySet(dependencySet, node) {
+    const existingNodes = dependencySet.get(node.value);
+    if (existingNodes != null) {
+        existingNodes.add(node);
+        return;
+    }
+    dependencySet.set(node.value, new Set([node]));
+}
 function visitOperationDefinitionNode(node, dependencySet) {
     if (node.name?.value) {
-        dependencySet.add(node.name.value);
+        addToDependencySet(dependencySet, node.name);
     }
     node.selectionSet.selections.forEach(selectionNode => visitSelectionNode(selectionNode, dependencySet));
 }
@@ -536,22 +542,20 @@ function visitFieldNode(node, dependencySet) {
     node.selectionSet?.selections.forEach(selectionNode => visitSelectionNode(selectionNode, dependencySet));
 }
 function visitFragmentSpreadNode(node, dependencySet) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
 }
 function visitInlineFragmentNode(node, dependencySet) {
     node.selectionSet.selections.forEach(selectionNode => visitSelectionNode(selectionNode, dependencySet));
 }
 function visitFragmentDefinitionNode(node, dependencySet) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.selectionSet.selections.forEach(selectionNode => visitSelectionNode(selectionNode, dependencySet));
 }
 function addInterfaceDependencies(node, dependencySet, dependenciesByDefinitionName) {
-    const typeName = node.name.value;
     // all interfaces should be dependent to each other
     const allDependencies = [
-        typeName,
-        ...(node.interfaces?.map((namedTypeNode) => namedTypeNode.name.value) ||
-            []),
+        node.name,
+        ...(node.interfaces?.map((namedTypeNode) => namedTypeNode.name) || []),
     ];
     node.interfaces?.forEach((namedTypeNode) => {
         visitNamedTypeNode(namedTypeNode, dependencySet);
@@ -559,19 +563,18 @@ function addInterfaceDependencies(node, dependencySet, dependenciesByDefinitionN
         let set = dependenciesByDefinitionName.get(interfaceName);
         // interface should be dependent to the type as well
         if (set == null) {
-            set = new Set();
+            set = new Map();
             dependenciesByDefinitionName.set(interfaceName, set);
         }
         allDependencies.forEach(dependency => {
-            if (dependency !== interfaceName) {
-                set.add(dependency);
+            if (dependency.value !== interfaceName) {
+                addToDependencySet(set, dependency);
             }
         });
     });
 }
 function visitObjectTypeDefinitionNode(node, dependencySet, dependenciesByDefinitionName) {
-    const typeName = node.name.value;
-    dependencySet.add(typeName);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.fields?.forEach(fieldDefinitionNode => visitFieldDefinitionNode(fieldDefinitionNode, dependencySet, dependenciesByDefinitionName));
     addInterfaceDependencies(node, dependencySet, dependenciesByDefinitionName);
@@ -579,7 +582,7 @@ function visitObjectTypeDefinitionNode(node, dependencySet, dependenciesByDefini
 function visitDirectiveNode(node, dependencySet) {
     const directiveName = node.name.value;
     if (!builtinDirectives.includes(directiveName)) {
-        dependencySet.add(node.name.value);
+        addToDependencySet(dependencySet, node.name);
     }
 }
 function visitFieldDefinitionNode(node, dependencySet, dependenciesByDefinitionName) {
@@ -609,7 +612,7 @@ function visitNonNullTypeNode(node, dependencySet, dependenciesByDefinitionName)
 function visitNamedTypeNode(node, dependencySet) {
     const namedTypeName = node.name.value;
     if (!builtinTypes.includes(namedTypeName)) {
-        dependencySet.add(node.name.value);
+        addToDependencySet(dependencySet, node.name);
     }
 }
 function visitInputValueDefinitionNode(node, dependencySet, dependenciesByDefinitionName) {
@@ -617,74 +620,69 @@ function visitInputValueDefinitionNode(node, dependencySet, dependenciesByDefini
     visitTypeNode(node.type, dependencySet, dependenciesByDefinitionName);
 }
 function visitInterfaceTypeDefinitionNode(node, dependencySet, dependenciesByDefinitionName) {
-    const typeName = node.name.value;
-    dependencySet.add(typeName);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.fields?.forEach(fieldDefinitionNode => visitFieldDefinitionNode(fieldDefinitionNode, dependencySet, dependenciesByDefinitionName));
     addInterfaceDependencies(node, dependencySet, dependenciesByDefinitionName);
 }
 function visitUnionTypeDefinitionNode(node, dependencySet) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.types?.forEach(namedTypeNode => visitNamedTypeNode(namedTypeNode, dependencySet));
 }
 function visitEnumTypeDefinitionNode(node, dependencySet) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
 }
 function visitInputObjectTypeDefinitionNode(node, dependencySet, dependenciesByDefinitionName) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.fields?.forEach(inputValueDefinitionNode => visitInputValueDefinitionNode(inputValueDefinitionNode, dependencySet, dependenciesByDefinitionName));
 }
 function visitDirectiveDefinitionNode(node, dependencySet, dependenciesByDefinitionName) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.arguments?.forEach(inputValueDefinitionNode => visitInputValueDefinitionNode(inputValueDefinitionNode, dependencySet, dependenciesByDefinitionName));
 }
 function visitObjectTypeExtensionNode(node, dependencySet, dependenciesByDefinitionName) {
-    const typeName = node.name.value;
-    dependencySet.add(typeName);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.fields?.forEach(fieldDefinitionNode => visitFieldDefinitionNode(fieldDefinitionNode, dependencySet, dependenciesByDefinitionName));
     addInterfaceDependencies(node, dependencySet, dependenciesByDefinitionName);
 }
 function visitInterfaceTypeExtensionNode(node, dependencySet, dependenciesByDefinitionName) {
-    const typeName = node.name.value;
-    dependencySet.add(typeName);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.fields?.forEach(fieldDefinitionNode => visitFieldDefinitionNode(fieldDefinitionNode, dependencySet, dependenciesByDefinitionName));
     addInterfaceDependencies(node, dependencySet, dependenciesByDefinitionName);
 }
 function visitUnionTypeExtensionNode(node, dependencySet) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.types?.forEach(namedTypeNode => visitNamedTypeNode(namedTypeNode, dependencySet));
 }
 function visitEnumTypeExtensionNode(node, dependencySet) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
 }
 function visitInputObjectTypeExtensionNode(node, dependencySet, dependenciesByDefinitionName) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.fields?.forEach(inputValueDefinitionNode => visitInputValueDefinitionNode(inputValueDefinitionNode, dependencySet, dependenciesByDefinitionName));
 }
 function visitSchemaDefinitionNode(node, dependencySet) {
-    dependencySet.add('schema');
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.operationTypes.forEach(operationTypeDefinitionNode => visitOperationTypeDefinitionNode(operationTypeDefinitionNode, dependencySet));
 }
 function visitSchemaExtensionDefinitionNode(node, dependencySet) {
-    dependencySet.add('schema');
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.operationTypes?.forEach(operationTypeDefinitionNode => visitOperationTypeDefinitionNode(operationTypeDefinitionNode, dependencySet));
 }
 function visitScalarDefinitionNode(node, dependencySet) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
 }
 function visitScalarExtensionNode(node, dependencySet) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
 }
 function visitOperationTypeDefinitionNode(node, dependencySet) {

package/esm/index.js

@@ -2,7 +2,7 @@ import { readFileSync, realpathSync } from 'fs';
 import { dirname, isAbsolute, join } from 'path';
 import { Kind, parse, print, Source, } from 'graphql';
 import resolveFrom from 'resolve-from';
-import { parseGraphQLSDL } from '@graphql-tools/utils';
+import { createGraphQLError, parseGraphQLSDL } from '@graphql-tools/utils';
 import { extractLinkImplementations } from '@theguild/federation-composition';
 const builtinTypes = ['String', 'Float', 'Int', 'Boolean', 'ID', 'Upload'];
 const federationV1Directives = ['key', 'provides', 'requires', 'external'];
@@ -87,7 +87,7 @@ function visitFile(filePath, cwd, visitedFiles, predefinedImports, pathAliases)
                                 addDefinition(importedDefinition, fieldDefinitionName, definitionsWithDeps);
                             }
                         });
-                        const newDependencySet = new Set();
+                        const newDependencySet = new Map();
                         switch (field.kind) {
                             case Kind.FIELD_DEFINITION:
                                 visitFieldDefinitionNode(field, newDependencySet, dependenciesByDefinitionName);
@@ -96,7 +96,7 @@ function visitFile(filePath, cwd, visitedFiles, predefinedImports, pathAliases)
                                 visitInputValueDefinitionNode(field, newDependencySet, dependenciesByDefinitionName);
                                 break;
                         }
-                        newDependencySet.forEach(dependencyName => {
+                        Array.from(newDependencySet.keys()).forEach(dependencyName => {
                             const definitionsInCurrentFile = fileDefinitionMap.get(dependencyName);
                             definitionsInCurrentFile?.forEach(def => addDefinition(def, definitionName, definitionSet));
                             const definitionsFromImports = allImportedDefinitionsMap.get(dependencyName);
@@ -123,11 +123,11 @@ function visitFile(filePath, cwd, visitedFiles, predefinedImports, pathAliases)
                         });
                         const dependenciesOfDefinition = dependenciesByDefinitionName.get(definitionName);
                         if (dependenciesOfDefinition) {
-                            for (const dependencyName of dependenciesOfDefinition) {
+                            for (const [dependencyName, dependencyNodes] of dependenciesOfDefinition.entries()) {
                                 // If that dependency cannot be found both in imports and this file, throw an error
                                 if (!allImportedDefinitionsMap.has(dependencyName) &&
                                     !definitionsByName.has(dependencyName)) {
-                                    throw new Error(`Couldn't find type ${dependencyName} in any of the schemas.`);
+                                    throw createGraphQLError(`Couldn't find type ${dependencyName} in any of the schemas.`, { nodes: Array.from(dependencyNodes) });
                                 }
                                 const dependencyDefinitionsFromImports = allImportedDefinitionsMap.get(dependencyName);
                                 dependencyDefinitionsFromImports?.forEach(dependencyDefinition => {
@@ -150,9 +150,7 @@ function visitFile(filePath, cwd, visitedFiles, predefinedImports, pathAliases)
 export function extractDependencies(filePath, fileContents) {
     const definitionsByName = new Map();
     const dependenciesByDefinitionName = new Map();
-    const { document } = parseGraphQLSDL(filePath, fileContents, {
-        noLocation: true,
-    });
+    const { document } = parseGraphQLSDL(filePath, fileContents);
     for (const definition of document.definitions) {
         visitDefinition(definition, definitionsByName, dependenciesByDefinitionName);
     }
@@ -226,7 +224,7 @@ function visitDefinition(definition, definitionsByName, dependenciesByDefinition
         definitionsSet.add(definition);
         let dependencySet = dependenciesByDefinitionName.get(definitionName);
         if (!dependencySet) {
-            dependencySet = new Set();
+            dependencySet = new Map();
             dependenciesByDefinitionName.set(definitionName, dependencySet);
         }
         switch (definition.kind) {
@@ -296,7 +294,7 @@ function visitDefinition(definition, definitionsByName, dependenciesByDefinition
                 });
                 let dependencySet = dependenciesByDefinitionName.get(definitionName);
                 if (!dependencySet) {
-                    dependencySet = new Set();
+                    dependencySet = new Map();
                     dependenciesByDefinitionName.set(definitionName, dependencySet);
                 }
                 switch (field.kind) {
@@ -324,7 +322,7 @@ function getFileDefinitionMap(definitionsByName, dependenciesByDefinitionName) {
         }
         const dependenciesOfDefinition = dependenciesByDefinitionName.get(definitionName);
         if (dependenciesOfDefinition) {
-            for (const dependencyName of dependenciesOfDefinition) {
+            for (const dependencyName of dependenciesOfDefinition.keys()) {
                 const dependencyDefinitions = definitionsByName.get(dependencyName);
                 if (dependencyDefinitions != null) {
                     for (const dependencyDefinition of dependencyDefinitions) {
@@ -505,9 +503,17 @@ function applyPathAlias(prefixPattern, mapping, importFrom) {
     }
     return mapping;
 }
+function addToDependencySet(dependencySet, node) {
+    const existingNodes = dependencySet.get(node.value);
+    if (existingNodes != null) {
+        existingNodes.add(node);
+        return;
+    }
+    dependencySet.set(node.value, new Set([node]));
+}
 function visitOperationDefinitionNode(node, dependencySet) {
     if (node.name?.value) {
-        dependencySet.add(node.name.value);
+        addToDependencySet(dependencySet, node.name);
     }
     node.selectionSet.selections.forEach(selectionNode => visitSelectionNode(selectionNode, dependencySet));
 }
@@ -528,22 +534,20 @@ function visitFieldNode(node, dependencySet) {
     node.selectionSet?.selections.forEach(selectionNode => visitSelectionNode(selectionNode, dependencySet));
 }
 function visitFragmentSpreadNode(node, dependencySet) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
 }
 function visitInlineFragmentNode(node, dependencySet) {
     node.selectionSet.selections.forEach(selectionNode => visitSelectionNode(selectionNode, dependencySet));
 }
 function visitFragmentDefinitionNode(node, dependencySet) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.selectionSet.selections.forEach(selectionNode => visitSelectionNode(selectionNode, dependencySet));
 }
 function addInterfaceDependencies(node, dependencySet, dependenciesByDefinitionName) {
-    const typeName = node.name.value;
     // all interfaces should be dependent to each other
     const allDependencies = [
-        typeName,
-        ...(node.interfaces?.map((namedTypeNode) => namedTypeNode.name.value) ||
-            []),
+        node.name,
+        ...(node.interfaces?.map((namedTypeNode) => namedTypeNode.name) || []),
     ];
     node.interfaces?.forEach((namedTypeNode) => {
         visitNamedTypeNode(namedTypeNode, dependencySet);
@@ -551,19 +555,18 @@ function addInterfaceDependencies(node, dependencySet, dependenciesByDefinitionN
         let set = dependenciesByDefinitionName.get(interfaceName);
         // interface should be dependent to the type as well
         if (set == null) {
-            set = new Set();
+            set = new Map();
             dependenciesByDefinitionName.set(interfaceName, set);
         }
         allDependencies.forEach(dependency => {
-            if (dependency !== interfaceName) {
-                set.add(dependency);
+            if (dependency.value !== interfaceName) {
+                addToDependencySet(set, dependency);
             }
         });
     });
 }
 function visitObjectTypeDefinitionNode(node, dependencySet, dependenciesByDefinitionName) {
-    const typeName = node.name.value;
-    dependencySet.add(typeName);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.fields?.forEach(fieldDefinitionNode => visitFieldDefinitionNode(fieldDefinitionNode, dependencySet, dependenciesByDefinitionName));
     addInterfaceDependencies(node, dependencySet, dependenciesByDefinitionName);
@@ -571,7 +574,7 @@ function visitObjectTypeDefinitionNode(node, dependencySet, dependenciesByDefini
 function visitDirectiveNode(node, dependencySet) {
     const directiveName = node.name.value;
     if (!builtinDirectives.includes(directiveName)) {
-        dependencySet.add(node.name.value);
+        addToDependencySet(dependencySet, node.name);
     }
 }
 function visitFieldDefinitionNode(node, dependencySet, dependenciesByDefinitionName) {
@@ -601,7 +604,7 @@ function visitNonNullTypeNode(node, dependencySet, dependenciesByDefinitionName)
 function visitNamedTypeNode(node, dependencySet) {
     const namedTypeName = node.name.value;
     if (!builtinTypes.includes(namedTypeName)) {
-        dependencySet.add(node.name.value);
+        addToDependencySet(dependencySet, node.name);
     }
 }
 function visitInputValueDefinitionNode(node, dependencySet, dependenciesByDefinitionName) {
@@ -609,74 +612,69 @@ function visitInputValueDefinitionNode(node, dependencySet, dependenciesByDefini
     visitTypeNode(node.type, dependencySet, dependenciesByDefinitionName);
 }
 function visitInterfaceTypeDefinitionNode(node, dependencySet, dependenciesByDefinitionName) {
-    const typeName = node.name.value;
-    dependencySet.add(typeName);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.fields?.forEach(fieldDefinitionNode => visitFieldDefinitionNode(fieldDefinitionNode, dependencySet, dependenciesByDefinitionName));
     addInterfaceDependencies(node, dependencySet, dependenciesByDefinitionName);
 }
 function visitUnionTypeDefinitionNode(node, dependencySet) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.types?.forEach(namedTypeNode => visitNamedTypeNode(namedTypeNode, dependencySet));
 }
 function visitEnumTypeDefinitionNode(node, dependencySet) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
 }
 function visitInputObjectTypeDefinitionNode(node, dependencySet, dependenciesByDefinitionName) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.fields?.forEach(inputValueDefinitionNode => visitInputValueDefinitionNode(inputValueDefinitionNode, dependencySet, dependenciesByDefinitionName));
 }
 function visitDirectiveDefinitionNode(node, dependencySet, dependenciesByDefinitionName) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.arguments?.forEach(inputValueDefinitionNode => visitInputValueDefinitionNode(inputValueDefinitionNode, dependencySet, dependenciesByDefinitionName));
 }
 function visitObjectTypeExtensionNode(node, dependencySet, dependenciesByDefinitionName) {
-    const typeName = node.name.value;
-    dependencySet.add(typeName);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.fields?.forEach(fieldDefinitionNode => visitFieldDefinitionNode(fieldDefinitionNode, dependencySet, dependenciesByDefinitionName));
     addInterfaceDependencies(node, dependencySet, dependenciesByDefinitionName);
 }
 function visitInterfaceTypeExtensionNode(node, dependencySet, dependenciesByDefinitionName) {
-    const typeName = node.name.value;
-    dependencySet.add(typeName);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.fields?.forEach(fieldDefinitionNode => visitFieldDefinitionNode(fieldDefinitionNode, dependencySet, dependenciesByDefinitionName));
     addInterfaceDependencies(node, dependencySet, dependenciesByDefinitionName);
 }
 function visitUnionTypeExtensionNode(node, dependencySet) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.types?.forEach(namedTypeNode => visitNamedTypeNode(namedTypeNode, dependencySet));
 }
 function visitEnumTypeExtensionNode(node, dependencySet) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
 }
 function visitInputObjectTypeExtensionNode(node, dependencySet, dependenciesByDefinitionName) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.fields?.forEach(inputValueDefinitionNode => visitInputValueDefinitionNode(inputValueDefinitionNode, dependencySet, dependenciesByDefinitionName));
 }
 function visitSchemaDefinitionNode(node, dependencySet) {
-    dependencySet.add('schema');
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.operationTypes.forEach(operationTypeDefinitionNode => visitOperationTypeDefinitionNode(operationTypeDefinitionNode, dependencySet));
 }
 function visitSchemaExtensionDefinitionNode(node, dependencySet) {
-    dependencySet.add('schema');
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
     node.operationTypes?.forEach(operationTypeDefinitionNode => visitOperationTypeDefinitionNode(operationTypeDefinitionNode, dependencySet));
 }
 function visitScalarDefinitionNode(node, dependencySet) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
 }
 function visitScalarExtensionNode(node, dependencySet) {
-    dependencySet.add(node.name.value);
+    addToDependencySet(dependencySet, node.name);
     node.directives?.forEach(directiveNode => visitDirectiveNode(directiveNode, dependencySet));
 }
 function visitOperationTypeDefinitionNode(node, dependencySet) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/import",
-  "version": "7.1.1-alpha-20250905084227-a20ed1fabf7f2c69761699dc9c4e0676cd9e8c28",
+  "version": "7.1.1-alpha-20250905110939-465ce4b83eaffe7e8ad2d10538526654c551aeff",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {

package/typings/index.d.cts

@@ -1,4 +1,4 @@
-import { DefinitionNode, DocumentNode } from 'graphql';
+import { DefinitionNode, DocumentNode, NameNode } from 'graphql';
 export type VisitedFilesMap = Map<string, Map<string, Set<DefinitionNode>>>;
 /**
  * Configuration for path aliasing in GraphQL import statements using the same
@@ -69,9 +69,11 @@ export interface PathAliases {
  * processImport does not merge the typeDefs as designed ( https://github.com/ardatan/graphql-tools/issues/2980#issuecomment-1003692728 )
  */
 export declare function processImport(filePath: string, cwd?: string, predefinedImports?: Record<string, string>, visitedFiles?: VisitedFilesMap, pathAliases?: PathAliases): DocumentNode;
+type DependencySet = Map<string, Set<NameNode>>;
+type DependenciesByDefinitionName = Map<string, DependencySet>;
 export declare function extractDependencies(filePath: string, fileContents: string): {
     definitionsByName: Map<string, Set<DefinitionNode>>;
-    dependenciesByDefinitionName: Map<string, Set<string>>;
+    dependenciesByDefinitionName: DependenciesByDefinitionName;
 };
 export declare function processImports(importLines: string[], filePath: string, visitedFiles: VisitedFilesMap, predefinedImports: Record<string, string>, pathAliases?: PathAliases): {
     allImportedDefinitionsMap: Map<string, Set<DefinitionNode>>;
@@ -95,3 +97,4 @@ export declare function parseImportLine(importLine: string): {
     imports: string[];
     from: string;
 };
+export {};

package/typings/index.d.ts

@@ -1,4 +1,4 @@
-import { DefinitionNode, DocumentNode } from 'graphql';
+import { DefinitionNode, DocumentNode, NameNode } from 'graphql';
 export type VisitedFilesMap = Map<string, Map<string, Set<DefinitionNode>>>;
 /**
  * Configuration for path aliasing in GraphQL import statements using the same
@@ -69,9 +69,11 @@ export interface PathAliases {
  * processImport does not merge the typeDefs as designed ( https://github.com/ardatan/graphql-tools/issues/2980#issuecomment-1003692728 )
  */
 export declare function processImport(filePath: string, cwd?: string, predefinedImports?: Record<string, string>, visitedFiles?: VisitedFilesMap, pathAliases?: PathAliases): DocumentNode;
+type DependencySet = Map<string, Set<NameNode>>;
+type DependenciesByDefinitionName = Map<string, DependencySet>;
 export declare function extractDependencies(filePath: string, fileContents: string): {
     definitionsByName: Map<string, Set<DefinitionNode>>;
-    dependenciesByDefinitionName: Map<string, Set<string>>;
+    dependenciesByDefinitionName: DependenciesByDefinitionName;
 };
 export declare function processImports(importLines: string[], filePath: string, visitedFiles: VisitedFilesMap, predefinedImports: Record<string, string>, pathAliases?: PathAliases): {
     allImportedDefinitionsMap: Map<string, Set<DefinitionNode>>;
@@ -95,3 +97,4 @@ export declare function parseImportLine(importLine: string): {
     imports: string[];
     from: string;
 };
+export {};