@nmarks/graphql-codegen-per-operation-file-preset 1.0.8 → 1.0.10

package/cjs/fragment-resolver.js

@@ -145,5 +145,5 @@ function buildFragmentResolver(collectorOptions, presetOptions, schemaObject, de
             })),
         };
     }
-    return resolveFragments;
+    return { resolveFragments, fragmentRegistry };
 }

package/cjs/index.js

@@ -24,18 +24,17 @@ function extractDefinitions(document) {
     return definitions;
 }
 /**
- * Finds "local" fragments - fragments defined in the same source file as the current definition.
- * These are initially local but become external after we split the file per-operation.
- *
- * Example:
- * Source file has: query MyQuery { ...MyFragment } + fragment MyFragment { ... }
- * After split: MyQuery.ts needs to import from MyFragment.ts
+ * Collects all fragment names directly referenced by a definition via FragmentSpread nodes.
+ * This only gets DIRECT references - not transitive dependencies.
  */
-function findLocalFragments(allDefinitions, currentDefinitionName) {
-    return allDefinitions
-        .filter(d => d.definition.kind === graphql_1.Kind.FRAGMENT_DEFINITION &&
-        d.name !== currentDefinitionName)
-        .map(d => d.definition);
+function getDirectlyReferencedFragments(definition) {
+    const referencedFragments = new Set();
+    (0, graphql_1.visit)(definition, {
+        FragmentSpread: (node) => {
+            referencedFragments.add(node.name.value);
+        },
+    });
+    return referencedFragments;
 }
 /**
  * Creates LoadedFragment objects for local fragments so they can be treated as external fragments
@@ -50,18 +49,72 @@ function createLoadedFragments(fragments) {
         node: frag,
     }));
 }
+/**
+ * Analyzes fragment dependencies for a definition.
+ *
+ * Returns two sets:
+ * 1. `allNeeded` - ALL fragments needed (including transitive) - for externalFragments
+ * 2. `directlyNeeded` - Only DIRECT dependencies - for fragmentImports
+ *
+ * Why the distinction?
+ * - `externalFragments` must include all transitive deps so the plugin can resolve types
+ * - `fragmentImports` should only include direct deps; transitive deps are imported by intermediate files
+ *
+ * Example: Query → FragA → FragB
+ * - Query's externalFragments: [FragA, FragB] (plugin needs both)
+ * - Query's fragmentImports: [FragA] (only direct; FragA.ts imports FragB)
+ *
+ * @param definition - The operation/fragment definition to analyze
+ * @param externalFragments - All external fragments available (from other files)
+ * @param localFragmentMap - Map of local fragment names to their definitions
+ */
+function analyzeFragmentDependencies(definition, externalFragments, localFragmentMap) {
+    const allNeeded = new Set();
+    // Build a map for quick lookup of external fragment nodes
+    const externalFragmentMap = new Map();
+    for (const frag of externalFragments) {
+        externalFragmentMap.set(frag.name, frag.node);
+    }
+    function collectTransitive(fragmentNames) {
+        for (const name of fragmentNames) {
+            if (allNeeded.has(name))
+                continue;
+            // Check if this fragment exists (either local or external)
+            const localDef = localFragmentMap.get(name);
+            const externalDef = externalFragmentMap.get(name);
+            const fragmentDef = localDef || externalDef;
+            if (fragmentDef) {
+                allNeeded.add(name);
+                // Get transitive dependencies
+                const transitiveDeps = getDirectlyReferencedFragments(fragmentDef);
+                collectTransitive(transitiveDeps);
+            }
+        }
+    }
+    // Get direct references from the definition
+    const directlyNeeded = getDirectlyReferencedFragments(definition);
+    // Collect all transitive dependencies (includes direct ones)
+    collectTransitive(directlyNeeded);
+    return { allNeeded, directlyNeeded };
+}
 /**
  * Creates fragment import declarations for local fragments.
  * After splitting, these fragments will be in separate files, so we need to generate imports.
  *
  * Example: query references RetailerServicesData → import from './RetailerServicesData.ts'
+ *
+ * NOTE: We use the fragment registry to get the proper import identifiers (with correct naming/suffix)
+ * instead of hardcoding them, since naming depends on config (dedupeOperationSuffix, etc.)
  */
-function createLocalFragmentImports(localFragments, sourceLocation, currentFilename, folder, extension, options) {
+function createLocalFragmentImports(localFragments, fragmentRegistry, sourceLocation, currentFilename, folder, extension, options) {
     return localFragments.map((frag) => {
         var _a;
         const fragmentFilePath = (0, utils_js_1.generateOperationFilePath)(sourceLocation, frag.name.value, folder, extension);
-        // Generate import identifiers: both the document (for runtime) and type (for TypeScript)
-        const identifiers = [
+        // Get the proper import identifiers from the fragment registry
+        // (calculated by fragment-resolver using BaseVisitor with correct naming conventions)
+        const registryEntry = fragmentRegistry[frag.name.value];
+        const identifiers = (registryEntry === null || registryEntry === void 0 ? void 0 : registryEntry.imports) || [
+            // Fallback if not in registry (shouldn't happen, but be safe)
             {
                 name: `${frag.name.value}FragmentDoc`,
                 kind: 'document',
@@ -97,7 +150,8 @@ function createLocalFragmentImports(localFragments, sourceLocation, currentFilen
  * We ONLY need the Types import when generated code actually references the Types namespace:
  *
  * ✅ NEEDS IMPORT:
- * - Operations (query/mutation/subscription) - generate `Types.Exact<{...}>` for Variables type
+ * - Operations (query/mutation/subscription) - ALWAYS generate `Types.Exact<{...}>` for Variables type
+ *   (even operations without variables: `Types.Exact<{ [key: string]: never; }>`)
  * - Enums - generate `role: Types.Role`
  * - Custom scalars (unless mapped to primitives) - generate `date: Types.DateTime`
  * - Input types - used in variables as `Types.MyInput`
@@ -116,8 +170,11 @@ function needsSchemaTypesImport(document, schema, config) {
     const scalarMappings = config.scalars || {};
     /**
      * STEP 1: Check for operations (queries/mutations/subscriptions)
-     * All operations generate a Variables type that uses Types.Exact, even without variables:
+     * ALL operations generate a Variables type that uses Types.Exact, even without variables:
      * `export type MyQueryVariables = Types.Exact<{ [key: string]: never; }>;`
+     *
+     * This is true for typescript-operations plugin regardless of whether the operation
+     * has any variable definitions or not.
      */
     let hasOperation = false;
     const referencedTypeNames = new Set();
@@ -133,6 +190,7 @@ function needsSchemaTypesImport(document, schema, config) {
             referencedTypeNames.add(node.typeCondition.name.value);
         },
     });
+    // All operations need Types import for Variables type
     if (hasOperation) {
         return true;
     }
@@ -195,9 +253,17 @@ function needsSchemaTypesImport(document, schema, config) {
      * STEP 4: Check field return types
      * Use TypeInfo to properly resolve field types through the schema.
      * This catches cases like: user { role } where 'role' returns an enum.
+     *
+     * IMPORTANT: Only check the FIRST definition (the actual operation/fragment being generated).
+     * Don't check external fragments - those will have their own imports.
      */
+    // Create a document with ONLY the first definition for type checking
+    const singleDefOnly = {
+        kind: graphql_1.Kind.DOCUMENT,
+        definitions: [document.definitions[0]],
+    };
     const typeInfo = new graphql_1.TypeInfo(schema);
-    (0, graphql_1.visit)(document, (0, graphql_1.visitWithTypeInfo)(typeInfo, {
+    (0, graphql_1.visit)(singleDefOnly, (0, graphql_1.visitWithTypeInfo)(typeInfo, {
         Field: () => {
             const fieldType = typeInfo.getType();
             if (checkType(fieldType)) {
@@ -261,7 +327,7 @@ exports.preset = {
          * This uses our adapted fragment-resolver that generates paths based on fragment NAMES
          * (not source file names), enabling proper imports after splitting.
          */
-        const sources = (0, resolve_document_imports_js_1.resolveDocumentImports)(options, schemaObject, {
+        const { results: sources, fragmentRegistry } = (0, resolve_document_imports_js_1.resolveDocumentImports)(options, schemaObject, {
             baseDir,
             folder,
             extension,
@@ -308,25 +374,72 @@ exports.preset = {
                  * resolver marked MyFrag as "local" (same document).
                  *
                  * Solution: Treat local fragments as external after splitting.
+                 * Only include fragments that are actually referenced by this definition.
                  */
-                const localFragments = findLocalFragments(definitions, name);
-                const localFragmentNodes = createLoadedFragments(localFragments);
-                // Combine external fragments (from other files) + local fragments (same source file)
+                // Build a map of local fragment names -> definitions for lookup
+                const localFragmentMap = new Map();
+                for (const d of definitions) {
+                    if (d.definition.kind === graphql_1.Kind.FRAGMENT_DEFINITION && d.name !== name) {
+                        localFragmentMap.set(d.name, d.definition);
+                    }
+                }
+                /**
+                 * ANALYZE FRAGMENT DEPENDENCIES
+                 *
+                 * We need two different sets of fragments:
+                 * 1. allNeeded - ALL transitive deps for externalFragments (plugin needs these for type resolution)
+                 * 2. directlyNeeded - Only DIRECT deps for fragmentImports (transitive deps handled by intermediate files)
+                 *
+                 * Example: Query → FragA → FragB
+                 * - externalFragments: [FragA, FragB] (plugin needs both for types)
+                 * - fragmentImports: [FragA] (only direct; FragA.ts already imports FragB)
+                 */
+                const { allNeeded, directlyNeeded } = analyzeFragmentDependencies(definition, source.externalFragments, localFragmentMap);
+                // Filter local fragments to only those in the transitive dependency set
+                // (for externalFragments - plugin needs all of them)
+                const allLocalFragments = Array.from(localFragmentMap.entries())
+                    .filter(([fragName]) => allNeeded.has(fragName))
+                    .map(([, fragDef]) => fragDef);
+                const localFragmentNodes = createLoadedFragments(allLocalFragments);
+                // Filter external fragments to only those actually needed by this definition
+                const filteredExternalFragments = source.externalFragments.filter(frag => allNeeded.has(frag.name));
+                // Combine filtered external fragments + local fragments (all transitive deps)
                 const allExternalFragments = [
-                    ...source.externalFragments,
+                    ...filteredExternalFragments,
                     ...localFragmentNodes,
                 ];
                 /**
                  * UPDATE FRAGMENT IMPORTS
                  *
-                 * 1. External fragments: Update outputPath to this operation's file
-                 * 2. Local fragments: Generate new imports pointing to their split files
+                 * Only import DIRECT dependencies, not transitive ones.
+                 * Transitive dependencies are imported by the intermediate fragment files.
+                 *
+                 * 1. External fragments: Filter to only DIRECTLY needed ones, update outputPath
+                 * 2. Local fragments: Generate imports only for DIRECTLY referenced fragments
                  */
-                const updatedFragmentImports = source.fragmentImports.map(fragmentImport => ({
+                const updatedFragmentImports = source.fragmentImports
+                    // Filter to only include imports for fragments DIRECTLY referenced
+                    .filter(fragmentImport => {
+                    // Check if any of the import's identifiers are for directly needed fragments
+                    return fragmentImport.importSource.identifiers.some(id => {
+                        // Check if this identifier's name matches a directly needed fragment
+                        for (const neededName of directlyNeeded) {
+                            if (id.name === neededName || id.name.startsWith(neededName)) {
+                                return true;
+                            }
+                        }
+                        return false;
+                    });
+                })
+                    .map(fragmentImport => ({
                     ...fragmentImport,
                     outputPath: filename,
                 }));
-                const localFragmentImports = createLocalFragmentImports(localFragments, source.documents[0].location, filename, folder, extension, {
+                // Only create imports for DIRECTLY referenced local fragments
+                const directlyNeededLocalFragments = Array.from(localFragmentMap.entries())
+                    .filter(([fragName]) => directlyNeeded.has(fragName))
+                    .map(([, fragDef]) => fragDef);
+                const localFragmentImports = createLocalFragmentImports(directlyNeededLocalFragments, fragmentRegistry, source.documents[0].location, filename, folder, extension, {
                     baseDir,
                     baseOutputDir: options.baseOutputDir,
                     emitLegacyCommonJSImports: options.config.emitLegacyCommonJSImports,

package/cjs/resolve-document-imports.js

@@ -12,10 +12,10 @@ const fragment_resolver_js_1 = tslib_1.__importDefault(require("./fragment-resol
  * Does not define specific plugins, but rather returns a string[] of `importStatements` for the calling plugin to make use of
  */
 function resolveDocumentImports(presetOptions, schemaObject, importResolverOptions, dedupeFragments = false) {
-    const resolveFragments = (0, fragment_resolver_js_1.default)(importResolverOptions, presetOptions, schemaObject, dedupeFragments);
+    const { resolveFragments, fragmentRegistry } = (0, fragment_resolver_js_1.default)(importResolverOptions, presetOptions, schemaObject, dedupeFragments);
     const { baseOutputDir, documents } = presetOptions;
     const { schemaTypesSource, baseDir, typesImport } = importResolverOptions;
-    return documents.map(documentFile => {
+    const results = documents.map(documentFile => {
         try {
             // NOTE: We pass a placeholder filename here since we'll generate proper filenames per-operation later
             // The important part is that fragment resolution will use the correct paths from the registry
@@ -55,4 +55,5 @@ function resolveDocumentImports(presetOptions, schemaObject, importResolverOptio
          ${e.message || e.toString()}`);
         }
     });
+    return { results, fragmentRegistry };
 }

package/esm/fragment-resolver.js

@@ -142,5 +142,5 @@ export default function buildFragmentResolver(collectorOptions, presetOptions, s
             })),
         };
     }
-    return resolveFragments;
+    return { resolveFragments, fragmentRegistry };
 }

package/esm/index.js

@@ -20,18 +20,17 @@ function extractDefinitions(document) {
     return definitions;
 }
 /**
- * Finds "local" fragments - fragments defined in the same source file as the current definition.
- * These are initially local but become external after we split the file per-operation.
- *
- * Example:
- * Source file has: query MyQuery { ...MyFragment } + fragment MyFragment { ... }
- * After split: MyQuery.ts needs to import from MyFragment.ts
+ * Collects all fragment names directly referenced by a definition via FragmentSpread nodes.
+ * This only gets DIRECT references - not transitive dependencies.
  */
-function findLocalFragments(allDefinitions, currentDefinitionName) {
-    return allDefinitions
-        .filter(d => d.definition.kind === Kind.FRAGMENT_DEFINITION &&
-        d.name !== currentDefinitionName)
-        .map(d => d.definition);
+function getDirectlyReferencedFragments(definition) {
+    const referencedFragments = new Set();
+    visit(definition, {
+        FragmentSpread: (node) => {
+            referencedFragments.add(node.name.value);
+        },
+    });
+    return referencedFragments;
 }
 /**
  * Creates LoadedFragment objects for local fragments so they can be treated as external fragments
@@ -46,18 +45,72 @@ function createLoadedFragments(fragments) {
         node: frag,
     }));
 }
+/**
+ * Analyzes fragment dependencies for a definition.
+ *
+ * Returns two sets:
+ * 1. `allNeeded` - ALL fragments needed (including transitive) - for externalFragments
+ * 2. `directlyNeeded` - Only DIRECT dependencies - for fragmentImports
+ *
+ * Why the distinction?
+ * - `externalFragments` must include all transitive deps so the plugin can resolve types
+ * - `fragmentImports` should only include direct deps; transitive deps are imported by intermediate files
+ *
+ * Example: Query → FragA → FragB
+ * - Query's externalFragments: [FragA, FragB] (plugin needs both)
+ * - Query's fragmentImports: [FragA] (only direct; FragA.ts imports FragB)
+ *
+ * @param definition - The operation/fragment definition to analyze
+ * @param externalFragments - All external fragments available (from other files)
+ * @param localFragmentMap - Map of local fragment names to their definitions
+ */
+function analyzeFragmentDependencies(definition, externalFragments, localFragmentMap) {
+    const allNeeded = new Set();
+    // Build a map for quick lookup of external fragment nodes
+    const externalFragmentMap = new Map();
+    for (const frag of externalFragments) {
+        externalFragmentMap.set(frag.name, frag.node);
+    }
+    function collectTransitive(fragmentNames) {
+        for (const name of fragmentNames) {
+            if (allNeeded.has(name))
+                continue;
+            // Check if this fragment exists (either local or external)
+            const localDef = localFragmentMap.get(name);
+            const externalDef = externalFragmentMap.get(name);
+            const fragmentDef = localDef || externalDef;
+            if (fragmentDef) {
+                allNeeded.add(name);
+                // Get transitive dependencies
+                const transitiveDeps = getDirectlyReferencedFragments(fragmentDef);
+                collectTransitive(transitiveDeps);
+            }
+        }
+    }
+    // Get direct references from the definition
+    const directlyNeeded = getDirectlyReferencedFragments(definition);
+    // Collect all transitive dependencies (includes direct ones)
+    collectTransitive(directlyNeeded);
+    return { allNeeded, directlyNeeded };
+}
 /**
  * Creates fragment import declarations for local fragments.
  * After splitting, these fragments will be in separate files, so we need to generate imports.
  *
  * Example: query references RetailerServicesData → import from './RetailerServicesData.ts'
+ *
+ * NOTE: We use the fragment registry to get the proper import identifiers (with correct naming/suffix)
+ * instead of hardcoding them, since naming depends on config (dedupeOperationSuffix, etc.)
  */
-function createLocalFragmentImports(localFragments, sourceLocation, currentFilename, folder, extension, options) {
+function createLocalFragmentImports(localFragments, fragmentRegistry, sourceLocation, currentFilename, folder, extension, options) {
     return localFragments.map((frag) => {
         var _a;
         const fragmentFilePath = generateOperationFilePath(sourceLocation, frag.name.value, folder, extension);
-        // Generate import identifiers: both the document (for runtime) and type (for TypeScript)
-        const identifiers = [
+        // Get the proper import identifiers from the fragment registry
+        // (calculated by fragment-resolver using BaseVisitor with correct naming conventions)
+        const registryEntry = fragmentRegistry[frag.name.value];
+        const identifiers = (registryEntry === null || registryEntry === void 0 ? void 0 : registryEntry.imports) || [
+            // Fallback if not in registry (shouldn't happen, but be safe)
             {
                 name: `${frag.name.value}FragmentDoc`,
                 kind: 'document',
@@ -93,7 +146,8 @@ function createLocalFragmentImports(localFragments, sourceLocation, currentFilen
  * We ONLY need the Types import when generated code actually references the Types namespace:
  *
  * ✅ NEEDS IMPORT:
- * - Operations (query/mutation/subscription) - generate `Types.Exact<{...}>` for Variables type
+ * - Operations (query/mutation/subscription) - ALWAYS generate `Types.Exact<{...}>` for Variables type
+ *   (even operations without variables: `Types.Exact<{ [key: string]: never; }>`)
  * - Enums - generate `role: Types.Role`
  * - Custom scalars (unless mapped to primitives) - generate `date: Types.DateTime`
  * - Input types - used in variables as `Types.MyInput`
@@ -112,8 +166,11 @@ function needsSchemaTypesImport(document, schema, config) {
     const scalarMappings = config.scalars || {};
     /**
      * STEP 1: Check for operations (queries/mutations/subscriptions)
-     * All operations generate a Variables type that uses Types.Exact, even without variables:
+     * ALL operations generate a Variables type that uses Types.Exact, even without variables:
      * `export type MyQueryVariables = Types.Exact<{ [key: string]: never; }>;`
+     *
+     * This is true for typescript-operations plugin regardless of whether the operation
+     * has any variable definitions or not.
      */
     let hasOperation = false;
     const referencedTypeNames = new Set();
@@ -129,6 +186,7 @@ function needsSchemaTypesImport(document, schema, config) {
             referencedTypeNames.add(node.typeCondition.name.value);
         },
     });
+    // All operations need Types import for Variables type
     if (hasOperation) {
         return true;
     }
@@ -191,9 +249,17 @@ function needsSchemaTypesImport(document, schema, config) {
      * STEP 4: Check field return types
      * Use TypeInfo to properly resolve field types through the schema.
      * This catches cases like: user { role } where 'role' returns an enum.
+     *
+     * IMPORTANT: Only check the FIRST definition (the actual operation/fragment being generated).
+     * Don't check external fragments - those will have their own imports.
      */
+    // Create a document with ONLY the first definition for type checking
+    const singleDefOnly = {
+        kind: Kind.DOCUMENT,
+        definitions: [document.definitions[0]],
+    };
     const typeInfo = new TypeInfo(schema);
-    visit(document, visitWithTypeInfo(typeInfo, {
+    visit(singleDefOnly, visitWithTypeInfo(typeInfo, {
         Field: () => {
             const fieldType = typeInfo.getType();
             if (checkType(fieldType)) {
@@ -257,7 +323,7 @@ export const preset = {
          * This uses our adapted fragment-resolver that generates paths based on fragment NAMES
          * (not source file names), enabling proper imports after splitting.
          */
-        const sources = resolveDocumentImports(options, schemaObject, {
+        const { results: sources, fragmentRegistry } = resolveDocumentImports(options, schemaObject, {
             baseDir,
             folder,
             extension,
@@ -304,25 +370,72 @@ export const preset = {
                  * resolver marked MyFrag as "local" (same document).
                  *
                  * Solution: Treat local fragments as external after splitting.
+                 * Only include fragments that are actually referenced by this definition.
                  */
-                const localFragments = findLocalFragments(definitions, name);
-                const localFragmentNodes = createLoadedFragments(localFragments);
-                // Combine external fragments (from other files) + local fragments (same source file)
+                // Build a map of local fragment names -> definitions for lookup
+                const localFragmentMap = new Map();
+                for (const d of definitions) {
+                    if (d.definition.kind === Kind.FRAGMENT_DEFINITION && d.name !== name) {
+                        localFragmentMap.set(d.name, d.definition);
+                    }
+                }
+                /**
+                 * ANALYZE FRAGMENT DEPENDENCIES
+                 *
+                 * We need two different sets of fragments:
+                 * 1. allNeeded - ALL transitive deps for externalFragments (plugin needs these for type resolution)
+                 * 2. directlyNeeded - Only DIRECT deps for fragmentImports (transitive deps handled by intermediate files)
+                 *
+                 * Example: Query → FragA → FragB
+                 * - externalFragments: [FragA, FragB] (plugin needs both for types)
+                 * - fragmentImports: [FragA] (only direct; FragA.ts already imports FragB)
+                 */
+                const { allNeeded, directlyNeeded } = analyzeFragmentDependencies(definition, source.externalFragments, localFragmentMap);
+                // Filter local fragments to only those in the transitive dependency set
+                // (for externalFragments - plugin needs all of them)
+                const allLocalFragments = Array.from(localFragmentMap.entries())
+                    .filter(([fragName]) => allNeeded.has(fragName))
+                    .map(([, fragDef]) => fragDef);
+                const localFragmentNodes = createLoadedFragments(allLocalFragments);
+                // Filter external fragments to only those actually needed by this definition
+                const filteredExternalFragments = source.externalFragments.filter(frag => allNeeded.has(frag.name));
+                // Combine filtered external fragments + local fragments (all transitive deps)
                 const allExternalFragments = [
-                    ...source.externalFragments,
+                    ...filteredExternalFragments,
                     ...localFragmentNodes,
                 ];
                 /**
                  * UPDATE FRAGMENT IMPORTS
                  *
-                 * 1. External fragments: Update outputPath to this operation's file
-                 * 2. Local fragments: Generate new imports pointing to their split files
+                 * Only import DIRECT dependencies, not transitive ones.
+                 * Transitive dependencies are imported by the intermediate fragment files.
+                 *
+                 * 1. External fragments: Filter to only DIRECTLY needed ones, update outputPath
+                 * 2. Local fragments: Generate imports only for DIRECTLY referenced fragments
                  */
-                const updatedFragmentImports = source.fragmentImports.map(fragmentImport => ({
+                const updatedFragmentImports = source.fragmentImports
+                    // Filter to only include imports for fragments DIRECTLY referenced
+                    .filter(fragmentImport => {
+                    // Check if any of the import's identifiers are for directly needed fragments
+                    return fragmentImport.importSource.identifiers.some(id => {
+                        // Check if this identifier's name matches a directly needed fragment
+                        for (const neededName of directlyNeeded) {
+                            if (id.name === neededName || id.name.startsWith(neededName)) {
+                                return true;
+                            }
+                        }
+                        return false;
+                    });
+                })
+                    .map(fragmentImport => ({
                     ...fragmentImport,
                     outputPath: filename,
                 }));
-                const localFragmentImports = createLocalFragmentImports(localFragments, source.documents[0].location, filename, folder, extension, {
+                // Only create imports for DIRECTLY referenced local fragments
+                const directlyNeededLocalFragments = Array.from(localFragmentMap.entries())
+                    .filter(([fragName]) => directlyNeeded.has(fragName))
+                    .map(([, fragDef]) => fragDef);
+                const localFragmentImports = createLocalFragmentImports(directlyNeededLocalFragments, fragmentRegistry, source.documents[0].location, filename, folder, extension, {
                     baseDir,
                     baseOutputDir: options.baseOutputDir,
                     emitLegacyCommonJSImports: options.config.emitLegacyCommonJSImports,

package/esm/resolve-document-imports.js

@@ -8,10 +8,10 @@ import buildFragmentResolver from './fragment-resolver.js';
  * Does not define specific plugins, but rather returns a string[] of `importStatements` for the calling plugin to make use of
  */
 export function resolveDocumentImports(presetOptions, schemaObject, importResolverOptions, dedupeFragments = false) {
-    const resolveFragments = buildFragmentResolver(importResolverOptions, presetOptions, schemaObject, dedupeFragments);
+    const { resolveFragments, fragmentRegistry } = buildFragmentResolver(importResolverOptions, presetOptions, schemaObject, dedupeFragments);
     const { baseOutputDir, documents } = presetOptions;
     const { schemaTypesSource, baseDir, typesImport } = importResolverOptions;
-    return documents.map(documentFile => {
+    const results = documents.map(documentFile => {
         try {
             // NOTE: We pass a placeholder filename here since we'll generate proper filenames per-operation later
             // The important part is that fragment resolution will use the correct paths from the registry
@@ -51,4 +51,5 @@ export function resolveDocumentImports(presetOptions, schemaObject, importResolv
          ${e.message || e.toString()}`);
         }
     });
+    return { results, fragmentRegistry };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nmarks/graphql-codegen-per-operation-file-preset",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "GraphQL Code Generator preset for generating one file per operation/fragment",
   "peerDependencies": {
     "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"

package/typings/fragment-resolver.d.cts

@@ -21,9 +21,12 @@ export type FragmentRegistry = {
 /**
  * Builds a fragment "resolver" that collects `externalFragments` definitions and `fragmentImportStatements`
  */
-export default function buildFragmentResolver<T>(collectorOptions: DocumentImportResolverOptions, presetOptions: Types.PresetFnArgs<T>, schemaObject: GraphQLSchema, dedupeFragments?: boolean): (generatedFilePath: string, documentFileContent: DocumentNode) => {
-    externalFragments: LoadedFragment<{
-        level: number;
-    }>[];
-    fragmentImports: ImportDeclaration<FragmentImport>[];
+export default function buildFragmentResolver<T>(collectorOptions: DocumentImportResolverOptions, presetOptions: Types.PresetFnArgs<T>, schemaObject: GraphQLSchema, dedupeFragments?: boolean): {
+    resolveFragments: (generatedFilePath: string, documentFileContent: DocumentNode) => {
+        externalFragments: LoadedFragment<{
+            level: number;
+        }>[];
+        fragmentImports: ImportDeclaration<FragmentImport>[];
+    };
+    fragmentRegistry: FragmentRegistry;
 };

package/typings/fragment-resolver.d.ts

@@ -21,9 +21,12 @@ export type FragmentRegistry = {
 /**
  * Builds a fragment "resolver" that collects `externalFragments` definitions and `fragmentImportStatements`
  */
-export default function buildFragmentResolver<T>(collectorOptions: DocumentImportResolverOptions, presetOptions: Types.PresetFnArgs<T>, schemaObject: GraphQLSchema, dedupeFragments?: boolean): (generatedFilePath: string, documentFileContent: DocumentNode) => {
-    externalFragments: LoadedFragment<{
-        level: number;
-    }>[];
-    fragmentImports: ImportDeclaration<FragmentImport>[];
+export default function buildFragmentResolver<T>(collectorOptions: DocumentImportResolverOptions, presetOptions: Types.PresetFnArgs<T>, schemaObject: GraphQLSchema, dedupeFragments?: boolean): {
+    resolveFragments: (generatedFilePath: string, documentFileContent: DocumentNode) => {
+        externalFragments: LoadedFragment<{
+            level: number;
+        }>[];
+        fragmentImports: ImportDeclaration<FragmentImport>[];
+    };
+    fragmentRegistry: FragmentRegistry;
 };

package/typings/resolve-document-imports.d.cts

@@ -44,5 +44,8 @@ interface ResolveDocumentImportResult {
  * Resolves user provided imports and fragment imports using the `DocumentImportResolverOptions`.
  * Does not define specific plugins, but rather returns a string[] of `importStatements` for the calling plugin to make use of
  */
-export declare function resolveDocumentImports<T>(presetOptions: Types.PresetFnArgs<T>, schemaObject: GraphQLSchema, importResolverOptions: DocumentImportResolverOptions, dedupeFragments?: boolean): Array<ResolveDocumentImportResult>;
+export declare function resolveDocumentImports<T>(presetOptions: Types.PresetFnArgs<T>, schemaObject: GraphQLSchema, importResolverOptions: DocumentImportResolverOptions, dedupeFragments?: boolean): {
+    results: ResolveDocumentImportResult[];
+    fragmentRegistry: any;
+};
 export {};

package/typings/resolve-document-imports.d.ts

@@ -44,5 +44,8 @@ interface ResolveDocumentImportResult {
  * Resolves user provided imports and fragment imports using the `DocumentImportResolverOptions`.
  * Does not define specific plugins, but rather returns a string[] of `importStatements` for the calling plugin to make use of
  */
-export declare function resolveDocumentImports<T>(presetOptions: Types.PresetFnArgs<T>, schemaObject: GraphQLSchema, importResolverOptions: DocumentImportResolverOptions, dedupeFragments?: boolean): Array<ResolveDocumentImportResult>;
+export declare function resolveDocumentImports<T>(presetOptions: Types.PresetFnArgs<T>, schemaObject: GraphQLSchema, importResolverOptions: DocumentImportResolverOptions, dedupeFragments?: boolean): {
+    results: ResolveDocumentImportResult[];
+    fragmentRegistry: any;
+};
 export {};